refactor(apify): move Actor tools into bundled plugin

Re-shelve the three Apify tools from core into plugins/apify/, matching
the Spotify plugin pattern for optional third-party SaaS integrations.
tools/ is reserved for foundational capabilities; third-party service
integrations live in plugins/.

- plugins/apify/{__init__,tools,client}.py + plugin.yaml + README
  (kind: backend, auto-loads; registers via ctx.register_tool())
- remove apify_* from _HERMES_CORE_TOOLS in toolsets.py
  (TOOLSETS["apify"] entry kept, mirroring spotify)
- tests moved tests/tools/test_apify_tool.py -> tests/plugins/test_apify.py,
  import paths updated (34 tests pass)
- add JanHranicky to AUTHOR_MAP in scripts/release.py (CI gate)

The tools_config.py / config.py / lazy_deps.py / pyproject.toml setup +
config UX from the original commit is retained unchanged.

Co-authored-by: JanHranicky <jan.hranicky@seznam.cz>

.github/workflows/deploy-site.yml

@@ -59,22 +59,12 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
-          # Rebuild the unified catalog. The file is gitignored, so a fresh
-          # checkout starts without it and we want the freshest crawl in
-          # every deploy.
-          #
-          # This MUST be fatal. build_skills_index.py runs a health check and
-          # exits non-zero WITHOUT writing the output file when a source
-          # collapses (e.g. a GitHub API rate limit zeroes the github /
-          # claude-marketplace / well-known taps all at once). Letting the
-          # deploy continue would either (a) ship a degenerate index missing
-          # whole hubs — the June 2026 regression where OpenAI/Anthropic/
-          # HuggingFace/NVIDIA tabs vanished — or (b) fall through to a
-          # local-only catalog. Failing here keeps the last good deployment
-          # live (GitHub Pages serves the previous build) instead of
-          # publishing a broken catalog. Re-run the workflow once the
-          # transient rate limit clears.
-          python3 scripts/build_skills_index.py
+          # Always rebuild — the file isn't committed (gitignored), so a
+          # fresh checkout starts without it and we want the freshest crawl
+          # in every deploy. Failure is non-fatal: extract-skills.py will
+          # fall back to the legacy snapshot cache and the Skills Hub page
+          # still renders, just without the latest community catalog.
+          python3 scripts/build_skills_index.py || echo "Skills index build failed (non-fatal)"
 
       - name: Extract skill metadata for dashboard
         run: python3 website/scripts/extract-skills.py

README.md

@@ -53,7 +53,7 @@ If you already have Git installed, the installer detects it and uses that instea
 
 > **Android / Termux:** The tested manual path is documented in the [Termux guide](https://hermes-agent.nousresearch.com/docs/getting-started/termux). On Termux, Hermes installs a curated `.[termux]` extra because the full `.[all]` extra currently pulls Android-incompatible voice dependencies.
 >
-> **Windows:** Native Windows is fully supported — the PowerShell one-liner above installs everything. If you'd rather use WSL2, the Linux command works there too. Native Windows install lives under `%LOCALAPPDATA%\hermes`; WSL2 installs under `~/.hermes` as on Linux.
+> **Windows:** Native Windows is fully supported — the PowerShell one-liner above installs everything. If you'd rather use WSL2, the Linux command works there too. Native Windows install lives under `%LOCALAPPDATA%\hermes`; WSL2 installs under `~/.hermes` as on Linux. The only Hermes feature that currently needs WSL2 specifically is the browser-based dashboard chat pane (it uses a POSIX PTY — classic CLI and gateway both run natively).
 
 After installation:
 

agent/agent_init.py

@@ -169,7 +169,6 @@ def init_agent(
     save_trajectories: bool = False,
     verbose_logging: bool = False,
     quiet_mode: bool = False,
-    tool_progress_mode: str = "all",
     ephemeral_system_prompt: str = None,
     log_prefix_chars: int = 100,
     log_prefix: str = "",
@@ -281,7 +280,6 @@ def init_agent(
     agent.save_trajectories = save_trajectories
     agent.verbose_logging = verbose_logging
     agent.quiet_mode = quiet_mode
-    agent.tool_progress_mode = tool_progress_mode
     agent.ephemeral_system_prompt = ephemeral_system_prompt
     agent.platform = platform  # "cli", "telegram", "discord", "whatsapp", etc.
     agent._user_id = user_id  # Platform user identifier (gateway sessions)

agent/anthropic_adapter.py

@@ -2301,43 +2301,3 @@ def build_anthropic_kwargs(
         kwargs["extra_headers"] = {"anthropic-beta": ",".join(betas)}
 
     return kwargs
-
-
-# Keys that belong exclusively to the OpenAI Responses / Codex API shape.
-# The Anthropic Messages SDK (``messages.create()`` / ``messages.stream()``)
-# raises ``TypeError: ... got an unexpected keyword argument`` on any of them.
-_RESPONSES_ONLY_KWARGS = frozenset(
-    {"instructions", "input", "store", "parallel_tool_calls"}
-)
-
-
-def sanitize_anthropic_kwargs(api_kwargs: Any, *, log_prefix: str = "") -> Any:
-    """Drop Responses-API-only keys before an Anthropic Messages SDK call.
-
-    Defensive boundary guard for #31673: under rare api_mode-flip races
-    (e.g. a concurrent auxiliary call mutating a shared agent between the
-    kwargs build and the stream dispatch), a Responses-shaped payload
-    carrying ``instructions=`` can reach ``messages.stream()`` /
-    ``messages.create()``. The Anthropic SDK rejects it with a
-    non-retryable ``TypeError`` that nukes the whole turn and propagates
-    the entire fallback chain.
-
-    Mutates ``api_kwargs`` in place and returns it. When a foreign key is
-    present we log a WARNING so the underlying race stays visible in the
-    wild instead of being silently papered over.
-    """
-    if not isinstance(api_kwargs, dict):
-        return api_kwargs
-    leaked = _RESPONSES_ONLY_KWARGS.intersection(api_kwargs)
-    if leaked:
-        for _key in leaked:
-            api_kwargs.pop(_key, None)
-        logger.warning(
-            "%sStripped Responses-only kwarg(s) %s from an Anthropic Messages "
-            "call (api_mode flip race — see #31673). The call will proceed; "
-            "this breadcrumb means a kwargs build ran under a Responses "
-            "api_mode while dispatch ran under anthropic_messages.",
-            log_prefix,
-            sorted(leaked),
-        )
-    return api_kwargs

agent/chat_completion_helpers.py

@@ -1986,58 +1986,6 @@ def interruptible_streaming_api_call(agent, api_kwargs: dict, *, on_first_delta=
                 "(possible upstream error or malformed SSE response)."
             )
 
-        # A stream that delivered a tool call but only partial/unparseable
-        # JSON args splits into two very different cases:
-        #
-        #   1. Provider sent finish_reason="length" → a genuine output-cap
-        #      truncation.  Boosting max_tokens on retry is the right move.
-        #
-        #   2. Provider sent NO finish_reason (the SSE simply stopped after
-        #      the opening "{" with no terminator and no [DONE]) → the
-        #      upstream dropped/stalled the connection mid tool-call.  This
-        #      is NOT an output cap — the model never reported hitting one.
-        #      Some dedicated endpoints (e.g. NVIDIA Nemotron Ultra on the
-        #      Nous dedicated endpoint) stall for minutes during large
-        #      tool-arg generation, then close the stream cleanly without a
-        #      finish_reason.  Stamping "length" here sends it down the
-        #      max_tokens-boost truncation path, which retries 3× to no
-        #      effect and finally reports the misleading "Response truncated
-        #      due to output length limit" — the red herring this guards
-        #      against.  Route it through the partial-stream-stub path
-        #      instead so the loop reports an honest mid-tool-call stream
-        #      drop and fails fast rather than escalating output budget.
-        _tool_args_dropped_no_finish = has_truncated_tool_args and finish_reason is None
-        if _tool_args_dropped_no_finish:
-            _dropped_names = [
-                (tool_calls_acc[idx]["function"]["name"] or "?")
-                for idx in sorted(tool_calls_acc)
-            ]
-            logger.warning(
-                "Stream ended with no finish_reason while a tool call's "
-                "arguments were still incomplete (tools=%s); treating as a "
-                "mid-tool-call stream drop, not an output-length truncation.",
-                _dropped_names,
-            )
-            full_reasoning = "".join(reasoning_parts) or None
-            mock_message = SimpleNamespace(
-                role=role,
-                content=full_content,
-                tool_calls=None,
-                reasoning_content=full_reasoning,
-            )
-            mock_choice = SimpleNamespace(
-                index=0,
-                message=mock_message,
-                finish_reason=FINISH_REASON_LENGTH,
-            )
-            return SimpleNamespace(
-                id=PARTIAL_STREAM_STUB_ID,
-                model=model_name,
-                choices=[mock_choice],
-                usage=usage_obj,
-                _dropped_tool_names=_dropped_names or None,
-            )
-
         effective_finish_reason = finish_reason or "stop"
         if has_truncated_tool_args:
             effective_finish_reason = "length"
@@ -2076,14 +2024,6 @@ def interruptible_streaming_api_call(agent, api_kwargs: dict, *, on_first_delta=
         # Per-attempt diagnostic dict for the retry block to consume.
         _diag = agent._stream_diag_init()
         request_client_holder["diag"] = _diag
-        # Defensive: strip Responses-only kwargs (instructions, input, ...)
-        # that can leak in under an api_mode-flip race. The Anthropic SDK
-        # raises a non-retryable TypeError on them, killing the turn. See
-        # #31673 / sanitize_anthropic_kwargs().
-        from agent.anthropic_adapter import sanitize_anthropic_kwargs
-        sanitize_anthropic_kwargs(
-            api_kwargs, log_prefix=getattr(agent, "log_prefix", "")
-        )
         # Use the Anthropic SDK's streaming context manager
         with agent._anthropic_client.messages.stream(**api_kwargs) as stream:
             # The Anthropic SDK exposes the raw httpx response on

agent/conversation_loop.py

@@ -4196,26 +4196,383 @@ def run_conversation(
                 messages.append({"role": "assistant", "content": final_response})
                 break
     
-    # Post-loop turn finalization extracted to agent/turn_finalizer.finalize_turn
-    # (god-file decomposition Phase 1 step 4). Behavior-neutral: the assembled
-    # result dict is returned exactly as before.
-    from agent.turn_finalizer import finalize_turn
-    return finalize_turn(
-        agent,
-        final_response=final_response,
-        api_call_count=api_call_count,
-        interrupted=interrupted,
-        failed=failed,
-        messages=messages,
-        conversation_history=conversation_history,
-        effective_task_id=effective_task_id,
-        turn_id=turn_id,
-        user_message=user_message,
-        original_user_message=original_user_message,
-        _should_review_memory=_should_review_memory,
-        _turn_exit_reason=_turn_exit_reason,
+    if final_response is None and (
+        api_call_count >= agent.max_iterations
+        or agent.iteration_budget.remaining <= 0
+    ):
+        # Budget exhausted — ask the model for a summary via one extra
+        # API call with tools stripped.  _handle_max_iterations injects a
+        # user message and makes a single toolless request.
+        _turn_exit_reason = f"max_iterations_reached({api_call_count}/{agent.max_iterations})"
+        agent._emit_status(
+            f"⚠️ Iteration budget exhausted ({api_call_count}/{agent.max_iterations}) "
+            "— asking model to summarise"
+        )
+        if not agent.quiet_mode:
+            agent._safe_print(
+                f"\n⚠️  Iteration budget exhausted ({api_call_count}/{agent.max_iterations}) "
+                "— requesting summary..."
+            )
+        final_response = agent._handle_max_iterations(messages, api_call_count)
+
+        # If running as a kanban worker, signal the dispatcher that the
+        # worker could not complete (rather than treating it as a
+        # protocol violation).  The agent loop strips tools before calling
+        # _handle_max_iterations, so the model cannot call kanban_block
+        # itself — we must do it on its behalf.
+        #
+        # We route through ``_record_task_failure(outcome="timed_out")``
+        # rather than ``kanban_block`` so this counts toward the
+        # ``consecutive_failures`` counter and the dispatcher's
+        # ``failure_limit`` circuit breaker (#29747 gap 2).  Without this,
+        # a task whose worker keeps exhausting its budget would block
+        # silently each run, get auto-promoted by the operator (or never
+        # surface), and re-block in an endless loop with no signal.
+        _kanban_task = os.environ.get("HERMES_KANBAN_TASK")
+        if _kanban_task:
+            try:
+                from hermes_cli import kanban_db as _kb
+                _conn = _kb.connect()
+                try:
+                    _kb._record_task_failure(
+                        _conn,
+                        _kanban_task,
+                        error=(
+                            f"Iteration budget exhausted "
+                            f"({api_call_count}/{agent.max_iterations}) — "
+                            "task could not complete within the allowed "
+                            "iterations"
+                        ),
+                        outcome="timed_out",
+                        release_claim=True,
+                        end_run=True,
+                        event_payload_extra={
+                            "budget_used": api_call_count,
+                            "budget_max": agent.max_iterations,
+                        },
+                    )
+                    logger.info(
+                        "recorded budget-exhausted failure for task %s (%d/%d)",
+                        _kanban_task, api_call_count, agent.max_iterations,
+                    )
+                finally:
+                    try:
+                        _conn.close()
+                    except Exception:
+                        pass
+            except Exception:
+                logger.warning(
+                    "Failed to record budget-exhausted failure for task %s",
+                    _kanban_task,
+                    exc_info=True,
+                )
+
+    # Determine if conversation completed successfully
+    completed = (
+        final_response is not None
+        and api_call_count < agent.max_iterations
+        and not failed
     )
 
+    # Save trajectory if enabled.  ``user_message`` may be a multimodal
+    # list of parts; the trajectory format wants a plain string.
+    agent._save_trajectory(messages, _summarize_user_message_for_log(user_message), completed)
+
+    # Clean up VM and browser for this task after conversation completes
+    agent._cleanup_task_resources(effective_task_id)
+
+    # Persist session to both JSON log and SQLite only after private retry
+    # scaffolding has been removed. Otherwise a later user "continue" turn
+    # can replay assistant("(empty)") / recovery nudges and fall into the
+    # same empty-response loop again.
+    agent._drop_trailing_empty_response_scaffolding(messages)
+    agent._persist_session(messages, conversation_history)
+
+    # ── Turn-exit diagnostic log ─────────────────────────────────────
+    # Always logged at INFO so agent.log captures WHY every turn ended.
+    # When the last message is a tool result (agent was mid-work), log
+    # at WARNING — this is the "just stops" scenario users report.
+    _last_msg_role = messages[-1].get("role") if messages else None
+    _last_tool_name = None
+    if _last_msg_role == "tool":
+        # Walk back to find the assistant message with the tool call
+        for _m in reversed(messages):
+            if _m.get("role") == "assistant" and _m.get("tool_calls"):
+                _tcs = _m["tool_calls"]
+                if _tcs and isinstance(_tcs[0], dict):
+                    _last_tool_name = _tcs[-1].get("function", {}).get("name")
+                break
+
+    _turn_tool_count = sum(
+        1 for m in messages
+        if isinstance(m, dict) and m.get("role") == "assistant" and m.get("tool_calls")
+    )
+    _resp_len = len(final_response) if final_response else 0
+    _budget_used = agent.iteration_budget.used if agent.iteration_budget else 0
+    _budget_max = agent.iteration_budget.max_total if agent.iteration_budget else 0
+
+    _diag_msg = (
+        "Turn ended: reason=%s model=%s api_calls=%d/%d budget=%d/%d "
+        "tool_turns=%d last_msg_role=%s response_len=%d session=%s"
+    )
+    _diag_args = (
+        _turn_exit_reason, agent.model, api_call_count, agent.max_iterations,
+        _budget_used, _budget_max,
+        _turn_tool_count, _last_msg_role, _resp_len,
+        agent.session_id or "none",
+    )
+
+    if _last_msg_role == "tool" and not interrupted:
+        # Agent was mid-work — this is the "just stops" case.
+        logger.warning(
+            "Turn ended with pending tool result (agent may appear stuck). "
+            + _diag_msg + " last_tool=%s",
+            *_diag_args, _last_tool_name,
+        )
+    else:
+        logger.info(_diag_msg, *_diag_args)
+
+    # File-mutation verifier footer.
+    # If one or more ``write_file`` / ``patch`` calls failed during this
+    # turn and were never superseded by a successful write to the same
+    # path, append an advisory footer to the assistant response.  This
+    # catches the specific case — reported by Ben Eng (#15524-adjacent)
+    # — where a model issues a batch of parallel patches, half of them
+    # fail with "Could not find old_string", and the model summarises
+    # the turn claiming every file was edited.  The user then has to
+    # manually run ``git status`` to catch the lie.  With this footer
+    # the truth is surfaced on every turn, so over-claiming is
+    # structurally impossible past the model.
+    #
+    # Gate: only applied when a real text response exists for this
+    # turn and the user didn't interrupt.  Empty/interrupted turns
+    # already have other surface text that shouldn't be augmented.
+    if final_response and not interrupted:
+        try:
+            _failed = getattr(agent, "_turn_failed_file_mutations", None) or {}
+            if _failed and agent._file_mutation_verifier_enabled():
+                footer = agent._format_file_mutation_failure_footer(_failed)
+                if footer:
+                    final_response = final_response.rstrip() + "\n\n" + footer
+        except Exception as _ver_err:
+            logger.debug("file-mutation verifier footer failed: %s", _ver_err)
+
+    # Turn-completion explainer.
+    # When a turn ends abnormally after substantive work — empty content
+    # after retries, a partial/truncated stream, a still-pending tool
+    # result, or an iteration/budget limit — the user otherwise gets a
+    # blank or fragmentary response box with no consolidated reason why
+    # the agent stopped (#34452).  Surface a single user-visible
+    # explanation derived from ``_turn_exit_reason``, mirroring the
+    # file-mutation verifier footer pattern above.
+    #
+    # Gate carefully so healthy turns stay quiet:
+    #   - ``text_response(...)`` exits never produce an explanation
+    #     (handled inside the formatter), so a terse ``Done.`` is silent.
+    #   - We only ACT when there is no genuinely usable reply this turn:
+    #     an empty response, the "(empty)" terminal sentinel, or a
+    #     suspiciously short partial fragment with no terminating
+    #     punctuation (e.g. "The").  A real short answer keeps its text.
+    if not interrupted:
+        try:
+            if agent._turn_completion_explainer_enabled():
+                _stripped = (final_response or "").strip()
+                _is_empty_terminal = _stripped == "" or _stripped == "(empty)"
+                # A short fragment that is not a normal text_response exit
+                # and lacks sentence-ending punctuation is treated as a
+                # truncated partial (the "The" case from #34452).
+                _is_partial_fragment = (
+                    not _is_empty_terminal
+                    and not str(_turn_exit_reason).startswith("text_response")
+                    and len(_stripped) <= 24
+                    and _stripped[-1:] not in {".", "!", "?", "。", "！", "？", "`", ")"}
+                )
+                if _is_empty_terminal or _is_partial_fragment:
+                    _explanation = agent._format_turn_completion_explanation(
+                        _turn_exit_reason
+                    )
+                    if _explanation:
+                        if _is_empty_terminal:
+                            # Replace the bare "(empty)"/blank sentinel with
+                            # the actionable explanation.
+                            final_response = _explanation
+                        else:
+                            # Keep the partial fragment, append the reason so
+                            # the user sees both what arrived and why it
+                            # stopped.
+                            final_response = (
+                                _stripped + "\n\n" + _explanation
+                            )
+        except Exception as _exp_err:
+            logger.debug("turn-completion explainer failed: %s", _exp_err)
+
+    _response_transformed = False
+
+    # Plugin hook: transform_llm_output
+    # Fired once per turn after the tool-calling loop completes.
+    # Plugins can transform the LLM's output text before it's returned.
+    # First hook to return a string wins; None/empty return leaves text unchanged.
+    if final_response and not interrupted:
+        try:
+            from hermes_cli.plugins import invoke_hook as _invoke_hook
+            _transform_results = _invoke_hook(
+                "transform_llm_output",
+                response_text=final_response,
+                session_id=agent.session_id or "",
+                model=agent.model,
+                platform=getattr(agent, "platform", None) or "",
+            )
+            for _hook_result in _transform_results:
+                if isinstance(_hook_result, str) and _hook_result:
+                    final_response = _hook_result
+                    _response_transformed = True
+                    break  # First non-empty string wins
+        except Exception as exc:
+            logger.warning("transform_llm_output hook failed: %s", exc)
+
+    # Plugin hook: post_llm_call
+    # Fired once per turn after the tool-calling loop completes.
+    # Plugins can use this to persist conversation data (e.g. sync
+    # to an external memory system).
+    if final_response and not interrupted:
+        try:
+            from hermes_cli.plugins import invoke_hook as _invoke_hook
+            _invoke_hook(
+                "post_llm_call",
+                session_id=agent.session_id,
+                task_id=effective_task_id,
+                turn_id=turn_id,
+                user_message=original_user_message,
+                assistant_response=final_response,
+                conversation_history=list(messages),
+                model=agent.model,
+                platform=getattr(agent, "platform", None) or "",
+            )
+        except Exception as exc:
+            logger.warning("post_llm_call hook failed: %s", exc)
+
+    # Extract reasoning from the CURRENT turn only.  Walk backwards
+    # but stop at the user message that started this turn — anything
+    # earlier is from a prior turn and must not leak into the reasoning
+    # box (confusing stale display; #17055).  Within the current turn
+    # we still want the *most recent* non-empty reasoning: many
+    # providers (Claude thinking, DeepSeek v4, Codex Responses) emit
+    # reasoning on the tool-call step and leave the final-answer step
+    # with reasoning=None, so picking only the last assistant would
+    # silently drop legitimate same-turn reasoning.
+    last_reasoning = None
+    for msg in reversed(messages):
+        if msg.get("role") == "user":
+            break  # turn boundary — don't cross into prior turns
+        if msg.get("role") == "assistant" and msg.get("reasoning"):
+            last_reasoning = msg["reasoning"]
+            break
+
+    # Build result with interrupt info if applicable
+    result = {
+        "final_response": final_response,
+        "last_reasoning": last_reasoning,
+        "messages": messages,
+        "api_calls": api_call_count,
+        "completed": completed,
+        "turn_exit_reason": _turn_exit_reason,
+        "failed": failed,
+        "partial": False,  # True only when stopped due to invalid tool calls
+        "interrupted": interrupted,
+        "response_transformed": _response_transformed,
+        "response_previewed": getattr(agent, "_response_was_previewed", False),
+        "model": agent.model,
+        "provider": agent.provider,
+        "base_url": agent.base_url,
+        "input_tokens": agent.session_input_tokens,
+        "output_tokens": agent.session_output_tokens,
+        "cache_read_tokens": agent.session_cache_read_tokens,
+        "cache_write_tokens": agent.session_cache_write_tokens,
+        "reasoning_tokens": agent.session_reasoning_tokens,
+        "prompt_tokens": agent.session_prompt_tokens,
+        "completion_tokens": agent.session_completion_tokens,
+        "total_tokens": agent.session_total_tokens,
+        "last_prompt_tokens": getattr(agent.context_compressor, "last_prompt_tokens", 0) or 0,
+        "estimated_cost_usd": agent.session_estimated_cost_usd,
+        "cost_status": agent.session_cost_status,
+        "cost_source": agent.session_cost_source,
+        "session_id": agent.session_id,
+    }
+    if agent._tool_guardrail_halt_decision is not None:
+        result["guardrail"] = agent._tool_guardrail_halt_decision.to_metadata()
+    # If a /steer landed after the final assistant turn (no more tool
+    # batches to drain into), hand it back to the caller so it can be
+    # delivered as the next user turn instead of being silently lost.
+    _leftover_steer = agent._drain_pending_steer()
+    if _leftover_steer:
+        result["pending_steer"] = _leftover_steer
+    agent._response_was_previewed = False
+    
+    # Include interrupt message if one triggered the interrupt
+    if interrupted and agent._interrupt_message:
+        result["interrupt_message"] = agent._interrupt_message
+    
+    # Clear interrupt state after handling
+    agent.clear_interrupt()
+
+    # Clear stream callback so it doesn't leak into future calls
+    agent._stream_callback = None
+
+    # Check skill trigger NOW — based on how many tool iterations THIS turn used.
+    _should_review_skills = False
+    if (agent._skill_nudge_interval > 0
+            and agent._iters_since_skill >= agent._skill_nudge_interval
+            and "skill_manage" in agent.valid_tool_names):
+        _should_review_skills = True
+        agent._iters_since_skill = 0
+
+    # External memory provider: sync the completed turn + queue next prefetch.
+    agent._sync_external_memory_for_turn(
+        original_user_message=original_user_message,
+        final_response=final_response,
+        interrupted=interrupted,
+        messages=messages,
+    )
+
+    # Background memory/skill review — runs AFTER the response is delivered
+    # so it never competes with the user's task for model attention.
+    if final_response and not interrupted and (_should_review_memory or _should_review_skills):
+        try:
+            agent._spawn_background_review(
+                messages_snapshot=list(messages),
+                review_memory=_should_review_memory,
+                review_skills=_should_review_skills,
+            )
+        except Exception:
+            pass  # Background review is best-effort
+
+    # Note: Memory provider on_session_end() + shutdown_all() are NOT
+    # called here — run_conversation() is called once per user message in
+    # multi-turn sessions. Shutting down after every turn would kill the
+    # provider before the second message. Actual session-end cleanup is
+    # handled by the CLI (atexit / /reset) and gateway (session expiry /
+    # _reset_session).
+
+    # Plugin hook: on_session_end
+    # Fired at the very end of every run_conversation call.
+    # Plugins can use this for cleanup, flushing buffers, etc.
+    try:
+        from hermes_cli.plugins import invoke_hook as _invoke_hook
+        _invoke_hook(
+            "on_session_end",
+            session_id=agent.session_id,
+            task_id=effective_task_id,
+            turn_id=turn_id,
+            completed=completed,
+            interrupted=interrupted,
+            model=agent.model,
+            platform=getattr(agent, "platform", None) or "",
+        )
+    except Exception as exc:
+        logger.warning("on_session_end hook failed: %s", exc)
+
+    return result
+
 
 
 __all__ = ["run_conversation"]

agent/credential_pool.py

@@ -91,7 +91,6 @@ AUTH_TYPE_OAUTH = "oauth"
 AUTH_TYPE_API_KEY = "api_key"
 
 SOURCE_MANUAL = "manual"
-SOURCE_MANUAL_DEVICE_CODE = f"{SOURCE_MANUAL}:device_code"
 
 STRATEGY_FILL_FIRST = "fill_first"
 STRATEGY_ROUND_ROBIN = "round_robin"

agent/tool_executor.py

@@ -702,7 +702,7 @@ def execute_tool_calls_concurrent(agent, assistant_message, messages: list, effe
         if agent._should_emit_quiet_tool_messages():
             cute_msg = _get_cute_tool_message_impl(name, args, tool_duration, result=function_result)
             agent._safe_print(f"  {cute_msg}")
-        elif getattr(agent, "tool_progress_mode", "all") != "off":
+        elif not agent.quiet_mode:
             _preview_str = _multimodal_text_summary(function_result)
             if agent.verbose_logging:
                 print(f"  ✅ Tool {i+1} completed in {tool_duration:.2f}s")

agent/turn_finalizer.py

@@ -1,428 +0,0 @@
-"""Post-loop turn finalization for ``run_conversation``.
-
-Extracted from ``agent/conversation_loop.py`` as part of the god-file
-decomposition campaign (``~/.hermes/plans/god-file-decomposition.md``, Phase 1
-step 4 — the post-loop ``TurnFinalizer`` seam). ``run_conversation``'s tail
-(everything after the main tool-calling ``while`` loop) is lifted here verbatim:
-budget-exhaustion summary, trajectory save, session persist, turn diagnostics,
-response transforms, result-dict assembly, steer drain, and the memory/skill
-review trigger.
-
-Behavior-neutral: the body is moved unchanged. All ``agent.*`` side effects fire
-exactly as before; only the post-loop *locals* are passed in as keyword args, and
-the assembled ``result`` dict is returned to ``run_conversation`` which returns it
-to the caller. The function is synchronous with a single return — mirroring the
-region it replaces (no awaits, no early returns).
-
-Module ``logger`` is imported lazily inside the body (``from
-agent.conversation_loop import logger``) so this module never imports
-``agent.conversation_loop`` at import time -> no import cycle, and the log records
-keep the exact logger name (``"agent.conversation_loop"``).
-"""
-
-from __future__ import annotations
-
-import os
-
-from agent.codex_responses_adapter import _summarize_user_message_for_log
-
-
-def finalize_turn(
-    agent,
-    *,
-    final_response,
-    api_call_count,
-    interrupted,
-    failed,
-    messages,
-    conversation_history,
-    effective_task_id,
-    turn_id,
-    user_message,
-    original_user_message,
-    _should_review_memory,
-    _turn_exit_reason,
-):
-    """Run the post-loop finalization and return the turn ``result`` dict.
-
-    Lifted verbatim from ``run_conversation`` (the region after the main agent
-    loop). See module docstring.
-    """
-    from agent.conversation_loop import logger
-
-    if final_response is None and (
-        api_call_count >= agent.max_iterations
-        or agent.iteration_budget.remaining <= 0
-    ):
-        # Budget exhausted — ask the model for a summary via one extra
-        # API call with tools stripped.  _handle_max_iterations injects a
-        # user message and makes a single toolless request.
-        _turn_exit_reason = f"max_iterations_reached({api_call_count}/{agent.max_iterations})"
-        agent._emit_status(
-            f"⚠️ Iteration budget exhausted ({api_call_count}/{agent.max_iterations}) "
-            "— asking model to summarise"
-        )
-        if not agent.quiet_mode:
-            agent._safe_print(
-                f"\n⚠️  Iteration budget exhausted ({api_call_count}/{agent.max_iterations}) "
-                "— requesting summary..."
-            )
-        final_response = agent._handle_max_iterations(messages, api_call_count)
-
-        # If running as a kanban worker, signal the dispatcher that the
-        # worker could not complete (rather than treating it as a
-        # protocol violation).  The agent loop strips tools before calling
-        # _handle_max_iterations, so the model cannot call kanban_block
-        # itself — we must do it on its behalf.
-        #
-        # We route through ``_record_task_failure(outcome="timed_out")``
-        # rather than ``kanban_block`` so this counts toward the
-        # ``consecutive_failures`` counter and the dispatcher's
-        # ``failure_limit`` circuit breaker (#29747 gap 2).  Without this,
-        # a task whose worker keeps exhausting its budget would block
-        # silently each run, get auto-promoted by the operator (or never
-        # surface), and re-block in an endless loop with no signal.
-        _kanban_task = os.environ.get("HERMES_KANBAN_TASK")
-        if _kanban_task:
-            try:
-                from hermes_cli import kanban_db as _kb
-                _conn = _kb.connect()
-                try:
-                    _kb._record_task_failure(
-                        _conn,
-                        _kanban_task,
-                        error=(
-                            f"Iteration budget exhausted "
-                            f"({api_call_count}/{agent.max_iterations}) — "
-                            "task could not complete within the allowed "
-                            "iterations"
-                        ),
-                        outcome="timed_out",
-                        release_claim=True,
-                        end_run=True,
-                        event_payload_extra={
-                            "budget_used": api_call_count,
-                            "budget_max": agent.max_iterations,
-                        },
-                    )
-                    logger.info(
-                        "recorded budget-exhausted failure for task %s (%d/%d)",
-                        _kanban_task, api_call_count, agent.max_iterations,
-                    )
-                finally:
-                    try:
-                        _conn.close()
-                    except Exception:
-                        pass
-            except Exception:
-                logger.warning(
-                    "Failed to record budget-exhausted failure for task %s",
-                    _kanban_task,
-                    exc_info=True,
-                )
-
-    # Determine if conversation completed successfully
-    completed = (
-        final_response is not None
-        and api_call_count < agent.max_iterations
-        and not failed
-    )
-
-    # Save trajectory if enabled.  ``user_message`` may be a multimodal
-    # list of parts; the trajectory format wants a plain string.
-    agent._save_trajectory(messages, _summarize_user_message_for_log(user_message), completed)
-
-    # Clean up VM and browser for this task after conversation completes
-    agent._cleanup_task_resources(effective_task_id)
-
-    # Persist session to both JSON log and SQLite only after private retry
-    # scaffolding has been removed. Otherwise a later user "continue" turn
-    # can replay assistant("(empty)") / recovery nudges and fall into the
-    # same empty-response loop again.
-    agent._drop_trailing_empty_response_scaffolding(messages)
-    agent._persist_session(messages, conversation_history)
-
-    # ── Turn-exit diagnostic log ─────────────────────────────────────
-    # Always logged at INFO so agent.log captures WHY every turn ended.
-    # When the last message is a tool result (agent was mid-work), log
-    # at WARNING — this is the "just stops" scenario users report.
-    _last_msg_role = messages[-1].get("role") if messages else None
-    _last_tool_name = None
-    if _last_msg_role == "tool":
-        # Walk back to find the assistant message with the tool call
-        for _m in reversed(messages):
-            if _m.get("role") == "assistant" and _m.get("tool_calls"):
-                _tcs = _m["tool_calls"]
-                if _tcs and isinstance(_tcs[0], dict):
-                    _last_tool_name = _tcs[-1].get("function", {}).get("name")
-                break
-
-    _turn_tool_count = sum(
-        1 for m in messages
-        if isinstance(m, dict) and m.get("role") == "assistant" and m.get("tool_calls")
-    )
-    _resp_len = len(final_response) if final_response else 0
-    _budget_used = agent.iteration_budget.used if agent.iteration_budget else 0
-    _budget_max = agent.iteration_budget.max_total if agent.iteration_budget else 0
-
-    _diag_msg = (
-        "Turn ended: reason=%s model=%s api_calls=%d/%d budget=%d/%d "
-        "tool_turns=%d last_msg_role=%s response_len=%d session=%s"
-    )
-    _diag_args = (
-        _turn_exit_reason, agent.model, api_call_count, agent.max_iterations,
-        _budget_used, _budget_max,
-        _turn_tool_count, _last_msg_role, _resp_len,
-        agent.session_id or "none",
-    )
-
-    if _last_msg_role == "tool" and not interrupted:
-        # Agent was mid-work — this is the "just stops" case.
-        logger.warning(
-            "Turn ended with pending tool result (agent may appear stuck). "
-            + _diag_msg + " last_tool=%s",
-            *_diag_args, _last_tool_name,
-        )
-    else:
-        logger.info(_diag_msg, *_diag_args)
-
-    # File-mutation verifier footer.
-    # If one or more ``write_file`` / ``patch`` calls failed during this
-    # turn and were never superseded by a successful write to the same
-    # path, append an advisory footer to the assistant response.  This
-    # catches the specific case — reported by Ben Eng (#15524-adjacent)
-    # — where a model issues a batch of parallel patches, half of them
-    # fail with "Could not find old_string", and the model summarises
-    # the turn claiming every file was edited.  The user then has to
-    # manually run ``git status`` to catch the lie.  With this footer
-    # the truth is surfaced on every turn, so over-claiming is
-    # structurally impossible past the model.
-    #
-    # Gate: only applied when a real text response exists for this
-    # turn and the user didn't interrupt.  Empty/interrupted turns
-    # already have other surface text that shouldn't be augmented.
-    if final_response and not interrupted:
-        try:
-            _failed = getattr(agent, "_turn_failed_file_mutations", None) or {}
-            if _failed and agent._file_mutation_verifier_enabled():
-                footer = agent._format_file_mutation_failure_footer(_failed)
-                if footer:
-                    final_response = final_response.rstrip() + "\n\n" + footer
-        except Exception as _ver_err:
-            logger.debug("file-mutation verifier footer failed: %s", _ver_err)
-
-    # Turn-completion explainer.
-    # When a turn ends abnormally after substantive work — empty content
-    # after retries, a partial/truncated stream, a still-pending tool
-    # result, or an iteration/budget limit — the user otherwise gets a
-    # blank or fragmentary response box with no consolidated reason why
-    # the agent stopped (#34452).  Surface a single user-visible
-    # explanation derived from ``_turn_exit_reason``, mirroring the
-    # file-mutation verifier footer pattern above.
-    #
-    # Gate carefully so healthy turns stay quiet:
-    #   - ``text_response(...)`` exits never produce an explanation
-    #     (handled inside the formatter), so a terse ``Done.`` is silent.
-    #   - We only ACT when there is no genuinely usable reply this turn:
-    #     an empty response, the "(empty)" terminal sentinel, or a
-    #     suspiciously short partial fragment with no terminating
-    #     punctuation (e.g. "The").  A real short answer keeps its text.
-    if not interrupted:
-        try:
-            if agent._turn_completion_explainer_enabled():
-                _stripped = (final_response or "").strip()
-                _is_empty_terminal = _stripped == "" or _stripped == "(empty)"
-                # A short fragment that is not a normal text_response exit
-                # and lacks sentence-ending punctuation is treated as a
-                # truncated partial (the "The" case from #34452).
-                _is_partial_fragment = (
-                    not _is_empty_terminal
-                    and not str(_turn_exit_reason).startswith("text_response")
-                    and len(_stripped) <= 24
-                    and _stripped[-1:] not in {".", "!", "?", "。", "！", "？", "`", ")"}
-                )
-                if _is_empty_terminal or _is_partial_fragment:
-                    _explanation = agent._format_turn_completion_explanation(
-                        _turn_exit_reason
-                    )
-                    if _explanation:
-                        if _is_empty_terminal:
-                            # Replace the bare "(empty)"/blank sentinel with
-                            # the actionable explanation.
-                            final_response = _explanation
-                        else:
-                            # Keep the partial fragment, append the reason so
-                            # the user sees both what arrived and why it
-                            # stopped.
-                            final_response = (
-                                _stripped + "\n\n" + _explanation
-                            )
-        except Exception as _exp_err:
-            logger.debug("turn-completion explainer failed: %s", _exp_err)
-
-    _response_transformed = False
-
-    # Plugin hook: transform_llm_output
-    # Fired once per turn after the tool-calling loop completes.
-    # Plugins can transform the LLM's output text before it's returned.
-    # First hook to return a string wins; None/empty return leaves text unchanged.
-    if final_response and not interrupted:
-        try:
-            from hermes_cli.plugins import invoke_hook as _invoke_hook
-            _transform_results = _invoke_hook(
-                "transform_llm_output",
-                response_text=final_response,
-                session_id=agent.session_id or "",
-                model=agent.model,
-                platform=getattr(agent, "platform", None) or "",
-            )
-            for _hook_result in _transform_results:
-                if isinstance(_hook_result, str) and _hook_result:
-                    final_response = _hook_result
-                    _response_transformed = True
-                    break  # First non-empty string wins
-        except Exception as exc:
-            logger.warning("transform_llm_output hook failed: %s", exc)
-
-    # Plugin hook: post_llm_call
-    # Fired once per turn after the tool-calling loop completes.
-    # Plugins can use this to persist conversation data (e.g. sync
-    # to an external memory system).
-    if final_response and not interrupted:
-        try:
-            from hermes_cli.plugins import invoke_hook as _invoke_hook
-            _invoke_hook(
-                "post_llm_call",
-                session_id=agent.session_id,
-                task_id=effective_task_id,
-                turn_id=turn_id,
-                user_message=original_user_message,
-                assistant_response=final_response,
-                conversation_history=list(messages),
-                model=agent.model,
-                platform=getattr(agent, "platform", None) or "",
-            )
-        except Exception as exc:
-            logger.warning("post_llm_call hook failed: %s", exc)
-
-    # Extract reasoning from the CURRENT turn only.  Walk backwards
-    # but stop at the user message that started this turn — anything
-    # earlier is from a prior turn and must not leak into the reasoning
-    # box (confusing stale display; #17055).  Within the current turn
-    # we still want the *most recent* non-empty reasoning: many
-    # providers (Claude thinking, DeepSeek v4, Codex Responses) emit
-    # reasoning on the tool-call step and leave the final-answer step
-    # with reasoning=None, so picking only the last assistant would
-    # silently drop legitimate same-turn reasoning.
-    last_reasoning = None
-    for msg in reversed(messages):
-        if msg.get("role") == "user":
-            break  # turn boundary — don't cross into prior turns
-        if msg.get("role") == "assistant" and msg.get("reasoning"):
-            last_reasoning = msg["reasoning"]
-            break
-
-    # Build result with interrupt info if applicable
-    result = {
-        "final_response": final_response,
-        "last_reasoning": last_reasoning,
-        "messages": messages,
-        "api_calls": api_call_count,
-        "completed": completed,
-        "turn_exit_reason": _turn_exit_reason,
-        "failed": failed,
-        "partial": False,  # True only when stopped due to invalid tool calls
-        "interrupted": interrupted,
-        "response_transformed": _response_transformed,
-        "response_previewed": getattr(agent, "_response_was_previewed", False),
-        "model": agent.model,
-        "provider": agent.provider,
-        "base_url": agent.base_url,
-        "input_tokens": agent.session_input_tokens,
-        "output_tokens": agent.session_output_tokens,
-        "cache_read_tokens": agent.session_cache_read_tokens,
-        "cache_write_tokens": agent.session_cache_write_tokens,
-        "reasoning_tokens": agent.session_reasoning_tokens,
-        "prompt_tokens": agent.session_prompt_tokens,
-        "completion_tokens": agent.session_completion_tokens,
-        "total_tokens": agent.session_total_tokens,
-        "last_prompt_tokens": getattr(agent.context_compressor, "last_prompt_tokens", 0) or 0,
-        "estimated_cost_usd": agent.session_estimated_cost_usd,
-        "cost_status": agent.session_cost_status,
-        "cost_source": agent.session_cost_source,
-        "session_id": agent.session_id,
-    }
-    if agent._tool_guardrail_halt_decision is not None:
-        result["guardrail"] = agent._tool_guardrail_halt_decision.to_metadata()
-    # If a /steer landed after the final assistant turn (no more tool
-    # batches to drain into), hand it back to the caller so it can be
-    # delivered as the next user turn instead of being silently lost.
-    _leftover_steer = agent._drain_pending_steer()
-    if _leftover_steer:
-        result["pending_steer"] = _leftover_steer
-    agent._response_was_previewed = False
-
-    # Include interrupt message if one triggered the interrupt
-    if interrupted and agent._interrupt_message:
-        result["interrupt_message"] = agent._interrupt_message
-
-    # Clear interrupt state after handling
-    agent.clear_interrupt()
-
-    # Clear stream callback so it doesn't leak into future calls
-    agent._stream_callback = None
-
-    # Check skill trigger NOW — based on how many tool iterations THIS turn used.
-    _should_review_skills = False
-    if (agent._skill_nudge_interval > 0
-            and agent._iters_since_skill >= agent._skill_nudge_interval
-            and "skill_manage" in agent.valid_tool_names):
-        _should_review_skills = True
-        agent._iters_since_skill = 0
-
-    # External memory provider: sync the completed turn + queue next prefetch.
-    agent._sync_external_memory_for_turn(
-        original_user_message=original_user_message,
-        final_response=final_response,
-        interrupted=interrupted,
-        messages=messages,
-    )
-
-    # Background memory/skill review — runs AFTER the response is delivered
-    # so it never competes with the user's task for model attention.
-    if final_response and not interrupted and (_should_review_memory or _should_review_skills):
-        try:
-            agent._spawn_background_review(
-                messages_snapshot=list(messages),
-                review_memory=_should_review_memory,
-                review_skills=_should_review_skills,
-            )
-        except Exception:
-            pass  # Background review is best-effort
-
-    # Note: Memory provider on_session_end() + shutdown_all() are NOT
-    # called here — run_conversation() is called once per user message in
-    # multi-turn sessions. Shutting down after every turn would kill the
-    # provider before the second message. Actual session-end cleanup is
-    # handled by the CLI (atexit / /reset) and gateway (session expiry /
-    # _reset_session).
-
-    # Plugin hook: on_session_end
-    # Fired at the very end of every run_conversation call.
-    # Plugins can use this for cleanup, flushing buffers, etc.
-    try:
-        from hermes_cli.plugins import invoke_hook as _invoke_hook
-        _invoke_hook(
-            "on_session_end",
-            session_id=agent.session_id,
-            task_id=effective_task_id,
-            turn_id=turn_id,
-            completed=completed,
-            interrupted=interrupted,
-            model=agent.model,
-            platform=getattr(agent, "platform", None) or "",
-        )
-    except Exception as exc:
-        logger.warning("on_session_end hook failed: %s", exc)
-
-    return result

apps/desktop/electron/main.cjs

@@ -119,20 +119,6 @@ if (REMOTE_DISPLAY_REASON) {
     `[hermes] remote display detected (${REMOTE_DISPLAY_REASON}); disabling GPU hardware acceleration to prevent flicker`
   )
 }
-
-// Keep the renderer running at full speed while the window is in the background
-// or occluded. The chat transcript streams to screen through a
-// requestAnimationFrame-gated flush; Chromium pauses rAF (and clamps timers)
-// for backgrounded/occluded renderers, so without these the live answer stalls
-// whenever the window loses focus (switching to your editor mid-turn, detached
-// devtools, another window covering it) and only paints on refocus or refresh.
-// `backgroundThrottling: false` on the BrowserWindow covers the blurred case;
-// these process-level switches additionally stop Chromium from backgrounding or
-// occlusion-throttling the renderer. Must run before app `ready`.
-app.commandLine.appendSwitch('disable-renderer-backgrounding')
-app.commandLine.appendSwitch('disable-backgrounding-occluded-windows')
-app.commandLine.appendSwitch('disable-background-timer-throttling')
-
 const SOURCE_REPO_ROOT = path.resolve(APP_ROOT, '../..')
 
 // Build-time install stamp -- the git ref this .exe was built against.
@@ -3913,12 +3899,10 @@ async function sanitizeDesktopConnectionConfig(config = readDesktopConnectionCon
   const scoped = key ? config.profiles?.[key] || null : null
   const block = key ? scoped || {} : config.remote || {}
 
-  const envOverride = key ? false : Boolean(process.env.HERMES_DESKTOP_REMOTE_URL)
-
   const remoteToken = decryptDesktopSecret(block.token)
   const authMode = normAuthMode(block.authMode)
-  const remoteUrl = envOverride ? String(process.env.HERMES_DESKTOP_REMOTE_URL || '') : String(block.url || '')
-  const mode = envOverride || (key ? scoped?.mode : config.mode) === 'remote' ? 'remote' : 'local'
+  const remoteUrl = String(block.url || '')
+  const mode = (key ? scoped?.mode : config.mode) === 'remote' ? 'remote' : 'local'
 
   let remoteOauthConnected = false
   if (authMode === 'oauth' && remoteUrl) {
@@ -3944,7 +3928,7 @@ async function sanitizeDesktopConnectionConfig(config = readDesktopConnectionCon
     remoteTokenSet: Boolean(remoteToken),
     // The env override only forces the global/primary connection; a per-profile
     // scope is never overridden by HERMES_DESKTOP_REMOTE_URL.
-    envOverride
+    envOverride: key ? false : Boolean(process.env.HERMES_DESKTOP_REMOTE_URL)
   }
 }
 
@@ -4703,16 +4687,7 @@ function createWindow() {
       webviewTag: true,
       sandbox: true,
       nodeIntegration: false,
-      devTools: true,
-      // Keep timers + requestAnimationFrame running at full speed when the
-      // window is blurred/occluded. The chat transcript streams to the screen
-      // through a requestAnimationFrame-gated flush (useSessionStateCache),
-      // so with Chromium's default background throttling the live answer
-      // stalls whenever this window isn't focused (e.g. you switch to your
-      // editor mid-turn, or open detached devtools) and only appears once you
-      // refocus or refresh. A streaming chat app must render in the
-      // background, so opt out — matching the secondary windows above.
-      backgroundThrottling: false
+      devTools: true
     }
   })
 

apps/desktop/src/app/desktop-controller.tsx

@@ -48,7 +48,6 @@ import {
   $sessions,
   $workingSessionIds,
   CRON_SECTION_LIMIT,
-  getRecentlySettledSessionIds,
   mergeSessionPage,
   sessionPinId,
   setAwaitingResponse,
@@ -131,18 +130,12 @@ function sameCronSignature(a: SessionInfo[], b: SessionInfo[]): boolean {
 }
 
 // Rows a session refresh must preserve even if the aggregator omits them:
-// in-flight first turns (message_count 0), pinned rows aged off the page, the
-// actively-viewed chat (its "working" flag clears a beat before the aggregator
-// sees the persisted row), and sessions whose turn just settled (same race, but
-// for a chat the user has already navigated away from). Pass `scope` to only
-// keep the active row when it belongs to the profile being paged.
+// in-flight first turns (message_count 0), pinned rows aged off the page, and
+// the actively-viewed chat (its "working" flag clears a beat before the
+// aggregator sees the persisted row). Pass `scope` to only keep the active row
+// when it belongs to the profile being paged.
 function sessionsToKeep(scope?: string): Set<string> {
-  const keep = new Set<string>([
-    ...$workingSessionIds.get(),
-    ...$pinnedSessionIds.get(),
-    ...getRecentlySettledSessionIds()
-  ])
-
+  const keep = new Set<string>([...$workingSessionIds.get(), ...$pinnedSessionIds.get()])
   const active = $selectedStoredSessionId.get()
 
   if (active) {

apps/desktop/src/app/session/hooks/use-message-stream.ts

@@ -14,7 +14,6 @@ import {
   upsertToolPart
 } from '@/lib/chat-messages'
 import { coerceGatewayText, coerceThinkingText, normalizePersonalityValue } from '@/lib/chat-runtime'
-import { gatewayEventRequiresSessionId } from '@/lib/gateway-events'
 import { triggerHaptic } from '@/lib/haptics'
 import { isProviderSetupErrorMessage } from '@/lib/provider-setup-errors'
 import { setClarifyRequest } from '@/store/clarify'
@@ -614,9 +613,6 @@ export function useMessageStream({
     (event: RpcEvent) => {
       const payload = event.payload as GatewayEventPayload | undefined
       const explicitSid = event.session_id || ''
-      if (!explicitSid && gatewayEventRequiresSessionId(event.type)) {
-        return
-      }
       const sessionId = explicitSid || activeSessionIdRef.current
       const isActiveEvent = !!sessionId && sessionId === activeSessionIdRef.current
 

apps/desktop/src/app/settings/appearance-settings.tsx

@@ -6,7 +6,6 @@ import { useI18n } from '@/i18n'
 import { triggerHaptic } from '@/lib/haptics'
 import { Check, Palette } from '@/lib/icons'
 import { cn } from '@/lib/utils'
-import { $activeGatewayProfile, $profiles, normalizeProfileKey } from '@/store/profile'
 import { $toolViewMode, setToolViewMode } from '@/store/tool-view'
 import { useTheme } from '@/themes/context'
 import { BUILTIN_THEMES } from '@/themes/presets'
@@ -58,17 +57,8 @@ export function AppearanceSettings() {
   const { t, isSavingLocale } = useI18n()
   const { themeName, mode, availableThemes, setTheme, setMode } = useTheme()
   const toolViewMode = useStore($toolViewMode)
-  const profiles = useStore($profiles)
-  const activeProfileKey = normalizeProfileKey(useStore($activeGatewayProfile))
   const a = t.settings.appearance
 
-  // Themes save per profile. Surface that only when the user actually has more
-  // than one profile (single-profile installs never see the distinction).
-  const showProfileNote = profiles.length > 1
-
-  const activeProfileName =
-    profiles.find(profile => normalizeProfileKey(profile.name) === activeProfileKey)?.name ?? activeProfileKey
-
   const modeOptions = MODE_OPTIONS.map(({ id, icon }) => ({ icon, id, label: t.settings.modeOptions[id].label }))
 
   const toolOptions = [
@@ -108,50 +98,43 @@ export function AppearanceSettings() {
 
           <ListRow
             below={
-              <>
-                <div className="mt-3 grid gap-3 sm:grid-cols-2 xl:grid-cols-3">
-                  {availableThemes.map(theme => {
-                    const active = themeName === theme.name
+              <div className="mt-3 grid gap-3 sm:grid-cols-2 xl:grid-cols-3">
+                {availableThemes.map(theme => {
+                  const active = themeName === theme.name
 
-                    return (
-                      <button
-                        className={cn(
-                          'rounded-lg border border-(--ui-stroke-tertiary) bg-(--ui-bg-quinary) p-2 text-left transition hover:bg-(--chrome-action-hover)',
-                          active && 'border-(--ui-stroke-secondary) bg-(--ui-bg-tertiary)'
-                        )}
-                        key={theme.name}
-                        onClick={() => {
-                          triggerHaptic('crisp')
-                          setTheme(theme.name)
-                        }}
-                        type="button"
-                      >
-                        <ThemePreview name={theme.name} />
-                        <div className="mt-3 flex items-start justify-between gap-3 px-1">
-                          <div className="min-w-0">
-                            <div className="truncate text-[length:var(--conversation-text-font-size)] font-medium">
-                              {theme.label}
-                            </div>
-                            <div className="mt-0.5 line-clamp-2 text-[length:var(--conversation-caption-font-size)] leading-(--conversation-caption-line-height) text-(--ui-text-tertiary)">
-                              {theme.description}
-                            </div>
+                  return (
+                    <button
+                      className={cn(
+                        'rounded-lg border border-(--ui-stroke-tertiary) bg-(--ui-bg-quinary) p-2 text-left transition hover:bg-(--chrome-action-hover)',
+                        active && 'border-(--ui-stroke-secondary) bg-(--ui-bg-tertiary)'
+                      )}
+                      key={theme.name}
+                      onClick={() => {
+                        triggerHaptic('crisp')
+                        setTheme(theme.name)
+                      }}
+                      type="button"
+                    >
+                      <ThemePreview name={theme.name} />
+                      <div className="mt-3 flex items-start justify-between gap-3 px-1">
+                        <div className="min-w-0">
+                          <div className="truncate text-[length:var(--conversation-text-font-size)] font-medium">
+                            {theme.label}
+                          </div>
+                          <div className="mt-0.5 line-clamp-2 text-[length:var(--conversation-caption-font-size)] leading-(--conversation-caption-line-height) text-(--ui-text-tertiary)">
+                            {theme.description}
                           </div>
-                          {active && (
-                            <span className="mt-0.5 grid size-5 shrink-0 place-items-center rounded-full bg-primary text-primary-foreground">
-                              <Check className="size-3.5" />
-                            </span>
-                          )}
                         </div>
-                      </button>
-                    )
-                  })}
-                </div>
-                {showProfileNote && (
-                  <p className="mt-3 text-[length:var(--conversation-caption-font-size)] leading-(--conversation-caption-line-height) text-(--ui-text-tertiary)">
-                    {a.themeProfileNote(activeProfileName)}
-                  </p>
-                )}
-              </>
+                        {active && (
+                          <span className="mt-0.5 grid size-5 shrink-0 place-items-center rounded-full bg-primary text-primary-foreground">
+                            <Check className="size-3.5" />
+                          </span>
+                        )}
+                      </div>
+                    </button>
+                  )
+                })}
+              </div>
             }
             description={a.themeDesc}
             title={a.themeTitle}

apps/desktop/src/app/shell/hooks/use-statusbar-items.tsx

@@ -27,7 +27,6 @@ import { $previewServerRestartStatus } from '@/store/preview'
 import {
   $activeSessionId,
   $busy,
-  $connection,
   $currentFastMode,
   $currentModel,
   $currentProvider,
@@ -41,14 +40,7 @@ import {
   setYoloActive
 } from '@/store/session'
 import { $subagentsBySession, activeSubagentCount } from '@/store/subagents'
-import {
-  $backendUpdateApply,
-  $backendUpdateStatus,
-  $desktopVersion,
-  $updateApply,
-  $updateStatus,
-  openUpdateOverlayFor
-} from '@/store/updates'
+import { $desktopVersion, $updateApply, $updateStatus, setUpdateOverlayOpen } from '@/store/updates'
 import type { StatusResponse } from '@/types/hermes'
 
 import { CRON_ROUTE } from '../../routes'
@@ -105,10 +97,7 @@ export function useStatusbarItems({
   const subagentsBySession = useStore($subagentsBySession)
   const updateStatus = useStore($updateStatus)
   const updateApply = useStore($updateApply)
-  const backendUpdateStatus = useStore($backendUpdateStatus)
-  const backendUpdateApply = useStore($backendUpdateApply)
   const desktopVersion = useStore($desktopVersion)
-  const connection = useStore($connection)
 
   const contextUsage = useMemo(() => usageContextLabel(currentUsage), [currentUsage])
   const contextBar = useMemo(() => contextBarLabel(currentUsage), [currentUsage])
@@ -205,19 +194,18 @@ export function useStatusbarItems({
       ? 'text-amber-600 hover:text-amber-600'
       : 'text-destructive hover:text-destructive'
 
-  const clientVersionItem = useMemo<StatusbarItem>(() => {
+  const versionItem = useMemo<StatusbarItem>(() => {
     const appVersion = desktopVersion?.appVersion
     const sha = updateStatus?.currentSha?.slice(0, 7) ?? null
     const behind = updateStatus?.behind ?? 0
     const applying = updateApply.applying || updateApply.stage === 'restart'
-    const remote = connection?.mode === 'remote'
-
-    const version = appVersion ? `v${appVersion}` : (sha ?? copy.unknown)
-    const base = remote ? copy.clientLabel(appVersion ?? sha ?? copy.unknown) : version
+    const base = appVersion ? `v${appVersion}` : (sha ?? copy.unknown)
     const behindHint = !applying && behind > 0 ? ` (+${behind})` : ''
 
     const label = applying
-      ? `${base} · ${updateApply.stage === 'restart' ? copy.restart : copy.update}`
+      ? updateApply.stage === 'restart'
+        ? `${base} · ${copy.restart}`
+        : `${base} · ${copy.update}`
       : `${base}${behindHint}`
 
     const tooltip = [
@@ -232,18 +220,17 @@ export function useStatusbarItems({
 
     return {
       className: !applying && behind > 0 ? 'text-primary hover:text-primary' : undefined,
-      detail: appVersion && sha && !applying && !remote ? sha : undefined,
+      detail: appVersion && sha && !applying ? sha : undefined,
       hidden: !appVersion && !sha,
       icon: applying ? <Loader2 className="size-3 animate-spin" /> : <Hash className="size-3" />,
-      id: 'version-client',
+      id: 'version',
       label,
-      onSelect: () => openUpdateOverlayFor('client'),
+      onSelect: () => setUpdateOverlayOpen(true),
       title: tooltip || undefined,
       variant: 'action'
     }
   }, [
     desktopVersion?.appVersion,
-    connection?.mode,
     copy,
     updateApply.applying,
     updateApply.message,
@@ -253,50 +240,6 @@ export function useStatusbarItems({
     updateStatus?.currentSha
   ])
 
-  const backendVersionItem = useMemo<StatusbarItem | null>(() => {
-    if (connection?.mode !== 'remote') {
-      return null
-    }
-
-    const backendVersion = statusSnapshot?.version
-    const behind = backendUpdateStatus?.behind ?? 0
-    const applying = backendUpdateApply.applying || backendUpdateApply.stage === 'restart'
-
-    const base = copy.backendLabel(backendVersion ?? copy.unknown)
-    const behindHint = !applying && behind > 0 ? ` (+${behind})` : ''
-
-    const label = applying
-      ? `${base} · ${backendUpdateApply.stage === 'restart' ? copy.restart : copy.update}`
-      : `${base}${behindHint}`
-
-    const tooltip = [
-      applying ? backendUpdateApply.message || copy.updateInProgress : null,
-      !applying && behind > 0 && copy.commitsBehind(behind, 'main'),
-      backendVersion && copy.backendVersion(backendVersion)
-    ]
-      .filter(Boolean)
-      .join(' · ')
-
-    return {
-      className: !applying && behind > 0 ? 'text-primary hover:text-primary' : undefined,
-      hidden: !backendVersion,
-      icon: applying ? <Loader2 className="size-3 animate-spin" /> : <Hash className="size-3" />,
-      id: 'version-backend',
-      label,
-      onSelect: () => openUpdateOverlayFor('backend'),
-      title: tooltip || undefined,
-      variant: 'action'
-    }
-  }, [
-    connection?.mode,
-    statusSnapshot?.version,
-    backendUpdateStatus?.behind,
-    backendUpdateApply.applying,
-    backendUpdateApply.message,
-    backendUpdateApply.stage,
-    copy
-  ])
-
   const coreLeftStatusbarItems = useMemo<readonly StatusbarItem[]>(
     () => [
       {
@@ -442,8 +385,7 @@ export function useStatusbarItems({
               variant: 'action' as const
             })
       },
-      clientVersionItem,
-      ...(backendVersionItem ? [backendVersionItem] : [])
+      versionItem
     ],
     [
       busy,
@@ -459,8 +401,7 @@ export function useStatusbarItems({
       showYoloToggle,
       toggleYolo,
       turnStartedAt,
-      clientVersionItem,
-      backendVersionItem,
+      versionItem,
       yoloActive
     ]
   )

apps/desktop/src/app/updates-overlay.tsx

@@ -12,19 +12,12 @@ import { useI18n } from '@/i18n'
 import { buildCommitChangelog, type CommitGroup } from '@/lib/commit-changelog'
 import { AlertCircle, Check, CheckCircle2, Copy, Terminal } from '@/lib/icons'
 import { cn } from '@/lib/utils'
-import { resolveUpdateCopy, type UpdateTarget } from '@/lib/update-copy'
 import {
-  $backendUpdateApply,
-  $backendUpdateChecking,
-  $backendUpdateStatus,
   $updateApply,
   $updateChecking,
   $updateOverlayOpen,
-  $updateOverlayTarget,
   $updateStatus,
-  applyBackendUpdate,
   applyUpdates,
-  checkBackendUpdates,
   checkUpdates,
   resetUpdateApplyState,
   setUpdateOverlayOpen,
@@ -37,27 +30,15 @@ function totalItems(groups: readonly CommitGroup[]) {
 
 export function UpdatesOverlay() {
   const open = useStore($updateOverlayOpen)
-  const target = useStore($updateOverlayTarget)
-
-  const clientStatus = useStore($updateStatus)
-  const clientChecking = useStore($updateChecking)
-  const clientApply = useStore($updateApply)
-  const backendStatus = useStore($backendUpdateStatus)
-  const backendChecking = useStore($backendUpdateChecking)
-  const backendApply = useStore($backendUpdateApply)
-
-  const isBackend = target === 'backend'
-  const status = isBackend ? backendStatus : clientStatus
-  const checking = isBackend ? backendChecking : clientChecking
-  const apply = isBackend ? backendApply : clientApply
-  const check = isBackend ? checkBackendUpdates : checkUpdates
-  const install = isBackend ? applyBackendUpdate : applyUpdates
+  const status = useStore($updateStatus)
+  const checking = useStore($updateChecking)
+  const apply = useStore($updateApply)
 
   useEffect(() => {
     if (open && !status && !checking) {
-      void check()
+      void checkUpdates()
     }
-  }, [check, checking, open, status])
+  }, [checking, open, status])
 
   const behind = status?.behind ?? 0
 
@@ -83,7 +64,7 @@ export function UpdatesOverlay() {
   }
 
   const handleInstall = () => {
-    void install()
+    void applyUpdates()
   }
 
   return (
@@ -92,7 +73,7 @@ export function UpdatesOverlay() {
         className="max-w-sm overflow-hidden border-border/70 p-0 gap-0"
         showCloseButton={phase !== 'applying'}
       >
-        {phase === 'applying' && <ApplyingView apply={apply} isBackend={isBackend} />}
+        {phase === 'applying' && <ApplyingView apply={apply} />}
 
         {phase === 'manual' && (
           <ManualView command={apply.command ?? 'hermes update'} onDone={() => handleClose(false)} />
@@ -109,9 +90,8 @@ export function UpdatesOverlay() {
             commits={status?.commits ?? []}
             onInstall={handleInstall}
             onLater={() => handleClose(false)}
-            onRetryCheck={() => void check()}
+            onRetryCheck={() => void checkUpdates()}
             status={status}
-            target={target}
           />
         )}
       </DialogContent>
@@ -126,8 +106,7 @@ function IdleView({
   onInstall,
   onLater,
   onRetryCheck,
-  status,
-  target
+  status
 }: {
   behind: number
   checking: boolean
@@ -136,7 +115,6 @@ function IdleView({
   onLater: () => void
   onRetryCheck: () => void
   status: DesktopUpdateStatus | null
-  target: UpdateTarget
 }) {
   const { t } = useI18n()
   const u = t.updates
@@ -189,7 +167,7 @@ function IdleView({
   if (behind === 0) {
     return (
       <CenteredStatus
-        body={target === 'backend' ? u.latestBodyBackend : u.latestBody}
+        body={u.latestBody}
         icon={<CheckCircle2 className="size-7 text-emerald-600 dark:text-emerald-400" />}
         title={u.allSetTitle}
       />
@@ -200,20 +178,14 @@ function IdleView({
   const shownItems = totalItems(groups)
   const remaining = Math.max(0, behind - shownItems)
 
-  // Name what's being updated. In remote mode the overlay acts on the connected
-  // backend, not the local client — say so. When there are no commit rows to
-  // show (e.g. pip/non-git backend), degrade to honest "no release notes" copy
-  // instead of generic filler.
-  const { title, body } = resolveUpdateCopy({ target, shownItems, copy: u })
-
   return (
     <div className="grid gap-5 px-6 pb-6 pt-7 pr-8">
       <div className="flex flex-col items-center gap-3 text-center">
         <BrandMark className="size-16" />
 
-        <DialogTitle className="text-center text-xl">{title}</DialogTitle>
+        <DialogTitle className="text-center text-xl">{u.availableTitle}</DialogTitle>
         <DialogDescription className="text-center text-sm">
-          {body}
+          {u.availableBody}
         </DialogDescription>
       </div>
 
@@ -309,11 +281,10 @@ function ManualView({ command, onDone }: { command: string; onDone: () => void }
   )
 }
 
-function ApplyingView({ apply, isBackend }: { apply: UpdateApplyState; isBackend: boolean }) {
+function ApplyingView({ apply }: { apply: UpdateApplyState }) {
   const { t } = useI18n()
   const u = t.updates
   const label = u.stages[apply.stage as DesktopUpdateStage] ?? u.stages.idle
-  const body = isBackend ? u.applyingBodyBackend : u.applyingBody
 
   const percent =
     typeof apply.percent === 'number' && Number.isFinite(apply.percent)
@@ -327,7 +298,7 @@ function ApplyingView({ apply, isBackend }: { apply: UpdateApplyState; isBackend
 
         <DialogTitle className="text-center text-xl">{label}</DialogTitle>
         <DialogDescription className="text-center text-sm">
-          {body}
+          {u.applyingBody}
         </DialogDescription>
       </div>
 

apps/desktop/src/hermes.ts

@@ -7,7 +7,6 @@ import type {
   AudioSpeakResponse,
   AudioTranscriptionResponse,
   AuxiliaryModelsResponse,
-  BackendUpdateCheckResponse,
   ConfigSchemaResponse,
   CronJob,
   CronJobCreatePayload,
@@ -54,7 +53,6 @@ export type {
   AnalyticsSkillEntry,
   AnalyticsSkillsSummary,
   AnalyticsTotals,
-  BackendUpdateCheckResponse,
   AudioSpeakResponse,
   AudioTranscriptionResponse,
   AuxiliaryModelsResponse,
@@ -688,15 +686,6 @@ export function updateHermes(): Promise<ActionResponse> {
   })
 }
 
-/** Query the connected backend's own update state. In remote mode this is the
- *  authoritative source for the backend's behind-count + "what's changed",
- *  distinct from the Electron client clone's git state. */
-export function checkHermesUpdate(force = false): Promise<BackendUpdateCheckResponse> {
-  return window.hermesDesktop.api<BackendUpdateCheckResponse>({
-    path: `/api/hermes/update/check${force ? '?force=true' : ''}`
-  })
-}
-
 export function getActionStatus(name: string, lines = 200): Promise<ActionStatusResponse> {
   return window.hermesDesktop.api<ActionStatusResponse>({
     path: `/api/actions/${encodeURIComponent(name)}/status?lines=${Math.max(1, lines)}`

apps/desktop/src/i18n/en.ts

@@ -292,8 +292,7 @@ export const en: Translations = {
       technical: 'Technical',
       technicalDesc: 'Include raw tool args/results and low-level details.',
       themeTitle: 'Theme',
-      themeDesc: 'Desktop palettes only. The selected mode is applied on top.',
-      themeProfileNote: profile => `Saved for the ${profile} profile — each profile keeps its own theme.`
+      themeDesc: 'Desktop palettes only. The selected mode is applied on top.'
     },
     fieldLabels: FIELD_LABELS,
     fieldDescriptions: FIELD_DESCRIPTIONS,
@@ -1238,13 +1237,9 @@ export const en: Translations = {
     unsupportedMessage: 'This version of Hermes can’t update itself from inside the app.',
     connectionRetry: 'Check your connection and try again.',
     latestBody: 'You’re running the latest version.',
-    latestBodyBackend: 'The backend is running the latest version.',
     allSetTitle: 'You’re all set',
     availableTitle: 'New update available',
     availableBody: 'A new version of Hermes is ready to install.',
-    availableTitleBackend: 'Backend update available',
-    availableBodyBackend: 'A newer version of the connected Hermes backend is ready to install.',
-    availableBodyNoChangelog: 'A newer version is ready. Release notes aren’t available for this install type.',
     updateNow: 'Update now',
     maybeLater: 'Maybe later',
     moreChanges: count => `+ ${count} more change${count === 1 ? '' : 's'} included.`,
@@ -1255,19 +1250,10 @@ export const en: Translations = {
     copied: 'Copied',
     done: 'Done',
     applyingBody: 'The Hermes updater will take over in its own window and reopen Hermes when it’s done.',
-    applyingBodyBackend: 'The remote backend is applying the update and will restart. Hermes reconnects automatically when it’s back.',
     applyingClose: 'Hermes will close to apply the update.',
     errorTitle: 'Update didn’t finish',
     errorBody: 'No worries — nothing was lost. You can try again now.',
-    notNow: 'Not now',
-    applyStatus: {
-      preparing: 'Updating backend…',
-      pulling: 'Backend updating…',
-      restarting: 'Backend restarting to load the update…',
-      notAvailable: 'Update not available for this backend.',
-      failed: 'Backend update failed.',
-      noReturn: 'Backend didn’t come back online. The update may not have completed — check the backend host.'
-    }
+    notNow: 'Not now'
   },
 
   install: {
@@ -1453,9 +1439,6 @@ export const en: Translations = {
       updateInProgress: 'Update in progress',
       commitsBehind: (count, branch) => `${count} commit${count === 1 ? '' : 's'} behind ${branch}`,
       desktopVersion: version => `Hermes Desktop v${version}`,
-      backendVersion: version => `Backend v${version}`,
-      clientLabel: version => `client v${version}`,
-      backendLabel: version => `backend v${version}`,
       commit: sha => `commit ${sha}`,
       branch: branch => `branch ${branch}`,
       closeCommandCenter: 'Close Command Center',

apps/desktop/src/i18n/ja.ts

@@ -215,8 +215,7 @@ export const ja = defineLocale({
       technical: 'テクニカル',
       technicalDesc: '生のツール引数、結果、低レベルの詳細を含めます。',
       themeTitle: 'テーマ',
-      themeDesc: 'デスクトップ専用のパレットです。選択したモードの上に適用されます。',
-      themeProfileNote: profile => `「${profile}」プロファイルに保存されます。プロファイルごとに個別のテーマを保持します。`
+      themeDesc: 'デスクトップ専用のパレットです。選択したモードの上に適用されます。'
     },
     fieldLabels: defineFieldCopy({
       model: 'デフォルトモデル',
@@ -1379,13 +1378,9 @@ export const ja = defineLocale({
     unsupportedMessage: 'このバージョンの Hermes はアプリ内から自分を更新できません。',
     connectionRetry: '接続を確認してもう一度試してください。',
     latestBody: '最新バージョンを実行しています。',
-    latestBodyBackend: 'バックエンドは最新バージョンを実行しています。',
     allSetTitle: '準備完了',
     availableTitle: '新しい更新が利用可能',
     availableBody: '新しいバージョンの Hermes をインストールする準備ができています。',
-    availableTitleBackend: 'バックエンドの更新があります',
-    availableBodyBackend: '接続中の Hermes バックエンドの新しいバージョンをインストールできます。',
-    availableBodyNoChangelog: '新しいバージョンを利用できます。このインストール形式ではリリースノートは表示できません。',
     updateNow: '今すぐ更新',
     maybeLater: '後で',
     moreChanges: count => `さらに ${count} 件の変更が含まれています。`,
@@ -1397,19 +1392,10 @@ export const ja = defineLocale({
     copied: 'コピーしました',
     done: '完了',
     applyingBody: 'Hermes アップデーターが独自のウィンドウで引き継ぎ、完了後に Hermes を再度開きます。',
-    applyingBodyBackend: 'リモートバックエンドが更新を適用して再起動します。復帰すると Hermes が自動的に再接続します。',
     applyingClose: 'Hermes は更新を適用するために閉じます。',
     errorTitle: '更新が完了しませんでした',
     errorBody: 'ご安心ください。何も失われていません。今すぐ再試行できます。',
-    notNow: '今は後で',
-    applyStatus: {
-      preparing: 'バックエンドを更新しています…',
-      pulling: 'バックエンドを更新中…',
-      restarting: 'バックエンドが更新を読み込むため再起動しています…',
-      notAvailable: 'このバックエンドでは更新を利用できません。',
-      failed: 'バックエンドの更新に失敗しました。',
-      noReturn: 'バックエンドがオンラインに戻りませんでした。更新が完了していない可能性があります。バックエンドホストを確認してください。'
-    }
+    notNow: '今は後で'
   },
 
   install: {
@@ -1596,9 +1582,6 @@ export const ja = defineLocale({
       updateInProgress: '更新中',
       commitsBehind: (count, branch) => `${branch} より ${count} コミット遅れています`,
       desktopVersion: version => `Hermes Desktop v${version}`,
-      backendVersion: version => `バックエンド v${version}`,
-      clientLabel: version => `クライアント v${version}`,
-      backendLabel: version => `バックエンド v${version}`,
       commit: sha => `コミット ${sha}`,
       branch: branch => `ブランチ ${branch}`,
       closeCommandCenter: 'コマンドセンターを閉じる',

apps/desktop/src/i18n/types.ts

@@ -219,7 +219,6 @@ export interface Translations {
       technicalDesc: string
       themeTitle: string
       themeDesc: string
-      themeProfileNote: (profile: string) => string
     }
     fieldLabels: Record<string, string>
     fieldDescriptions: Record<string, string>
@@ -938,13 +937,9 @@ export interface Translations {
     unsupportedMessage: string
     connectionRetry: string
     latestBody: string
-    latestBodyBackend: string
     allSetTitle: string
     availableTitle: string
     availableBody: string
-    availableTitleBackend: string
-    availableBodyBackend: string
-    availableBodyNoChangelog: string
     updateNow: string
     maybeLater: string
     moreChanges: (count: number) => string
@@ -955,19 +950,10 @@ export interface Translations {
     copied: string
     done: string
     applyingBody: string
-    applyingBodyBackend: string
     applyingClose: string
     errorTitle: string
     errorBody: string
     notNow: string
-    applyStatus: {
-      preparing: string
-      pulling: string
-      restarting: string
-      notAvailable: string
-      failed: string
-      noReturn: string
-    }
   }
 
   install: {
@@ -1125,9 +1111,6 @@ export interface Translations {
       updateInProgress: string
       commitsBehind: (count: number, branch: string) => string
       desktopVersion: (version: string) => string
-      backendVersion: (version: string) => string
-      clientLabel: (version: string) => string
-      backendLabel: (version: string) => string
       commit: (sha: string) => string
       branch: (branch: string) => string
       closeCommandCenter: string

apps/desktop/src/i18n/zh-hant.ts

@@ -209,8 +209,7 @@ export const zhHant = defineLocale({
       technical: '技術',
       technicalDesc: '包含原始工具參數、結果與底層細節。',
       themeTitle: '主題',
-      themeDesc: '僅限桌面端的調色盤。所選模式會套用在其上。',
-      themeProfileNote: profile => `已為「${profile}」設定檔儲存——每個設定檔保留各自的主題。`
+      themeDesc: '僅限桌面端的調色盤。所選模式會套用在其上。'
     },
     fieldLabels: defineFieldCopy({
       model: '預設模型',
@@ -1345,13 +1344,9 @@ export const zhHant = defineLocale({
     unsupportedMessage: '此版本的 Hermes 無法在應用程式內自行更新。',
     connectionRetry: '請檢查網路連線後重試。',
     latestBody: '您正在執行最新版本。',
-    latestBodyBackend: '後端正在執行最新版本。',
     allSetTitle: '已是最新版本',
     availableTitle: '有可用更新',
     availableBody: '新版 Hermes 已可安裝。',
-    availableTitleBackend: '後端有可用更新',
-    availableBodyBackend: '已連接的 Hermes 後端有新版本可安裝。',
-    availableBodyNoChangelog: '已有新版本可用。此安裝方式無法顯示更新日誌。',
     updateNow: '立即更新',
     maybeLater: '稍後再說',
     moreChanges: count => `另有 ${count} 項變更。`,
@@ -1362,19 +1357,10 @@ export const zhHant = defineLocale({
     copied: '已複製',
     done: '完成',
     applyingBody: 'Hermes 更新程式會在自己的視窗中接管，並在完成後重新開啟 Hermes。',
-    applyingBodyBackend: '遠端後端正在套用更新並將重新啟動。恢復後 Hermes 會自動重新連線。',
     applyingClose: 'Hermes 將關閉以套用更新。',
     errorTitle: '更新未完成',
     errorBody: '沒有資料遺失。您可以現在重試。',
-    notNow: '暫不',
-    applyStatus: {
-      preparing: '正在更新後端…',
-      pulling: '後端更新中…',
-      restarting: '後端正在重新啟動以載入更新…',
-      notAvailable: '此後端無法更新。',
-      failed: '後端更新失敗。',
-      noReturn: '後端未恢復連線。更新可能未完成——請檢查後端主機。'
-    }
+    notNow: '暫不'
   },
 
   install: {
@@ -1557,9 +1543,6 @@ export const zhHant = defineLocale({
       updateInProgress: '更新中',
       commitsBehind: (count, branch) => `落後 ${branch} ${count} 個提交`,
       desktopVersion: version => `Hermes Desktop v${version}`,
-      backendVersion: version => `後端 v${version}`,
-      clientLabel: version => `用戶端 v${version}`,
-      backendLabel: version => `後端 v${version}`,
       commit: sha => `提交 ${sha}`,
       branch: branch => `分支 ${branch}`,
       closeCommandCenter: '關閉命令中心',

apps/desktop/src/i18n/zh.ts

@@ -287,8 +287,7 @@ export const zh: Translations = {
       technical: '技术',
       technicalDesc: '包含原始工具参数/结果及底层细节。',
       themeTitle: '主题',
-      themeDesc: '仅桌面端调色板。所选模式叠加其上。',
-      themeProfileNote: profile => `已为「${profile}」配置文件保存——每个配置文件保留各自的主题。`
+      themeDesc: '仅桌面端调色板。所选模式叠加其上。'
     },
     fieldLabels: defineFieldCopy({
       model: '默认模型',
@@ -1425,13 +1424,9 @@ export const zh: Translations = {
     unsupportedMessage: '此版本的 Hermes 无法在应用内自行更新。',
     connectionRetry: '请检查网络连接后重试。',
     latestBody: '你正在运行最新版本。',
-    latestBodyBackend: '后端正在运行最新版本。',
     allSetTitle: '已是最新',
     availableTitle: '有可用更新',
     availableBody: '新版 Hermes 已可安装。',
-    availableTitleBackend: '后端有可用更新',
-    availableBodyBackend: '已连接的 Hermes 后端有新版本可安装。',
-    availableBodyNoChangelog: '已有新版本可用。此安装方式无法显示更新日志。',
     updateNow: '立即更新',
     maybeLater: '稍后再说',
     moreChanges: count => `另有 ${count} 项更改。`,
@@ -1442,19 +1437,10 @@ export const zh: Translations = {
     copied: '已复制',
     done: '完成',
     applyingBody: 'Hermes 更新器会在自己的窗口中接管，并在完成后重新打开 Hermes。',
-    applyingBodyBackend: '远程后端正在应用更新并将重启。恢复后 Hermes 会自动重新连接。',
     applyingClose: 'Hermes 将关闭以应用更新。',
     errorTitle: '更新未完成',
     errorBody: '没有数据丢失。你可以现在重试。',
-    notNow: '暂不',
-    applyStatus: {
-      preparing: '正在更新后端…',
-      pulling: '后端更新中…',
-      restarting: '后端正在重启以加载更新…',
-      notAvailable: '此后端无法更新。',
-      failed: '后端更新失败。',
-      noReturn: '后端未恢复在线。更新可能未完成——请检查后端主机。'
-    }
+    notNow: '暂不'
   },
 
   install: {
@@ -1634,9 +1620,6 @@ export const zh: Translations = {
       updateInProgress: '正在更新',
       commitsBehind: (count, branch) => `落后 ${branch} ${count} 个提交`,
       desktopVersion: version => `Hermes Desktop v${version}`,
-      backendVersion: version => `后端 v${version}`,
-      clientLabel: version => `客户端 v${version}`,
-      backendLabel: version => `后端 v${version}`,
       commit: sha => `提交 ${sha}`,
       branch: branch => `分支 ${branch}`,
       closeCommandCenter: '关闭命令中心',

apps/desktop/src/lib/gateway-events.test.ts

@@ -1,27 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { gatewayEventRequiresSessionId } from './gateway-events'
-
-describe('gateway event routing', () => {
-  it('drops only unscoped subagent events (genuinely background work)', () => {
-    expect(gatewayEventRequiresSessionId('subagent.progress')).toBe(true)
-    expect(gatewayEventRequiresSessionId('subagent.start')).toBe(true)
-  })
-
-  it('attributes unscoped foreground turn events to the active chat', () => {
-    // These must NOT be dropped when unscoped — they are the focused turn's own
-    // output, and dropping them loses the live response until a refetch (#42178).
-    expect(gatewayEventRequiresSessionId('message.delta')).toBe(false)
-    expect(gatewayEventRequiresSessionId('message.complete')).toBe(false)
-    expect(gatewayEventRequiresSessionId('reasoning.delta')).toBe(false)
-    expect(gatewayEventRequiresSessionId('tool.start')).toBe(false)
-    expect(gatewayEventRequiresSessionId('approval.request')).toBe(false)
-  })
-
-  it('allows global events to remain unscoped', () => {
-    expect(gatewayEventRequiresSessionId('gateway.ready')).toBe(false)
-    expect(gatewayEventRequiresSessionId('preview.restart.progress')).toBe(false)
-    expect(gatewayEventRequiresSessionId('session.info')).toBe(false)
-    expect(gatewayEventRequiresSessionId(undefined)).toBe(false)
-  })
-})

apps/desktop/src/lib/gateway-events.ts

@@ -11,22 +11,6 @@ function asRecord(payload: unknown): Record<string, unknown> {
   return payload && typeof payload === 'object' ? (payload as Record<string, unknown>) : {}
 }
 
-/**
- * Whether an unscoped event (no `session_id`) must be dropped rather than
- * attributed to the focused chat.
- *
- * Only `subagent.*` qualifies: it describes background/async work that must
- * never attach to whichever chat happens to be focused. Every other scoped
- * event — message/reasoning/thinking/tool/status/prompt — is, when unscoped,
- * the active turn's own output. The gateway always stamps a *background*
- * session's events with that session's id, so a missing id can only mean "the
- * focused turn". #42178 dropped those too, which silently swallowed the live
- * answer; it then reappeared only after a transcript refetch (manual refresh).
- */
-export function gatewayEventRequiresSessionId(eventType: string | undefined): boolean {
-  return eventType?.startsWith('subagent.') ?? false
-}
-
 export function gatewayEventCompletedFileDiff(event: RpcEventLike): boolean {
   if (event.type !== 'tool.complete') {
     return false

apps/desktop/src/lib/update-copy.test.ts

@@ -1,38 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { resolveUpdateCopy } from './update-copy'
-
-const copy = {
-  availableTitle: 'New update available',
-  availableBody: 'A new version of Hermes is ready to install.',
-  availableTitleBackend: 'Backend update available',
-  availableBodyBackend: 'A newer version of the connected Hermes backend is ready to install.',
-  availableBodyNoChangelog: 'A newer version is ready. Release notes aren’t available for this install type.'
-}
-
-describe('resolveUpdateCopy', () => {
-  it('client target with commits: client title + client body', () => {
-    const r = resolveUpdateCopy({ target: 'client', shownItems: 5, copy })
-    expect(r.title).toBe('New update available')
-    expect(r.body).toBe('A new version of Hermes is ready to install.')
-  })
-
-  it('backend target with commits: names the backend in title and body', () => {
-    const r = resolveUpdateCopy({ target: 'backend', shownItems: 5, copy })
-    expect(r.title).toBe('Backend update available')
-    expect(r.body).toContain('backend')
-  })
-
-  it('no changelog (pip/non-git backend): degrades honestly, still names backend target in title', () => {
-    const r = resolveUpdateCopy({ target: 'backend', shownItems: 0, copy })
-    expect(r.title).toBe('Backend update available')
-    // Body must NOT pretend there are notes — it states they're unavailable.
-    expect(r.body).toBe(copy.availableBodyNoChangelog)
-  })
-
-  it('no changelog on client: same honest degrade', () => {
-    const r = resolveUpdateCopy({ target: 'client', shownItems: 0, copy })
-    expect(r.title).toBe('New update available')
-    expect(r.body).toBe(copy.availableBodyNoChangelog)
-  })
-})

apps/desktop/src/lib/update-copy.ts

@@ -1,44 +0,0 @@
-/**
- * Pure copy-selection for the updates overlay's "available" state.
- *
- * Names the update target (client vs the connected backend in remote mode) and
- * degrades honestly when there's no commit changelog to show (e.g. a pip /
- * non-git backend where `git log` yields nothing) instead of generic filler.
- *
- * Extracted from updates-overlay.tsx so the wording logic is unit-testable.
- */
-
-export type UpdateTarget = 'client' | 'backend'
-
-export interface UpdateCopyStrings {
-  availableTitle: string
-  availableBody: string
-  availableTitleBackend: string
-  availableBodyBackend: string
-  availableBodyNoChangelog: string
-}
-
-export interface ResolveUpdateCopyInput {
-  target: UpdateTarget
-  /** Number of commit rows actually shown in the changelog. 0 → no notes. */
-  shownItems: number
-  copy: UpdateCopyStrings
-}
-
-export interface UpdateCopyResult {
-  title: string
-  body: string
-}
-
-export function resolveUpdateCopy({ target, shownItems, copy }: ResolveUpdateCopyInput): UpdateCopyResult {
-  const title = target === 'backend' ? copy.availableTitleBackend : copy.availableTitle
-
-  const body =
-    shownItems === 0
-      ? copy.availableBodyNoChangelog
-      : target === 'backend'
-        ? copy.availableBodyBackend
-        : copy.availableBody
-
-  return { title, body }
-}

apps/desktop/src/store/session.test.ts

@@ -1,16 +1,8 @@
-import { afterEach, describe, expect, it, vi } from 'vitest'
+import { describe, expect, it } from 'vitest'
 
 import type { SessionInfo } from '@/types/hermes'
 
-import {
-  $attentionSessionIds,
-  $workingSessionIds,
-  getRecentlySettledSessionIds,
-  mergeSessionPage,
-  sessionPinId,
-  setSessionAttention,
-  setSessionWorking
-} from './session'
+import { $attentionSessionIds, mergeSessionPage, sessionPinId, setSessionAttention } from './session'
 
 const session = (over: Partial<SessionInfo>): SessionInfo => ({
   archived: false,
@@ -137,61 +129,3 @@ describe('mergeSessionPage', () => {
     expect(merged.map(s => s.id)).toEqual(['tip', 'other'])
   })
 })
-
-describe('getRecentlySettledSessionIds', () => {
-  afterEach(() => {
-    vi.useRealTimers()
-    $workingSessionIds.set([])
-
-    // Drain anything left in the grace map so tests stay isolated.
-    for (const id of getRecentlySettledSessionIds(Number.MAX_SAFE_INTEGER)) {
-      void id
-    }
-  })
-
-  it('keeps a session for the grace window after its turn settles, then drops it', () => {
-    vi.useFakeTimers()
-    vi.setSystemTime(0)
-    $workingSessionIds.set([])
-
-    // A turn starts then ends: the working→idle transition grants grace.
-    setSessionWorking('s1', true)
-    setSessionWorking('s1', false)
-    expect(getRecentlySettledSessionIds()).toEqual(['s1'])
-
-    // Still inside the window.
-    vi.setSystemTime(29_000)
-    expect(getRecentlySettledSessionIds()).toEqual(['s1'])
-
-    // Past the window: the entry is pruned on read.
-    vi.setSystemTime(31_000)
-    expect(getRecentlySettledSessionIds()).toEqual([])
-  })
-
-  it('does not grant grace when the session was never working (idle re-asserts)', () => {
-    vi.useFakeTimers()
-    vi.setSystemTime(0)
-    $workingSessionIds.set([])
-
-    // updateSessionState re-asserts `false` for idle sessions on every tick;
-    // these must not pin an idle chat into the keep-set indefinitely.
-    setSessionWorking('idle', false)
-    setSessionWorking('idle', false)
-    expect(getRecentlySettledSessionIds()).toEqual([])
-  })
-
-  it('clears the grace timer when the session goes busy again', () => {
-    vi.useFakeTimers()
-    vi.setSystemTime(0)
-    $workingSessionIds.set([])
-
-    setSessionWorking('s2', true)
-    setSessionWorking('s2', false)
-    expect(getRecentlySettledSessionIds()).toEqual(['s2'])
-
-    // A new turn for the same session is "working" again — drop it from the
-    // settled set so it's tracked as working, not recently-finished.
-    setSessionWorking('s2', true)
-    expect(getRecentlySettledSessionIds()).toEqual([])
-  })
-})

apps/desktop/src/store/session.ts

@@ -202,47 +202,6 @@ function clearSessionWatchdog(sessionId: string) {
   }
 }
 
-// A session's "working" flag clears the instant its turn ends, but the
-// cross-profile aggregator (listSessions with min_messages=1) only sees the
-// just-persisted first turn a beat later. The active chat is shielded from that
-// race by sessionsToKeep(), but a brand-new session that finished *while you
-// were viewing a different chat* is, at the next refresh, neither working,
-// pinned, nor active — so mergeSessionPage() evicts it. Nothing re-fetches
-// afterward, so it stays gone until the app restarts. (Repro: start a new chat,
-// then click another session before the first reply lands.)
-//
-// To bridge that window we keep a session in the merge keep-set for a short
-// grace period after its turn settles, giving the aggregator time to catch up.
-// Entries auto-expire, so this never accumulates and can't resurrect a deleted
-// session (mergeSessionPage only revives rows still present in the in-memory
-// list, which optimistic delete/archive already drops).
-const SESSION_SETTLE_GRACE_MS = 30 * 1000
-const settledSessionExpiry = new Map<string, number>()
-
-function markSessionSettled(sessionId: string) {
-  settledSessionExpiry.set(sessionId, Date.now() + SESSION_SETTLE_GRACE_MS)
-}
-
-function clearSessionSettled(sessionId: string) {
-  settledSessionExpiry.delete(sessionId)
-}
-
-/** Stored ids of sessions whose turn ended within the grace window. Prunes
- *  expired entries as it reads, so it stays bounded without a timer. */
-export function getRecentlySettledSessionIds(now: number = Date.now()): string[] {
-  const live: string[] = []
-
-  for (const [id, expiry] of settledSessionExpiry) {
-    if (expiry > now) {
-      live.push(id)
-    } else {
-      settledSessionExpiry.delete(id)
-    }
-  }
-
-  return live
-}
-
 /** Call when a streaming event for a session lands. Refreshes the watchdog
  *  so the session keeps its "working" status as long as data keeps coming. */
 export function noteSessionActivity(sessionId: string | null | undefined) {
@@ -284,24 +243,13 @@ export function setSessionWorking(sessionId: string | null | undefined, working:
     return
   }
 
-  const wasWorking = $workingSessionIds.get().includes(sessionId)
-
   toggleMembership(setWorkingSessionIds, sessionId, working)
 
   // Bookend the watchdog: arm on enter, disarm on leave. A later
   // noteSessionActivity() from a streaming event refreshes the timer.
   if (working) {
-    clearSessionSettled(sessionId)
     armSessionWatchdog(sessionId)
   } else {
     clearSessionWatchdog(sessionId)
-
-    // Only grant grace on a real working→idle transition (updateSessionState
-    // re-asserts `false` on every state tick, which must not keep extending the
-    // window). This keeps the just-finished session visible long enough for the
-    // aggregator to return its now-persisted row.
-    if (wasWorking) {
-      markSessionSettled(sessionId)
-    }
   }
 }

apps/desktop/src/store/updates.test.ts

@@ -1,4 +1,4 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 import type { DesktopUpdateStatus } from '@/global'
 
@@ -23,18 +23,7 @@ vi.mock('@/store/notifications', () => ({
   dismissNotification: (...args: unknown[]) => dismissSpy(...args)
 }))
 
-const checkHermesUpdateSpy = vi.fn()
-const updateHermesSpy = vi.fn()
-const getActionStatusSpy = vi.fn()
-
-vi.mock('@/hermes', () => ({
-  checkHermesUpdate: (...args: unknown[]) => checkHermesUpdateSpy(...args),
-  updateHermes: (...args: unknown[]) => updateHermesSpy(...args),
-  getActionStatus: (...args: unknown[]) => getActionStatusSpy(...args)
-}))
-
-const { maybeNotifyUpdateAvailable, checkBackendUpdates, $backendUpdateStatus, applyBackendUpdate, $backendUpdateApply } = await import('./updates')
-const { setConnection } = await import('./session')
+const { maybeNotifyUpdateAvailable } = await import('./updates')
 
 const status = (over: Partial<DesktopUpdateStatus> = {}): DesktopUpdateStatus => ({
   supported: true,
@@ -86,114 +75,3 @@ describe('maybeNotifyUpdateAvailable', () => {
     expect(notifySpy).not.toHaveBeenCalled()
   })
 })
-
-describe('checkBackendUpdates', () => {
-  beforeEach(() => {
-    storage.clear()
-    notifySpy.mockClear()
-    checkHermesUpdateSpy.mockReset()
-    $backendUpdateStatus.set(null)
-    vi.useRealTimers()
-  })
-
-  const setRemote = (on: boolean) =>
-    setConnection({
-      baseUrl: 'http://box:9119',
-      isFullscreen: false,
-      mode: on ? 'remote' : 'local',
-      nativeOverlayWidth: 0,
-      token: 't',
-      wsUrl: 'ws://box:9119',
-      logs: [],
-      windowButtonPosition: null
-    })
-
-  it('maps the backend /update/check onto the backend status, including commits', async () => {
-    setRemote(true)
-    checkHermesUpdateSpy.mockResolvedValue({
-      install_method: 'git',
-      current_version: '0.16.0',
-      behind: 2,
-      update_available: true,
-      can_apply: true,
-      update_command: 'hermes update',
-      message: null,
-      commits: [{ sha: 'abc1234', summary: 'feat: x', author: 'a', at: 1 }]
-    })
-
-    const result = await checkBackendUpdates()
-
-    expect(checkHermesUpdateSpy).toHaveBeenCalled()
-    expect(result?.behind).toBe(2)
-    expect(result?.commits?.[0]?.sha).toBe('abc1234')
-    expect(result?.supported).toBe(true)
-    expect($backendUpdateStatus.get()?.commits?.[0]?.summary).toBe('feat: x')
-  })
-
-  it('honours can_apply=false (docker/nix): not supported, carries message', async () => {
-    setRemote(true)
-    checkHermesUpdateSpy.mockResolvedValue({
-      install_method: 'docker',
-      current_version: '0.16.0',
-      behind: null,
-      update_available: false,
-      can_apply: false,
-      update_command: 'docker pull ...',
-      message: 'Docker images are immutable.'
-    })
-
-    const result = await checkBackendUpdates()
-
-    expect(result?.supported).toBe(false)
-    expect(result?.message).toBe('Docker images are immutable.')
-  })
-
-  it('is a no-op in local mode (backend check only runs when remote)', async () => {
-    setRemote(false)
-    await checkBackendUpdates()
-    expect(checkHermesUpdateSpy).not.toHaveBeenCalled()
-  })
-})
-
-describe('applyBackendUpdate recovery', () => {
-  beforeEach(() => {
-    storage.clear()
-    checkHermesUpdateSpy.mockReset()
-    updateHermesSpy.mockReset()
-    getActionStatusSpy.mockReset()
-    $backendUpdateApply.set({ applying: false, stage: 'idle', message: '', percent: null, error: null, command: null, log: [] })
-    vi.useFakeTimers()
-  })
-
-  afterEach(() => {
-    vi.useRealTimers()
-  })
-
-  it('waits for the backend to return after the restart drops the connection, then clears the overlay', async () => {
-    updateHermesSpy.mockResolvedValue({ ok: true, name: 'update', pid: 1 })
-    getActionStatusSpy.mockRejectedValue(new Error('ECONNREFUSED'))
-    checkHermesUpdateSpy.mockResolvedValue({ install_method: 'git', current_version: '0.16.0', behind: 0, update_available: false, can_apply: true, update_command: 'hermes update', message: null })
-
-    const promise = applyBackendUpdate()
-    await vi.advanceTimersByTimeAsync(5000)
-    const result = await promise
-
-    expect(result.ok).toBe(true)
-    expect($backendUpdateApply.get().stage).toBe('idle')
-    expect($backendUpdateApply.get().applying).toBe(false)
-  })
-
-  it('surfaces an error when the backend never comes back after the restart', async () => {
-    updateHermesSpy.mockResolvedValue({ ok: true, name: 'update', pid: 1 })
-    getActionStatusSpy.mockRejectedValue(new Error('ECONNREFUSED'))
-    checkHermesUpdateSpy.mockRejectedValue(new Error('ECONNREFUSED'))
-
-    const promise = applyBackendUpdate()
-    await vi.advanceTimersByTimeAsync(70000)
-    const result = await promise
-
-    expect(result.ok).toBe(false)
-    expect($backendUpdateApply.get().stage).toBe('error')
-  })
-})
-

apps/desktop/src/store/updates.ts

@@ -13,12 +13,9 @@ import type {
   DesktopUpdateStatus,
   DesktopVersionInfo
 } from '@/global'
-import { checkHermesUpdate, getActionStatus, updateHermes } from '@/hermes'
 import { translateNow } from '@/i18n'
 import { persistString, storedString } from '@/lib/storage'
 import { dismissNotification, notify } from '@/store/notifications'
-import { $connection } from '@/store/session'
-import type { BackendUpdateCheckResponse } from '@/types/hermes'
 
 export interface UpdateApplyState {
   applying: boolean
@@ -48,24 +45,8 @@ export const $updateChecking = atom<boolean>(false)
 export const $updateOverlayOpen = atom<boolean>(false)
 export const $updateStatus = atom<DesktopUpdateStatus | null>(null)
 
-// Client and backend are independently updatable; each keeps its own state.
-export const $backendUpdateStatus = atom<DesktopUpdateStatus | null>(null)
-export const $backendUpdateApply = atom<UpdateApplyState>(IDLE)
-export const $backendUpdateChecking = atom<boolean>(false)
-
-export type UpdateTarget = 'client' | 'backend'
-export const $updateOverlayTarget = atom<UpdateTarget>('client')
-
 export const setUpdateOverlayOpen = (open: boolean) => $updateOverlayOpen.set(open)
-export const openUpdateOverlayFor = (target: UpdateTarget) => {
-  $updateOverlayTarget.set(target)
-  $updateOverlayOpen.set(true)
-  void (target === 'backend' ? checkBackendUpdates() : checkUpdates())
-}
-export const resetUpdateApplyState = () => {
-  $updateApply.set(IDLE)
-  $backendUpdateApply.set(IDLE)
-}
+export const resetUpdateApplyState = () => $updateApply.set(IDLE)
 
 const UPDATE_TOAST_ID = 'desktop-update-available'
 // Time-based snooze instead of per-sha dismissal: this repo lands ~100 commits
@@ -105,7 +86,7 @@ export function reportBackendContract(contract: number | undefined): void {
   }
 
   notify({
-    action: { label: translateNow('notifications.updateHermes'), onClick: () => void applyBackendUpdate() },
+    action: { label: translateNow('notifications.updateHermes'), onClick: () => void applyUpdates() },
     durationMs: 0,
     id: SKEW_TOAST_ID,
     kind: 'warning',
@@ -156,8 +137,13 @@ export function maybeNotifyUpdateAvailable(status: DesktopUpdateStatus | null) {
   })
 }
 
+/**
+ * Opens the updates dialog and kicks off a fresh check so the user always
+ * sees current state, even if a stale status is cached from earlier.
+ */
 export function openUpdatesWindow(): void {
-  openUpdateOverlayFor(isRemoteMode() ? 'backend' : 'client')
+  $updateOverlayOpen.set(true)
+  void checkUpdates()
 }
 
 /** Re-read the running app's version from the Electron main process and
@@ -188,52 +174,6 @@ export async function refreshDesktopVersion(): Promise<DesktopVersionInfo | null
   }
 }
 
-function isRemoteMode(): boolean {
-  return $connection.get()?.mode === 'remote'
-}
-
-function mapBackendCheck(res: BackendUpdateCheckResponse): DesktopUpdateStatus {
-  const behind = res.behind ?? 0
-
-  return {
-    supported: res.can_apply,
-    message: res.message ?? undefined,
-    behind: behind > 0 ? behind : 0,
-    targetSha: res.update_available ? `backend:${res.current_version}` : undefined,
-    commits: res.commits,
-    fetchedAt: Date.now()
-  }
-}
-
-export async function checkBackendUpdates(): Promise<DesktopUpdateStatus | null> {
-  if (!isRemoteMode() || $backendUpdateChecking.get()) {
-    return $backendUpdateStatus.get()
-  }
-
-  $backendUpdateChecking.set(true)
-
-  try {
-    const status = mapBackendCheck(await checkHermesUpdate(true))
-    $backendUpdateStatus.set(status)
-    maybeNotifyUpdateAvailable(status)
-
-    return status
-  } catch (error) {
-    const fallback: DesktopUpdateStatus = {
-      supported: $backendUpdateStatus.get()?.supported ?? true,
-      error: 'check-failed',
-      message: error instanceof Error ? error.message : String(error),
-      fetchedAt: Date.now()
-    }
-
-    $backendUpdateStatus.set(fallback)
-
-    return fallback
-  } finally {
-    $backendUpdateChecking.set(false)
-  }
-}
-
 export async function checkUpdates(): Promise<DesktopUpdateStatus | null> {
   const bridge = window.hermesDesktop?.updates
 
@@ -247,6 +187,9 @@ export async function checkUpdates(): Promise<DesktopUpdateStatus | null> {
     const status = await bridge.check()
     $updateStatus.set(status)
     maybeNotifyUpdateAvailable(status)
+    // The update check pulls the latest hermes_cli + bundled package metadata
+    // into place. Re-read the running version so About reflects the now-fresh
+    // checkout rather than the one captured at process start.
     void refreshDesktopVersion()
 
     return status
@@ -304,107 +247,6 @@ export async function applyUpdates(opts: DesktopUpdateApplyOptions = {}): Promis
   }
 }
 
-const BACKEND_RETURN_POLL_MS = 1500
-const BACKEND_RETURN_MAX_ATTEMPTS = 40
-
-async function waitForBackendReturn(): Promise<boolean> {
-  for (let attempt = 0; attempt < BACKEND_RETURN_MAX_ATTEMPTS; attempt += 1) {
-    await new Promise(resolve => globalThis.setTimeout(resolve, BACKEND_RETURN_POLL_MS))
-    try {
-      await checkHermesUpdate()
-
-      return true
-    } catch {
-      continue
-    }
-  }
-
-  return false
-}
-
-function finishBackendApply(returned: boolean): DesktopUpdateApplyResult {
-  if (returned) {
-    $backendUpdateApply.set(IDLE)
-    setUpdateOverlayOpen(false)
-    void checkBackendUpdates()
-
-    return { ok: true, message: 'Backend update applied.' }
-  }
-
-  $backendUpdateApply.set({
-    ...$backendUpdateApply.get(),
-    applying: false,
-    stage: 'error',
-    error: 'apply-failed',
-    message: translateNow('updates.applyStatus.noReturn')
-  })
-
-  return { ok: false, error: 'apply-failed', message: 'Backend did not come back online.' }
-}
-
-export async function applyBackendUpdate(): Promise<DesktopUpdateApplyResult> {
-  dismissNotification(UPDATE_TOAST_ID)
-  $backendUpdateApply.set({ ...IDLE, applying: true, stage: 'prepare', message: translateNow('updates.applyStatus.preparing') })
-
-  try {
-    const started = await updateHermes()
-
-    if (!started.ok) {
-      const message = (started as { message?: string }).message || translateNow('updates.applyStatus.notAvailable')
-      const command = (started as { update_command?: string }).update_command || 'hermes update'
-      $backendUpdateApply.set({ ...IDLE, applying: false, stage: 'manual', message, command })
-
-      return { ok: false, error: 'manual', manual: true, message, command }
-    }
-
-    $backendUpdateApply.set({ ...IDLE, applying: true, stage: 'pull', message: translateNow('updates.applyStatus.pulling') })
-
-    let last: Awaited<ReturnType<typeof getActionStatus>> | null = null
-    for (let attempt = 0; attempt < 30; attempt += 1) {
-      await new Promise(resolve => globalThis.setTimeout(resolve, 1500))
-      try {
-        last = await getActionStatus(started.name, 200)
-      } catch {
-        // The dashboard restarts mid-update, dropping this connection — expected, not a failure.
-        $backendUpdateApply.set({
-          ...$backendUpdateApply.get(),
-          applying: true,
-          stage: 'restart',
-          message: translateNow('updates.applyStatus.restarting')
-        })
-
-        return finishBackendApply(await waitForBackendReturn())
-      }
-
-      if (last && !last.running) {
-        break
-      }
-    }
-
-    const ok = !!last && (last.exit_code ?? 1) === 0
-    if (ok) {
-      $backendUpdateApply.set({ ...$backendUpdateApply.get(), applying: true, stage: 'restart', message: translateNow('updates.applyStatus.restarting') })
-
-      return finishBackendApply(await waitForBackendReturn())
-    }
-
-    $backendUpdateApply.set({
-      ...$backendUpdateApply.get(),
-      applying: false,
-      stage: 'error',
-      error: 'apply-failed',
-      message: translateNow('updates.applyStatus.failed')
-    })
-
-    return { ok: false, error: 'apply-failed', message: 'Backend update failed.' }
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error)
-    $backendUpdateApply.set({ ...$backendUpdateApply.get(), applying: false, stage: 'error', error: 'apply-failed', message })
-
-    return { ok: false, error: 'apply-failed', message }
-  }
-}
-
 function ingestProgress(payload: DesktopUpdateProgress): void {
   const current = $updateApply.get()
   const log = [...current.log, { stage: payload.stage, message: payload.message, at: payload.at }].slice(-50)
@@ -425,8 +267,6 @@ function ingestProgress(payload: DesktopUpdateProgress): void {
 let pollerStarted = false
 let backgroundTimer: ReturnType<typeof setInterval> | null = null
 let lastFocusAt = 0
-let connectionUnsub: (() => void) | null = null
-let lastConnectionMode: string | undefined
 
 /** Wire up background polling + progress streaming. Idempotent. */
 export function startUpdatePoller(): void {
@@ -442,28 +282,11 @@ export function startUpdatePoller(): void {
 
   pollerStarted = true
   void checkUpdates()
-  void checkBackendUpdates()
   void refreshDesktopVersion()
   bridge.onProgress(ingestProgress)
 
-  // The poller starts at mount, before the gateway connects — so the first
-  // backend check above sees mode≠remote and no-ops. Re-check once the
-  // connection resolves to remote.
-  connectionUnsub = $connection.subscribe(conn => {
-    if (conn?.mode === lastConnectionMode) {
-      return
-    }
-    lastConnectionMode = conn?.mode
-    if (conn?.mode === 'remote') {
-      void checkBackendUpdates()
-    }
-  })
-
   window.addEventListener('focus', onFocus)
-  backgroundTimer = setInterval(() => {
-    void checkUpdates()
-    void checkBackendUpdates()
-  }, 30 * 60 * 1000)
+  backgroundTimer = setInterval(() => void checkUpdates(), 30 * 60 * 1000)
 }
 
 export function stopUpdatePoller(): void {
@@ -472,9 +295,6 @@ export function stopUpdatePoller(): void {
     backgroundTimer = null
   }
 
-  connectionUnsub?.()
-  connectionUnsub = null
-  lastConnectionMode = undefined
   window.removeEventListener('focus', onFocus)
   pollerStarted = false
 }
@@ -488,6 +308,8 @@ function onFocus() {
 
   lastFocusAt = now
   void checkUpdates()
-  void checkBackendUpdates()
+  // Cheap and safe to re-read on every (throttled) focus: the user may have
+  // updated Hermes from another window/CLI between focuses, and About should
+  // catch up without forcing a restart.
   void refreshDesktopVersion()
 }

apps/desktop/src/themes/context.tsx

@@ -9,28 +9,15 @@
  * The two are persisted independently. Shift+X toggles light/dark.
  */
 
-import { useStore } from '@nanostores/react'
 import { createContext, type ReactNode, useCallback, useContext, useEffect, useMemo, useState } from 'react'
 
 import { matchesQuery, useMediaQuery } from '@/hooks/use-media-query'
-import { persistString, persistStringRecord, storedString, storedStringRecord } from '@/lib/storage'
-import { $activeGatewayProfile, normalizeProfileKey } from '@/store/profile'
 
 import { BUILTIN_THEME_LIST, BUILTIN_THEMES, DEFAULT_SKIN_NAME, DEFAULT_TYPOGRAPHY, nousTheme } from './presets'
 import type { DesktopTheme, DesktopThemeColors } from './types'
 
-// Legacy global skin (pre per-profile themes). Still the inheritance fallback
-// for any profile without its own assignment, so single-profile users and old
-// installs are unaffected.
 const SKIN_KEY = 'hermes-desktop-theme-v2'
 const MODE_KEY = 'hermes-desktop-mode-v1'
-// Per-profile skin + light/dark mode assignments: { [profileKey]: value }. A
-// profile inherits the global default until it's given its own appearance.
-const PROFILE_SKINS_KEY = 'hermes-desktop-profile-themes-v1'
-const PROFILE_MODES_KEY = 'hermes-desktop-profile-modes-v1'
-// Last active profile, recorded so the boot-time paint can pick that profile's
-// theme before the gateway reports which profile actually launched.
-const LAST_PROFILE_KEY = 'hermes-desktop-active-profile-v1'
 const RETIRED_SKINS = new Set(['nous-light', 'default', 'gold'])
 
 export type ThemeMode = 'light' | 'dark' | 'system'
@@ -40,36 +27,9 @@ const INJECTED_FONT_URLS = new Set<string>()
 const resolveMode = (mode: ThemeMode, systemDark = matchesQuery('(prefers-color-scheme: dark)')): 'light' | 'dark' =>
   mode === 'system' ? (systemDark ? 'dark' : 'light') : mode
 
-const normalizeSkin = (name: string | null): string =>
+const normalizeSkin = (name: string | null | undefined): string =>
   name && BUILTIN_THEMES[name] && !RETIRED_SKINS.has(name) ? name : DEFAULT_SKIN_NAME
 
-const normalizeMode = (value: string | null): ThemeMode =>
-  value === 'light' || value === 'dark' || value === 'system' ? value : 'light'
-
-// ─── Per-profile appearance persistence ─────────────────────────────────────
-// Skin and mode are each stored per profile. "default" isn't a real profile —
-// it *is* the legacy global slot, so it reads/writes the global directly. Named
-// profiles get their own entry and fall back to that global until assigned, so
-// unassigned profiles and pre-per-profile installs stay on the global value.
-const profilePref = <T extends string>(record: string, legacy: string, normalize: (v: string | null) => T) => ({
-  resolve: (profile: string): T => normalize(storedStringRecord(record)[profile] ?? storedString(legacy)),
-  assign: (profile: string, value: T): void => {
-    if (profile === 'default') {
-      persistString(legacy, value)
-    } else {
-      persistStringRecord(record, { ...storedStringRecord(record), [profile]: value })
-    }
-  }
-})
-
-export const skinPref = profilePref(PROFILE_SKINS_KEY, SKIN_KEY, normalizeSkin)
-export const modePref = profilePref(PROFILE_MODES_KEY, MODE_KEY, normalizeMode)
-
-// Last active profile — lets the boot paint pick its appearance before the
-// gateway reports which profile actually launched.
-const readBootProfileKey = () => normalizeProfileKey(storedString(LAST_PROFILE_KEY))
-const rememberActiveProfileKey = (profile: string) => persistString(LAST_PROFILE_KEY, profile)
-
 // ─── Color math (for synthesised light variants of dark-only skins) ────────
 
 function hexToRgb(hex: string): [number, number, number] | null {
@@ -271,13 +231,12 @@ function applyTheme(theme: DesktopTheme, mode: 'light' | 'dark') {
   }
 }
 
-// Boot-time paint to avoid a flash before <ThemeProvider> mounts. Use the last
-// active profile's appearance so a non-default profile relaunch paints its own
-// skin + light/dark mode.
+// Boot-time paint to avoid a flash before <ThemeProvider> mounts.
 if (typeof window !== 'undefined') {
-  const profile = readBootProfileKey()
-  const resolved = resolveMode(modePref.resolve(profile))
-  applyTheme(deriveTheme(skinPref.resolve(profile), resolved), resolved)
+  const skin = normalizeSkin(window.localStorage.getItem(SKIN_KEY))
+  const mode = (window.localStorage.getItem(MODE_KEY) as ThemeMode) ?? 'light'
+  const resolved = resolveMode(mode)
+  applyTheme(deriveTheme(skin, resolved), resolved)
 }
 
 // ─── Context ────────────────────────────────────────────────────────────────
@@ -305,46 +264,29 @@ const ThemeContext = createContext<ThemeContextValue>({
 })
 
 export function ThemeProvider({ children }: { children: ReactNode }) {
-  // Skin + mode are assigned per profile; the active profile drives which
-  // appearance shows. Single-profile users only ever see "default", so their
-  // behavior is unchanged.
-  const profileKey = normalizeProfileKey(useStore($activeGatewayProfile))
-
   const [themeName, setThemeNameState] = useState(() =>
-    typeof window === 'undefined' ? DEFAULT_SKIN_NAME : skinPref.resolve(readBootProfileKey())
+    typeof window === 'undefined' ? DEFAULT_SKIN_NAME : normalizeSkin(window.localStorage.getItem(SKIN_KEY))
   )
 
   const [mode, setModeState] = useState<ThemeMode>(() =>
-    typeof window === 'undefined' ? 'light' : modePref.resolve(readBootProfileKey())
+    typeof window === 'undefined' ? 'light' : ((window.localStorage.getItem(MODE_KEY) as ThemeMode) ?? 'light')
   )
 
-  // Follow profile switches: paint the profile's assigned skin + mode and
-  // remember it for the next boot's first paint.
-  useEffect(() => {
-    rememberActiveProfileKey(profileKey)
-    setThemeNameState(skinPref.resolve(profileKey))
-    setModeState(modePref.resolve(profileKey))
-  }, [profileKey])
-
   const systemDark = useMediaQuery('(prefers-color-scheme: dark)')
   const resolvedMode = resolveMode(mode, systemDark)
   const activeTheme = useMemo(() => deriveTheme(themeName, resolvedMode), [themeName, resolvedMode])
 
   useEffect(() => applyTheme(activeTheme, resolvedMode), [activeTheme, resolvedMode])
 
-  // Assign to whichever profile is live right now (read fresh so the callbacks
-  // stay stable across profile switches).
-  const liveProfile = () => normalizeProfileKey($activeGatewayProfile.get())
-
   const setTheme = useCallback((name: string) => {
     const next = normalizeSkin(name)
     setThemeNameState(next)
-    skinPref.assign(liveProfile(), next)
+    window.localStorage.setItem(SKIN_KEY, next)
   }, [])
 
   const setMode = useCallback((next: ThemeMode) => {
     setModeState(next)
-    modePref.assign(liveProfile(), next)
+    window.localStorage.setItem(MODE_KEY, next)
   }, [])
 
   // The light/dark toggle (Shift+X by default) is owned by the keybind runtime

apps/desktop/src/themes/profile-theme.test.ts

@@ -1,41 +0,0 @@
-import { beforeEach, describe, expect, it } from 'vitest'
-
-import { modePref, skinPref } from './context'
-import { DEFAULT_SKIN_NAME } from './presets'
-
-// Skin and mode share one per-profile contract, so assert it once over both.
-interface Pref {
-  resolve: (profile: string) => string
-  assign: (profile: string, value: string) => void
-}
-
-const cases = [
-  { name: 'skin', pref: skinPref as unknown as Pref, fallback: DEFAULT_SKIN_NAME, a: 'ember', b: 'midnight', junk: 'nope' },
-  { name: 'mode', pref: modePref as unknown as Pref, fallback: 'light', a: 'dark', b: 'system', junk: 'dusk' }
-]
-
-describe.each(cases)('per-profile $name', ({ pref, fallback, a, b, junk }) => {
-  beforeEach(() => window.localStorage.clear())
-
-  it('falls back to the default when unassigned', () => {
-    expect(pref.resolve('default')).toBe(fallback)
-    expect(pref.resolve('work')).toBe(fallback)
-  })
-
-  it('keeps each profile on its own value', () => {
-    pref.assign('work', a)
-    pref.assign('default', b)
-    expect(pref.resolve('work')).toBe(a)
-    expect(pref.resolve('default')).toBe(b)
-  })
-
-  it('lets unassigned profiles inherit the default profile as the global fallback', () => {
-    pref.assign('default', a)
-    expect(pref.resolve('never-themed')).toBe(a)
-  })
-
-  it('normalizes an unknown stored value back to the default', () => {
-    pref.assign('work', junk)
-    expect(pref.resolve('work')).toBe(fallback)
-  })
-})

apps/desktop/src/types/hermes.ts

@@ -596,27 +596,6 @@ export interface ActionStatusResponse {
   running: boolean
 }
 
-export interface BackendUpdateCommit {
-  sha: string
-  summary: string
-  author: string
-  at: number
-}
-
-/** Shape of `GET /api/hermes/update/check` — the backend's own update state.
- *  Used by the desktop's remote update overlay so the backend version (not the
- *  Electron client clone) drives "what's changed + Install" in remote mode. */
-export interface BackendUpdateCheckResponse {
-  install_method: string
-  current_version: string
-  behind: number | null
-  update_available: boolean
-  can_apply: boolean
-  update_command: string | null
-  message: string | null
-  commits?: BackendUpdateCommit[]
-}
-
 export interface AuxiliaryTaskAssignment {
   base_url: string
   model: string

cli-config.yaml.example

@@ -528,15 +528,6 @@ session_reset:
   idle_minutes: 1440   # Inactivity timeout in minutes (default: 1440 = 24 hours)
   at_hour: 4           # Daily reset hour, 0-23 local time (default: 4 AM)
 
-# Maximum number of simultaneously active chat sessions across CLI, TUI,
-# dashboard chat, and messaging gateway. Set to null, 0, or omit to allow
-# unlimited concurrent sessions. When the limit is reached, new sessions get a
-# clean error while existing active sessions keep their normal behavior. This
-# top-level key takes precedence over gateway.max_concurrent_sessions. The cap
-# is a best-effort single-host/profile runtime guard; Hermes fails open if the
-# local runtime lease registry cannot be read or locked.
-max_concurrent_sessions: null
-
 # When true, group/channel chats use one session per participant when the platform
 # provides a user ID. This is the secure default and prevents users in the same
 # room from sharing context, interrupts, and token costs. Set false only if you

gateway/authz_mixin.py

@@ -1,426 +0,0 @@
-"""User-authorization methods for ``GatewayRunner``.
-
-Extracted from ``gateway/run.py`` as part of the god-file decomposition campaign
-(``~/.hermes/plans/god-file-decomposition.md``, Phase 3 mechanical mixin lifts).
-This mixin holds the inbound-message authorization cluster: whether a user/chat
-is allowed to talk to the agent, the per-adapter DM policy, and the
-unauthorized-DM behavior.
-
-Behavior-neutral: every method is lifted verbatim from ``GatewayRunner``.
-``self.*`` calls resolve unchanged via the MRO. Neutral dependencies import at
-module top; the module-level ``logger`` is imported lazily inside the one method
-that uses it (``from gateway.run import logger`` resolves at call time, when
-``gateway.run`` is fully loaded) so this module never imports ``gateway.run`` at
-import time -> no import cycle. The lazy import preserves the exact logger name
-(``"gateway.run"``) so log records are unchanged.
-"""
-
-from __future__ import annotations
-
-import os
-from typing import Optional
-
-from gateway.config import Platform
-from gateway.session import SessionSource
-from gateway.whatsapp_identity import (
-    expand_whatsapp_aliases as _expand_whatsapp_auth_aliases,
-    normalize_whatsapp_identifier as _normalize_whatsapp_identifier,
-)
-
-
-class GatewayAuthorizationMixin:
-    """User/chat authorization methods for ``GatewayRunner``."""
-
-    def _adapter_enforces_own_access_policy(self, platform: Optional[Platform]) -> bool:
-        """Whether the adapter for *platform* gates access at intake itself.
-
-        Mirrors ``BasePlatformAdapter.enforces_own_access_policy``. Adapters
-        such as WeCom, Weixin, Yuanbao, QQBot, and WhatsApp evaluate their
-        documented ``dm_policy`` / ``group_policy`` / ``allow_from`` config before a
-        message is dispatched to the gateway, so a message that reaches
-        ``_is_user_authorized`` has already been authorized by the adapter.
-        Defaults to ``False`` when the adapter is unknown or doesn't expose
-        the flag.
-        """
-        if not platform:
-            return False
-        # Some test helpers build a bare GatewayRunner via object.__new__ and
-        # never set ``adapters``; treat a missing/empty map as "no adapter"
-        # rather than raising (see pitfalls.md #17).
-        adapters = getattr(self, "adapters", None)
-        if not adapters:
-            return False
-        adapter = adapters.get(platform)
-        if adapter is None:
-            return False
-        return bool(getattr(adapter, "enforces_own_access_policy", False))
-
-    def _adapter_dm_policy(self, platform: Optional[Platform]) -> str:
-        """Best-effort read of an own-policy adapter's effective DM policy.
-
-        Returns the lowercased ``dm_policy`` (``"open"`` / ``"allowlist"`` /
-        ``"disabled"`` / ``"pairing"``) for *platform*, or ``""`` when unknown.
-        Prefers the live adapter's resolved ``_dm_policy`` — which already folds
-        in both ``config.extra`` and the ``<PLATFORM>_DM_POLICY`` env var (the
-        env var is not always bridged back into ``config.extra``) — and falls
-        back to ``config.extra`` for bare runners built without a live adapter.
-
-        Used by ``_is_user_authorized`` to carve ``dm_policy: pairing`` out of
-        the adapter-trust shortcut: in pairing mode the adapter forwards the DM
-        so the gateway can run its pairing handshake, so "reached the gateway"
-        must not be read as "authorized".
-        """
-        if not platform:
-            return ""
-        adapters = getattr(self, "adapters", None) or {}
-        adapter = adapters.get(platform)
-        policy = getattr(adapter, "_dm_policy", None) if adapter is not None else None
-        if policy is None:
-            config = getattr(self, "config", None)
-            platform_cfg = (
-                config.platforms.get(platform)
-                if config is not None and hasattr(config, "platforms")
-                else None
-            )
-            extra = getattr(platform_cfg, "extra", None) if platform_cfg else None
-            if isinstance(extra, dict):
-                policy = extra.get("dm_policy")
-        return str(policy or "").strip().lower()
-
-    def _is_user_authorized(self, source: SessionSource) -> bool:
-        """
-        Check if a user is authorized to use the bot.
-        
-        Checks in order:
-        1. Per-platform allow-all flag (e.g., DISCORD_ALLOW_ALL_USERS=true)
-        2. Environment variable allowlists (TELEGRAM_ALLOWED_USERS, etc.)
-        3. DM pairing approved list
-        4. Global allow-all (GATEWAY_ALLOW_ALL_USERS=true)
-        5. Default: deny
-        """
-        from gateway.run import logger
-        # Home Assistant events are system-generated (state changes), not
-        # user-initiated messages.  The HASS_TOKEN already authenticates the
-        # connection, so HA events are always authorized.
-        # Webhook events are authenticated via HMAC signature validation in
-        # the adapter itself — no user allowlist applies.
-        if source.platform in {Platform.HOMEASSISTANT, Platform.WEBHOOK}:
-            return True
-
-        user_id = source.user_id
-
-        # Telegram (and similar) authorize entire group/forum/channel chats
-        # by chat ID via TELEGRAM_GROUP_ALLOWED_CHATS / QQ_GROUP_ALLOWED_USERS.
-        # That allowlist is chat-scoped, so it must work even when
-        # source.user_id is None — Telegram emits anonymous-admin posts,
-        # sender_chat traffic, and channel broadcasts with no `from_user`,
-        # and an operator who explicitly listed the chat expects those to
-        # be honored. Run this check before the no-user-id guard below so
-        # documented behavior matches reality
-        # (website/docs/reference/environment-variables.md,
-        # website/docs/user-guide/messaging/telegram.md).
-        if source.chat_type in {"group", "forum", "channel"} and source.chat_id:
-            chat_allowlist_env = {
-                Platform.TELEGRAM: "TELEGRAM_GROUP_ALLOWED_CHATS",
-                Platform.QQBOT: "QQ_GROUP_ALLOWED_USERS",
-            }.get(source.platform, "")
-            if chat_allowlist_env:
-                raw_chat_allowlist = os.getenv(chat_allowlist_env, "").strip()
-                if raw_chat_allowlist:
-                    allowed_group_ids = {
-                        cid.strip()
-                        for cid in raw_chat_allowlist.split(",")
-                        if cid.strip()
-                    }
-                    if "*" in allowed_group_ids or source.chat_id in allowed_group_ids:
-                        return True
-
-        if not user_id:
-            return False
-
-        platform_env_map = {
-            Platform.TELEGRAM: "TELEGRAM_ALLOWED_USERS",
-            Platform.DISCORD: "DISCORD_ALLOWED_USERS",
-            Platform.WHATSAPP: "WHATSAPP_ALLOWED_USERS",
-            Platform.SLACK: "SLACK_ALLOWED_USERS",
-            Platform.SIGNAL: "SIGNAL_ALLOWED_USERS",
-            Platform.EMAIL: "EMAIL_ALLOWED_USERS",
-            Platform.SMS: "SMS_ALLOWED_USERS",
-            Platform.MATTERMOST: "MATTERMOST_ALLOWED_USERS",
-            Platform.MATRIX: "MATRIX_ALLOWED_USERS",
-            Platform.DINGTALK: "DINGTALK_ALLOWED_USERS",
-            Platform.FEISHU: "FEISHU_ALLOWED_USERS",
-            Platform.WECOM: "WECOM_ALLOWED_USERS",
-            Platform.WECOM_CALLBACK: "WECOM_CALLBACK_ALLOWED_USERS",
-            Platform.WEIXIN: "WEIXIN_ALLOWED_USERS",
-            Platform.BLUEBUBBLES: "BLUEBUBBLES_ALLOWED_USERS",
-            Platform.QQBOT: "QQ_ALLOWED_USERS",
-            Platform.YUANBAO: "YUANBAO_ALLOWED_USERS",
-        }
-        platform_group_user_env_map = {
-            Platform.TELEGRAM: "TELEGRAM_GROUP_ALLOWED_USERS",
-        }
-        platform_group_chat_env_map = {
-            Platform.TELEGRAM: "TELEGRAM_GROUP_ALLOWED_CHATS",
-            Platform.QQBOT: "QQ_GROUP_ALLOWED_USERS",
-        }
-        platform_allow_all_map = {
-            Platform.TELEGRAM: "TELEGRAM_ALLOW_ALL_USERS",
-            Platform.DISCORD: "DISCORD_ALLOW_ALL_USERS",
-            Platform.WHATSAPP: "WHATSAPP_ALLOW_ALL_USERS",
-            Platform.SLACK: "SLACK_ALLOW_ALL_USERS",
-            Platform.SIGNAL: "SIGNAL_ALLOW_ALL_USERS",
-            Platform.EMAIL: "EMAIL_ALLOW_ALL_USERS",
-            Platform.SMS: "SMS_ALLOW_ALL_USERS",
-            Platform.MATTERMOST: "MATTERMOST_ALLOW_ALL_USERS",
-            Platform.MATRIX: "MATRIX_ALLOW_ALL_USERS",
-            Platform.DINGTALK: "DINGTALK_ALLOW_ALL_USERS",
-            Platform.FEISHU: "FEISHU_ALLOW_ALL_USERS",
-            Platform.WECOM: "WECOM_ALLOW_ALL_USERS",
-            Platform.WECOM_CALLBACK: "WECOM_CALLBACK_ALLOW_ALL_USERS",
-            Platform.WEIXIN: "WEIXIN_ALLOW_ALL_USERS",
-            Platform.BLUEBUBBLES: "BLUEBUBBLES_ALLOW_ALL_USERS",
-            Platform.QQBOT: "QQ_ALLOW_ALL_USERS",
-            Platform.YUANBAO: "YUANBAO_ALLOW_ALL_USERS",
-        }
-        # Bots admitted by {PLATFORM}_ALLOW_BOTS bypass the human allowlist (#4466).
-        platform_allow_bots_map = {
-            Platform.DISCORD: "DISCORD_ALLOW_BOTS",
-            Platform.FEISHU: "FEISHU_ALLOW_BOTS",
-        }
-
-        # Plugin platforms: check the registry for auth env var names
-        if source.platform not in platform_env_map:
-            try:
-                from gateway.platform_registry import platform_registry
-                entry = platform_registry.get(source.platform.value)
-                if entry:
-                    if entry.allowed_users_env:
-                        platform_env_map[source.platform] = entry.allowed_users_env
-                    if entry.allow_all_env:
-                        platform_allow_all_map[source.platform] = entry.allow_all_env
-            except Exception:
-                pass
-
-        # Per-platform allow-all flag (e.g., DISCORD_ALLOW_ALL_USERS=true)
-        platform_allow_all_var = platform_allow_all_map.get(source.platform, "")
-        if platform_allow_all_var and os.getenv(platform_allow_all_var, "").lower() in {"true", "1", "yes"}:
-            return True
-
-        if getattr(source, "is_bot", False):
-            allow_bots_var = platform_allow_bots_map.get(source.platform)
-            if allow_bots_var and os.getenv(allow_bots_var, "none").lower().strip() in {"mentions", "all"}:
-                return True
-
-        # Check pairing store (always checked, regardless of allowlists)
-        platform_name = source.platform.value if source.platform else ""
-        if self.pairing_store.is_approved(platform_name, user_id):
-            return True
-
-        # Check platform-specific and global allowlists
-        platform_allowlist = os.getenv(platform_env_map.get(source.platform, ""), "").strip()
-        group_user_allowlist = ""
-        group_chat_allowlist = ""
-        if source.chat_type in {"group", "forum"}:
-            group_user_allowlist = os.getenv(platform_group_user_env_map.get(source.platform, ""), "").strip()
-            group_chat_allowlist = os.getenv(platform_group_chat_env_map.get(source.platform, ""), "").strip()
-        global_allowlist = os.getenv("GATEWAY_ALLOWED_USERS", "").strip()
-
-        if not platform_allowlist and not group_user_allowlist and not group_chat_allowlist and not global_allowlist:
-            # No env allowlists configured. Adapters that own their own
-            # config-driven access policy (dm_policy / group_policy /
-            # allow_from / group_allow_from) already gated this message at
-            # intake — it would not have reached the gateway otherwise — so
-            # honor that decision instead of falling through to the
-            # env-only default-deny below, which would silently break
-            # `dm_policy: open` and config-only allowlists. (#34515)
-            if self._adapter_enforces_own_access_policy(source.platform):
-                # Exception: `dm_policy: pairing` does NOT authorize at intake.
-                # The adapter forwards the DM precisely so the gateway can run
-                # its pairing handshake (issue a code, consult the pairing
-                # store). The pairing-store approval check above already ran and
-                # returned False for this sender, so blanket-trusting the
-                # adapter here would silently turn pairing mode into open
-                # access. Fall through to default-deny so the unpaired sender is
-                # offered a pairing code instead. (Pairing is DM-only; group
-                # traffic keeps the adapter-trust path.)
-                if not (
-                    source.chat_type == "dm"
-                    and self._adapter_dm_policy(source.platform) == "pairing"
-                ):
-                    return True
-            # No allowlists configured -- check global allow-all flag
-            return os.getenv("GATEWAY_ALLOW_ALL_USERS", "").lower() in {"true", "1", "yes"}
-
-        # Telegram can optionally authorize group traffic by chat ID.
-        # Keep this separate from TELEGRAM_GROUP_ALLOWED_USERS, which gates
-        # the sender user ID for group/forum messages.
-        if group_chat_allowlist and source.chat_type in {"group", "forum"} and source.chat_id:
-            allowed_group_ids = {
-                chat_id.strip() for chat_id in group_chat_allowlist.split(",") if chat_id.strip()
-            }
-            if "*" in allowed_group_ids or source.chat_id in allowed_group_ids:
-                return True
-
-        # Backward-compat shim for #15027: prior to PR #17686,
-        # TELEGRAM_GROUP_ALLOWED_USERS was (mis)used as a chat-ID allowlist.
-        # Values starting with "-" are Telegram chat IDs, not user IDs, so if
-        # users still have those in TELEGRAM_GROUP_ALLOWED_USERS we honor them
-        # as chat IDs and warn once. The correct var is now
-        # TELEGRAM_GROUP_ALLOWED_CHATS.
-        if (
-            source.platform == Platform.TELEGRAM
-            and group_user_allowlist
-            and source.chat_type in {"group", "forum"}
-            and source.chat_id
-        ):
-            legacy_chat_ids = {
-                v.strip()
-                for v in group_user_allowlist.split(",")
-                if v.strip().startswith("-")
-            }
-            if legacy_chat_ids:
-                if not getattr(self, "_warned_telegram_group_users_legacy", False):
-                    logger.warning(
-                        "TELEGRAM_GROUP_ALLOWED_USERS contains chat-ID-shaped values "
-                        "(%s). Treating them as chat IDs for backward compatibility. "
-                        "Move chat IDs to TELEGRAM_GROUP_ALLOWED_CHATS — the _USERS var "
-                        "is now for sender user IDs.",
-                        ",".join(sorted(legacy_chat_ids)),
-                    )
-                    self._warned_telegram_group_users_legacy = True
-                if source.chat_id in legacy_chat_ids:
-                    return True
-
-        # Check if user is in any allowlist. In group/forum chats,
-        # TELEGRAM_GROUP_ALLOWED_USERS is the scoped allowlist and should not
-        # imply DM access; TELEGRAM_ALLOWED_USERS remains the platform-wide
-        # allowlist and still works everywhere for backward compatibility.
-        allowed_ids = set()
-        if platform_allowlist:
-            allowed_ids.update(uid.strip() for uid in platform_allowlist.split(",") if uid.strip())
-        if group_user_allowlist:
-            allowed_ids.update(uid.strip() for uid in group_user_allowlist.split(",") if uid.strip())
-        if global_allowlist:
-            allowed_ids.update(uid.strip() for uid in global_allowlist.split(",") if uid.strip())
-
-        # "*" in any allowlist means allow everyone (consistent with
-        # SIGNAL_GROUP_ALLOWED_USERS precedent)
-        if "*" in allowed_ids:
-            return True
-
-        check_ids = {user_id}
-        if "@" in user_id:
-            check_ids.add(user_id.split("@")[0])
-
-        # WhatsApp: resolve phone↔LID aliases from bridge session mapping files
-        if source.platform == Platform.WHATSAPP:
-            normalized_allowed_ids = set()
-            for allowed_id in allowed_ids:
-                normalized_allowed_ids.update(_expand_whatsapp_auth_aliases(allowed_id))
-            if normalized_allowed_ids:
-                allowed_ids = normalized_allowed_ids
-
-            check_ids.update(_expand_whatsapp_auth_aliases(user_id))
-            normalized_user_id = _normalize_whatsapp_identifier(user_id)
-            if normalized_user_id:
-                check_ids.add(normalized_user_id)
-
-        # SimpleX: SIMPLEX_ALLOWED_USERS accepts either the numeric contactId
-        # or the contact's display name. The adapter sets user_id=contactId for
-        # stability across renames, but the SimpleX UI never surfaces the
-        # numeric id — operators only see display names, so that's what they
-        # naturally put in the env var. Match both so the allowlist works
-        # regardless of which form was chosen.
-        # Plugin platform: compare by value since Platform.SIMPLEX is not a
-        # hardcoded enum member (it's a dynamic plugin platform).
-        if (
-            source.platform is not None
-            and source.platform.value == "simplex"
-            and source.user_name
-        ):
-            check_ids.add(source.user_name)
-
-        return bool(check_ids & allowed_ids)
-
-    def _get_unauthorized_dm_behavior(self, platform: Optional[Platform]) -> str:
-        """Return how unauthorized DMs should be handled for a platform.
-
-        Resolution order:
-        1. Explicit per-platform ``unauthorized_dm_behavior`` in config — always wins.
-        2. Explicit global ``unauthorized_dm_behavior`` in config — wins when no per-platform.
-        3. When an allowlist (``PLATFORM_ALLOWED_USERS``,
-           ``PLATFORM_GROUP_ALLOWED_USERS`` / ``PLATFORM_GROUP_ALLOWED_CHATS``,
-           or ``GATEWAY_ALLOWED_USERS``) is configured, default to ``"ignore"`` —
-           the allowlist signals that the owner has deliberately restricted
-           access; spamming unknown contacts with pairing codes is both noisy
-           and a potential info-leak. (#9337)
-        4. No allowlist and no explicit config → ``"pair"`` (open-gateway default).
-        """
-        config = getattr(self, "config", None)
-
-        # Check for an explicit per-platform override first.
-        if config and hasattr(config, "get_unauthorized_dm_behavior") and platform:
-            platform_cfg = config.platforms.get(platform) if hasattr(config, "platforms") else None
-            if platform_cfg and "unauthorized_dm_behavior" in getattr(platform_cfg, "extra", {}):
-                # Operator explicitly configured behavior for this platform — respect it.
-                return config.get_unauthorized_dm_behavior(platform)
-
-        # Check for an explicit global config override.
-        if config and hasattr(config, "unauthorized_dm_behavior"):
-            if config.unauthorized_dm_behavior != "pair":  # non-default → explicit override
-                return config.unauthorized_dm_behavior
-
-        # Config-driven dm_policy (WeCom / Weixin / Yuanbao / QQBot). An
-        # allowlist or disabled DM policy means the operator restricted access,
-        # so unauthorized DMs should be dropped silently rather than answered
-        # with a pairing code. An explicit pairing policy opts back into codes.
-        if platform and config and hasattr(config, "platforms"):
-            platform_cfg = config.platforms.get(platform)
-            extra = getattr(platform_cfg, "extra", None) if platform_cfg else None
-            if isinstance(extra, dict):
-                dm_policy = str(extra.get("dm_policy") or "").strip().lower()
-                if dm_policy == "pairing":
-                    return "pair"
-                if dm_policy in {"allowlist", "disabled"}:
-                    return "ignore"
-
-        # No explicit override.  Fall back to allowlist-aware default:
-        # if any allowlist is configured for this platform, silently drop
-        # unauthorized messages instead of sending pairing codes.
-        if platform:
-            platform_env_map = {
-                Platform.TELEGRAM: "TELEGRAM_ALLOWED_USERS",
-                Platform.DISCORD:  "DISCORD_ALLOWED_USERS",
-                Platform.WHATSAPP: "WHATSAPP_ALLOWED_USERS",
-                Platform.SLACK:    "SLACK_ALLOWED_USERS",
-                Platform.SIGNAL:   "SIGNAL_ALLOWED_USERS",
-                Platform.EMAIL:    "EMAIL_ALLOWED_USERS",
-                Platform.SMS:      "SMS_ALLOWED_USERS",
-                Platform.MATTERMOST: "MATTERMOST_ALLOWED_USERS",
-                Platform.MATRIX:   "MATRIX_ALLOWED_USERS",
-                Platform.DINGTALK: "DINGTALK_ALLOWED_USERS",
-                Platform.FEISHU:   "FEISHU_ALLOWED_USERS",
-                Platform.WECOM:    "WECOM_ALLOWED_USERS",
-                Platform.WECOM_CALLBACK: "WECOM_CALLBACK_ALLOWED_USERS",
-                Platform.WEIXIN:   "WEIXIN_ALLOWED_USERS",
-                Platform.BLUEBUBBLES: "BLUEBUBBLES_ALLOWED_USERS",
-                Platform.QQBOT:    "QQ_ALLOWED_USERS",
-            }
-            platform_group_env_map = {
-                Platform.TELEGRAM: (
-                    "TELEGRAM_GROUP_ALLOWED_USERS",
-                    "TELEGRAM_GROUP_ALLOWED_CHATS",
-                ),
-                Platform.QQBOT: ("QQ_GROUP_ALLOWED_USERS",),
-            }
-            if os.getenv(platform_env_map.get(platform, ""), "").strip():
-                return "ignore"
-            for env_key in platform_group_env_map.get(platform, ()):
-                if os.getenv(env_key, "").strip():
-                    return "ignore"
-
-        if os.getenv("GATEWAY_ALLOWED_USERS", "").strip():
-            return "ignore"
-
-        return "pair"

gateway/config.py

@@ -56,42 +56,6 @@ def _coerce_int(value: Any, default: int) -> int:
         return default
 
 
-def _coerce_optional_positive_int(value: Any, key: str) -> Optional[int]:
-    """Coerce an optional positive integer config value.
-
-    ``None``/0/negative disable the setting. Malformed values are ignored with
-    a warning so a typo never prevents the gateway from starting.
-    """
-    if value is None:
-        return None
-    if isinstance(value, bool):
-        logger.warning(
-            "Ignoring invalid %s=%r (expected a positive integer; 0/null disables)",
-            key,
-            value,
-        )
-        return None
-    try:
-        if isinstance(value, float):
-            if not value.is_integer():
-                raise ValueError(value)
-            parsed = int(value)
-        elif isinstance(value, str):
-            parsed = int(value.strip(), 10)
-        else:
-            parsed = int(value)
-    except (TypeError, ValueError):
-        logger.warning(
-            "Ignoring invalid %s=%r (expected a positive integer; 0/null disables)",
-            key,
-            value,
-        )
-        return None
-    if parsed <= 0:
-        return None
-    return parsed
-
-
 def _normalize_unauthorized_dm_behavior(value: Any, default: str = "pair") -> str:
     """Normalize unauthorized DM behavior to a supported value."""
     if isinstance(value, str):
@@ -531,7 +495,6 @@ class GatewayConfig:
     # Session isolation in shared chats
     group_sessions_per_user: bool = True  # Isolate group/channel sessions per participant when user IDs are available
     thread_sessions_per_user: bool = False  # When False (default), threads are shared across all participants
-    max_concurrent_sessions: Optional[int] = None  # Positive int caps simultaneous active chat sessions
 
     # Unauthorized DM policy
     unauthorized_dm_behavior: str = "pair"  # "pair" or "ignore"
@@ -637,7 +600,6 @@ class GatewayConfig:
             "stt_enabled": self.stt_enabled,
             "group_sessions_per_user": self.group_sessions_per_user,
             "thread_sessions_per_user": self.thread_sessions_per_user,
-            "max_concurrent_sessions": self.max_concurrent_sessions,
             "unauthorized_dm_behavior": self.unauthorized_dm_behavior,
             "streaming": self.streaming.to_dict(),
             "session_store_max_age_days": self.session_store_max_age_days,
@@ -683,17 +645,6 @@ class GatewayConfig:
 
         group_sessions_per_user = data.get("group_sessions_per_user")
         thread_sessions_per_user = data.get("thread_sessions_per_user")
-        nested_gateway = data.get("gateway") if isinstance(data.get("gateway"), dict) else {}
-        if "max_concurrent_sessions" in data:
-            max_concurrent_raw = data.get("max_concurrent_sessions")
-            max_concurrent_key = "max_concurrent_sessions"
-        else:
-            max_concurrent_raw = nested_gateway.get("max_concurrent_sessions")
-            max_concurrent_key = "gateway.max_concurrent_sessions"
-        max_concurrent_sessions = _coerce_optional_positive_int(
-            max_concurrent_raw,
-            max_concurrent_key,
-        )
         unauthorized_dm_behavior = _normalize_unauthorized_dm_behavior(
             data.get("unauthorized_dm_behavior"),
             "pair",
@@ -720,7 +671,6 @@ class GatewayConfig:
             stt_enabled=_coerce_bool(stt_enabled, True),
             group_sessions_per_user=_coerce_bool(group_sessions_per_user, True),
             thread_sessions_per_user=_coerce_bool(thread_sessions_per_user, False),
-            max_concurrent_sessions=max_concurrent_sessions,
             unauthorized_dm_behavior=unauthorized_dm_behavior,
             streaming=StreamingConfig.from_dict(data.get("streaming", {})),
             session_store_max_age_days=session_store_max_age_days,
@@ -811,13 +761,6 @@ def load_gateway_config() -> GatewayConfig:
             if "thread_sessions_per_user" in yaml_cfg:
                 gw_data["thread_sessions_per_user"] = yaml_cfg["thread_sessions_per_user"]
 
-            gateway_section = yaml_cfg.get("gateway")
-            if isinstance(gateway_section, dict) and "max_concurrent_sessions" in gateway_section:
-                gw_data["max_concurrent_sessions"] = gateway_section["max_concurrent_sessions"]
-
-            if "max_concurrent_sessions" in yaml_cfg:
-                gw_data["max_concurrent_sessions"] = yaml_cfg["max_concurrent_sessions"]
-
             streaming_cfg = yaml_cfg.get("streaming")
             if not isinstance(streaming_cfg, dict):
                 # Fall back to nested gateway.streaming written by

gateway/run.py

@@ -1160,7 +1160,6 @@ from gateway.session import (
     is_shared_multi_user_session,
 )
 from gateway.delivery import DeliveryRouter
-from gateway.authz_mixin import GatewayAuthorizationMixin
 from gateway.kanban_watchers import GatewayKanbanWatchersMixin
 from gateway.slash_commands import GatewaySlashCommandsMixin
 from gateway.platforms.base import (
@@ -1863,7 +1862,7 @@ async def _dispose_unused_adapter(adapter: "BasePlatformAdapter | None") -> None
         )
 
 
-class GatewayRunner(GatewayAuthorizationMixin, GatewayKanbanWatchersMixin, GatewaySlashCommandsMixin):
+class GatewayRunner(GatewayKanbanWatchersMixin, GatewaySlashCommandsMixin):
     """
     Main gateway controller.
 
@@ -1934,7 +1933,6 @@ class GatewayRunner(GatewayAuthorizationMixin, GatewayKanbanWatchersMixin, Gatew
         # Key: session_key, Value: AIAgent instance
         self._running_agents: Dict[str, Any] = {}
         self._running_agents_ts: Dict[str, float] = {}  # start timestamp per session
-        self._active_session_leases: Dict[str, Any] = {}
         self._pending_messages: Dict[str, str] = {}  # Queued messages during interrupt
         # Last successfully-resolved (non-empty) model, keyed by session. Used
         # as a fallback when a fresh config read transiently returns an empty
@@ -3391,59 +3389,6 @@ class GatewayRunner(GatewayAuthorizationMixin, GatewayKanbanWatchersMixin, Gatew
             if agent is not _AGENT_PENDING_SENTINEL
         }
 
-    def _get_max_concurrent_sessions(self) -> Optional[int]:
-        """Return the configured active chat session cap, if enabled."""
-        try:
-            from hermes_cli.active_sessions import resolve_max_concurrent_sessions
-
-            return resolve_max_concurrent_sessions(getattr(self, "config", None))
-        except Exception:
-            return None
-
-    def _active_session_limit_message(self, session_key: str) -> Optional[str]:
-        """Return a user-facing rejection when starting a new session exceeds the cap."""
-        max_sessions = self._get_max_concurrent_sessions()
-        if max_sessions is None:
-            return None
-        if session_key in getattr(self, "_running_agents", {}):
-            return None
-        active_count = len(getattr(self, "_running_agents", {}))
-        if active_count < max_sessions:
-            return None
-        return (
-            f"Hermes is at the active session limit ({active_count}/{max_sessions}). "
-            "Try again when another session finishes."
-        )
-
-    def _claim_active_session_slot(
-        self,
-        session_key: str,
-        source: SessionSource,
-    ) -> tuple[Any, Optional[str]]:
-        """Claim a cross-process active-session slot for a new gateway turn."""
-        if session_key in getattr(self, "_running_agents", {}):
-            return None, None
-        local_limit_message = self._active_session_limit_message(session_key)
-        if local_limit_message is not None:
-            return None, local_limit_message
-        try:
-            from hermes_cli.active_sessions import try_acquire_active_session
-
-            platform = source.platform.value if source and source.platform else "gateway"
-            return try_acquire_active_session(
-                session_id=session_key,
-                surface=f"gateway:{platform}",
-                config=getattr(self, "config", None),
-                metadata={
-                    "platform": platform,
-                    "chat_id": getattr(source, "chat_id", "") or "",
-                    "user_id": getattr(source, "user_id", "") or "",
-                },
-            )
-        except Exception as exc:
-            logger.warning("Failed to claim active session slot: %s", exc)
-            return None, None
-
     @staticmethod
     def _agent_has_active_subagents(running_agent: Any) -> bool:
         """Return True when *running_agent* is currently driving subagents
@@ -5270,23 +5215,8 @@ class GatewayRunner(GatewayAuthorizationMixin, GatewayKanbanWatchersMixin, Gatew
                         # be garbage-collected.  Otherwise the cache grows
                         # unbounded across the gateway's lifetime.
                         self._evict_cached_agent(key)
-                        # Permanently finalizing this session — drop its
-                        # per-session control state so the dicts don't grow
-                        # unbounded across the gateway's lifetime. (Idle
-                        # agent-cache eviction must NOT prune these: the
-                        # session is still alive and a resumed turn rebuilds
-                        # its agent from these overrides. Only true session
-                        # finalization, /new, and /reset clear them.)
-                        self._session_model_overrides.pop(key, None)
-                        self._set_session_reasoning_override(key, None)
-                        if hasattr(self, "_pending_model_notes"):
-                            self._pending_model_notes.pop(key, None)
-                        _pending_approvals = getattr(self, "_pending_approvals", None)
-                        if isinstance(_pending_approvals, dict):
-                            _pending_approvals.pop(key, None)
-                        _update_prompt_pending = getattr(self, "_update_prompt_pending", None)
-                        if isinstance(_update_prompt_pending, dict):
-                            _update_prompt_pending.pop(key, None)
+                        # Mark as finalized and persist to disk so the flag
+                        # survives gateway restarts.
                         with self.session_store._lock:
                             entry.expiry_finalized = True
                             self.session_store._save()
@@ -5805,12 +5735,8 @@ class GatewayRunner(GatewayAuthorizationMixin, GatewayKanbanWatchersMixin, Gatew
             self._background_tasks.clear()
 
             self.adapters.clear()
-            for _session_key in list(self._running_agents):
-                self._release_running_agent_state(_session_key)
             self._running_agents.clear()
             self._running_agents_ts.clear()
-            if hasattr(self, "_active_session_leases"):
-                self._active_session_leases.clear()
             self._pending_messages.clear()
             self._pending_approvals.clear()
             if hasattr(self, '_busy_ack_ts'):
@@ -6136,9 +6062,398 @@ class GatewayRunner(GatewayAuthorizationMixin, GatewayKanbanWatchersMixin, Gatew
 
         return None
 
+    def _adapter_enforces_own_access_policy(self, platform: Optional[Platform]) -> bool:
+        """Whether the adapter for *platform* gates access at intake itself.
 
+        Mirrors ``BasePlatformAdapter.enforces_own_access_policy``. Adapters
+        such as WeCom, Weixin, Yuanbao, QQBot, and WhatsApp evaluate their
+        documented ``dm_policy`` / ``group_policy`` / ``allow_from`` config before a
+        message is dispatched to the gateway, so a message that reaches
+        ``_is_user_authorized`` has already been authorized by the adapter.
+        Defaults to ``False`` when the adapter is unknown or doesn't expose
+        the flag.
+        """
+        if not platform:
+            return False
+        # Some test helpers build a bare GatewayRunner via object.__new__ and
+        # never set ``adapters``; treat a missing/empty map as "no adapter"
+        # rather than raising (see pitfalls.md #17).
+        adapters = getattr(self, "adapters", None)
+        if not adapters:
+            return False
+        adapter = adapters.get(platform)
+        if adapter is None:
+            return False
+        return bool(getattr(adapter, "enforces_own_access_policy", False))
 
+    def _adapter_dm_policy(self, platform: Optional[Platform]) -> str:
+        """Best-effort read of an own-policy adapter's effective DM policy.
 
+        Returns the lowercased ``dm_policy`` (``"open"`` / ``"allowlist"`` /
+        ``"disabled"`` / ``"pairing"``) for *platform*, or ``""`` when unknown.
+        Prefers the live adapter's resolved ``_dm_policy`` — which already folds
+        in both ``config.extra`` and the ``<PLATFORM>_DM_POLICY`` env var (the
+        env var is not always bridged back into ``config.extra``) — and falls
+        back to ``config.extra`` for bare runners built without a live adapter.
+
+        Used by ``_is_user_authorized`` to carve ``dm_policy: pairing`` out of
+        the adapter-trust shortcut: in pairing mode the adapter forwards the DM
+        so the gateway can run its pairing handshake, so "reached the gateway"
+        must not be read as "authorized".
+        """
+        if not platform:
+            return ""
+        adapters = getattr(self, "adapters", None) or {}
+        adapter = adapters.get(platform)
+        policy = getattr(adapter, "_dm_policy", None) if adapter is not None else None
+        if policy is None:
+            config = getattr(self, "config", None)
+            platform_cfg = (
+                config.platforms.get(platform)
+                if config is not None and hasattr(config, "platforms")
+                else None
+            )
+            extra = getattr(platform_cfg, "extra", None) if platform_cfg else None
+            if isinstance(extra, dict):
+                policy = extra.get("dm_policy")
+        return str(policy or "").strip().lower()
+
+    def _is_user_authorized(self, source: SessionSource) -> bool:
+        """
+        Check if a user is authorized to use the bot.
+        
+        Checks in order:
+        1. Per-platform allow-all flag (e.g., DISCORD_ALLOW_ALL_USERS=true)
+        2. Environment variable allowlists (TELEGRAM_ALLOWED_USERS, etc.)
+        3. DM pairing approved list
+        4. Global allow-all (GATEWAY_ALLOW_ALL_USERS=true)
+        5. Default: deny
+        """
+        # Home Assistant events are system-generated (state changes), not
+        # user-initiated messages.  The HASS_TOKEN already authenticates the
+        # connection, so HA events are always authorized.
+        # Webhook events are authenticated via HMAC signature validation in
+        # the adapter itself — no user allowlist applies.
+        if source.platform in {Platform.HOMEASSISTANT, Platform.WEBHOOK}:
+            return True
+
+        user_id = source.user_id
+
+        # Telegram (and similar) authorize entire group/forum/channel chats
+        # by chat ID via TELEGRAM_GROUP_ALLOWED_CHATS / QQ_GROUP_ALLOWED_USERS.
+        # That allowlist is chat-scoped, so it must work even when
+        # source.user_id is None — Telegram emits anonymous-admin posts,
+        # sender_chat traffic, and channel broadcasts with no `from_user`,
+        # and an operator who explicitly listed the chat expects those to
+        # be honored. Run this check before the no-user-id guard below so
+        # documented behavior matches reality
+        # (website/docs/reference/environment-variables.md,
+        # website/docs/user-guide/messaging/telegram.md).
+        if source.chat_type in {"group", "forum", "channel"} and source.chat_id:
+            chat_allowlist_env = {
+                Platform.TELEGRAM: "TELEGRAM_GROUP_ALLOWED_CHATS",
+                Platform.QQBOT: "QQ_GROUP_ALLOWED_USERS",
+            }.get(source.platform, "")
+            if chat_allowlist_env:
+                raw_chat_allowlist = os.getenv(chat_allowlist_env, "").strip()
+                if raw_chat_allowlist:
+                    allowed_group_ids = {
+                        cid.strip()
+                        for cid in raw_chat_allowlist.split(",")
+                        if cid.strip()
+                    }
+                    if "*" in allowed_group_ids or source.chat_id in allowed_group_ids:
+                        return True
+
+        if not user_id:
+            return False
+
+        platform_env_map = {
+            Platform.TELEGRAM: "TELEGRAM_ALLOWED_USERS",
+            Platform.DISCORD: "DISCORD_ALLOWED_USERS",
+            Platform.WHATSAPP: "WHATSAPP_ALLOWED_USERS",
+            Platform.SLACK: "SLACK_ALLOWED_USERS",
+            Platform.SIGNAL: "SIGNAL_ALLOWED_USERS",
+            Platform.EMAIL: "EMAIL_ALLOWED_USERS",
+            Platform.SMS: "SMS_ALLOWED_USERS",
+            Platform.MATTERMOST: "MATTERMOST_ALLOWED_USERS",
+            Platform.MATRIX: "MATRIX_ALLOWED_USERS",
+            Platform.DINGTALK: "DINGTALK_ALLOWED_USERS",
+            Platform.FEISHU: "FEISHU_ALLOWED_USERS",
+            Platform.WECOM: "WECOM_ALLOWED_USERS",
+            Platform.WECOM_CALLBACK: "WECOM_CALLBACK_ALLOWED_USERS",
+            Platform.WEIXIN: "WEIXIN_ALLOWED_USERS",
+            Platform.BLUEBUBBLES: "BLUEBUBBLES_ALLOWED_USERS",
+            Platform.QQBOT: "QQ_ALLOWED_USERS",
+            Platform.YUANBAO: "YUANBAO_ALLOWED_USERS",
+        }
+        platform_group_user_env_map = {
+            Platform.TELEGRAM: "TELEGRAM_GROUP_ALLOWED_USERS",
+        }
+        platform_group_chat_env_map = {
+            Platform.TELEGRAM: "TELEGRAM_GROUP_ALLOWED_CHATS",
+            Platform.QQBOT: "QQ_GROUP_ALLOWED_USERS",
+        }
+        platform_allow_all_map = {
+            Platform.TELEGRAM: "TELEGRAM_ALLOW_ALL_USERS",
+            Platform.DISCORD: "DISCORD_ALLOW_ALL_USERS",
+            Platform.WHATSAPP: "WHATSAPP_ALLOW_ALL_USERS",
+            Platform.SLACK: "SLACK_ALLOW_ALL_USERS",
+            Platform.SIGNAL: "SIGNAL_ALLOW_ALL_USERS",
+            Platform.EMAIL: "EMAIL_ALLOW_ALL_USERS",
+            Platform.SMS: "SMS_ALLOW_ALL_USERS",
+            Platform.MATTERMOST: "MATTERMOST_ALLOW_ALL_USERS",
+            Platform.MATRIX: "MATRIX_ALLOW_ALL_USERS",
+            Platform.DINGTALK: "DINGTALK_ALLOW_ALL_USERS",
+            Platform.FEISHU: "FEISHU_ALLOW_ALL_USERS",
+            Platform.WECOM: "WECOM_ALLOW_ALL_USERS",
+            Platform.WECOM_CALLBACK: "WECOM_CALLBACK_ALLOW_ALL_USERS",
+            Platform.WEIXIN: "WEIXIN_ALLOW_ALL_USERS",
+            Platform.BLUEBUBBLES: "BLUEBUBBLES_ALLOW_ALL_USERS",
+            Platform.QQBOT: "QQ_ALLOW_ALL_USERS",
+            Platform.YUANBAO: "YUANBAO_ALLOW_ALL_USERS",
+        }
+        # Bots admitted by {PLATFORM}_ALLOW_BOTS bypass the human allowlist (#4466).
+        platform_allow_bots_map = {
+            Platform.DISCORD: "DISCORD_ALLOW_BOTS",
+            Platform.FEISHU: "FEISHU_ALLOW_BOTS",
+        }
+
+        # Plugin platforms: check the registry for auth env var names
+        if source.platform not in platform_env_map:
+            try:
+                from gateway.platform_registry import platform_registry
+                entry = platform_registry.get(source.platform.value)
+                if entry:
+                    if entry.allowed_users_env:
+                        platform_env_map[source.platform] = entry.allowed_users_env
+                    if entry.allow_all_env:
+                        platform_allow_all_map[source.platform] = entry.allow_all_env
+            except Exception:
+                pass
+
+        # Per-platform allow-all flag (e.g., DISCORD_ALLOW_ALL_USERS=true)
+        platform_allow_all_var = platform_allow_all_map.get(source.platform, "")
+        if platform_allow_all_var and os.getenv(platform_allow_all_var, "").lower() in {"true", "1", "yes"}:
+            return True
+
+        if getattr(source, "is_bot", False):
+            allow_bots_var = platform_allow_bots_map.get(source.platform)
+            if allow_bots_var and os.getenv(allow_bots_var, "none").lower().strip() in {"mentions", "all"}:
+                return True
+
+        # Check pairing store (always checked, regardless of allowlists)
+        platform_name = source.platform.value if source.platform else ""
+        if self.pairing_store.is_approved(platform_name, user_id):
+            return True
+
+        # Check platform-specific and global allowlists
+        platform_allowlist = os.getenv(platform_env_map.get(source.platform, ""), "").strip()
+        group_user_allowlist = ""
+        group_chat_allowlist = ""
+        if source.chat_type in {"group", "forum"}:
+            group_user_allowlist = os.getenv(platform_group_user_env_map.get(source.platform, ""), "").strip()
+            group_chat_allowlist = os.getenv(platform_group_chat_env_map.get(source.platform, ""), "").strip()
+        global_allowlist = os.getenv("GATEWAY_ALLOWED_USERS", "").strip()
+
+        if not platform_allowlist and not group_user_allowlist and not group_chat_allowlist and not global_allowlist:
+            # No env allowlists configured. Adapters that own their own
+            # config-driven access policy (dm_policy / group_policy /
+            # allow_from / group_allow_from) already gated this message at
+            # intake — it would not have reached the gateway otherwise — so
+            # honor that decision instead of falling through to the
+            # env-only default-deny below, which would silently break
+            # `dm_policy: open` and config-only allowlists. (#34515)
+            if self._adapter_enforces_own_access_policy(source.platform):
+                # Exception: `dm_policy: pairing` does NOT authorize at intake.
+                # The adapter forwards the DM precisely so the gateway can run
+                # its pairing handshake (issue a code, consult the pairing
+                # store). The pairing-store approval check above already ran and
+                # returned False for this sender, so blanket-trusting the
+                # adapter here would silently turn pairing mode into open
+                # access. Fall through to default-deny so the unpaired sender is
+                # offered a pairing code instead. (Pairing is DM-only; group
+                # traffic keeps the adapter-trust path.)
+                if not (
+                    source.chat_type == "dm"
+                    and self._adapter_dm_policy(source.platform) == "pairing"
+                ):
+                    return True
+            # No allowlists configured -- check global allow-all flag
+            return os.getenv("GATEWAY_ALLOW_ALL_USERS", "").lower() in {"true", "1", "yes"}
+
+        # Telegram can optionally authorize group traffic by chat ID.
+        # Keep this separate from TELEGRAM_GROUP_ALLOWED_USERS, which gates
+        # the sender user ID for group/forum messages.
+        if group_chat_allowlist and source.chat_type in {"group", "forum"} and source.chat_id:
+            allowed_group_ids = {
+                chat_id.strip() for chat_id in group_chat_allowlist.split(",") if chat_id.strip()
+            }
+            if "*" in allowed_group_ids or source.chat_id in allowed_group_ids:
+                return True
+
+        # Backward-compat shim for #15027: prior to PR #17686,
+        # TELEGRAM_GROUP_ALLOWED_USERS was (mis)used as a chat-ID allowlist.
+        # Values starting with "-" are Telegram chat IDs, not user IDs, so if
+        # users still have those in TELEGRAM_GROUP_ALLOWED_USERS we honor them
+        # as chat IDs and warn once. The correct var is now
+        # TELEGRAM_GROUP_ALLOWED_CHATS.
+        if (
+            source.platform == Platform.TELEGRAM
+            and group_user_allowlist
+            and source.chat_type in {"group", "forum"}
+            and source.chat_id
+        ):
+            legacy_chat_ids = {
+                v.strip()
+                for v in group_user_allowlist.split(",")
+                if v.strip().startswith("-")
+            }
+            if legacy_chat_ids:
+                if not getattr(self, "_warned_telegram_group_users_legacy", False):
+                    logger.warning(
+                        "TELEGRAM_GROUP_ALLOWED_USERS contains chat-ID-shaped values "
+                        "(%s). Treating them as chat IDs for backward compatibility. "
+                        "Move chat IDs to TELEGRAM_GROUP_ALLOWED_CHATS — the _USERS var "
+                        "is now for sender user IDs.",
+                        ",".join(sorted(legacy_chat_ids)),
+                    )
+                    self._warned_telegram_group_users_legacy = True
+                if source.chat_id in legacy_chat_ids:
+                    return True
+
+        # Check if user is in any allowlist. In group/forum chats,
+        # TELEGRAM_GROUP_ALLOWED_USERS is the scoped allowlist and should not
+        # imply DM access; TELEGRAM_ALLOWED_USERS remains the platform-wide
+        # allowlist and still works everywhere for backward compatibility.
+        allowed_ids = set()
+        if platform_allowlist:
+            allowed_ids.update(uid.strip() for uid in platform_allowlist.split(",") if uid.strip())
+        if group_user_allowlist:
+            allowed_ids.update(uid.strip() for uid in group_user_allowlist.split(",") if uid.strip())
+        if global_allowlist:
+            allowed_ids.update(uid.strip() for uid in global_allowlist.split(",") if uid.strip())
+
+        # "*" in any allowlist means allow everyone (consistent with
+        # SIGNAL_GROUP_ALLOWED_USERS precedent)
+        if "*" in allowed_ids:
+            return True
+
+        check_ids = {user_id}
+        if "@" in user_id:
+            check_ids.add(user_id.split("@")[0])
+
+        # WhatsApp: resolve phone↔LID aliases from bridge session mapping files
+        if source.platform == Platform.WHATSAPP:
+            normalized_allowed_ids = set()
+            for allowed_id in allowed_ids:
+                normalized_allowed_ids.update(_expand_whatsapp_auth_aliases(allowed_id))
+            if normalized_allowed_ids:
+                allowed_ids = normalized_allowed_ids
+
+            check_ids.update(_expand_whatsapp_auth_aliases(user_id))
+            normalized_user_id = _normalize_whatsapp_identifier(user_id)
+            if normalized_user_id:
+                check_ids.add(normalized_user_id)
+
+        # SimpleX: SIMPLEX_ALLOWED_USERS accepts either the numeric contactId
+        # or the contact's display name. The adapter sets user_id=contactId for
+        # stability across renames, but the SimpleX UI never surfaces the
+        # numeric id — operators only see display names, so that's what they
+        # naturally put in the env var. Match both so the allowlist works
+        # regardless of which form was chosen.
+        # Plugin platform: compare by value since Platform.SIMPLEX is not a
+        # hardcoded enum member (it's a dynamic plugin platform).
+        if (
+            source.platform is not None
+            and source.platform.value == "simplex"
+            and source.user_name
+        ):
+            check_ids.add(source.user_name)
+
+        return bool(check_ids & allowed_ids)
+
+    def _get_unauthorized_dm_behavior(self, platform: Optional[Platform]) -> str:
+        """Return how unauthorized DMs should be handled for a platform.
+
+        Resolution order:
+        1. Explicit per-platform ``unauthorized_dm_behavior`` in config — always wins.
+        2. Explicit global ``unauthorized_dm_behavior`` in config — wins when no per-platform.
+        3. When an allowlist (``PLATFORM_ALLOWED_USERS``,
+           ``PLATFORM_GROUP_ALLOWED_USERS`` / ``PLATFORM_GROUP_ALLOWED_CHATS``,
+           or ``GATEWAY_ALLOWED_USERS``) is configured, default to ``"ignore"`` —
+           the allowlist signals that the owner has deliberately restricted
+           access; spamming unknown contacts with pairing codes is both noisy
+           and a potential info-leak. (#9337)
+        4. No allowlist and no explicit config → ``"pair"`` (open-gateway default).
+        """
+        config = getattr(self, "config", None)
+
+        # Check for an explicit per-platform override first.
+        if config and hasattr(config, "get_unauthorized_dm_behavior") and platform:
+            platform_cfg = config.platforms.get(platform) if hasattr(config, "platforms") else None
+            if platform_cfg and "unauthorized_dm_behavior" in getattr(platform_cfg, "extra", {}):
+                # Operator explicitly configured behavior for this platform — respect it.
+                return config.get_unauthorized_dm_behavior(platform)
+
+        # Check for an explicit global config override.
+        if config and hasattr(config, "unauthorized_dm_behavior"):
+            if config.unauthorized_dm_behavior != "pair":  # non-default → explicit override
+                return config.unauthorized_dm_behavior
+
+        # Config-driven dm_policy (WeCom / Weixin / Yuanbao / QQBot). An
+        # allowlist or disabled DM policy means the operator restricted access,
+        # so unauthorized DMs should be dropped silently rather than answered
+        # with a pairing code. An explicit pairing policy opts back into codes.
+        if platform and config and hasattr(config, "platforms"):
+            platform_cfg = config.platforms.get(platform)
+            extra = getattr(platform_cfg, "extra", None) if platform_cfg else None
+            if isinstance(extra, dict):
+                dm_policy = str(extra.get("dm_policy") or "").strip().lower()
+                if dm_policy == "pairing":
+                    return "pair"
+                if dm_policy in {"allowlist", "disabled"}:
+                    return "ignore"
+
+        # No explicit override.  Fall back to allowlist-aware default:
+        # if any allowlist is configured for this platform, silently drop
+        # unauthorized messages instead of sending pairing codes.
+        if platform:
+            platform_env_map = {
+                Platform.TELEGRAM: "TELEGRAM_ALLOWED_USERS",
+                Platform.DISCORD:  "DISCORD_ALLOWED_USERS",
+                Platform.WHATSAPP: "WHATSAPP_ALLOWED_USERS",
+                Platform.SLACK:    "SLACK_ALLOWED_USERS",
+                Platform.SIGNAL:   "SIGNAL_ALLOWED_USERS",
+                Platform.EMAIL:    "EMAIL_ALLOWED_USERS",
+                Platform.SMS:      "SMS_ALLOWED_USERS",
+                Platform.MATTERMOST: "MATTERMOST_ALLOWED_USERS",
+                Platform.MATRIX:   "MATRIX_ALLOWED_USERS",
+                Platform.DINGTALK: "DINGTALK_ALLOWED_USERS",
+                Platform.FEISHU:   "FEISHU_ALLOWED_USERS",
+                Platform.WECOM:    "WECOM_ALLOWED_USERS",
+                Platform.WECOM_CALLBACK: "WECOM_CALLBACK_ALLOWED_USERS",
+                Platform.WEIXIN:   "WEIXIN_ALLOWED_USERS",
+                Platform.BLUEBUBBLES: "BLUEBUBBLES_ALLOWED_USERS",
+                Platform.QQBOT:    "QQ_ALLOWED_USERS",
+            }
+            platform_group_env_map = {
+                Platform.TELEGRAM: (
+                    "TELEGRAM_GROUP_ALLOWED_USERS",
+                    "TELEGRAM_GROUP_ALLOWED_CHATS",
+                ),
+                Platform.QQBOT: ("QQ_GROUP_ALLOWED_USERS",),
+            }
+            if os.getenv(platform_env_map.get(platform, ""), "").strip():
+                return "ignore"
+            for env_key in platform_group_env_map.get(platform, ()):
+                if os.getenv(env_key, "").strip():
+                    return "ignore"
+
+        if os.getenv("GATEWAY_ALLOWED_USERS", "").strip():
+            return "ignore"
+
+        return "pair"
 
     async def _deliver_platform_notice(self, source, content: str) -> None:
         """Deliver a setup/operational notice using platform-specific privacy rules."""
@@ -7295,20 +7610,6 @@ class GatewayRunner(GatewayAuthorizationMixin, GatewayKanbanWatchersMixin, Gatew
         # message arriving during any of those yields would pass the
         # "already running" guard and spin up a duplicate agent for the
         # same session — corrupting the transcript.
-        _active_session_lease, _limit_message = self._claim_active_session_slot(
-            _quick_key,
-            source,
-        )
-        if _limit_message is not None:
-            logger.info(
-                "Rejecting new active session %s: max_concurrent_sessions reached",
-                _quick_key,
-            )
-            return _limit_message
-        if _active_session_lease is not None:
-            if not hasattr(self, "_active_session_leases"):
-                self._active_session_leases = {}
-            self._active_session_leases[_quick_key] = _active_session_lease
         self._running_agents[_quick_key] = _AGENT_PENDING_SENTINEL
         self._running_agents_ts[_quick_key] = time.time()
         _run_generation = self._begin_session_run_generation(_quick_key)
@@ -7447,28 +7748,10 @@ class GatewayRunner(GatewayAuthorizationMixin, GatewayKanbanWatchersMixin, Gatew
                     )
 
             if audio_paths:
-                message_text, _successful_transcripts = await self._enrich_message_with_transcription(
+                message_text = await self._enrich_message_with_transcription(
                     message_text,
                     audio_paths,
                 )
-                # Echo each successful transcript back to the user immediately,
-                # before the agent loop runs. Lets the user verify STT quality
-                # in real-time and see the raw whisper output verbatim.
-                if _successful_transcripts:
-                    _echo_adapter = self.adapters.get(source.platform)
-                    _echo_meta = self._thread_metadata_for_source(source, self._reply_anchor_for_event(event))
-                    if _echo_adapter:
-                        for _tx in _successful_transcripts:
-                            try:
-                                await _echo_adapter.send(
-                                    source.chat_id,
-                                    f'🎙️ "{_tx}"',
-                                    metadata=_echo_meta,
-                                )
-                            except Exception as _echo_exc:
-                                logger.debug(
-                                    "Transcript echo failed (non-fatal): %s", _echo_exc,
-                                )
                 _stt_fail_markers = (
                     "No STT provider",
                     "STT is disabled",
@@ -8596,11 +8879,6 @@ class GatewayRunner(GatewayAuthorizationMixin, GatewayKanbanWatchersMixin, Gatew
                     }
                 )
             
-            # The agent already persisted these messages to SQLite via
-            # _flush_messages_to_session_db(), so skip the DB write here
-            # to prevent the duplicate-write bug (#860 / #42039).
-            agent_persisted = self._session_db is not None
-
             # Find only the NEW messages from this turn (skip history we loaded).
             # Use the filtered history length (history_offset) that was actually
             # passed to the agent, not len(history) which includes session_meta
@@ -8618,7 +8896,6 @@ class GatewayRunner(GatewayAuthorizationMixin, GatewayKanbanWatchersMixin, Gatew
                 self.session_store.append_to_transcript(
                     session_entry.session_id,
                     _user_entry,
-                    skip_db=agent_persisted,
                 )
             else:
                 history_len = agent_result.get("history_offset", len(history))
@@ -8632,15 +8909,18 @@ class GatewayRunner(GatewayAuthorizationMixin, GatewayKanbanWatchersMixin, Gatew
                     self.session_store.append_to_transcript(
                         session_entry.session_id,
                         _user_entry,
-                        skip_db=agent_persisted,
                     )
                     if response:
                         self.session_store.append_to_transcript(
                             session_entry.session_id,
-                            {"role": "assistant", "content": response, "timestamp": ts},
-                            skip_db=agent_persisted,
+                            {"role": "assistant", "content": response, "timestamp": ts}
                         )
                 else:
+                    # The agent already persisted these messages to SQLite via
+                    # _flush_messages_to_session_db(), so skip the DB write here
+                    # to prevent the duplicate-write bug (#860).  We still write
+                    # to JSONL for backward compatibility and as a backup.
+                    agent_persisted = self._session_db is not None
                     # Attach the inbound platform message_id to the first user
                     # entry written this turn so platform-level quote-resolution
                     # (e.g. Yuanbao QuoteContextMiddleware's transcript fallback)
@@ -11375,7 +11655,7 @@ class GatewayRunner(GatewayAuthorizationMixin, GatewayKanbanWatchersMixin, Gatew
         self,
         user_text: str,
         audio_paths: List[str],
-    ) -> tuple[str, List[str]]:
+    ) -> str:
         """
         Auto-transcribe user voice/audio messages using the configured STT provider
         and prepend the transcript to the message text.
@@ -11385,13 +11665,7 @@ class GatewayRunner(GatewayAuthorizationMixin, GatewayKanbanWatchersMixin, Gatew
             audio_paths: List of local file paths to cached audio files.
 
         Returns:
-            A tuple of ``(enriched_text, successful_transcripts)``:
-              - ``enriched_text``: the message string with transcription wrappers
-                prepended (same as before).
-              - ``successful_transcripts``: the raw transcript strings for audio
-                clips that were successfully transcribed, in input order. Empty
-                list if every clip failed or STT is disabled. Callers can use
-                this to echo transcripts back to the user before the agent loop.
+            The enriched message string with transcriptions prepended.
         """
         if not getattr(self.config, "stt_enabled", True):
             notes = []
@@ -11405,26 +11679,24 @@ class GatewayRunner(GatewayAuthorizationMixin, GatewayKanbanWatchersMixin, Gatew
                 else:
                     notes.append(f"[The user sent a voice message: {abs_path}]")
             if not notes:
-                return user_text, []
+                return user_text
             prefix = "\n\n".join(notes)
             _placeholder = "(The user sent a message with no text content)"
             if user_text and user_text.strip() == _placeholder:
-                return prefix, []
+                return prefix
             if user_text:
-                return f"{prefix}\n\n{user_text}", []
-            return prefix, []
+                return f"{prefix}\n\n{user_text}"
+            return prefix
 
         from tools.transcription_tools import transcribe_audio
 
         enriched_parts = []
-        successful_transcripts: List[str] = []
         for path in audio_paths:
             try:
                 logger.debug("Transcribing user voice: %s", path)
                 result = await asyncio.to_thread(transcribe_audio, path)
                 if result["success"]:
                     transcript = result["transcript"]
-                    successful_transcripts.append(transcript)
                     enriched_parts.append(
                         f'[The user sent a voice message~ '
                         f'Here\'s what they said: "{transcript}"]'
@@ -11469,75 +11741,9 @@ class GatewayRunner(GatewayAuthorizationMixin, GatewayKanbanWatchersMixin, Gatew
             if user_text and user_text.strip() == _placeholder:
                 return prefix
             if user_text:
-                return f"{prefix}\n\n{user_text}", successful_transcripts
-            return prefix, successful_transcripts
-        return user_text, successful_transcripts
-
-    async def _dequeue_pending_with_transcription(
-        self,
-        adapter,
-        session_key: str,
-        source,
-    ) -> str | None:
-        """Dequeue a pending queued message, auto-transcribing audio media.
-
-        When a voice/audio message arrives during an active agent run, the
-        adapter stores the event in its pending queue and signals an interrupt
-        (see base.BaseAdapter.handle_message). The adapter path bypasses
-        _handle_message entirely, so the normal STT pipeline at message-receive
-        time never runs.
-
-        This helper fills that gap: when the dequeued event has audio media,
-        we transcribe inline, echo the raw transcript back to the user (same
-        "🎙️" format as the fresh-message path), and return enriched text.
-        Non-audio events fall back to _build_media_placeholder, matching the
-        original _dequeue_pending_text behavior.
-        """
-        event = adapter.get_pending_message(session_key)
-        if not event:
-            return None
-
-        text = event.text or ""
-
-        audio_paths: List[str] = []
-        media_urls = getattr(event, "media_urls", None) or []
-        media_types = getattr(event, "media_types", None) or []
-        for i, path in enumerate(media_urls):
-            mtype = media_types[i] if i < len(media_types) else ""
-            is_audio = (
-                mtype.startswith("audio/")
-                or getattr(event, "message_type", None) in (MessageType.VOICE, MessageType.AUDIO)
-            )
-            if is_audio:
-                audio_paths.append(path)
-
-        if audio_paths:
-            enriched_text, successful_transcripts = await self._enrich_message_with_transcription(
-                text, audio_paths,
-            )
-            # Echo raw transcripts back to the user so voice interrupts
-            # feel identical to fresh voice messages.
-            if successful_transcripts:
-                echo_adapter = self.adapters.get(source.platform)
-                echo_meta = {"thread_id": source.thread_id} if source.thread_id else None
-                if echo_adapter:
-                    for tx in successful_transcripts:
-                        try:
-                            await echo_adapter.send(
-                                source.chat_id,
-                                f'🎙️ "{tx}"',
-                                metadata=echo_meta,
-                            )
-                        except Exception as echo_exc:
-                            logger.debug(
-                                "Transcript echo failed (non-fatal): %s", echo_exc,
-                            )
-            return enriched_text or None
-
-        # Non-audio fallback: preserve original _dequeue_pending_text semantics.
-        if not text and media_urls:
-            text = _build_media_placeholder(event)
-        return text or None
+                return f"{prefix}\n\n{user_text}"
+            return prefix
+        return user_text
 
     def _build_process_event_source(self, evt: dict):
         """Resolve the canonical source for a synthetic background-process event.
@@ -12048,12 +12254,6 @@ class GatewayRunner(GatewayAuthorizationMixin, GatewayKanbanWatchersMixin, Gatew
             session_key, run_generation
         ):
             return False
-        lease = getattr(self, "_active_session_leases", {}).pop(session_key, None)
-        if lease is not None:
-            try:
-                lease.release()
-            except Exception:
-                logger.debug("Failed to release active session slot", exc_info=True)
         self._running_agents.pop(session_key, None)
         self._running_agents_ts.pop(session_key, None)
         if hasattr(self, "_busy_ack_ts"):
@@ -12186,67 +12386,11 @@ class GatewayRunner(GatewayAuthorizationMixin, GatewayKanbanWatchersMixin, Gatew
             self._release_running_agent_state(session_key)
 
     def _evict_cached_agent(self, session_key: str) -> None:
-        """Remove a cached agent for a session (called on /new, /model, etc).
-
-        Pops the entry AND soft-releases the evicted agent's LLM client
-        pool so the httpx connection (sockets + held buffers) is freed
-        promptly rather than waiting on CPython GC — AIAgent holds
-        reference cycles (callbacks, tool state) that delay refcount
-        collection, so a manual release is required to keep gateway RSS
-        flat across many /new, /model, undo and reset operations (#29298,
-        same leak class as #25315).
-
-        The release is soft (``release_clients()``): it frees the client
-        pool and per-turn child subagents but PRESERVES the session's
-        terminal sandbox, browser daemon, and tracked bg processes (keyed
-        on task_id), because the session may resume with a freshly-built
-        agent.  Call sites that want a hard teardown (true conversation
-        boundaries like /new) already call ``_cleanup_agent_resources``
-        before evicting; ``release_clients`` is idempotent and safe to
-        run again after that (the client is already None).
-
-        Cleanup runs on a daemon thread so we never block holding
-        ``_agent_cache_lock`` on slow socket teardown — mirrors the
-        cap-enforcer and idle-sweeper paths.
-        """
+        """Remove a cached agent for a session (called on /new, /model, etc)."""
         _lock = getattr(self, "_agent_cache_lock", None)
-        evicted = None
         if _lock:
             with _lock:
-                evicted = self._agent_cache.pop(session_key, None)
-        else:
-            _cache = getattr(self, "_agent_cache", None)
-            if _cache is not None:
-                evicted = _cache.pop(session_key, None)
-
-        agent = evicted[0] if isinstance(evicted, tuple) and evicted else evicted
-        if agent is None or agent is _AGENT_PENDING_SENTINEL:
-            return
-
-        # Don't tear down an agent that's actively mid-turn — its client,
-        # sandbox and child subagents are in use by the running request.
-        running_ids = {
-            id(a)
-            for a in getattr(self, "_running_agents", {}).values()
-            if a is not None and a is not _AGENT_PENDING_SENTINEL
-        }
-        if id(agent) in running_ids:
-            return
-
-        try:
-            threading.Thread(
-                target=self._release_evicted_agent_soft,
-                args=(agent,),
-                daemon=True,
-                name=f"agent-evict-{str(session_key)[:24]}",
-            ).start()
-        except Exception:
-            # If we can't spawn a thread (interpreter shutdown), release
-            # inline as a best-effort fallback.
-            try:
-                self._release_evicted_agent_soft(agent)
-            except Exception:
-                pass
+                self._agent_cache.pop(session_key, None)
 
     @staticmethod
     def _init_cached_agent_for_turn(agent: Any, interrupt_depth: int) -> None:
@@ -12288,13 +12432,6 @@ class GatewayRunner(GatewayAuthorizationMixin, GatewayKanbanWatchersMixin, Gatew
                 self._cleanup_agent_resources(agent)
         except Exception:
             pass
-        # Free conversation history memory — can be tens of MB with tool
-        # outputs (file reads, terminal output, search results) on heavy
-        # 100+-tool-call sessions. release_clients() deliberately preserves
-        # session tool state for resume, but the message list is rebuilt from
-        # persisted session JSON on the next turn, so dropping it here is safe.
-        if hasattr(agent, "_session_messages"):
-            agent._session_messages = []
 
     def _enforce_agent_cache_cap(self) -> None:
         """Evict oldest cached agents when cache exceeds _AGENT_CACHE_MAX_SIZE.
@@ -14454,52 +14591,7 @@ class GatewayRunner(GatewayAuthorizationMixin, GatewayKanbanWatchersMixin, Gatew
                             # is lost — neither the interrupt path nor the dequeue
                             # path finds it.
                             _peek_event = _adapter._pending_messages.get(session_key)
-                            pending_text = None
-                            if _peek_event is not None:
-                                pending_text = _peek_event.text or ""
-                                # Transcribe audio media BEFORE signaling the
-                                # agent, so voice messages interrupt with the
-                                # real transcript instead of an empty string
-                                # (or file-path placeholder). Matches the UX
-                                # of fresh voice messages including the
-                                # 🎙️ echo back to the user.
-                                _media_urls = getattr(_peek_event, "media_urls", None) or []
-                                _media_types = getattr(_peek_event, "media_types", None) or []
-                                _audio_paths = []
-                                for _i, _path in enumerate(_media_urls):
-                                    _mtype = _media_types[_i] if _i < len(_media_types) else ""
-                                    _is_audio = (
-                                        _mtype.startswith("audio/")
-                                        or getattr(_peek_event, "message_type", None) in (MessageType.VOICE, MessageType.AUDIO)
-                                    )
-                                    if _is_audio:
-                                        _audio_paths.append(_path)
-                                if _audio_paths:
-                                    try:
-                                        _enriched, _transcripts = await self._enrich_message_with_transcription(
-                                            pending_text, _audio_paths,
-                                        )
-                                        pending_text = _enriched
-                                        if _transcripts:
-                                            _echo_meta = {"thread_id": source.thread_id} if source.thread_id else None
-                                            for _tx in _transcripts:
-                                                try:
-                                                    await _adapter.send(
-                                                        source.chat_id,
-                                                        f'🎙️ "{_tx}"',
-                                                        metadata=_echo_meta,
-                                                    )
-                                                except Exception as _echo_exc:
-                                                    logger.debug(
-                                                        "Voice-interrupt echo failed (non-fatal): %s",
-                                                        _echo_exc,
-                                                    )
-                                    except Exception as _trans_exc:
-                                        logger.warning(
-                                            "Voice-interrupt transcription failed: %s", _trans_exc,
-                                        )
-                                elif not pending_text and _media_urls:
-                                    pending_text = _build_media_placeholder(_peek_event)
+                            pending_text = _peek_event.text if _peek_event else None
                             logger.debug("Interrupt detected from adapter, signaling agent...")
                             agent.interrupt(pending_text)
                             _interrupt_detected.set()
@@ -14824,52 +14916,8 @@ class GatewayRunner(GatewayAuthorizationMixin, GatewayKanbanWatchersMixin, Gatew
                     else:
                         pending = interrupt_message
                 elif pending_event:
-                    # Transcribe audio media on the dequeued event BEFORE it is
-                    # handed back as the next user turn, so queued/interrupting
-                    # voice messages drain with the real transcript instead of
-                    # a file-path placeholder. Echo each transcript back to the
-                    # user (same 🎙️ format as fresh voice messages) so voice
-                    # interrupts feel identical to text interrupts.
-                    _pending_text = pending_event.text or ""
-                    _media_urls = getattr(pending_event, "media_urls", None) or []
-                    _media_types = getattr(pending_event, "media_types", None) or []
-                    _audio_paths = []
-                    for _i, _path in enumerate(_media_urls):
-                        _mtype = _media_types[_i] if _i < len(_media_types) else ""
-                        _is_audio = (
-                            _mtype.startswith("audio/")
-                            or getattr(pending_event, "message_type", None) in (MessageType.VOICE, MessageType.AUDIO)
-                        )
-                        if _is_audio:
-                            _audio_paths.append(_path)
-                    if _audio_paths:
-                        try:
-                            _enriched, _transcripts = await self._enrich_message_with_transcription(
-                                _pending_text, _audio_paths,
-                            )
-                            pending = _enriched or None
-                            if _transcripts:
-                                _echo_meta = {"thread_id": source.thread_id} if source.thread_id else None
-                                for _tx in _transcripts:
-                                    try:
-                                        await adapter.send(
-                                            source.chat_id,
-                                            f'🎙️ "{_tx}"',
-                                            metadata=_echo_meta,
-                                        )
-                                    except Exception as _echo_exc:
-                                        logger.debug(
-                                            "Voice-drain echo failed (non-fatal): %s", _echo_exc,
-                                        )
-                        except Exception as _trans_exc:
-                            logger.warning(
-                                "Voice-drain transcription failed: %s", _trans_exc,
-                            )
-                            pending = _pending_text or _build_media_placeholder(pending_event)
-                    else:
-                        pending = _pending_text or _build_media_placeholder(pending_event)
-                    if pending:
-                        logger.debug("Processing queued message after agent completion: '%s...'", pending[:40])
+                    pending = pending_event.text or _build_media_placeholder(pending_event)
+                    logger.debug("Processing queued message after agent completion: '%s...'", pending[:40])
 
             # Leftover /steer: if a steer arrived after the last tool batch
             # (e.g. during the final API call), the agent couldn't inject it

hermes_cli/active_sessions.py

@@ -1,320 +0,0 @@
-"""Cross-process active chat session leases.
-
-The session database records persisted conversations.  This module records
-currently open chat surfaces, including idle CLI/TUI sessions that have not
-written a transcript row yet.
-"""
-
-from __future__ import annotations
-
-import json
-import logging
-import os
-import time
-import uuid
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Any, Optional
-
-from hermes_constants import get_hermes_home
-
-logger = logging.getLogger(__name__)
-
-
-def coerce_max_concurrent_sessions(value: Any, key: str = "max_concurrent_sessions") -> Optional[int]:
-    """Return a positive integer cap, or None when disabled/invalid."""
-    if value is None:
-        return None
-    if isinstance(value, bool):
-        logger.warning(
-            "Ignoring invalid %s=%r (expected a positive integer; 0/null disables)",
-            key,
-            value,
-        )
-        return None
-    try:
-        if isinstance(value, float):
-            if not value.is_integer():
-                raise ValueError(value)
-            parsed = int(value)
-        elif isinstance(value, str):
-            parsed = int(value.strip(), 10)
-        else:
-            parsed = int(value)
-    except (TypeError, ValueError):
-        logger.warning(
-            "Ignoring invalid %s=%r (expected a positive integer; 0/null disables)",
-            key,
-            value,
-        )
-        return None
-    if parsed <= 0:
-        return None
-    return parsed
-
-
-def resolve_max_concurrent_sessions(config: Any) -> Optional[int]:
-    """Resolve top-level max_concurrent_sessions with gateway.* fallback."""
-    raw: Any = None
-    key = "max_concurrent_sessions"
-    if isinstance(config, dict):
-        if "max_concurrent_sessions" in config:
-            raw = config.get("max_concurrent_sessions")
-        else:
-            gateway_cfg = config.get("gateway")
-            if isinstance(gateway_cfg, dict):
-                raw = gateway_cfg.get("max_concurrent_sessions")
-                key = "gateway.max_concurrent_sessions"
-    else:
-        raw = getattr(config, "max_concurrent_sessions", None)
-    return coerce_max_concurrent_sessions(raw, key=key)
-
-
-def active_session_limit_message(active_count: int, max_sessions: int) -> str:
-    return (
-        f"Hermes is at the active session limit ({active_count}/{max_sessions}). "
-        "Try again when another session finishes."
-    )
-
-
-def _state_dir() -> Path:
-    return get_hermes_home() / "runtime"
-
-
-def _state_path() -> Path:
-    return _state_dir() / "active_sessions.json"
-
-
-def _lock_path() -> Path:
-    return _state_dir() / "active_sessions.lock"
-
-
-class _FileLock:
-    def __init__(self, path: Path):
-        self.path = path
-        self._fh = None
-
-    def __enter__(self):
-        self.path.parent.mkdir(parents=True, exist_ok=True)
-        self._fh = open(self.path, "a+b")
-        if os.name == "nt":
-            try:
-                import msvcrt
-
-                self._fh.seek(0)
-                msvcrt.locking(self._fh.fileno(), msvcrt.LK_LOCK, 1)
-            except Exception as exc:
-                self._fh.close()
-                self._fh = None
-                raise RuntimeError("active session file lock unavailable") from exc
-        else:
-            try:
-                import fcntl
-
-                fcntl.flock(self._fh.fileno(), fcntl.LOCK_EX)
-            except Exception as exc:
-                self._fh.close()
-                self._fh = None
-                raise RuntimeError("active session file lock unavailable") from exc
-        return self
-
-    def __exit__(self, exc_type, exc, tb):
-        if self._fh is None:
-            return
-        if os.name == "nt":
-            try:
-                import msvcrt
-
-                self._fh.seek(0)
-                msvcrt.locking(self._fh.fileno(), msvcrt.LK_UNLCK, 1)
-            except Exception:
-                pass
-        else:
-            try:
-                import fcntl
-
-                fcntl.flock(self._fh.fileno(), fcntl.LOCK_UN)
-            except Exception:
-                pass
-        try:
-            self._fh.close()
-        finally:
-            self._fh = None
-
-
-def _read_entries(path: Path) -> list[dict[str, Any]]:
-    try:
-        with open(path, "r", encoding="utf-8") as fh:
-            data = json.load(fh)
-    except FileNotFoundError:
-        return []
-    except Exception:
-        logger.warning("Ignoring corrupt active session registry at %s", path)
-        return []
-    entries = data.get("entries") if isinstance(data, dict) else data
-    if not isinstance(entries, list):
-        return []
-    return [entry for entry in entries if isinstance(entry, dict)]
-
-
-def _write_entries(path: Path, entries: list[dict[str, Any]]) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    tmp = path.with_name(f"{path.name}.{os.getpid()}.{uuid.uuid4().hex}.tmp")
-    with open(tmp, "w", encoding="utf-8") as fh:
-        json.dump({"entries": entries}, fh, sort_keys=True)
-    os.replace(tmp, path)
-
-
-def _process_start_time(pid: int) -> Optional[float]:
-    # Pair pid with process create_time when psutil can read it, so a recycled
-    # pid does not keep a stale lease alive indefinitely.
-    try:
-        import psutil  # type: ignore
-
-        return float(psutil.Process(pid).create_time())
-    except Exception:
-        return None
-
-
-def _optional_float(value: Any) -> Optional[float]:
-    if value is None or value == "":
-        return None
-    try:
-        return float(value)
-    except (TypeError, ValueError):
-        return None
-
-
-def _pid_alive(pid: Any, process_start_time: Any = None) -> bool:
-    try:
-        pid_int = int(pid)
-    except (TypeError, ValueError):
-        return False
-    if pid_int <= 0:
-        return False
-    try:
-        from gateway.status import _pid_exists
-
-        exists = bool(_pid_exists(pid_int))
-    except Exception:
-        return False
-    if not exists:
-        return False
-    expected_start = _optional_float(process_start_time)
-    if expected_start is None:
-        return True
-    current_start = _process_start_time(pid_int)
-    if current_start is None:
-        return True
-    return abs(current_start - expected_start) < 0.001
-
-
-def _prune_dead(entries: list[dict[str, Any]]) -> list[dict[str, Any]]:
-    return [
-        entry
-        for entry in entries
-        if _pid_alive(entry.get("pid"), entry.get("process_start_time"))
-    ]
-
-
-@dataclass
-class ActiveSessionLease:
-    lease_id: str
-    session_id: str
-    surface: str
-    enabled: bool = True
-    released: bool = False
-
-    def release(self) -> None:
-        if self.released or not self.enabled:
-            return
-        release_active_session(self)
-
-
-def try_acquire_active_session(
-    *,
-    session_id: str,
-    surface: str,
-    config: Any,
-    metadata: Optional[dict[str, Any]] = None,
-) -> tuple[Optional[ActiveSessionLease], Optional[str]]:
-    """Acquire an active-session slot.
-
-    Returns ``(lease, None)`` on success.  When the cap is disabled, the lease is
-    a no-op object so callers can unconditionally call ``release()``.
-    """
-    max_sessions = resolve_max_concurrent_sessions(config)
-    lease_id = uuid.uuid4().hex
-    if max_sessions is None:
-        return ActiveSessionLease(
-            lease_id=lease_id,
-            session_id=session_id,
-            surface=surface,
-            enabled=False,
-        ), None
-
-    now = time.time()
-    entry = {
-        "lease_id": lease_id,
-        "session_id": str(session_id),
-        "surface": str(surface),
-        "pid": os.getpid(),
-        "process_start_time": _process_start_time(os.getpid()),
-        "started_at": now,
-        "updated_at": now,
-    }
-    if metadata:
-        entry["metadata"] = {
-            str(k): v for k, v in metadata.items() if isinstance(k, str)
-        }
-
-    state_path = _state_path()
-    with _FileLock(_lock_path()):
-        raw_entries = _read_entries(state_path)
-        entries = _prune_dead(raw_entries)
-        pruned = len(raw_entries) - len(entries)
-        if pruned:
-            logger.info("Pruned %d stale active session lease(s)", pruned)
-        active_count = len(entries)
-        if active_count >= max_sessions:
-            _write_entries(state_path, entries)
-            logger.info(
-                "Active session limit reached: active=%d max=%d surface=%s",
-                active_count,
-                max_sessions,
-                surface,
-            )
-            return None, active_session_limit_message(active_count, max_sessions)
-        entries.append(entry)
-        _write_entries(state_path, entries)
-
-    return ActiveSessionLease(
-        lease_id=lease_id,
-        session_id=str(session_id),
-        surface=str(surface),
-    ), None
-
-
-def release_active_session(lease: ActiveSessionLease) -> None:
-    state_path = _state_path()
-    try:
-        with _FileLock(_lock_path()):
-            entries = _prune_dead(_read_entries(state_path))
-            kept = [
-                entry
-                for entry in entries
-                if str(entry.get("lease_id") or "") != lease.lease_id
-            ]
-            if len(kept) != len(entries):
-                _write_entries(state_path, kept)
-    finally:
-        lease.released = True
-
-
-def active_session_registry_snapshot() -> list[dict[str, Any]]:
-    """Return the pruned active-session registry for diagnostics/tests."""
-    state_path = _state_path()
-    with _FileLock(_lock_path()):
-        entries = _prune_dead(_read_entries(state_path))
-        _write_entries(state_path, entries)
-        return entries

hermes_cli/auth.py

@@ -1182,24 +1182,6 @@ def _store_provider_state(
         auth_store["active_provider"] = provider_id
 
 
-def mark_provider_active_if_unset(provider_id: str) -> None:
-    """Set ``active_provider`` to *provider_id* only when none is set yet.
-
-    Used by ``hermes auth add`` OAuth paths that create credential-pool
-    entries directly (no singleton ``providers.<id>`` block). Adding the
-    very first credential for a provider should make it the active provider
-    so the setup wizard's ``_model_section_has_credentials()`` check (which
-    consults ``get_active_provider()``) does not report "No inference
-    provider configured". Subsequent adds for an already-active setup leave
-    the user's chosen active provider untouched.
-    """
-    with _auth_store_lock():
-        auth_store = _load_auth_store()
-        if not (auth_store.get("active_provider") or "").strip():
-            auth_store["active_provider"] = provider_id
-            _save_auth_store(auth_store)
-
-
 def is_known_auth_provider(provider_id: str) -> bool:
     normalized = (provider_id or "").strip().lower()
     return normalized in PROVIDER_REGISTRY or normalized in SERVICE_PROVIDER_NAMES
@@ -1579,21 +1561,6 @@ def resolve_provider(
     if has_usable_secret(os.getenv("OPENAI_API_KEY")) or has_usable_secret(os.getenv("OPENROUTER_API_KEY")):
         return "openrouter"
 
-    # Auto-detect an OpenRouter credential added via `hermes auth add openrouter`
-    # (manual pool entry, no env var). Without this, a key that only lives in
-    # the credential pool is invisible to auto-detection — the user sees
-    # `hermes auth list` showing the credential while requests go out with no
-    # Authorization header ("HTTP 401: Missing Authentication header"). The
-    # env-var check above only covers keys exported as OPENROUTER_API_KEY /
-    # OPENAI_API_KEY. See issue #42130.
-    try:
-        from agent.credential_pool import load_pool as _load_pool
-
-        if _load_pool("openrouter").has_credentials():
-            return "openrouter"
-    except Exception as e:
-        logger.debug("Could not check OpenRouter credential pool: %s", e)
-
     # Auto-detect API-key providers by checking their env vars
     for pid, pconfig in PROVIDER_REGISTRY.items():
         if pconfig.auth_type != "api_key":
@@ -3373,7 +3340,6 @@ def _sync_codex_pool_entries(
     auth_store: Dict[str, Any],
     tokens: Dict[str, str],
     last_refresh: Optional[str],
-    previous_singleton_tokens: Optional[Dict[str, str]] = None,
 ) -> None:
     """Mirror a fresh Codex re-auth into the credential_pool OAuth entries.
 
@@ -3389,34 +3355,24 @@ def _sync_codex_pool_entries(
       OAuth flow when the user logged in via ``hermes setup`` / the model
       picker.  Always synced with the fresh tokens.
     * ``manual:device_code`` — entries created by ``hermes auth add openai-codex``
-      that use the same device-code OAuth mechanism.  ONLY synced if the
-      entry's existing access_token matches the *previous* singleton
-      access_token (i.e. the entry is a legacy singleton-alias from the
-      #33000 workaround era).  Manual entries whose tokens never matched the
-      singleton represent INDEPENDENT accounts added via
-      ``hermes auth add openai-codex`` and must not be overwritten by a
-      re-auth that targeted a different account (regression for #39236).
-
-      The original #33538 fix refreshed every ``manual:device_code`` entry
-      unconditionally.  That worked when ``manual:device_code`` only meant
-      "legacy alias of the singleton", but the same source string is now
-      also produced by independent-account additions, and the broad sync
-      silently clobbered distinct accounts with the latest-authenticated
-      token pair.  The access_token-match check distinguishes the two cases
-      without changing the source-string contract.
+      that use the same device-code OAuth mechanism.  An interactive re-auth
+      proves the user owns the ChatGPT account, so it is safe (and expected)
+      to refresh these entries too.  Without this, a user who once ran the
+      ``hermes auth add`` workaround for #33000 would silently leave that
+      manual entry stale on every subsequent re-auth, recreating the issue
+      reported in #33538.
 
     What does NOT get refreshed:
 
     * ``manual:api_key`` and any other non-device-code manual sources — those
       are independent credentials (an explicit API key, a different ChatGPT
       account, etc.) and must not be overwritten by a single re-auth.
-    * ``manual:device_code`` entries whose access_token does NOT match the
-      previous singleton — see above; these are independent accounts.
 
-    Error markers (``last_status``, ``last_error_*``) are cleared ONLY on
-    entries that actually had their tokens rewritten by this re-auth.
-    Independent entries keep their own error state (their 401/429 markers
-    belong to that account's own auth flow, not this re-auth).
+    Error markers (``last_status``, ``last_error_*``) are also cleared on
+    every device-code-backed entry — even those whose tokens we did not
+    rewrite — so that an interactive re-auth gives every relevant pool entry
+    a fresh selection chance instead of leaving them marked unhealthy from a
+    pre-re-auth 401.
     """
     access_token = tokens.get("access_token")
     if not access_token:
@@ -3428,34 +3384,15 @@ def _sync_codex_pool_entries(
     entries = pool.get("openai-codex")
     if not isinstance(entries, list):
         return
-    # Previous singleton access_token (before this re-auth overwrote it) —
-    # used to distinguish legacy singleton-aliases from independent accounts.
-    # When None or empty, no manual entry can be treated as an alias (which
-    # is the right default for first-ever-save or a freshly initialized
-    # auth.json).
-    prev_at = None
-    if isinstance(previous_singleton_tokens, dict):
-        prev_at = previous_singleton_tokens.get("access_token") or None
+    # Sources whose tokens should be rewritten by a fresh Codex device-code
+    # OAuth re-auth.  ``manual:api_key`` and unknown sources are intentionally
+    # excluded — they represent independent credentials.
+    REFRESHABLE_SOURCES = {"device_code", "manual:device_code"}
     for entry in entries:
         if not isinstance(entry, dict):
             continue
         source = entry.get("source")
-        if source == "device_code":
-            # Singleton-seeded mirror — always refresh.
-            refresh_this_entry = True
-        elif source == "manual:device_code":
-            # Refresh only if this entry's existing access_token matches the
-            # previous singleton access_token (i.e. it is a true alias of the
-            # singleton from the #33000 workaround era).  An entry with its
-            # own distinct token material is an independent account and must
-            # be left alone (#39236).
-            refresh_this_entry = bool(
-                prev_at and entry.get("access_token") == prev_at
-            )
-        else:
-            # ``manual:api_key`` and any future non-device-code sources.
-            refresh_this_entry = False
-        if not refresh_this_entry:
+        if source not in REFRESHABLE_SOURCES:
             continue
         entry["access_token"] = access_token
         if refresh_token:
@@ -3477,24 +3414,13 @@ def _save_codex_tokens(tokens: Dict[str, str], last_refresh: str = None, label:
     with _auth_store_lock():
         auth_store = _load_auth_store()
         state = _load_provider_state(auth_store, "openai-codex") or {}
-        # Capture the previous singleton tokens BEFORE overwriting them.  The
-        # pool-sync step uses this to distinguish legacy singleton-aliases
-        # (which should be refreshed) from independent accounts that
-        # ``hermes auth add openai-codex`` created (which must not be
-        # overwritten — see #39236).
-        previous_singleton_tokens = state.get("tokens") if isinstance(state.get("tokens"), dict) else None
         state["tokens"] = tokens
         state["last_refresh"] = last_refresh
         state["auth_mode"] = "chatgpt"
         if label and str(label).strip():
             state["label"] = str(label).strip()
         _save_provider_state(auth_store, "openai-codex", state)
-        _sync_codex_pool_entries(
-            auth_store,
-            tokens,
-            last_refresh,
-            previous_singleton_tokens=previous_singleton_tokens,
-        )
+        _sync_codex_pool_entries(auth_store, tokens, last_refresh)
         _save_auth_store(auth_store)
 
 

hermes_cli/auth_commands.py

@@ -13,7 +13,6 @@ from agent.credential_pool import (
     AUTH_TYPE_OAUTH,
     CUSTOM_POOL_PREFIX,
     SOURCE_MANUAL,
-    SOURCE_MANUAL_DEVICE_CODE,
     STATUS_EXHAUSTED,
     STRATEGY_FILL_FIRST,
     STRATEGY_ROUND_ROBIN,
@@ -313,35 +312,15 @@ def auth_add_command(args) -> None:
             creds["tokens"]["access_token"],
             _oauth_default_label(provider, len(pool.entries()) + 1),
         )
-        # Add a distinct, self-contained pool entry per account (matching the
-        # xai-oauth / google-gemini-cli / qwen-oauth patterns) instead of
-        # routing through the singleton ``_save_codex_tokens`` save path.
-        # The singleton round-trip collapsed every added account into the
-        # latest login: a second ``hermes auth add openai-codex`` overwrote
-        # the first account's singleton-mirrored ``device_code`` entry rather
-        # than creating an independent one (#39236). ``manual:device_code``
-        # entries refresh from their own token pair, so they need no singleton
-        # shadow.
-        entry = PooledCredential(
-            provider=provider,
-            id=uuid.uuid4().hex[:6],
-            label=label,
-            auth_type=AUTH_TYPE_OAUTH,
-            priority=0,
-            source=SOURCE_MANUAL_DEVICE_CODE,
-            access_token=creds["tokens"]["access_token"],
-            refresh_token=creds["tokens"].get("refresh_token"),
-            base_url=creds.get("base_url"),
+        auth_mod._save_codex_tokens(
+            creds["tokens"],
             last_refresh=creds.get("last_refresh"),
+            label=label,
         )
-        first_credential = not pool.entries()
-        pool.add_entry(entry)
-        # Adding the first Codex credential should make it the active provider
-        # (the old singleton save path did this implicitly via
-        # _save_provider_state). Subsequent adds leave the active provider as-is.
-        if first_credential:
-            auth_mod.mark_provider_active_if_unset(provider)
-        print(f'Added {provider} OAuth credential #{len(pool.entries())}: "{entry.label}"')
+        pool = load_pool(provider)
+        entry = next((item for item in pool.entries() if item.source == "device_code"), None)
+        shown_label = entry.label if entry is not None else label
+        print(f'Saved {provider} OAuth device-code credentials: "{shown_label}"')
         return
 
     if provider == "xai-oauth":

hermes_cli/cli_agent_setup_mixin.py

@@ -1,681 +0,0 @@
-"""Agent-construction and session-resume display methods for ``HermesCLI``.
-
-Extracted from ``cli.py`` as part of the god-file decomposition campaign
-(``~/.hermes/plans/god-file-decomposition.md``, Phase 4 step 2). This mixin holds
-the agent lifecycle/setup cluster: runtime-credential resolution, per-turn agent
-config, first-use agent construction, and resumed-session preload + history recap.
-
-Behavior-neutral: every method is lifted verbatim from ``HermesCLI``. ``self.*``
-calls resolve unchanged via the MRO. Neutral dependencies are imported at module
-top level; ``cli.py``-internal helpers/constants are imported lazily inside each
-method (``from cli import ...`` resolves at call time, when ``cli`` is fully
-loaded) so this module never imports ``cli`` at import time -> no import cycle.
-"""
-
-from __future__ import annotations
-
-import sys
-
-from rich.markup import escape as _escape
-
-
-class CLIAgentSetupMixin:
-    """Agent construction + session-resume display methods for ``HermesCLI``."""
-
-    def _ensure_runtime_credentials(self) -> bool:
-        """
-        Ensure runtime credentials are resolved before agent use.
-        Re-resolves provider credentials so key rotation and token refresh
-        are picked up without restarting the CLI.
-        Returns True if credentials are ready, False on auth failure.
-        """
-        from cli import ChatConsole, _cprint, logger
-        from hermes_cli.runtime_provider import (
-            resolve_runtime_provider,
-            format_runtime_provider_error,
-        )
-
-        _primary_exc = None
-        runtime = None
-        try:
-            runtime = resolve_runtime_provider(
-                requested=self.requested_provider,
-                explicit_api_key=self._explicit_api_key,
-                explicit_base_url=self._explicit_base_url,
-            )
-        except Exception as exc:
-            _primary_exc = exc
-
-        # Primary provider auth failed — try fallback providers before giving up.
-        if runtime is None and _primary_exc is not None:
-            from hermes_cli.auth import AuthError
-            if isinstance(_primary_exc, AuthError):
-                _fb_chain = self._fallback_model if isinstance(self._fallback_model, list) else []
-                for _fb in _fb_chain:
-                    _fb_provider = (_fb.get("provider") or "").strip().lower()
-                    _fb_model = (_fb.get("model") or "").strip()
-                    if not _fb_provider or not _fb_model:
-                        continue
-                    try:
-                        runtime = resolve_runtime_provider(requested=_fb_provider)
-                        logger.warning(
-                            "Primary provider auth failed (%s). Falling through to fallback: %s/%s",
-                            _primary_exc, _fb_provider, _fb_model,
-                        )
-                        _cprint(f"⚠️  Primary auth failed — switching to fallback: {_fb_provider} / {_fb_model}")
-                        self.requested_provider = _fb_provider
-                        self.model = _fb_model
-                        _primary_exc = None
-                        break
-                    except Exception:
-                        continue
-
-        if runtime is None:
-            message = format_runtime_provider_error(_primary_exc) if _primary_exc else "Provider resolution failed."
-            ChatConsole().print(f"[bold red]{message}[/]")
-            return False
-
-        api_key = runtime.get("api_key")
-        base_url = runtime.get("base_url")
-        resolved_provider = runtime.get("provider", "openrouter")
-        resolved_api_mode = runtime.get("api_mode", self.api_mode)
-        resolved_acp_command = runtime.get("command")
-        resolved_acp_args = list(runtime.get("args") or [])
-        resolved_credential_pool = runtime.get("credential_pool")
-        # A callable api_key is a bearer-token provider (Azure Foundry
-        # Entra ID — ``azure_identity_adapter.build_token_provider``).
-        # The OpenAI SDK accepts ``Callable[[], str]`` for ``api_key`` and
-        # invokes it before every request. Skip the string-only validation
-        # and placeholder substitution for callables.
-        _is_callable_provider = callable(api_key) and not isinstance(api_key, str)
-        if not _is_callable_provider and (not isinstance(api_key, str) or not api_key):
-            # Custom / local endpoints (llama.cpp, ollama, vLLM, etc.) often
-            # don't require authentication.  When a base_url IS configured but
-            # no API key was found, use a placeholder so the OpenAI SDK
-            # doesn't reject the request and local servers just ignore it.
-            _source = runtime.get("source", "")
-            _has_custom_base = isinstance(base_url, str) and base_url and "openrouter.ai" not in base_url
-            if _has_custom_base:
-                api_key = "no-key-required"
-                logger.debug(
-                    "No API key for custom endpoint %s (source=%s), "
-                    "using placeholder — local servers typically ignore auth",
-                    base_url, _source,
-                )
-            else:
-                print("\n⚠️  Provider resolver returned an empty API key. "
-                      "Set OPENROUTER_API_KEY or run: hermes setup")
-                return False
-        if not isinstance(base_url, str) or not base_url:
-            print("\n⚠️  Provider resolver returned an empty base URL. "
-                  "Check your provider config or run: hermes setup")
-            return False
-
-        credentials_changed = api_key != self.api_key or base_url != self.base_url
-        routing_changed = (
-            resolved_provider != self.provider
-            or resolved_api_mode != self.api_mode
-            or resolved_acp_command != self.acp_command
-            or resolved_acp_args != self.acp_args
-        )
-        self.provider = resolved_provider
-        self.api_mode = resolved_api_mode
-        self.acp_command = resolved_acp_command
-        self.acp_args = resolved_acp_args
-        self._credential_pool = resolved_credential_pool
-        self._provider_source = runtime.get("source")
-        self.api_key = api_key
-        self.base_url = base_url
-
-        # When a custom_provider entry carries an explicit `model` field,
-        # use it as the effective model name.  Without this, running
-        # `hermes chat --model <provider-name>` sends the provider name
-        # (e.g. "my-provider") as the model string to the API instead of
-        # the configured model (e.g. "qwen3.6-plus"), causing 400 errors.
-        runtime_model = runtime.get("model")
-        if runtime_model and isinstance(runtime_model, str):
-            # Only use runtime model if: model is unset, or model equals provider name
-            should_use_runtime_model = (
-                not self.model or  # No model configured yet
-                self.model == self.provider or  # Model is the provider slug
-                self.model == runtime.get("name")  # Model matches provider display name
-            )
-            if should_use_runtime_model:
-                self.model = runtime_model
-
-        # If model is still empty (e.g. user ran `hermes auth add openai-codex`
-        # without `hermes model`), fall back to the provider's first catalog
-        # model so the API call doesn't fail with "model must be non-empty".
-        if not self.model and resolved_provider:
-            try:
-                from hermes_cli.models import get_default_model_for_provider
-                _default = get_default_model_for_provider(resolved_provider)
-                if _default:
-                    self.model = _default
-                    logger.info(
-                        "No model configured — defaulting to %s for provider %s",
-                        _default, resolved_provider,
-                    )
-            except Exception:
-                pass
-
-        # Normalize model for the resolved provider (e.g. swap non-Codex
-        # models when provider is openai-codex).  Fixes #651.
-        model_changed = self._normalize_model_for_provider(resolved_provider)
-
-        # AIAgent/OpenAI client holds auth at init time, so rebuild if key,
-        # routing, or the effective model changed.
-        if (credentials_changed or routing_changed or model_changed) and self.agent is not None:
-            self.agent = None
-            self._active_agent_route_signature = None
-
-        return True
-
-    def _resolve_turn_agent_config(self, user_message: str) -> dict:
-        """Build the effective model/runtime config for a single user turn.
-
-        Always uses the session's primary model/provider.  If the user has
-        toggled `/fast` on and the current model supports Priority
-        Processing / Anthropic fast mode, attach `request_overrides` so the
-        API call is marked accordingly.
-        """
-        from hermes_cli.models import resolve_fast_mode_overrides
-
-        runtime = {
-            "api_key": self.api_key,
-            "base_url": self.base_url,
-            "provider": self.provider,
-            "api_mode": self.api_mode,
-            "command": self.acp_command,
-            "args": list(self.acp_args or []),
-            "credential_pool": getattr(self, "_credential_pool", None),
-        }
-        route = {
-            "model": self.model,
-            "runtime": runtime,
-            "signature": (
-                self.model,
-                runtime["provider"],
-                runtime["base_url"],
-                runtime["api_mode"],
-                runtime["command"],
-                tuple(runtime["args"]),
-            ),
-        }
-
-        service_tier = getattr(self, "service_tier", None)
-        if not service_tier:
-            route["request_overrides"] = None
-            return route
-
-        try:
-            overrides = resolve_fast_mode_overrides(route["model"])
-        except Exception:
-            overrides = None
-        route["request_overrides"] = overrides
-        return route
-
-    def _init_agent(self, *, model_override: str = None, runtime_override: dict = None, request_overrides: dict | None = None) -> bool:
-        """
-        Initialize the agent on first use.
-        When resuming a session, restores conversation history from SQLite.
-        
-        Returns:
-            bool: True if successful, False otherwise
-        """
-        from cli import AIAgent, ChatConsole, _DIM, _RST, _accent_hex, _cprint, _prepare_deferred_agent_startup, logger
-        if self.agent is not None:
-            return True
-
-        _prepare_deferred_agent_startup()
-        self._install_tool_callbacks()
-        self._ensure_tirith_security()
-
-        if not self._ensure_runtime_credentials():
-            return False
-
-        from hermes_cli.mcp_startup import wait_for_mcp_discovery
-
-        wait_for_mcp_discovery()
-
-        # Initialize SQLite session store for CLI sessions (if not already done in __init__)
-        if self._session_db is None:
-            try:
-                from hermes_state import SessionDB
-                self._session_db = SessionDB()
-            except Exception as e:
-                logger.warning("SQLite session store not available — session will NOT be indexed: %s", e)
-        
-        # If resuming, validate the session exists and load its history.
-        # _preload_resumed_session() may have already loaded it (called from
-        # run() for immediate display).  In that case, conversation_history
-        # is non-empty and we skip the DB round-trip.
-        if self._resumed and self._session_db and not self.conversation_history:
-            session_meta = self._session_db.get_session(self.session_id)
-            # In quiet mode (`hermes chat -Q` / --quiet, surfaced via
-            # tool_progress_mode == "off"), resume status lines go to stderr
-            # so stdout stays machine-readable for automation wrappers that
-            # do `$(hermes chat -Q --resume <id> -q "...")`. Without this,
-            # the resume banner pollutes captured stdout. See #11793.
-            _quiet_mode = getattr(self, "tool_progress_mode", "full") == "off"
-            if not session_meta:
-                if _quiet_mode:
-                    print(f"Session not found: {self.session_id}", file=sys.stderr)
-                    print(
-                        "Use a session ID from a previous CLI run (hermes sessions list).",
-                        file=sys.stderr,
-                    )
-                else:
-                    _cprint(f"\033[1;31mSession not found: {self.session_id}{_RST}")
-                    _cprint(f"{_DIM}Use a session ID from a previous CLI run (hermes sessions list).{_RST}")
-                return False
-            # If the requested session is the (empty) head of a compression
-            # chain, walk to the descendant that actually holds the messages.
-            # See #15000 and SessionDB.resolve_resume_session_id.
-            try:
-                resolved_id = self._session_db.resolve_resume_session_id(self.session_id)
-            except Exception:
-                resolved_id = self.session_id
-            if resolved_id and resolved_id != self.session_id:
-                ChatConsole().print(
-                    f"[dim]Session {_escape(self.session_id)} was compressed into "
-                    f"{_escape(resolved_id)}; resuming the descendant with your "
-                    f"transcript.[/dim]"
-                )
-                self.session_id = resolved_id
-                resolved_meta = self._session_db.get_session(self.session_id)
-                if resolved_meta:
-                    session_meta = resolved_meta
-            restored = self._session_db.get_messages_as_conversation(self.session_id)
-            if restored:
-                restored = [m for m in restored if m.get("role") != "session_meta"]
-                self.conversation_history = restored
-                msg_count = len([m for m in restored if m.get("role") == "user"])
-                title_part = ""
-                if session_meta.get("title"):
-                    title_part = f" \"{session_meta['title']}\""
-                if _quiet_mode:
-                    print(
-                        f"↻ Resumed session {self.session_id}{title_part} "
-                        f"({msg_count} user message{'s' if msg_count != 1 else ''}, "
-                        f"{len(restored)} total messages)",
-                        file=sys.stderr,
-                    )
-                else:
-                    ChatConsole().print(
-                        f"[bold {_accent_hex()}]↻ Resumed session[/] "
-                        f"[bold]{_escape(self.session_id)}[/]"
-                        f"[bold {_accent_hex()}]{_escape(title_part)}[/] "
-                        f"({msg_count} user message{'s' if msg_count != 1 else ''}, {len(restored)} total messages)"
-                    )
-                self._restore_session_cwd(session_meta, quiet=_quiet_mode)
-            else:
-                if _quiet_mode:
-                    print(
-                        f"Session {self.session_id} found but has no messages. Starting fresh.",
-                        file=sys.stderr,
-                    )
-                else:
-                    ChatConsole().print(
-                        f"[bold {_accent_hex()}]Session {_escape(self.session_id)} found but has no messages. Starting fresh.[/]"
-                    )
-            # Re-open the session (clear ended_at so it's active again)
-            try:
-                self._session_db._conn.execute(
-                    "UPDATE sessions SET ended_at = NULL, end_reason = NULL WHERE id = ?",
-                    (self.session_id,),
-                )
-                self._session_db._conn.commit()
-            except Exception:
-                pass
-        
-        try:
-            runtime = runtime_override or {
-                "api_key": self.api_key,
-                "base_url": self.base_url,
-                "provider": self.provider,
-                "api_mode": self.api_mode,
-                "command": self.acp_command,
-                "args": list(self.acp_args or []),
-                "credential_pool": getattr(self, "_credential_pool", None),
-            }
-            effective_model = model_override or self.model
-            self.agent = AIAgent(
-                model=effective_model,
-                api_key=runtime.get("api_key"),
-                base_url=runtime.get("base_url"),
-                provider=runtime.get("provider"),
-                api_mode=runtime.get("api_mode"),
-                acp_command=runtime.get("command"),
-                acp_args=runtime.get("args"),
-                credential_pool=runtime.get("credential_pool"),
-                max_tokens=self.max_tokens,
-                max_iterations=self.max_turns,
-                enabled_toolsets=self.enabled_toolsets,
-                disabled_toolsets=self.disabled_toolsets,
-                verbose_logging=self.verbose,
-                quiet_mode=not self.verbose,
-                tool_progress_mode=getattr(self, "tool_progress_mode", "all"),
-                ephemeral_system_prompt=self.system_prompt if self.system_prompt else None,
-                prefill_messages=self.prefill_messages or None,
-                reasoning_config=self.reasoning_config,
-                service_tier=self.service_tier,
-                request_overrides=request_overrides,
-                providers_allowed=self._providers_only,
-                providers_ignored=self._providers_ignore,
-                providers_order=self._providers_order,
-                provider_sort=self._provider_sort,
-                provider_require_parameters=self._provider_require_params,
-                provider_data_collection=self._provider_data_collection,
-                openrouter_min_coding_score=self._openrouter_min_coding_score,
-                session_id=self.session_id,
-                platform="cli",
-                session_db=self._session_db,
-                clarify_callback=self._clarify_callback,
-                reasoning_callback=self._current_reasoning_callback(),
-
-                fallback_model=self._fallback_model,
-                thinking_callback=self._on_thinking,
-                checkpoints_enabled=self.checkpoints_enabled,
-                checkpoint_max_snapshots=self.checkpoint_max_snapshots,
-                checkpoint_max_total_size_mb=self.checkpoint_max_total_size_mb,
-                checkpoint_max_file_size_mb=self.checkpoint_max_file_size_mb,
-                pass_session_id=self.pass_session_id,
-                skip_context_files=self.ignore_rules,
-                skip_memory=self.ignore_rules,
-                tool_progress_callback=self._on_tool_progress,
-                tool_start_callback=self._on_tool_start if self._inline_diffs_enabled else None,
-                tool_complete_callback=self._on_tool_complete if self._inline_diffs_enabled else None,
-                stream_delta_callback=self._stream_delta if self.streaming_enabled else None,
-                tool_gen_callback=self._on_tool_gen_start if self.streaming_enabled else None,
-                notice_callback=self._on_notice,
-                notice_clear_callback=self._on_notice_clear,
-            )
-            # Store reference for atexit memory provider shutdown
-            global _active_agent_ref
-            _active_agent_ref = self.agent
-            # Route agent status output through prompt_toolkit so ANSI escape
-            # sequences aren't garbled by patch_stdout's StdoutProxy (#2262).
-            self.agent._print_fn = _cprint
-            # Hydrate credits notices at session OPEN (parity with the TUI), so a
-            # depletion / usage-band warning shows before the first message. The
-            # notice_callback is bound above → _on_notice renders the line. Idempotent
-            # + fail-open inside the helper; harmless for non-Nous providers.
-            try:
-                from agent.credits_tracker import seed_credits_at_session_start
-
-                seed_credits_at_session_start(self.agent)
-            except Exception:
-                pass
-            self._active_agent_route_signature = (
-                effective_model,
-                runtime.get("provider"),
-                runtime.get("base_url"),
-                runtime.get("api_mode"),
-                runtime.get("command"),
-                tuple(runtime.get("args") or ()),
-            )
-
-            # Force-create DB row on /title intent, then apply title.
-            if self._pending_title and self._session_db and self.agent:
-                try:
-                    self.agent._ensure_db_session()
-                    if self.agent._session_db_created:
-                        self._session_db.set_session_title(self.session_id, self._pending_title)
-                        _cprint(f"  Session title applied: {self._pending_title}")
-                        self._pending_title = None
-                    # else: row creation failed transiently — keep _pending_title for retry
-                except (ValueError, Exception) as e:
-                    _cprint(f"  Could not apply pending title: {e}")
-                    # Keep _pending_title so it can be retried after row creation succeeds
-            return True
-        except Exception as e:
-            ChatConsole().print(f"[bold red]Failed to initialize agent: {e}[/]")
-            return False
-
-    def _preload_resumed_session(self) -> bool:
-        """Load a resumed session's history from the DB early (before first chat).
-
-        Called from run() so the conversation history is available for display
-        before the user sends their first message.  Sets
-        ``self.conversation_history`` and prints the one-liner status.  Returns
-        True if history was loaded, False otherwise.
-
-        The corresponding block in ``_init_agent()`` checks whether history is
-        already populated and skips the DB round-trip.
-        """
-        from cli import _accent_hex
-        if not self._resumed or not self._session_db:
-            return False
-
-        session_meta = self._session_db.get_session(self.session_id)
-        if not session_meta:
-            self._console_print(
-                f"[bold red]Session not found: {self.session_id}[/]"
-            )
-            self._console_print(
-                "[dim]Use a session ID from a previous CLI run "
-                "(hermes sessions list).[/]"
-            )
-            return False
-
-        # If the requested session is the (empty) head of a compression chain,
-        # walk to the descendant that actually holds the messages. See #15000.
-        try:
-            resolved_id = self._session_db.resolve_resume_session_id(self.session_id)
-        except Exception:
-            resolved_id = self.session_id
-        if resolved_id and resolved_id != self.session_id:
-            self._console_print(
-                f"[dim]Session {self.session_id} was compressed into "
-                f"{resolved_id}; resuming the descendant with your transcript.[/]"
-            )
-            self.session_id = resolved_id
-            resolved_meta = self._session_db.get_session(self.session_id)
-            if resolved_meta:
-                session_meta = resolved_meta
-
-        restored = self._session_db.get_messages_as_conversation(self.session_id)
-        if restored:
-            restored = [m for m in restored if m.get("role") != "session_meta"]
-            self.conversation_history = restored
-            msg_count = len([m for m in restored if m.get("role") == "user"])
-            title_part = ""
-            if session_meta.get("title"):
-                title_part = f' "{session_meta["title"]}"'
-            accent_color = _accent_hex()
-            self._console_print(
-                f"[{accent_color}]↻ Resumed session [bold]{self.session_id}[/bold]"
-                f"{title_part} "
-                f"({msg_count} user message{'s' if msg_count != 1 else ''}, "
-                f"{len(restored)} total messages)[/]"
-            )
-            self._restore_session_cwd(session_meta)
-        else:
-            accent_color = _accent_hex()
-            self._console_print(
-                f"[{accent_color}]Session {self.session_id} found but has no "
-                f"messages. Starting fresh.[/]"
-            )
-            return False
-
-        # Re-open the session (clear ended_at so it's active again)
-        try:
-            self._session_db._conn.execute(
-                "UPDATE sessions SET ended_at = NULL, end_reason = NULL "
-                "WHERE id = ?",
-                (self.session_id,),
-            )
-            self._session_db._conn.commit()
-        except Exception:
-            pass
-
-        return True
-
-    def _display_resumed_history(self):
-        """Render a compact recap of previous conversation messages.
-
-        Uses Rich markup with dim/muted styling so the recap is visually
-        distinct from the active conversation.  Caps the display at the
-        last ``MAX_DISPLAY_EXCHANGES`` user/assistant exchanges and shows
-        an indicator for earlier hidden messages.
-        """
-        from cli import CLI_CONFIG, _record_output_history_entry, _strip_reasoning_tags, _suspend_output_history
-        if not self.conversation_history:
-            return
-
-        # Check config: resume_display setting
-        if self.resume_display == "minimal":
-            return
-
-        # Read limits from config (with hardcoded defaults)
-        _disp = CLI_CONFIG.get("display", {})
-        MAX_DISPLAY_EXCHANGES = int(_disp.get("resume_exchanges", 10))
-        MAX_USER_LEN = int(_disp.get("resume_max_user_chars", 300))
-        MAX_ASST_LEN = int(_disp.get("resume_max_assistant_chars", 200))
-        MAX_ASST_LINES = int(_disp.get("resume_max_assistant_lines", 3))
-        SKIP_TOOL_ONLY = _disp.get("resume_skip_tool_only", True)
-
-        # Collect displayable entries (skip system, tool-result messages)
-        entries = []  # list of (role, display_text)
-        _last_asst_idx = None       # index of last assistant entry
-        _last_asst_full = None      # un-truncated display text for last assistant
-        for msg in self.conversation_history:
-            role = msg.get("role", "")
-            content = msg.get("content")
-            tool_calls = msg.get("tool_calls") or []
-
-            if role == "system":
-                continue
-            if role == "tool":
-                continue
-
-            if role == "user":
-                text = "" if content is None else str(content)
-                # Handle multimodal content (list of dicts)
-                if isinstance(content, list):
-                    parts = []
-                    for part in content:
-                        if isinstance(part, dict) and part.get("type") == "text":
-                            parts.append(part.get("text", ""))
-                        elif isinstance(part, dict) and part.get("type") == "image_url":
-                            parts.append("[image]")
-                    text = " ".join(parts)
-                if len(text) > MAX_USER_LEN:
-                    text = text[:MAX_USER_LEN] + "..."
-                entries.append(("user", text))
-
-            elif role == "assistant":
-                text = "" if content is None else str(content)
-                text = _strip_reasoning_tags(text)
-                parts = []
-                full_parts = []  # un-truncated version
-                if text:
-                    full_parts.append(text)
-                    lines = text.splitlines()
-                    if len(lines) > MAX_ASST_LINES:
-                        text = "\n".join(lines[:MAX_ASST_LINES]) + " ..."
-                    if len(text) > MAX_ASST_LEN:
-                        text = text[:MAX_ASST_LEN] + "..."
-                    parts.append(text)
-                if tool_calls:
-                    tc_count = len(tool_calls)
-                    # Extract tool names
-                    names = []
-                    for tc in tool_calls:
-                        fn = tc.get("function", {})
-                        name = fn.get("name", "unknown") if isinstance(fn, dict) else "unknown"
-                        if name not in names:
-                            names.append(name)
-                    names_str = ", ".join(names[:4])
-                    if len(names) > 4:
-                        names_str += ", ..."
-                    noun = "call" if tc_count == 1 else "calls"
-                    tc_summary = f"[{tc_count} tool {noun}: {names_str}]"
-                    parts.append(tc_summary)
-                    full_parts.append(tc_summary)
-                if not parts:
-                    # Skip pure-reasoning messages that have no visible output
-                    continue
-                # Skip tool-call-only entries when SKIP_TOOL_ONLY is enabled
-                has_text = bool(text)
-                if SKIP_TOOL_ONLY and not has_text and tool_calls:
-                    continue
-                entries.append(("assistant", " ".join(parts)))
-                _last_asst_idx = len(entries) - 1
-                _last_asst_full = " ".join(full_parts)
-
-        if not entries:
-            return
-
-        # Determine if we need to truncate
-        skipped = 0
-        if len(entries) > MAX_DISPLAY_EXCHANGES * 2:
-            skipped = len(entries) - MAX_DISPLAY_EXCHANGES * 2
-            entries = entries[skipped:]
-
-        # Replace last assistant entry with full (un-truncated) text
-        # so the user can see where they left off without wasting tokens.
-        if _last_asst_idx is not None and _last_asst_full:
-            adj_idx = _last_asst_idx - skipped
-            if 0 <= adj_idx < len(entries):
-                entries[adj_idx] = ("assistant_last", _last_asst_full)
-
-        # Build the display using Rich
-        from rich.panel import Panel
-        from rich.text import Text
-
-        try:
-            from hermes_cli.skin_engine import get_active_skin
-            _skin = get_active_skin()
-            _history_text_c = _skin.get_color("banner_text", "#FFF8DC")
-            _session_label_c = _skin.get_color("session_label", "#DAA520")
-            _session_border_c = _skin.get_color("session_border", "#8B8682")
-            _assistant_label_c = _skin.get_color("ui_ok", "#8FBC8F")
-        except Exception:
-            _history_text_c = "#FFF8DC"
-            _session_label_c = "#DAA520"
-            _session_border_c = "#8B8682"
-            _assistant_label_c = "#8FBC8F"
-
-        lines = Text()
-        if skipped:
-            lines.append(
-                f"  ... {skipped} earlier messages ...\n\n",
-                style="dim italic",
-            )
-
-        for i, (role, text) in enumerate(entries):
-            if role == "user":
-                lines.append("  ● You: ", style=f"dim bold {_session_label_c}")
-                # Show first line inline, indent rest
-                msg_lines = text.splitlines()
-                lines.append(msg_lines[0] + "\n", style="dim")
-                for ml in msg_lines[1:]:
-                    lines.append(f"         {ml}\n", style="dim")
-            elif role == "assistant_last":
-                # Last assistant response shown in full, non-dim
-                lines.append("  ◆ Hermes: ", style=f"bold {_assistant_label_c}")
-                msg_lines = text.splitlines()
-                lines.append(msg_lines[0] + "\n", style="")
-                for ml in msg_lines[1:]:
-                    lines.append(f"            {ml}\n", style="")
-            else:
-                lines.append("  ◆ Hermes: ", style=f"dim bold {_assistant_label_c}")
-                msg_lines = text.splitlines()
-                lines.append(msg_lines[0] + "\n", style="dim")
-                for ml in msg_lines[1:]:
-                    lines.append(f"            {ml}\n", style="dim")
-            if i < len(entries) - 1:
-                lines.append("")  # small gap
-
-        panel = Panel(
-            lines,
-            title=f"[dim {_session_label_c}]Previous Conversation[/]",
-            border_style=f"dim {_session_border_c}",
-            padding=(0, 1),
-            style=_history_text_c,
-        )
-        _record_output_history_entry(lambda: self._render_resume_history_panel_lines(panel))
-        with _suspend_output_history():
-            self._console_print(panel)

hermes_cli/config.py

@@ -805,9 +805,6 @@ DEFAULT_CONFIG = {
     "fallback_providers": [],
     "credential_pool_strategies": {},
     "toolsets": ["hermes-cli"],
-    # Global active chat session cap across CLI, TUI/dashboard, and messaging.
-    # None/0 = unbounded.
-    "max_concurrent_sessions": None,
     "agent": {
         "max_turns": 90,
         # Inactivity timeout for gateway agent execution (seconds).
@@ -2935,6 +2932,14 @@ OPTIONAL_ENV_VARS = {
         "password": True,
         "category": "tool",
     },
+    "APIFY_API_TOKEN": {
+        "description": "Apify API token for Actor execution tools (apify_discover, apify_start, apify_collect)",
+        "prompt": "Apify API token",
+        "url": "https://apify.com/account/integrations",
+        "tools": ["apify_discover", "apify_start", "apify_collect"],
+        "password": True,
+        "category": "tool",
+    },
     "SEARXNG_URL": {
         "description": "URL of your SearXNG instance for free self-hosted web search",
         "prompt": "SearXNG URL (e.g. http://localhost:8080)",

hermes_cli/dump.py

@@ -318,17 +318,6 @@ def run_dump(args):
             display = _redact(val)
         else:
             display = "set" if val else "not set"
-        # A credential added via `hermes auth add openrouter` lives in the
-        # credential pool, not as an env var — surface it so the dump doesn't
-        # misleadingly read "not set" while `hermes auth list` shows it (#42130).
-        if not val and label == "openrouter":
-            try:
-                from agent.credential_pool import load_pool as _load_pool
-
-                if _load_pool("openrouter").has_credentials():
-                    display = "set (auth pool)"
-            except Exception:
-                pass
         lines.append(f"  {label:<20} {display}")
 
     # Features summary

hermes_cli/plugins_cmd.py

@@ -135,89 +135,34 @@ def _sanitize_plugin_name(
     return target
 
 
-def _resolve_git_url(identifier: str) -> tuple[str, Optional[str]]:
-    """Turn an identifier into a cloneable Git URL and optional subdirectory.
-
-    Returns ``(git_url, subdir)`` where ``subdir`` is the path within the
-    cloned repository that contains the plugin (``None`` when the plugin lives
-    at the repo root).
+def _resolve_git_url(identifier: str) -> str:
+    """Turn an identifier into a cloneable Git URL.
 
     Accepted formats:
     - Full URL: https://github.com/owner/repo.git
     - Full URL: git@github.com:owner/repo.git
     - Full URL: ssh://git@github.com/owner/repo.git
     - Shorthand: owner/repo  →  https://github.com/owner/repo.git
-    - Shorthand w/ subdir: owner/repo/path/to/plugin
-      →  (https://github.com/owner/repo.git, "path/to/plugin")
-    - Full URL w/ subdir (``.git`` boundary):
-      https://github.com/owner/repo.git/path/to/plugin
-      →  (https://github.com/owner/repo.git, "path/to/plugin")
-    - Any URL w/ explicit subdir fragment (works for every scheme, incl.
-      ``file://`` and ssh): <url>#path/to/plugin
-      →  (<url>, "path/to/plugin")
 
     NOTE: ``http://`` and ``file://`` schemes are accepted but will trigger a
     security warning at install time.
     """
-    # Already a URL.
+    # Already a URL
     if identifier.startswith(("https://", "http://", "git@", "ssh://", "file://")):
-        # Explicit ``#subdir`` fragment — unambiguous for any scheme.
-        if "#" in identifier:
-            git_url, _, frag = identifier.partition("#")
-            return git_url, (frag.strip("/") or None)
-        # Natural ``.git/`` boundary (GitHub-style URLs).
-        marker = ".git/"
-        idx = identifier.find(marker)
-        if idx != -1:
-            git_url = identifier[: idx + len(".git")]
-            subdir = identifier[idx + len(marker) :].strip("/")
-            return git_url, (subdir or None)
-        return identifier, None
+        return identifier
 
-    # owner/repo[/subdir...] shorthand
-    parts = [p for p in identifier.strip("/").split("/") if p]
-    if len(parts) >= 2:
-        owner, repo = parts[0], parts[1]
-        subdir = "/".join(parts[2:]).strip("/")
-        git_url = f"https://github.com/{owner}/{repo}.git"
-        return git_url, (subdir or None)
+    # owner/repo shorthand
+    parts = identifier.strip("/").split("/")
+    if len(parts) == 2:
+        owner, repo = parts
+        return f"https://github.com/{owner}/{repo}.git"
 
     raise ValueError(
         f"Invalid plugin identifier: '{identifier}'. "
-        "Use a Git URL or 'owner/repo' shorthand (optionally with a subdirectory: "
-        "'owner/repo/path/to/plugin')."
+        "Use a Git URL or owner/repo shorthand."
     )
 
 
-def _resolve_subdir_within(clone_root: Path, subdir: str) -> Path:
-    """Resolve ``subdir`` inside ``clone_root``, rejecting path traversal.
-
-    Guards against ``..`` segments, absolute paths, and symlinks that would
-    escape the cloned repository. Returns the resolved directory path.
-    Raises ``PluginOperationError`` if the path escapes the clone, doesn't
-    exist, or is not a directory.
-    """
-    clone_root = clone_root.resolve()
-    candidate = (clone_root / subdir).resolve()
-
-    # The resolved candidate must stay within the clone root.
-    if candidate != clone_root and clone_root not in candidate.parents:
-        raise PluginOperationError(
-            f"Plugin subdirectory '{subdir}' escapes the repository.",
-        )
-
-    if not candidate.exists():
-        raise PluginOperationError(
-            f"Plugin subdirectory '{subdir}' does not exist in the repository.",
-        )
-    if not candidate.is_dir():
-        raise PluginOperationError(
-            f"Plugin subdirectory '{subdir}' is not a directory.",
-        )
-
-    return candidate
-
-
 def _repo_name_from_url(url: str) -> str:
     """Extract the repo name from a Git URL for the plugin directory name."""
     # Strip trailing .git and slashes
@@ -427,14 +372,14 @@ def _install_plugin_core(identifier: str, *, force: bool) -> tuple[Path, dict, s
     import tempfile
 
     try:
-        git_url, subdir = _resolve_git_url(identifier)
+        git_url = _resolve_git_url(identifier)
     except ValueError as e:
         raise PluginOperationError(str(e)) from e
 
     plugins_dir = _plugins_dir()
 
     with tempfile.TemporaryDirectory() as tmp:
-        tmp_clone = Path(tmp) / "plugin"
+        tmp_target = Path(tmp) / "plugin"
 
         git_exe = _resolve_git_executable()
         if not git_exe:
@@ -442,7 +387,7 @@ def _install_plugin_core(identifier: str, *, force: bool) -> tuple[Path, dict, s
 
         try:
             result = subprocess.run(
-                [git_exe, "clone", "--depth", "1", git_url, str(tmp_clone)],
+                [git_exe, "clone", "--depth", "1", git_url, str(tmp_target)],
                 capture_output=True,
                 text=True,
                 timeout=60,
@@ -460,16 +405,8 @@ def _install_plugin_core(identifier: str, *, force: bool) -> tuple[Path, dict, s
             err = (result.stderr or result.stdout or "").strip()
             raise PluginOperationError(f"Git clone failed:\n{err}")
 
-        # Resolve the directory within the clone that holds the plugin.
-        if subdir:
-            tmp_target = _resolve_subdir_within(tmp_clone, subdir)
-        else:
-            tmp_target = tmp_clone
-
         manifest = _read_manifest(tmp_target)
-        plugin_name = manifest.get("name") or (
-            subdir.rstrip("/").rsplit("/", 1)[-1] if subdir else _repo_name_from_url(git_url)
-        )
+        plugin_name = manifest.get("name") or _repo_name_from_url(git_url)
 
         try:
             target = _sanitize_plugin_name(plugin_name, plugins_dir)
@@ -534,7 +471,7 @@ def cmd_install(
     console = Console()
 
     try:
-        git_url, _subdir = _resolve_git_url(identifier)
+        git_url = _resolve_git_url(identifier)
     except ValueError as e:
         console.print(f"[red]Error:[/red] {e}")
         sys.exit(1)
@@ -545,10 +482,7 @@ def cmd_install(
             "Consider using https:// or git@ for production installs.",
         )
 
-    if _subdir:
-        console.print(f"[dim]Cloning {git_url} (subdir: {_subdir})...[/dim]")
-    else:
-        console.print(f"[dim]Cloning {git_url}...[/dim]")
+    console.print(f"[dim]Cloning {git_url}...[/dim]")
 
     try:
         target, installed_manifest, installed_name = _install_plugin_core(
@@ -715,62 +649,29 @@ def _save_enabled_set(enabled: set) -> None:
     save_config(config)
 
 
-def _resolve_plugin_key(name: str) -> Optional[str]:
-    """Resolve a user-supplied plugin identifier to its canonical registry key.
-
-    Accepts either the bare manifest name (``nemo_relay``), the directory
-    name, or the full path-derived key (``observability/nemo_relay``) and
-    returns the canonical key the loader gates on (``manifest.key`` or, for a
-    flat plugin, the bare name). Returns ``None`` when no plugin matches.
-
-    This is the single normalization point so ``hermes plugins enable`` /
-    ``disable`` write the same key that ``PluginManager`` matches against —
-    nested category plugins (e.g. ``observability/nemo_relay``) included.
-    """
-    entries = _discover_all_plugins()
-    # 1. Exact match on canonical key or manifest name — always unambiguous.
-    for entry in entries:
-        # entry = (name, version, description, source, dir_path, key)
-        if name == entry[5] or name == entry[0]:
-            return entry[5]
-    # 2. Fall back to a bare leaf-name match (e.g. "nemo_relay" ->
-    #    "observability/nemo_relay"), but only when it resolves to exactly one
-    #    plugin so we never silently pick the wrong same-named nested plugin.
-    leaf_matches = [entry[5] for entry in entries if name == entry[5].split("/")[-1]]
-    if len(leaf_matches) == 1:
-        return leaf_matches[0]
-    return None
-
-
 def cmd_enable(name: str) -> None:
     """Add a plugin to the enabled allow-list (and remove it from disabled)."""
     from rich.console import Console
 
     console = Console()
-    # Discover the plugin — check installed (user) AND bundled, including
-    # nested category plugins — and normalize to its canonical registry key.
-    key = _resolve_plugin_key(name)
-    if key is None:
+    # Discover the plugin — check installed (user) AND bundled.
+    if not _plugin_exists(name):
         console.print(f"[red]Plugin '{name}' is not installed or bundled.[/red]")
         sys.exit(1)
 
     enabled = _get_enabled_set()
     disabled = _get_disabled_set()
 
-    if key in enabled and key not in disabled:
-        console.print(f"[dim]Plugin '{key}' is already enabled.[/dim]")
+    if name in enabled and name not in disabled:
+        console.print(f"[dim]Plugin '{name}' is already enabled.[/dim]")
         return
 
-    enabled.add(key)
-    disabled.discard(key)
-    # Drop any legacy bare-name entry so the two don't drift out of sync.
-    bare = key.split("/")[-1]
-    if bare != key:
-        disabled.discard(bare)
+    enabled.add(name)
+    disabled.discard(name)
     _save_enabled_set(enabled)
     _save_disabled_set(disabled)
     console.print(
-        f"[green]✓[/green] Plugin [bold]{key}[/bold] enabled. "
+        f"[green]✓[/green] Plugin [bold]{name}[/bold] enabled. "
         "Takes effect on next session."
     )
 
@@ -780,129 +681,111 @@ def cmd_disable(name: str) -> None:
     from rich.console import Console
 
     console = Console()
-    key = _resolve_plugin_key(name)
-    if key is None:
+    if not _plugin_exists(name):
         console.print(f"[red]Plugin '{name}' is not installed or bundled.[/red]")
         sys.exit(1)
 
     enabled = _get_enabled_set()
     disabled = _get_disabled_set()
 
-    if key not in enabled and key in disabled:
-        console.print(f"[dim]Plugin '{key}' is already disabled.[/dim]")
+    if name not in enabled and name in disabled:
+        console.print(f"[dim]Plugin '{name}' is already disabled.[/dim]")
         return
 
-    enabled.discard(key)
-    # Drop any legacy bare-name entry from the allow-list too, so a stale
-    # bare name can't keep a nested plugin loading after an explicit disable.
-    bare = key.split("/")[-1]
-    if bare != key:
-        enabled.discard(bare)
-    disabled.add(key)
+    enabled.discard(name)
+    disabled.add(name)
     _save_enabled_set(enabled)
     _save_disabled_set(disabled)
     console.print(
-        f"[yellow]\u2298[/yellow] Plugin [bold]{key}[/bold] disabled. "
+        f"[yellow]\u2298[/yellow] Plugin [bold]{name}[/bold] disabled. "
         "Takes effect on next session."
     )
 
 
 def _plugin_exists(name: str) -> bool:
-    """Return True if a plugin with *name* (bare name or key) exists."""
-    return _resolve_plugin_key(name) is not None
-
-
-def _read_manifest_info(d: Path, prefix: str):
-    """Read a plugin.yaml manifest and return (name, version, description, key).
-
-    Returns None if no manifest file exists.
-    """
-    manifest_file = d / "plugin.yaml"
-    if not manifest_file.exists():
-        manifest_file = d / "plugin.yml"
-    if not manifest_file.exists():
-        return None
-    try:
-        import yaml
-    except ImportError:
-        yaml = None
-    name = d.name
-    version = ""
-    description = ""
-    if yaml:
-        try:
-            with open(manifest_file, encoding="utf-8") as f:
-                manifest = yaml.safe_load(f) or {}
-            name = manifest.get("name", d.name)
-            version = manifest.get("version", "")
-            description = manifest.get("description", "")
-        except Exception:
-            pass
-    key = f"{prefix}/{d.name}" if prefix else name
-    return name, version, description, key
-
-
-def _scan_level(
-    base: Path,
-    source: str,
-    skip_names: set,
-    prefix: str,
-    depth: int,
-    seen: dict,
-) -> None:
-    """Recursive directory scan matching PluginManager._scan_directory_level.
-
-    Populates *seen* with key -> (name, version, description, source, dir, key).
-    """
-    if not base.is_dir():
-        return
-    for d in sorted(base.iterdir()):
-        if not d.is_dir():
-            continue
-        if depth == 0 and skip_names and d.name in skip_names:
-            continue
-        info = _read_manifest_info(d, prefix)
-        if info is not None:
-            name, version, description, key = info
-            if key in seen and source == "bundled":
+    """Return True if a plugin with *name* is installed (user) or bundled."""
+    # Installed: directory name or manifest name match in user plugins dir
+    user_dir = _plugins_dir()
+    if user_dir.is_dir():
+        if (user_dir / name).is_dir():
+            return True
+        for child in user_dir.iterdir():
+            if not child.is_dir():
                 continue
-            src_label = source
-            if source == "user" and (d / ".git").exists():
-                src_label = "git"
-            seen[key] = (name, version, description, src_label, d, key)
-            continue
-        if depth >= 1:
-            continue
-        sub_prefix = f"{prefix}/{d.name}" if prefix else d.name
-        _scan_level(d, source, set(), sub_prefix, depth + 1, seen)
+            manifest = _read_manifest(child)
+            if manifest.get("name") == name:
+                return True
+    # Bundled: <repo>/plugins/<name>/ (or HERMES_BUNDLED_PLUGINS on Nix).
+    from hermes_cli.plugins import get_bundled_plugins_dir
+    repo_plugins = get_bundled_plugins_dir()
+    if repo_plugins.is_dir():
+        candidate = repo_plugins / name
+        if candidate.is_dir() and (
+            (candidate / "plugin.yaml").exists()
+            or (candidate / "plugin.yml").exists()
+        ):
+            return True
+    return False
 
 
 def _discover_all_plugins() -> list:
-    """Return a list of (name, version, description, source, dir_path, key) for
+    """Return a list of (name, version, description, source, dir_path) for
     every plugin the loader can see — user + bundled + project.
 
     Matches the ordering/dedup of ``PluginManager.discover_and_load``:
     bundled first, then user, then project; user overrides bundled on
-    key collision.
+    name collision.
     """
-    seen: dict = {}  # key -> (name, version, description, source, path, key)
+    try:
+        import yaml
+    except ImportError:
+        yaml = None
+
+    seen: dict = {}  # name -> (name, version, description, source, path)
 
     # Bundled (<repo>/plugins/<name>/), excluding memory/ and context_engine/
     from hermes_cli.plugins import get_bundled_plugins_dir
     repo_plugins = get_bundled_plugins_dir()
-    for base, source, skip in (
-        (repo_plugins, "bundled", {"memory", "context_engine"}),
-        (_plugins_dir(), "user", set()),
-    ):
-        _scan_level(base, source, skip, "", 0, seen)
+    for base, source in ((repo_plugins, "bundled"), (_plugins_dir(), "user")):
+        if not base.is_dir():
+            continue
+        for d in sorted(base.iterdir()):
+            if not d.is_dir():
+                continue
+            if source == "bundled" and d.name in {"memory", "context_engine"}:
+                continue
+            manifest_file = d / "plugin.yaml"
+            if not manifest_file.exists():
+                manifest_file = d / "plugin.yml"
+            if not manifest_file.exists():
+                continue
+            name = d.name
+            version = ""
+            description = ""
+            if yaml:
+                try:
+                    with open(manifest_file, encoding="utf-8") as f:
+                        manifest = yaml.safe_load(f) or {}
+                    name = manifest.get("name", d.name)
+                    version = manifest.get("version", "")
+                    description = manifest.get("description", "")
+                except Exception:
+                    pass
+            # User plugins override bundled on name collision.
+            if name in seen and source == "bundled":
+                continue
+            src_label = source
+            if source == "user" and (d / ".git").exists():
+                src_label = "git"
+            seen[name] = (name, version, description, src_label, d)
     return list(seen.values())
 
 
-def _plugin_status(name: str, enabled: set, disabled: set, key: str = "") -> str:
-    """Return the user-facing activation state for a plugin name or key."""
-    if name in disabled or key in disabled:
+def _plugin_status(name: str, enabled: set, disabled: set) -> str:
+    """Return the user-facing activation state for a plugin name."""
+    if name in disabled:
         return "disabled"
-    if name in enabled or key in enabled:
+    if name in enabled:
         return "enabled"
     return "not enabled"
 
@@ -915,7 +798,7 @@ def _filter_plugin_entries(entries: list, args: Any, enabled: set, disabled: set
     if getattr(args, "enabled", False):
         filtered = [
             entry for entry in filtered
-            if _plugin_status(entry[0], enabled, disabled, key=entry[5]) == "enabled"
+            if _plugin_status(entry[0], enabled, disabled) == "enabled"
         ]
     return filtered
 
@@ -940,19 +823,19 @@ def cmd_list(args: Any | None = None) -> None:
         payload = [
             {
                 "name": name,
-                "status": _plugin_status(name, enabled, disabled, key=key),
+                "status": _plugin_status(name, enabled, disabled),
                 "version": str(version),
                 "description": description,
                 "source": source,
             }
-            for name, version, description, source, _dir, key in entries
+            for name, version, description, source, _dir in entries
         ]
         print(json.dumps(payload, indent=2))
         return
 
     if getattr(args, "plain", False):
-        for name, version, _description, source, _dir, key in entries:
-            status = _plugin_status(name, enabled, disabled, key=key)
+        for name, version, _description, source, _dir in entries:
+            status = _plugin_status(name, enabled, disabled)
             print(f"{status:12} {source:8} {str(version):8} {name}")
         return
 
@@ -967,8 +850,8 @@ def cmd_list(args: Any | None = None) -> None:
     table.add_column("Description")
     table.add_column("Source", style="dim")
 
-    for name, version, description, source, _dir, key in entries:
-        status_name = _plugin_status(name, enabled, disabled, key=key)
+    for name, version, description, source, _dir in entries:
+        status_name = _plugin_status(name, enabled, disabled)
         if status_name == "disabled":
             status = "[red]disabled[/red]"
         elif status_name == "enabled":
@@ -1168,14 +1051,14 @@ def cmd_toggle() -> None:
     plugin_labels = []
     plugin_selected = set()
 
-    for i, (name, _version, description, source, _d, key) in enumerate(entries):
+    for i, (name, _version, description, source, _d) in enumerate(entries):
         label = f"{name} \u2014 {description}" if description else name
         if source == "bundled":
             label = f"{label} [bundled]"
         plugin_names.append(name)
         plugin_labels.append(label)
         # Selected (enabled) when in enabled-set AND not in disabled-set
-        if (name in enabled_set or key in enabled_set) and name not in disabled_set and key not in disabled_set:
+        if name in enabled_set and name not in disabled_set:
             plugin_selected.add(i)
 
     # -- Provider categories --
@@ -1539,7 +1422,7 @@ def dashboard_install_plugin(
     """Non-interactive install for the web dashboard. Returns a JSON-serializable dict."""
     warnings: list[str] = []
     try:
-        git_url, _subdir = _resolve_git_url(identifier)
+        git_url = _resolve_git_url(identifier)
         if git_url.startswith(("http://", "file://")):
             warnings.append(
                 "Insecure URL scheme; prefer https:// or git@ for production installs.",
@@ -1758,7 +1641,7 @@ def _git_pull_plugin_dir(target: Path) -> tuple[bool, str]:
 def dashboard_remove_user_plugin(name: str) -> dict[str, Any]:
     """Delete a plugin tree under ``~/.hermes/plugins/`` only."""
     plugins_dir = _plugins_dir()
-    for n, _ver, _d, src, _path, _key in _discover_all_plugins():
+    for n, _ver, _d, src, _path in _discover_all_plugins():
         if n == name and src == "bundled":
             return {"ok": False, "error": "Bundled plugins cannot be removed from the dashboard."}
 

hermes_cli/pty_bridge.py

@@ -250,23 +250,13 @@ class PtyBridge:
             return
         self._closed = True
 
-        try:
-            pgid = os.getpgid(self._proc.pid)  # windows-footgun: ok — POSIX-only module (imports fcntl/termios/ptyprocess at top)
-        except Exception:
-            pgid = None
-
         # SIGHUP is the conventional "your terminal went away" signal.
-        # Send it to the whole foreground process group, not just the PTY
-        # leader: the dashboard TUI starts helper children such as the Python
-        # slash worker, and killing only the leader can strand those helpers.
+        # We escalate if the child ignores it.
         for sig in (signal.SIGHUP, signal.SIGTERM, signal.SIGKILL):  # windows-footgun: ok — POSIX-only module (imports fcntl/termios/ptyprocess at top)
             if not self._proc.isalive():
                 break
             try:
-                if pgid is not None:
-                    os.killpg(pgid, sig)  # windows-footgun: ok — POSIX-only module (imports fcntl/termios/ptyprocess at top)
-                else:
-                    self._proc.kill(sig)
+                self._proc.kill(sig)
             except Exception:
                 pass
             deadline = time.monotonic() + 0.5

hermes_cli/tools_config.py

@@ -80,6 +80,7 @@ CONFIGURABLE_TOOLSETS = [
     ("discord_admin",   "🛡️  Discord Server Admin",    "list channels/roles, pin, assign roles"),
     ("yuanbao",          "🤖 Yuanbao",                  "group info, member queries, DM"),
     ("computer_use",     "🖱️  Computer Use (macOS)",     "background desktop control via cua-driver"),
+    ("apify",            "🎭  Apify Actors",              "discover, start, and collect Actor runs (requires APIFY_API_TOKEN)"),
 ]
 
 
@@ -112,7 +113,7 @@ def gui_toolset_label(label: str) -> str:
 # `hermes tools` → X (Twitter) Search setup walks users through credential
 # setup. The tool's check_fn means the schema still won't appear to the
 # model if the credential later goes missing or expires.
-_DEFAULT_OFF_TOOLSETS = {"moa", "homeassistant", "spotify", "discord", "discord_admin", "video", "video_gen", "x_search"}
+_DEFAULT_OFF_TOOLSETS = {"moa", "homeassistant", "spotify", "discord", "discord_admin", "video", "video_gen", "x_search", "apify"}
 
 
 def _xai_credentials_present() -> bool:
@@ -562,6 +563,27 @@ TOOL_CATEGORIES = {
             },
         ],
     },
+    "apify": {
+        "name": "Apify Actors",
+        "icon": "🕷️",
+        "providers": [
+            {
+                "name": "Apify",
+                "badge": "paid",
+                "tag": (
+                    "Run any Actor from the Apify Store — social media, "
+                    "Google Maps, e-commerce, and more."
+                ),
+                "env_vars": [
+                    {
+                        "key": "APIFY_API_TOKEN",
+                        "prompt": "Apify API token",
+                        "url": "https://apify.com/account/integrations",
+                    },
+                ],
+            },
+        ],
+    },
 }
 
 # Simple env-var requirements for toolsets NOT in TOOL_CATEGORIES.

hermes_cli/web_server.py

@@ -1405,54 +1405,6 @@ async def update_hermes():
     }
 
 
-def _recent_upstream_commits(n: int = 20) -> List[Dict[str, Any]]:
-    """Commits the local checkout is behind ``origin/main`` by, newest first.
-
-    Logs the SAME range the behind-count uses (``HEAD..origin/main`` — see
-    ``banner._check_via_local_git``), NOT the branch's ``@{upstream}``. On a
-    feature-branch checkout ``@{upstream}`` is the branch's own tip (zero
-    commits), which would leave the changelog empty even though the count is
-    non-zero. Pinning to ``origin/main`` keeps count and changelog consistent.
-
-    Best-effort: returns [] if not a git checkout, origin/main is unreachable,
-    or git is unavailable. Never raises into the request path.
-    """
-    try:
-        out = subprocess.run(
-            [
-                "git",
-                "-C",
-                str(PROJECT_ROOT),
-                "log",
-                "--format=%H%x1f%s%x1f%an%x1f%ct",
-                "HEAD..origin/main",
-                f"-n{int(n)}",
-            ],
-            capture_output=True,
-            text=True,
-            timeout=5,
-        )
-        if out.returncode != 0:
-            return []
-        rows: List[Dict[str, Any]] = []
-        for line in out.stdout.splitlines():
-            if not line.strip():
-                continue
-            parts = (line.split("\x1f") + ["", "", "", "0"])[:4]
-            sha, summary, author, at = parts
-            rows.append(
-                {
-                    "sha": sha[:7],
-                    "summary": summary,
-                    "author": author,
-                    "at": int(at or 0),
-                }
-            )
-        return rows
-    except Exception:
-        return []
-
-
 @app.get("/api/hermes/update/check")
 async def check_hermes_update(force: bool = False):
     """Report whether a Hermes update is available, without applying it.
@@ -1473,11 +1425,6 @@ async def check_hermes_update(force: bool = False):
                    user must update out-of-band
         update_command: the recommended command for this install method
         message: human-readable guidance for non-applyable methods
-        commits: for git/pip installs that are behind, a list of the commits
-                 the local checkout is behind upstream by — each
-                 {sha, summary, author, at}. Absent/empty otherwise. The
-                 desktop's remote update overlay renders this as "what's
-                 changed". Additive: existing consumers ignore it.
     """
     install_method = detect_install_method(PROJECT_ROOT)
     update_command = recommended_update_command_for_method(install_method)
@@ -1520,11 +1467,6 @@ async def check_hermes_update(force: bool = False):
         payload["message"] = "You're on the latest version."
     else:
         payload["update_available"] = True
-        # Enrich with the actual commits we're behind by, so the desktop's
-        # remote update overlay can show "what's changed". git/pip only;
-        # best-effort (empty list on any failure).
-        if install_method in ("git", "pip"):
-            payload["commits"] = await asyncio.to_thread(_recent_upstream_commits)
 
     return payload
 
@@ -8288,32 +8230,20 @@ async def get_models_analytics(days: int = 30):
 # though uvicorn binds to 127.0.0.1.
 # ---------------------------------------------------------------------------
 
-# PTY bridge: POSIX uses pty_bridge (fcntl/termios/ptyprocess); native Windows
-# uses win_pty_bridge (pywinpty/ConPTY, already a declared dependency).  Both
-# expose the same public surface — spawn/read/write/resize/close/is_available —
-# so the /api/pty WebSocket handler needs no platform guards.
-if sys.platform.startswith("win"):
-    try:
-        from hermes_cli.win_pty_bridge import WinPtyBridge as PtyBridge, PtyUnavailableError
-        _PTY_BRIDGE_AVAILABLE = True
-    except ImportError:  # pragma: no cover - pywinpty missing
-        PtyBridge = None  # type: ignore[assignment]
-        _PTY_BRIDGE_AVAILABLE = False
+# PTY bridge is POSIX-only (depends on fcntl/termios/ptyprocess).  On native
+# Windows the import raises; catch and leave PtyBridge=None so the rest of
+# the dashboard (sessions, jobs, metrics, config editor) still loads and the
+# /api/pty endpoint cleanly refuses with a WSL-suggested message.
+try:
+    from hermes_cli.pty_bridge import PtyBridge, PtyUnavailableError
+    _PTY_BRIDGE_AVAILABLE = True
+except ImportError as _pty_import_err:  # pragma: no cover - Windows-only path
+    PtyBridge = None  # type: ignore[assignment]
+    _PTY_BRIDGE_AVAILABLE = False
 
-        class PtyUnavailableError(RuntimeError):  # type: ignore[no-redef]
-            """Stub when win_pty_bridge cannot be imported."""
-            pass
-else:
-    try:
-        from hermes_cli.pty_bridge import PtyBridge, PtyUnavailableError
-        _PTY_BRIDGE_AVAILABLE = True
-    except ImportError:  # pragma: no cover - dev env without ptyprocess
-        PtyBridge = None  # type: ignore[assignment]
-        _PTY_BRIDGE_AVAILABLE = False
-
-        class PtyUnavailableError(RuntimeError):  # type: ignore[no-redef]
-            """Stub on platforms where pty_bridge can't be imported."""
-            pass
+    class PtyUnavailableError(RuntimeError):  # type: ignore[no-redef]
+        """Stub on platforms where pty_bridge can't be imported."""
+        pass
 
 _RESIZE_RE = re.compile(rb"\x1b\[RESIZE:(\d+);(\d+)\]")
 _PTY_READ_CHUNK_TIMEOUT = 0.2
@@ -9645,16 +9575,10 @@ def _merged_plugins_hub() -> Dict[str, Any]:
     plugins_root_resolved = (get_hermes_home() / "plugins").resolve()
     rows: List[Dict[str, Any]] = []
 
-    for name, version, description, source, dir_str, key in _discover_all_plugins():
-        # Both the path-derived key (nested category plugins) and the bare
-        # manifest name count for enabled/disabled state, matching the runtime
-        # loader's back-compat lookup.
-        aliases = {name}
-        if key:
-            aliases.add(key)
-        if aliases & disabled_set:
+    for name, version, description, source, dir_str in _discover_all_plugins():
+        if name in disabled_set:
             runtime_status = "disabled"
-        elif aliases & enabled_set:
+        elif name in enabled_set:
             runtime_status = "enabled"
         else:
             runtime_status = "inactive"
@@ -10154,9 +10078,4 @@ def start_server(
     uvicorn.run(
         app, host=host, port=port, log_level="warning",
         proxy_headers=bool(app.state.auth_required),
-        # Detect half-open WS connections (reverse-proxy 524, dropped tunnels)
-        # within ~20-40s so WebSocketDisconnect fires the disconnect→reap path.
-        # 20s stays under Cloudflare Tunnel's idle timeout, keeping it warm.
-        ws_ping_interval=20.0,
-        ws_ping_timeout=20.0,
     )

hermes_cli/win_pty_bridge.py

@@ -1,179 +0,0 @@
-"""Windows ConPTY bridge for the `hermes dashboard` chat tab.
-
-Drop-in counterpart to ``hermes_cli.pty_bridge.PtyBridge`` for native
-Windows. Mirrors the exact public surface the ``/api/pty`` WebSocket
-handler in ``hermes_cli.web_server`` consumes: ``spawn``, ``read``,
-``write``, ``resize``, ``close``, ``is_available``, plus the
-``PtyUnavailableError`` type.
-
-Backed by ``pywinpty`` (already a declared win32 dependency in
-pyproject.toml) instead of ``ptyprocess``/``fcntl``/``termios``, none of
-which exist on native Windows. The read/write/terminate calls here match
-the working winpty usage already shipping in ``tools/process_registry.py``.
-"""
-
-from __future__ import annotations
-
-import os
-import sys
-import time
-from typing import Optional, Sequence
-
-try:
-    from winpty import PtyProcess  # type: ignore
-    _PTY_AVAILABLE = sys.platform.startswith("win")
-except ImportError:  # pragma: no cover - non-Windows or pywinpty missing
-    PtyProcess = None  # type: ignore
-    _PTY_AVAILABLE = False
-
-
-__all__ = ["WinPtyBridge", "PtyUnavailableError"]
-
-
-# Same clamp ceiling as the POSIX bridge: a broken winsize probe must never
-# reach the resize call. ConPTY tolerates large values better than ioctl,
-# but we keep parity to avoid layout surprises.
-_MIN_DIMENSION = 1
-_MAX_COLS = 2000
-_MAX_ROWS = 1000
-
-
-def _clamp(value: int, maximum: int) -> int:
-    try:
-        n = int(value)
-    except (TypeError, ValueError, OverflowError):
-        return _MIN_DIMENSION
-    if n < _MIN_DIMENSION:
-        return _MIN_DIMENSION
-    if n > maximum:
-        return maximum
-    return n
-
-
-class PtyUnavailableError(RuntimeError):
-    """Raised when a PTY cannot be created on this platform."""
-
-
-class WinPtyBridge:
-    """pywinpty-backed bridge with the same interface as ``PtyBridge``.
-
-    ``web_server`` calls :meth:`read` inside ``run_in_executor``, so a
-    blocking/polling read here never stalls the event loop. ConPTY exposes
-    no selectable fd, so we poll with a short sleep instead of ``select``.
-    """
-
-    def __init__(self, proc: "PtyProcess") -> None:  # type: ignore[name-defined]
-        self._proc = proc
-        self._closed = False
-
-    # -- lifecycle --------------------------------------------------------
-
-    @classmethod
-    def is_available(cls) -> bool:
-        return bool(_PTY_AVAILABLE)
-
-    @classmethod
-    def spawn(
-        cls,
-        argv: Sequence[str],
-        *,
-        cwd: Optional[str] = None,
-        env: Optional[dict] = None,
-        cols: int = 80,
-        rows: int = 24,
-    ) -> "WinPtyBridge":
-        if not _PTY_AVAILABLE:
-            if PtyProcess is None:
-                raise PtyUnavailableError(
-                    "pywinpty is not installed. Install with: pip install pywinpty"
-                )
-            raise PtyUnavailableError("ConPTY is unavailable on this platform.")
-        spawn_env = (os.environ.copy() if env is None else dict(env))
-        if not spawn_env.get("TERM"):
-            spawn_env["TERM"] = "xterm-256color"
-        # pywinpty mirrors ptyprocess: dimensions=(rows, cols).
-        # This call shape is the one already used in tools/process_registry.py.
-        proc = PtyProcess.spawn(  # type: ignore[union-attr]
-            list(argv),
-            cwd=cwd,
-            env=spawn_env,
-            dimensions=(rows, cols),
-        )
-        return cls(proc)
-
-    @property
-    def pid(self) -> int:
-        return int(self._proc.pid)
-
-    def is_alive(self) -> bool:
-        if self._closed:
-            return False
-        try:
-            return bool(self._proc.isalive())
-        except Exception:
-            return False
-
-    # -- I/O --------------------------------------------------------------
-
-    def read(self, timeout: float = 0.2) -> Optional[bytes]:
-        """Up to 64 KiB of child output.
-
-        Returns bytes, ``b""`` when nothing is available this tick, or
-        ``None`` once the child has exited (EOF).
-        """
-        if self._closed:
-            return None
-        try:
-            data = self._proc.read(65536)  # pywinpty returns str
-        except EOFError:
-            return None
-        except Exception:
-            return None
-        if not data:
-            # No fd to select on; poll politely so the executor thread
-            # doesn't pin a core while the TUI is idle.
-            time.sleep(min(timeout, 0.02))
-            return b""
-        if isinstance(data, bytes):
-            return data
-        # NOTE: pywinpty decodes internally, so a multibyte UTF-8 sequence
-        # can in theory split across reads. xterm.js tolerates the rare
-        # replacement char; this is the one fidelity tradeoff vs the POSIX
-        # raw-fd path.
-        return data.encode("utf-8", errors="replace")
-
-    def write(self, data: bytes) -> None:
-        if self._closed or not data:
-            return
-        try:
-            # The dashboard sends raw keystroke bytes; pywinpty.write wants text.
-            self._proc.write(data.decode("utf-8", errors="replace"))
-        except Exception:
-            return
-
-    def resize(self, cols: int, rows: int) -> None:
-        if self._closed:
-            return
-        cols = _clamp(cols, _MAX_COLS)
-        rows = _clamp(rows, _MAX_ROWS)
-        try:
-            self._proc.setwinsize(rows, cols)  # pywinpty: (rows, cols)
-        except Exception:
-            pass
-
-    # -- teardown ---------------------------------------------------------
-
-    def close(self) -> None:
-        if self._closed:
-            return
-        self._closed = True
-        try:
-            self._proc.terminate(force=True)
-        except Exception:
-            pass
-
-    def __enter__(self) -> "WinPtyBridge":
-        return self
-
-    def __exit__(self, *_exc) -> None:
-        self.close()

model_tools.py

@@ -253,14 +253,6 @@ _LEGACY_TOOLSET_MAP = {
 # daemon start/stop, env var changes, etc.) on a 30 s horizon.
 _tool_defs_cache: Dict[tuple, List[Dict[str, Any]]] = {}
 
-# Hard cap on memoized get_tool_definitions() results. A long-lived Gateway
-# process sees many distinct toolset/config fingerprints over its lifetime
-# (per-session toolset sets, config edits, kanban-task toggles); without a
-# bound the cache grows unboundedly. 8 comfortably covers the warm working
-# set (the handful of distinct platform/toolset combos a gateway actually
-# serves) while keeping the cap small. (#19251)
-_TOOL_DEFS_CACHE_MAX = 8
-
 
 def _clear_tool_defs_cache() -> None:
     """Drop memoized get_tool_definitions() results. Called when dynamic
@@ -337,11 +329,6 @@ def get_tool_definitions(
         # agent inits and providers that enforce unique tool names
         # (DeepSeek, Xiaomi MiMo, Moonshot Kimi) reject the request with
         # HTTP 400. Mirrors the cache-hit path above. (issue #17335)
-        # Bound the cache with LRU eviction so a long-lived Gateway process
-        # doesn't accumulate entries unboundedly across the many distinct
-        # toolset/config fingerprints it sees over its lifetime (#19251).
-        if len(_tool_defs_cache) >= _TOOL_DEFS_CACHE_MAX:
-            _tool_defs_cache.pop(next(iter(_tool_defs_cache)))  # evict oldest
         _tool_defs_cache[cache_key] = result
         return list(result)
     return result

nix/lib.nix

@@ -73,24 +73,25 @@ in
 
       patchPhase = ''
         runHook prePatch
-        # Normalize trailing newlines on the root lockfile so source and
-        # npm-deps always match, regardless of what fetchNpmDeps preserves.
-        sed -i -z 's/\\n*$/\\n/' package-lock.json
 
-        # Make npmConfigHook's byte-for-byte diff newline-agnostic by
-        # replacing its hardcoded /nix/store/.../diff with a wrapper that
-        # normalizes trailing newlines on both sides before comparing.
-        mkdir -p "$TMPDIR/bin"
-        cat > "$TMPDIR/bin/diff" << DIFFWRAP
-        #!/bin/sh
-        f1=\\$(mktemp) && sed -z 's/\\n*$/\\n/' "\\$1" > "\\$f1"
-        f2=\\$(mktemp) && sed -z 's/\\n*$/\\n/' "\\$2" > "\\$f2"
-        ${pkgs.diffutils}/bin/diff "\\$f1" "\\$f2" && rc=0 || rc=\\$?
-        rm -f "\\$f1" "\\$f2"
-        exit \\$rc
-        DIFFWRAP
-        chmod +x "$TMPDIR/bin/diff"
-        export PATH="$TMPDIR/bin:$PATH"
+        # prefetch-npm-deps stores a *normalized* package-lock.json in the deps
+        # cache: newer npm writes advisory fields (engines/os/cpu/funding/bin/…)
+        # into lockfile entries, and prefetch strips the ones that don't affect
+        # which tarballs are fetched. npmConfigHook then does a byte-for-byte
+        # diff of the source lockfile against the cache's copy and fails on
+        # those purely-cosmetic differences — this is what breaks cold builds
+        # on a nixpkgs whose prefetch-npm-deps strips fields the committed
+        # lockfile carries.
+        #
+        # Adopt the cache's own normalized lockfile as the source so the
+        # consistency check is trivially satisfied. The resolved dependency set
+        # (version/resolved/integrity/dependencies) is byte-identical either
+        # way — fetchNpmDeps derived the cache *from* this lockfile — so `npm
+        # ci` installs exactly the same tree; only advisory metadata is dropped.
+        # Genuine drift is still caught upstream: a changed lockfile that didn't
+        # get its npmDepsHash refreshed fails the fixed-output hash check before
+        # this phase ever runs.
+        cp --no-preserve=mode,ownership ${npmDeps}/package-lock.json package-lock.json
 
         runHook postPatch
       '';

nix/nixosModules.nix

@@ -49,12 +49,6 @@
 
     configMergeScript = pkgs.callPackage ./configMergeScript.nix { };
 
-    # config.yaml mode: group-writable (0660) when interactive users share this
-    # HERMES_HOME via addToSystemPackages, so they can save settings through the
-    # CLI/TUI without hitting EACCES; otherwise group-read-only (0640). Secrets
-    # (.env) stay 0640 regardless — see below.
-    configYamlMode = if cfg.addToSystemPackages then "0660" else "0640";
-
     # Generate .env from non-secret environment attrset
     envFileContent = lib.concatStringsSep "\n" (
       lib.mapAttrsToList (k: v: "${k}=${v}") cfg.environment
@@ -734,8 +728,7 @@
           chmod 0750 ${cfg.stateDir}/home
 
           # Create subdirs, set setgid + group-writable, migrate existing files.
-          # Nix-managed .env/.managed stay 0640/0644; config.yaml uses
-          # configYamlMode (0660 under addToSystemPackages, else 0640).
+          # Nix-managed files (config.yaml, .env, .managed) stay 0640/0644.
           find ${cfg.stateDir}/.hermes -maxdepth 1 \
             \( -name "*.db" -o -name "*.db-wal" -o -name "*.db-shm" -o -name "SOUL.md" \) \
             -exec chmod g+rw {} + 2>/dev/null || true
@@ -750,14 +743,12 @@
           # Merge Nix settings into existing config.yaml.
           # Preserves user-added keys (skills, streaming, etc.); Nix keys win.
           # If configFile is user-provided (not generated), overwrite instead of merge.
-          # Mode is configYamlMode (0660 under addToSystemPackages so interactive
-          # hermes-group users can save settings via the CLI/TUI, else 0640).
           ${if cfg.configFile != null then ''
-            install -o ${cfg.user} -g ${cfg.group} -m ${configYamlMode} -D ${configFile} ${cfg.stateDir}/.hermes/config.yaml
+            install -o ${cfg.user} -g ${cfg.group} -m 0640 -D ${configFile} ${cfg.stateDir}/.hermes/config.yaml
           '' else ''
             ${configMergeScript} ${generatedConfigFile} ${cfg.stateDir}/.hermes/config.yaml
             chown ${cfg.user}:${cfg.group} ${cfg.stateDir}/.hermes/config.yaml
-            chmod ${configYamlMode} ${cfg.stateDir}/.hermes/config.yaml
+            chmod 0640 ${cfg.stateDir}/.hermes/config.yaml
           ''}
 
           # Managed mode marker (so interactive shells also detect NixOS management)

plugins/apify/README.md

@@ -0,0 +1,41 @@
+# Apify Actor Tools
+
+Bundled plugin that brings [Apify](https://apify.com/) Actors into Hermes. Apify
+hosts 20,000+ ready-made Actors for web automation and data extraction
+(Instagram, YouTube, Google Maps, LinkedIn, Amazon, and more). The agent can
+discover the right Actor, inspect its input schema, run it, and collect
+structured results.
+
+## Tools
+
+| Tool | What it does |
+|------|--------------|
+| `apify_discover` | Search the Apify Store by keyword, or fetch a specific Actor's input schema + README by `actor_id`. |
+| `apify_start` | Fire-and-forget batch Actor starts (up to 10 per call). Returns run refs immediately so the agent keeps reasoning while Actors run. |
+| `apify_collect` | Poll run statuses and return completed dataset results, wrapped in `EXTERNAL_UNTRUSTED_CONTENT` markers. Supports `limit` / `may_have_more` pagination. |
+
+## Setup
+
+1. Create an Apify account and get a token at
+   <https://apify.com/account/integrations>.
+2. Run `hermes tools`, open **Apify Actors**, enable the toolset, and paste your
+   token. (The token is stored in `~/.hermes/.env` as `APIFY_API_TOKEN` and is
+   never sent to the model.)
+
+The `apify` toolset is **off by default**. The three tools register on startup
+but stay invisible to the model until `APIFY_API_TOKEN` is set (runtime
+`check_fn` gate).
+
+## Architecture
+
+This is a bundled `kind: backend` plugin (auto-loads, no opt-in), modeled on the
+Spotify plugin. Tool registration goes through the plugin API
+(`ctx.register_tool()`), so the Apify tools never enter `_HERMES_CORE_TOOLS`. The
+`apify-client` SDK is installed on demand via `tools.lazy_deps` (`search.apify`)
+the first time an Actor runs.
+
+| File | Purpose |
+|------|---------|
+| `__init__.py` | `register(ctx)` — wires the three tools via `ctx.register_tool()`. |
+| `tools.py` | Handlers + JSON schemas. |
+| `client.py` | Lazy `apify-client` import, token validation, module-level cache. |

plugins/apify/__init__.py

@@ -0,0 +1,72 @@
+"""Apify Actor execution plugin — bundled, auto-loaded.
+
+Registers three tools (``apify_discover``, ``apify_start``, ``apify_collect``)
+into the ``apify`` toolset. Each tool is gated by ``_check_token()`` — when the
+user has not set ``APIFY_API_TOKEN`` the tools stay registered (so they appear
+in ``hermes tools``) but the runtime check prevents dispatch.
+
+Why a plugin instead of top-level ``tools/`` files?
+
+- ``plugins/`` is where third-party service integrations live (see
+  ``plugins/spotify/`` for the same pattern — optional SaaS, token-gated,
+  default-off toolset). ``tools/`` is reserved for foundational capabilities
+  (terminal, read_file, web_search, etc.).
+- Bundled + ``kind: backend`` auto-loads on startup just like the Spotify
+  plugin — no user opt-in needed, no ``plugins.enabled`` config.
+- Keeps the three Apify tools out of ``_HERMES_CORE_TOOLS`` in ``toolsets.py``;
+  the plugin loader registers them via ``ctx.register_tool()``.
+
+The ``apify`` toolset is default-off (``_DEFAULT_OFF_TOOLSETS`` in
+``hermes_cli/tools_config.py``) and the ``APIFY_API_TOKEN`` setup UX is wired
+through ``hermes tools`` (``TOOL_CATEGORIES``) and ``OPTIONAL_ENV_VARS``.
+"""
+from __future__ import annotations
+
+import json
+from typing import Any, Dict
+
+from plugins.apify.tools import (
+    _COLLECT_SCHEMA,
+    _DISCOVER_SCHEMA,
+    _START_SCHEMA,
+    _check_token,
+    _collect_handler,
+    _discover_handler,
+    _start_handler,
+)
+
+
+async def _collect_handler_str(args: Dict[str, Any], **_kw: Any) -> str:
+    return json.dumps(await _collect_handler(args), default=str)
+
+
+def register(ctx) -> None:
+    """Register the Apify Actor tools. Called once by the plugin loader."""
+    ctx.register_tool(
+        name="apify_discover",
+        toolset="apify",
+        schema=_DISCOVER_SCHEMA,
+        handler=lambda args, **kw: json.dumps(_discover_handler(args), default=str),
+        check_fn=_check_token,
+        requires_env=["APIFY_API_TOKEN"],
+        emoji="🔍",
+    )
+    ctx.register_tool(
+        name="apify_start",
+        toolset="apify",
+        schema=_START_SCHEMA,
+        handler=lambda args, **kw: json.dumps(_start_handler(args), default=str),
+        check_fn=_check_token,
+        requires_env=["APIFY_API_TOKEN"],
+        emoji="▶️",
+    )
+    ctx.register_tool(
+        name="apify_collect",
+        toolset="apify",
+        schema=_COLLECT_SCHEMA,
+        handler=_collect_handler_str,
+        check_fn=_check_token,
+        requires_env=["APIFY_API_TOKEN"],
+        is_async=True,
+        emoji="📦",
+    )

plugins/apify/client.py

@@ -0,0 +1,65 @@
+"""Shared Apify SDK client — lazy import, token validation, and cache.
+
+Used by the Apify Actor execution tools (plugins/apify/tools.py). The
+``apify-client`` SDK is installed on demand via ``tools.lazy_deps`` so the
+dependency is only pulled when the user actually enables the plugin and runs
+an Actor.
+"""
+from __future__ import annotations
+
+import os
+from typing import Any, Optional
+
+# Sent with every request so Apify can attribute traffic to this integration.
+_HERMES_HEADERS = {"x-apify-integration-platform": "hermes-agent"}
+
+_CLIENT_CLS: Optional[type] = None
+_CLIENT: Optional[Any] = None
+_CLIENT_CONFIG: Optional[Any] = None
+
+
+def _load_client_cls() -> type:
+    global _CLIENT_CLS
+    if _CLIENT_CLS is None:
+        try:
+            from tools.lazy_deps import ensure as _lazy_ensure
+            _lazy_ensure("search.apify", prompt=False)
+        except ImportError:
+            pass
+        except Exception as exc:  # noqa: BLE001
+            raise ImportError(str(exc))
+        from apify_client import ApifyClient
+        _CLIENT_CLS = ApifyClient
+    return _CLIENT_CLS
+
+
+def check_apify_api_key() -> bool:
+    """Return True when APIFY_API_TOKEN is configured."""
+    return bool(os.getenv("APIFY_API_TOKEN", "").strip())
+
+
+def get_apify_client() -> Any:
+    """Return a cached ApifyClient built from APIFY_API_TOKEN.
+
+    Raises ValueError when the token is not set.
+    """
+    global _CLIENT, _CLIENT_CONFIG
+    api_token = os.getenv("APIFY_API_TOKEN", "").strip()
+    if not api_token:
+        raise ValueError(
+            "Apify tools are not configured. "
+            "Set APIFY_API_TOKEN (get one at https://apify.com/account/integrations)."
+        )
+    client_config = ("direct", api_token)
+    if _CLIENT is not None and _CLIENT_CONFIG == client_config:
+        return _CLIENT
+    _CLIENT = _load_client_cls()(token=api_token, headers=_HERMES_HEADERS)
+    _CLIENT_CONFIG = client_config
+    return _CLIENT
+
+
+def _reset_client_for_tests() -> None:
+    """Drop cached client so tests can re-instantiate cleanly."""
+    global _CLIENT, _CLIENT_CONFIG
+    _CLIENT = None
+    _CLIENT_CONFIG = None

plugins/apify/plugin.yaml

@@ -0,0 +1,9 @@
+name: apify
+version: 1.0.0
+description: "Apify Actor execution — 3 tools (discover, start, collect) for running any of 20,000+ Actors from the Apify Store (web automation, data extraction, social media, maps, e-commerce). Gated on APIFY_API_TOKEN. Toolset is default-off; enable via `hermes tools` → Apify Actors."
+author: JanHranicky
+kind: backend
+provides_tools:
+  - apify_discover
+  - apify_start
+  - apify_collect

plugins/apify/tools.py

@@ -0,0 +1,390 @@
+"""Apify Actor execution tools — discover, start, collect.
+
+Handlers and schemas for the three Apify tools. Registration happens in
+``plugins/apify/__init__.py`` via ``ctx.register_tool()`` (the plugin API),
+not via direct ``registry.register()`` calls.
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+from typing import Any, Dict, List
+
+logger = logging.getLogger(__name__)
+
+_TERMINAL_STATUSES = {"SUCCEEDED", "FAILED", "ABORTED", "TIMED-OUT"}
+_MAX_BATCH_RUNS = 10
+_COLLECT_DEFAULT_LIMIT = 100
+
+
+def _attr(obj: Any, key: str, default: Any = None) -> Any:
+    """Get attribute or dict key from SDK response objects (apify_client returns either)."""
+    if isinstance(obj, dict):
+        return obj.get(key, default)
+    if obj is not None and hasattr(obj, key):
+        return getattr(obj, key)
+    return default
+
+
+def _get_client() -> Any:
+    from plugins.apify.client import get_apify_client
+    return get_apify_client()
+
+
+def _check_token() -> bool:
+    from plugins.apify.client import check_apify_api_key
+    return check_apify_api_key()
+
+
+# ---------------------------------------------------------------------------
+# Handlers
+# ---------------------------------------------------------------------------
+
+def _discover_handler(args: Dict[str, Any]) -> Dict[str, Any]:
+    from tools.interrupt import is_interrupted
+    if is_interrupted():
+        return {"error": "Interrupted"}
+
+    query = (_attr(args, "query") or "").strip() or None
+    actor_id = (_attr(args, "actor_id") or "").strip() or None
+
+    if not query and not actor_id:
+        return {
+            "error": (
+                "Provide exactly one of 'query' (to search the Apify Store) "
+                "or 'actor_id' (to fetch an Actor's input schema)."
+            )
+        }
+
+    client = _get_client()
+
+    if actor_id:
+        try:
+            actor_info = client.actor(actor_id).get()
+            if actor_info is None:
+                return {
+                    "error": (
+                        f"Actor '{actor_id}' not found. "
+                        "Check the ID format: username~actor-name."
+                    )
+                }
+
+            input_schema: Any = None
+            readme: Any = None
+
+            build_detail = client.actor(actor_id).default_build().get()
+            if build_detail is not None:
+                actor_def = _attr(build_detail, "actorDefinition") or {}
+                raw_schema = _attr(actor_def, "input")
+                if raw_schema:
+                    input_schema = json.dumps(raw_schema)
+                else:
+                    fallback = _attr(build_detail, "inputSchema")
+                    if fallback:
+                        input_schema = str(fallback)
+
+                raw_readme = _attr(actor_def, "readme") or _attr(build_detail, "readme")
+                if raw_readme:
+                    readme = str(raw_readme)[:3000]
+
+            username = _attr(actor_info, "username", "")
+            name = _attr(actor_info, "name", "")
+            title = _attr(actor_info, "title", "") or name
+            return {
+                "actor_id": f"{username}~{name}",
+                "name": name,
+                "title": title,
+                "username": username,
+                "description": _attr(actor_info, "description", ""),
+                "input_schema": input_schema,
+                "readme": readme,
+                "tip": (
+                    f"Use apify_start with actor_id='{username}~{name}' "
+                    "and an input matching the input_schema above."
+                ),
+            }
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("apify_discover schema fetch error for %s: %s", actor_id, exc)
+            return {"error": str(exc)}
+
+    # Store search
+    try:
+        result = client.store().list(search=query, limit=10, sort_by="relevance")
+        items = _attr(result, "items") or []
+        actors: List[Dict[str, Any]] = []
+        for item in items:
+            stats = _attr(item, "stats") or {}
+            name = _attr(item, "name", "")
+            username = _attr(item, "username", "")
+            title = _attr(item, "title") or name
+            desc = (_attr(item, "description") or "")[:200]
+            run_count = _attr(stats, "totalRuns", 0) or 0
+            rating = _attr(stats, "averageRating")
+            actors.append({
+                "actor_id": f"{username}~{name}",
+                "name": name,
+                "title": title,
+                "username": username,
+                "description": desc,
+                "run_count": run_count,
+                "rating": rating,
+            })
+        return {"actors": actors}
+    except Exception as exc:  # noqa: BLE001
+        logger.warning("apify_discover store search error for '%s': %s", query, exc)
+        return {"error": str(exc)}
+
+
+def _start_handler(args: Dict[str, Any]) -> Dict[str, Any]:
+    from tools.interrupt import is_interrupted
+    if is_interrupted():
+        return {"error": "Interrupted"}
+
+    run_specs = args.get("runs") or []
+    if not run_specs:
+        return {"error": "Provide at least one run spec in 'runs'."}
+    if len(run_specs) > _MAX_BATCH_RUNS:
+        return {"error": f"Batch too large: {len(run_specs)} runs requested, maximum is {_MAX_BATCH_RUNS}."}
+
+    client = _get_client()
+    started: List[Dict[str, Any]] = []
+    errors: List[Dict[str, Any]] = []
+
+    for spec in run_specs:
+        from tools.interrupt import is_interrupted
+        if is_interrupted():
+            break
+
+        actor_id = (spec.get("actor_id") or "").strip()
+        run_input = spec.get("input") or {}
+        label = spec.get("label")
+
+        if not actor_id:
+            errors.append({"error": "Missing 'actor_id' in run spec."})
+            continue
+
+        try:
+            run = client.actor(actor_id).start(run_input=run_input)
+            entry: Dict[str, Any] = {
+                "run_id": _attr(run, "id"),
+                "actor_id": actor_id,
+                "dataset_id": _attr(run, "default_dataset_id"),
+                "status": _attr(run, "status"),
+            }
+            if label:
+                entry["label"] = label
+            started.append(entry)
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("apify_start error for %s: %s", actor_id, exc)
+            err: Dict[str, Any] = {"actor_id": actor_id, "error": str(exc)}
+            if label:
+                err["label"] = label
+            errors.append(err)
+
+    result: Dict[str, Any] = {"runs": started}
+    if errors:
+        result["errors"] = errors
+    return result
+
+
+async def _collect_handler(args: Dict[str, Any]) -> Dict[str, Any]:
+    from tools.interrupt import is_interrupted
+    if is_interrupted():
+        return {"error": "Interrupted"}
+
+    run_refs = args.get("runs") or []
+    if not run_refs:
+        return {"error": "Provide 'runs' array (from apify_start)."}
+
+    limit = int(args.get("limit") or _COLLECT_DEFAULT_LIMIT)
+    client = _get_client()
+
+    async def _check_run(ref: Dict[str, Any]) -> Dict[str, Any]:
+        run_id = ref.get("run_id", "")
+        actor_id = ref.get("actor_id", "")
+        dataset_id = ref.get("dataset_id", "")
+        label = ref.get("label")
+
+        base: Dict[str, Any] = {
+            "run_id": run_id,
+            "actor_id": actor_id,
+            "dataset_id": dataset_id,
+        }
+        if label:
+            base["label"] = label
+
+        try:
+            run_info = await asyncio.to_thread(client.run(run_id).get)
+
+            if run_info is None:
+                return {**base, "_type": "error", "error": "Run not found."}
+
+            status = _attr(run_info, "status", "UNKNOWN")
+            base["status"] = status
+
+            if status not in _TERMINAL_STATUSES:
+                return {**base, "_type": "pending"}
+
+            if status != "SUCCEEDED":
+                return {**base, "_type": "error", "error": f"Run ended with status: {status}"}
+
+            # SUCCEEDED — fetch dataset and wrap as external content
+            dataset_result = await asyncio.to_thread(
+                client.dataset(dataset_id).list_items, limit=limit
+            )
+            items = list(_attr(dataset_result, "items") or [])
+            may_have_more = len(items) == limit
+            if may_have_more:
+                logger.warning(
+                    "apify_collect run %s: fetched %d items (hit limit=%d) — "
+                    "dataset may have more; re-call with a higher limit if needed",
+                    run_id, len(items), limit,
+                )
+            raw = json.dumps(items, indent=2, default=str)
+            if len(raw) > 50_000:
+                raw = raw[:50_000] + "\n\n[…truncated]"
+            wrapped = (
+                "<<<EXTERNAL_UNTRUSTED_CONTENT>>>\n"
+                + raw
+                + "\n<<<END_EXTERNAL_UNTRUSTED_CONTENT>>>"
+            )
+            result: Dict[str, Any] = {
+                **base,
+                "_type": "completed",
+                "result_count": len(items),
+                "data": wrapped,
+            }
+            if may_have_more:
+                result["may_have_more"] = True
+            return result
+
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("apify_collect error for run %s: %s", run_id, exc)
+            return {**base, "_type": "error", "error": str(exc)}
+
+    raw_results = await asyncio.gather(*[_check_run(ref) for ref in run_refs])
+
+    completed: List[Dict[str, Any]] = []
+    pending: List[Dict[str, Any]] = []
+    errors: List[Dict[str, Any]] = []
+
+    for r in raw_results:
+        t = r.pop("_type", "error")
+        if t == "pending":
+            pending.append(r)
+        elif t == "error":
+            errors.append(r)
+        else:
+            completed.append(r)
+
+    return {
+        "all_done": len(pending) == 0,
+        "completed": completed,
+        "pending": pending,
+        "errors": errors,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Schemas
+# ---------------------------------------------------------------------------
+
+_DISCOVER_SCHEMA: Dict[str, Any] = {
+    "name": "apify_discover",
+    "description": (
+        "Search the Apify Store for Actors by keyword, or fetch an Actor's "
+        "input schema and README. Provide 'query' to search, or 'actor_id' "
+        "to inspect a specific Actor. Actor IDs use tilde: username~actor-name."
+    ),
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "query": {
+                "type": "string",
+                "description": "Keywords to search the Apify Store (e.g. 'instagram scraper').",
+            },
+            "actor_id": {
+                "type": "string",
+                "description": (
+                    "Actor ID to fetch its input schema and README "
+                    "(e.g. 'apify~google-search-scraper')."
+                ),
+            },
+        },
+    },
+}
+
+_START_SCHEMA: Dict[str, Any] = {
+    "name": "apify_start",
+    "description": (
+        "Start one or more Apify Actor runs. Returns run references immediately "
+        f"(fire-and-forget). Pass the returned run refs to apify_collect to get results. "
+        f"Maximum {_MAX_BATCH_RUNS} runs per call."
+    ),
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "runs": {
+                "type": "array",
+                "description": f"List of Actor runs to start (max {_MAX_BATCH_RUNS}).",
+                "maxItems": _MAX_BATCH_RUNS,
+                "items": {
+                    "type": "object",
+                    "properties": {
+                        "actor_id": {
+                            "type": "string",
+                            "description": "Actor ID (username~actor-name).",
+                        },
+                        "input": {
+                            "type": "object",
+                            "description": "Actor input parameters.",
+                        },
+                        "label": {
+                            "type": "string",
+                            "description": "Optional label to identify this run in results.",
+                        },
+                    },
+                    "required": ["actor_id"],
+                },
+            },
+        },
+        "required": ["runs"],
+    },
+}
+
+_COLLECT_SCHEMA: Dict[str, Any] = {
+    "name": "apify_collect",
+    "description": (
+        "Poll the status of Apify Actor runs started with apify_start. "
+        "Returns completed results, still-running refs, and errors. "
+        "Re-call with the same run refs until all_done is true."
+    ),
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "runs": {
+                "type": "array",
+                "description": "Run references returned by apify_start.",
+                "items": {
+                    "type": "object",
+                    "properties": {
+                        "run_id": {"type": "string"},
+                        "actor_id": {"type": "string"},
+                        "dataset_id": {"type": "string"},
+                        "label": {"type": "string"},
+                    },
+                    "required": ["run_id", "actor_id", "dataset_id"],
+                },
+            },
+            "limit": {
+                "type": "integer",
+                "description": (
+                    f"Max dataset items to fetch per run (default {_COLLECT_DEFAULT_LIMIT}). "
+                    "Increase if may_have_more is true in a previous response."
+                ),
+            },
+        },
+        "required": ["runs"],
+    },
+}

plugins/memory/honcho/client.py

@@ -22,7 +22,6 @@ from pathlib import Path
 
 from hermes_constants import get_hermes_home
 from hermes_cli.profiles import _get_default_hermes_home
-from plugins.plugin_utils import SingletonSlot
 from typing import Any, TYPE_CHECKING
 
 if TYPE_CHECKING:
@@ -738,7 +737,7 @@ class HonchoClientConfig:
         return self.workspace_id
 
 
-_honcho_client_slot: SingletonSlot = SingletonSlot()
+_honcho_client: Honcho | None = None
 
 
 def get_honcho_client(config: HonchoClientConfig | None = None) -> Honcho:
@@ -746,14 +745,11 @@ def get_honcho_client(config: HonchoClientConfig | None = None) -> Honcho:
 
     When no config is provided, attempts to load ~/.honcho/config.json
     first, falling back to environment variables.
-
-    Thread-safe: the client is built exactly once even under concurrent
-    first calls (double-checked locking via ``SingletonSlot``), so racing
-    threads can't each construct a client and leak the loser's connection.
     """
-    cached = _honcho_client_slot.peek()
-    if cached is not None:
-        return cached
+    global _honcho_client
+
+    if _honcho_client is not None:
+        return _honcho_client
 
     if config is None:
         config = HonchoClientConfig.from_global_config()
@@ -766,116 +762,111 @@ def get_honcho_client(config: HonchoClientConfig | None = None) -> Honcho:
             "For local instances, set HONCHO_BASE_URL instead."
         )
 
-    # Everything below is the expensive part the issue flags: lazy SDK
-    # install, config resolution, and client construction. Run it inside the
-    # slot's factory so it executes exactly once even when several threads
-    # race the first call — the slot's double-checked lock serializes them and
-    # the losers get the winner's client instead of building their own.
-    def _build() -> "Honcho":
-        # Lazy-install the honcho SDK on demand. ensure() honors
-        # security.allow_lazy_installs (default true). On failure we surface
-        # the original ImportError-shape message so existing callers still get
-        # the "go run hermes honcho setup" hint they used to.
-        try:
-            from tools.lazy_deps import FeatureUnavailable, ensure as _lazy_ensure
-            _lazy_ensure("memory.honcho", prompt=False)
-        except ImportError:
-            # lazy_deps module missing — fall through to the raw import below.
-            pass
-        except Exception:
-            # FeatureUnavailable or unexpected error. Don't crash here; let the
-            # actual import attempt produce the canonical error message.
-            pass
+    # Lazy-install the honcho SDK on demand. ensure() honors
+    # security.allow_lazy_installs (default true). On failure we surface
+    # the original ImportError-shape message so existing callers still get
+    # the "go run hermes honcho setup" hint they used to.
+    try:
+        from tools.lazy_deps import FeatureUnavailable, ensure as _lazy_ensure
+        _lazy_ensure("memory.honcho", prompt=False)
+    except ImportError:
+        # lazy_deps module missing — fall through to the raw import below.
+        pass
+    except Exception:
+        # FeatureUnavailable or unexpected error. Don't crash here; let the
+        # actual import attempt produce the canonical error message.
+        pass
 
-        try:
-            from honcho import Honcho
-        except ImportError:
-            raise ImportError(
-                "honcho-ai is required for Honcho integration. "
-                "Install it with: pip install honcho-ai  "
-                "(or run `hermes honcho setup` to configure)."
-            )
-
-        # Allow config.yaml honcho.base_url to override the SDK's environment
-        # mapping, enabling remote self-hosted Honcho deployments without
-        # requiring the server to live on localhost.
-        resolved_base_url = config.base_url
-        resolved_timeout = config.timeout
-        if not resolved_base_url or resolved_timeout is None:
-            try:
-                from hermes_cli.config import load_config
-                hermes_cfg = load_config()
-                honcho_cfg = hermes_cfg.get("honcho", {})
-                if isinstance(honcho_cfg, dict):
-                    if not resolved_base_url:
-                        resolved_base_url = honcho_cfg.get("base_url", "").strip() or None
-                    if resolved_timeout is None:
-                        resolved_timeout = _resolve_optional_float(
-                            honcho_cfg.get("timeout"),
-                            honcho_cfg.get("request_timeout"),
-                        )
-            except Exception:
-                pass
-
-        # Fall back to the default so an unconfigured install cannot hang
-        # indefinitely on a stalled Honcho request.
-        if resolved_timeout is None:
-            resolved_timeout = _DEFAULT_HTTP_TIMEOUT
-
-        if resolved_base_url:
-            logger.info("Initializing Honcho client (base_url: %s, workspace: %s)", resolved_base_url, config.workspace_id)
-        else:
-            logger.info("Initializing Honcho client (host: %s, workspace: %s)", config.host, config.workspace_id)
-
-        # Local Honcho instances don't require an API key, but the SDK
-        # expects a non-empty string.  Use a placeholder for local URLs.
-        # For local: only use config.api_key if the host block explicitly
-        # sets apiKey (meaning the user wants local auth). Otherwise skip
-        # the stored key -- it's likely a cloud key that would break local.
-        _is_local = resolved_base_url and (
-            "localhost" in resolved_base_url
-            or "127.0.0.1" in resolved_base_url
-            or "::1" in resolved_base_url
+    try:
+        from honcho import Honcho
+    except ImportError:
+        raise ImportError(
+            "honcho-ai is required for Honcho integration. "
+            "Install it with: pip install honcho-ai  "
+            "(or run `hermes honcho setup` to configure)."
         )
-        if _is_local:
-            # Check if the host block has its own apiKey (explicit local auth).
-            # Auth-skipping is loopback-only: a stored key is likely a cloud key
-            # that would break a no-auth local server, so we substitute the SDK's
-            # required-non-empty placeholder unless the host block opts in.
-            _raw = config.raw or {}
-            _host_block = (_raw.get("hosts") or {}).get(config.host, {})
-            _host_has_key = bool(_host_block.get("apiKey"))
-            effective_api_key = config.api_key if _host_has_key else "local"
-        else:
-            effective_api_key = config.api_key
 
-        # The Honcho SDK's route builders (e.g. routes.workspaces()) already
-        # include the version prefix (e.g. "/v3/workspaces").  When a user-supplied
-        # base_url already ends in a version segment (e.g.
-        # "http://localhost:38000/v3", "https://honcho.my.ts.net/v3"), concatenating
-        # the two produces "/v3/v3/workspaces" → 404 on every call.  This is a pure
-        # routing concern independent of host, so strip a trailing version segment
-        # from ANY base_url — loopback, LAN, custom domain, or cloud alike.  The
-        # SDK then appends its own versioned paths correctly.
-        if resolved_base_url:
-            import re as _re
-            resolved_base_url = _re.sub(r"/v\d+/*$", "", resolved_base_url).rstrip("/")
+    # Allow config.yaml honcho.base_url to override the SDK's environment
+    # mapping, enabling remote self-hosted Honcho deployments without
+    # requiring the server to live on localhost.
+    resolved_base_url = config.base_url
+    resolved_timeout = config.timeout
+    if not resolved_base_url or resolved_timeout is None:
+        try:
+            from hermes_cli.config import load_config
+            hermes_cfg = load_config()
+            honcho_cfg = hermes_cfg.get("honcho", {})
+            if isinstance(honcho_cfg, dict):
+                if not resolved_base_url:
+                    resolved_base_url = honcho_cfg.get("base_url", "").strip() or None
+                if resolved_timeout is None:
+                    resolved_timeout = _resolve_optional_float(
+                        honcho_cfg.get("timeout"),
+                        honcho_cfg.get("request_timeout"),
+                    )
+        except Exception:
+            pass
 
-        kwargs: dict = {
-            "workspace_id": config.workspace_id,
-            "api_key": effective_api_key,
-            "environment": config.environment,
-        }
-        if resolved_base_url:
-            kwargs["base_url"] = resolved_base_url
-        if resolved_timeout is not None:
-            kwargs["timeout"] = resolved_timeout
+    # Fall back to the default so an unconfigured install cannot hang
+    # indefinitely on a stalled Honcho request.
+    if resolved_timeout is None:
+        resolved_timeout = _DEFAULT_HTTP_TIMEOUT
 
-        return Honcho(**kwargs)
+    if resolved_base_url:
+        logger.info("Initializing Honcho client (base_url: %s, workspace: %s)", resolved_base_url, config.workspace_id)
+    else:
+        logger.info("Initializing Honcho client (host: %s, workspace: %s)", config.host, config.workspace_id)
 
-    return _honcho_client_slot.get(_build)
+    # Local Honcho instances don't require an API key, but the SDK
+    # expects a non-empty string.  Use a placeholder for local URLs.
+    # For local: only use config.api_key if the host block explicitly
+    # sets apiKey (meaning the user wants local auth). Otherwise skip
+    # the stored key -- it's likely a cloud key that would break local.
+    _is_local = resolved_base_url and (
+        "localhost" in resolved_base_url
+        or "127.0.0.1" in resolved_base_url
+        or "::1" in resolved_base_url
+    )
+    if _is_local:
+        # Check if the host block has its own apiKey (explicit local auth).
+        # Auth-skipping is loopback-only: a stored key is likely a cloud key
+        # that would break a no-auth local server, so we substitute the SDK's
+        # required-non-empty placeholder unless the host block opts in.
+        _raw = config.raw or {}
+        _host_block = (_raw.get("hosts") or {}).get(config.host, {})
+        _host_has_key = bool(_host_block.get("apiKey"))
+        effective_api_key = config.api_key if _host_has_key else "local"
+    else:
+        effective_api_key = config.api_key
+
+    # The Honcho SDK's route builders (e.g. routes.workspaces()) already
+    # include the version prefix (e.g. "/v3/workspaces").  When a user-supplied
+    # base_url already ends in a version segment (e.g.
+    # "http://localhost:38000/v3", "https://honcho.my.ts.net/v3"), concatenating
+    # the two produces "/v3/v3/workspaces" → 404 on every call.  This is a pure
+    # routing concern independent of host, so strip a trailing version segment
+    # from ANY base_url — loopback, LAN, custom domain, or cloud alike.  The
+    # SDK then appends its own versioned paths correctly.
+    if resolved_base_url:
+        import re as _re
+        resolved_base_url = _re.sub(r"/v\d+/*$", "", resolved_base_url).rstrip("/")
+
+    kwargs: dict = {
+        "workspace_id": config.workspace_id,
+        "api_key": effective_api_key,
+        "environment": config.environment,
+    }
+    if resolved_base_url:
+        kwargs["base_url"] = resolved_base_url
+    if resolved_timeout is not None:
+        kwargs["timeout"] = resolved_timeout
+
+    _honcho_client = Honcho(**kwargs)
+
+    return _honcho_client
 
 
 def reset_honcho_client() -> None:
     """Reset the Honcho client singleton (useful for testing)."""
-    _honcho_client_slot.reset()
+    global _honcho_client
+    _honcho_client = None

plugins/observability/langfuse/__init__.py

@@ -837,16 +837,8 @@ def on_post_llm_call(*, task_id: str = "", session_id: str = "", provider: str =
     if output.get("tool_calls"):
         state.turn_tool_calls.extend(output["tool_calls"])
 
-    # Extract usage: prefer a real response object that carries usage, else
-    # fall back to the usage summary dict from post_api_request.
-    #
-    # post_api_request passes `response` as a SANITIZED dict (no ``.usage``
-    # attribute) alongside a separate `usage` summary dict. Gating on
-    # ``response is not None`` here took the response-object path on that dict,
-    # where ``getattr(response, "usage", None)`` is always None — so usage and
-    # cost were silently dropped for every gateway turn. Gate on a real
-    # ``.usage`` attribute instead so the usage-dict fallback below is reached.
-    if getattr(response, "usage", None) is not None:
+    # Extract usage: prefer response object, fall back to usage dict from post_api_request
+    if response is not None:
         usage_details, cost_details = _usage_and_cost(
             response,
             provider=provider,

plugins/observability/nemo_relay/README.md

@@ -163,11 +163,7 @@ agent_version = "local"
 
 When `HERMES_NEMO_RELAY_PLUGINS_TOML` is set and initializes successfully, NeMo
 Relay owns exporter lifecycle through that config. The direct
-`HERMES_NEMO_RELAY_ATOF_*` fallback setup is skipped. If the same
-`plugins.toml` observability config enables `atif`, the direct
-`HERMES_NEMO_RELAY_ATIF_*` fallback setup is also skipped so Hermes does not
-double-export trajectories on teardown. If `plugins.toml` initialization fails,
-Hermes keeps the direct env-var fallbacks active for that run.
+`HERMES_NEMO_RELAY_ATOF_*` fallback setup is skipped.
 
 To enable NeMo Relay managed execution intercepts for provider and tool calls,
 include an adaptive component in the same `plugins.toml`:
@@ -177,8 +173,8 @@ include an adaptive component in the same `plugins.toml`:
 kind = "adaptive"
 enabled = true
 
-[components.config.tool_parallelism]
-mode = "observe_only"
+[components.config]
+mode = "route"
 ```
 
 When the adaptive component is enabled and the installed NeMo Relay runtime
@@ -186,16 +182,15 @@ exposes `llm.execute(...)` / `tools.execute(...)`, Hermes routes LLM and tool
 execution through those middleware boundaries. The observer hooks still emit
 session, turn, approval, and subagent marks; the plugin skips its manual
 `llm.call` and `tools.call` spans for executions that are already managed by
-NeMo Relay. `tool_parallelism.mode = "observe_only"` keeps tool scheduling
-observational while still wrapping the real execution boundary.
+NeMo Relay.
 
 For the full generic Hermes middleware contract, see
 [`docs/middleware/README.md`](../../../docs/middleware/README.md).
 
 ## Canonical Local Examples
 
-The observe-only examples in this section use the official `nemo-relay==0.3`
-distribution and a local Ollama model served through the OpenAI-compatible API.
+The examples below use the official `nemo-relay==0.3` distribution and a local
+Ollama model served through the OpenAI-compatible API.
 
 ```bash
 pip install "nemo-relay==0.3"
@@ -409,8 +404,8 @@ version = 1
 kind = "adaptive"
 enabled = true
 
-[components.config.tool_parallelism]
-mode = "observe_only"
+[components.config]
+mode = "route"
 ```
 
 Enable it for Hermes:
@@ -443,12 +438,11 @@ for the same execution.
 ### Local Adaptive E2E
 
 This example enables both NeMo Relay observability export and adaptive execution
-middleware for a local Hermes run. This path requires a NeMo Relay runtime that
-supports `[components.config.tool_parallelism]`; the `nemo-relay==0.3`
-install used by the earlier observability-only examples does not support this
-adaptive config.
+middleware for a local Hermes run.
 
 ```bash
+pip install "nemo-relay==0.3"
+
 export HERMES_HOME=/tmp/hermes-middleware-test/hermes-home
 mkdir -p "$HERMES_HOME" /tmp/hermes-middleware-test/nemo-relay
 
@@ -490,8 +484,8 @@ agent_version = "local"
 kind = "adaptive"
 enabled = true
 
-[components.config.tool_parallelism]
-mode = "observe_only"
+[components.config]
+mode = "route"
 TOML
 
 export HERMES_NEMO_RELAY_PLUGINS_TOML=/tmp/hermes-middleware-test/nemo-relay/plugins.toml
@@ -516,8 +510,8 @@ middleware_execution_ok
 Expected ATOF shape:
 
 ```jsonl
-{"kind":"scope","category":"llm","name":"custom","scope_category":"start","metadata":{"session_id":"middleware-demo-session"},"data":{"mode":"observe_only"}}
-{"kind":"scope","category":"tool","name":"terminal","scope_category":"start","metadata":{"session_id":"middleware-demo-session","tool_call_id":"call_terminal"},"data":{"mode":"observe_only"}}
+{"kind":"scope","category":"llm","name":"custom","scope_category":"start","metadata":{"session_id":"middleware-demo-session"},"data":{"mode":"route"}}
+{"kind":"scope","category":"tool","name":"terminal","scope_category":"start","metadata":{"session_id":"middleware-demo-session","tool_call_id":"call_terminal"},"data":{"mode":"route"}}
 {"kind":"scope","category":"tool","name":"terminal","scope_category":"end","metadata":{"session_id":"middleware-demo-session","tool_call_id":"call_terminal","status":"ok"},"data":"{\"output\":\"middleware_execution_ok\",\"exit_code\":0,\"error\":null}"}
 ```
 

plugins/observability/nemo_relay/__init__.py

@@ -44,7 +44,7 @@ class _Settings:
     plugins_toml_path: str = ""
     plugins_config: dict[str, Any] | None = None
     adaptive_enabled: bool = False
-    adaptive_mode: str = "observe_only"
+    adaptive_mode: str = "observe"
     atof_enabled: bool = False
     atof_output_directory: str = ""
     atof_filename: str = "hermes-atof.jsonl"
@@ -65,11 +65,9 @@ class _Runtime:
         self.sessions: dict[str, _SessionState] = {}
         self.subagent_parents: dict[str, _SubagentParent] = {}
         self.atof_exporter: Any = None
-        self._atof_subscriber_name = "hermes.nemo_relay.atof"
         self._plugin_config_initialized = self._configure_plugins_toml()
-        self._plugin_config_needs_reinit = False
         if not self._plugin_config_initialized:
-            self._activate_direct_fallbacks()
+            self._configure_atof()
 
     def _configure_plugins_toml(self) -> bool:
         if not self.settings.plugins_config:
@@ -80,45 +78,17 @@ class _Runtime:
             return False
         try:
             self._ensure_plugin_config_output_dirs(self.settings.plugins_config)
-            _resolve_awaitable(initialize(self.settings.plugins_config))
+            result = initialize(self.settings.plugins_config)
+            if inspect.isawaitable(result):
+                asyncio.run(result)
             return True
+        except RuntimeError:
+            logger.debug("NeMo Relay plugins.toml init skipped inside a running event loop")
+            return False
         except Exception as exc:
             logger.debug("NeMo Relay plugins.toml init failed: %s", exc, exc_info=True)
             return False
 
-    def _clear_plugins_toml(self) -> None:
-        if not self._plugin_config_initialized:
-            return
-        plugin_mod = getattr(self.nemo_relay, "plugin", None)
-        clear = getattr(plugin_mod, "clear", None)
-        if not callable(clear):
-            return
-        try:
-            _resolve_awaitable(clear())
-        finally:
-            self._plugin_config_initialized = False
-            self._plugin_config_needs_reinit = bool(self.settings.plugins_config)
-
-    def _activate_direct_fallbacks(self) -> None:
-        self._plugin_config_needs_reinit = False
-        self._configure_atof()
-
-    def _maybe_reinitialize_plugins_toml(self) -> None:
-        if not self._plugin_config_needs_reinit or self._plugin_config_initialized:
-            return
-        self._plugin_config_initialized = self._configure_plugins_toml()
-        if not self._plugin_config_initialized:
-            self._activate_direct_fallbacks()
-            return
-        self._clear_atof()
-        self._plugin_config_needs_reinit = False
-
-    def _plugins_toml_owns_exporter(self, exporter_name: str) -> bool:
-        return self._plugin_config_initialized and _observability_exporter_enabled(
-            self.settings.plugins_config,
-            exporter_name,
-        )
-
     def _ensure_plugin_config_output_dirs(self, config: dict[str, Any]) -> None:
         for component in config.get("components", []):
             if not isinstance(component, dict):
@@ -139,7 +109,7 @@ class _Runtime:
                     Path(output_directory).mkdir(parents=True, exist_ok=True)
 
     def _configure_atof(self) -> None:
-        if not self.settings.atof_enabled or self.atof_exporter is not None:
+        if not self.settings.atof_enabled:
             return
         config = self.nemo_relay.AtofExporterConfig()
         if self.settings.atof_output_directory:
@@ -151,28 +121,16 @@ class _Runtime:
         else:
             config.mode = self.nemo_relay.AtofExporterMode.Append
         self.atof_exporter = self.nemo_relay.AtofExporter(config)
-        self.atof_exporter.register(self._atof_subscriber_name)
-
-    def _clear_atof(self) -> None:
-        if self.atof_exporter is None:
-            return
-        deregister = getattr(self.atof_exporter, "deregister", None)
-        if callable(deregister):
-            try:
-                deregister(self._atof_subscriber_name)
-            except Exception:
-                logger.debug("NeMo Relay ATOF deregister failed", exc_info=True)
-        self.atof_exporter = None
+        self.atof_exporter.register("hermes.nemo_relay.atof")
 
     def ensure_session(self, kwargs: dict[str, Any]) -> _SessionState:
-        self._maybe_reinitialize_plugins_toml()
         session_id = _session_id(kwargs)
         state = self.sessions.get(session_id)
         if state is not None:
             return state
 
         state = _SessionState(session_id=session_id)
-        if self.settings.atif_enabled and not self._plugins_toml_owns_exporter("atif"):
+        if self.settings.atif_enabled:
             state.atif_exporter = self.nemo_relay.AtifExporter(
                 session_id,
                 self.settings.atif_agent_name,
@@ -231,13 +189,6 @@ class _Runtime:
                 state.atif_exporter.deregister(state.atif_subscriber_name)
             except Exception:
                 logger.debug("NeMo Relay ATIF deregister failed", exc_info=True)
-        if self._plugin_config_initialized and not self.sessions:
-            try:
-                self._clear_plugins_toml()
-            except Exception:
-                logger.debug("NeMo Relay plugins.toml clear failed", exc_info=True)
-        elif self.settings.plugins_config and not self.sessions:
-            self._plugin_config_needs_reinit = True
 
     def mark(self, name: str, kwargs: dict[str, Any]) -> None:
         state = self.ensure_session(kwargs)
@@ -660,29 +611,11 @@ def _enabled_component_config(
 
 def _adaptive_mode(config: dict[str, Any] | None) -> str:
     if not isinstance(config, dict):
-        return "observe_only"
-    tool_parallelism = config.get("tool_parallelism")
-    if isinstance(tool_parallelism, dict):
-        mode = tool_parallelism.get("mode")
-        if isinstance(mode, str) and mode.strip():
-            return mode.strip()
+        return "observe"
     mode = config.get("mode")
     if isinstance(mode, str) and mode.strip():
         return mode.strip()
-    return "observe_only"
-
-
-def _observability_exporter_enabled(
-    plugins_config: dict[str, Any] | None,
-    exporter_name: str,
-) -> bool:
-    observability_config = _enabled_component_config(plugins_config, "observability")
-    if not isinstance(observability_config, dict):
-        return False
-    exporter_config = observability_config.get(exporter_name)
-    if not isinstance(exporter_config, dict):
-        return False
-    return exporter_config.get("enabled", True) is not False
+    return "observe"
 
 
 def _env(name: str) -> str:

plugins/platforms/photon/README.md

@@ -1,123 +0,0 @@
-# Photon iMessage platform plugin
-
-This plugin connects Hermes Agent to iMessage (and WhatsApp Business +
-future Spectrum interfaces) through [Photon][photon] — a managed
-service that handles the iMessage line allocation, delivery, and
-abuse-prevention layer so users don't have to run their own Mac
-relay.
-
-The free tier uses Photon's shared iMessage line pool (`type: shared`)
-and is the path we recommend for everyone who doesn't already pay for a
-dedicated number.
-
-## Architecture
-
-```
-┌─────────────────────────┐    HMAC-signed POSTs      ┌──────────────────┐
-│  Photon Spectrum cloud  │ ──────────────────────►   │  Hermes Agent    │
-│  (iMessage line owner)  │                           │  (Python)        │
-└─────────────────────────┘    JSON over loopback     │                  │
-        ▲                  ◄──────────────────────    │  PhotonAdapter   │
-        │                                             │  + aiohttp recv  │
-        │  spectrum-ts                                │                  │
-        │  SDK (Node)                                 │  spawns + super- │
-        ▼                                             │  vises ▼         │
-┌─────────────────────────┐                           ├──────────────────┤
-│  Node sidecar           │   ◄────  X-Hermes-      ─ │  Node sidecar    │
-│  (plugins/.../sidecar)  │       Sidecar-Token       │  child process   │
-└─────────────────────────┘                           └──────────────────┘
-```
-
-Inbound traffic is webhook-only — Hermes runs an aiohttp listener
-that verifies `X-Spectrum-Signature` and dedupes on `message.id`.
-
-Outbound traffic goes through a tiny Node sidecar that runs the
-`spectrum-ts` SDK. Photon does not currently expose an HTTP
-send-message endpoint; their own docs say:
-
-> Pass `space.id` to `Space.send(...)` from a separate `spectrum-ts`
-> SDK instance to reply. **No public HTTP send endpoint exists today.**
-> — https://photon.codes/docs/webhooks/events
-
-When Photon ships an HTTP send endpoint, `_sidecar_send` is the one
-function that swaps and the sidecar disappears. The rest of the
-plugin stays the same.
-
-## First-time setup
-
-```bash
-# 1. One-shot setup: device login (opens browser) + project + user + sidecar deps
-hermes photon setup --phone +15551234567
-
-# 2. Expose your webhook URL to the public internet
-#    (cloudflared, ngrok, your gateway's public hostname, etc.)
-#    Then register it with Photon:
-hermes photon webhook register https://your-host.example.com/photon/webhook
-
-# 3. Save the signing secret it prints to ~/.hermes/.env
-#    as PHOTON_WEBHOOK_SECRET=...
-#    Photon only returns it ONCE.
-
-# 4. Start the gateway
-hermes gateway start --platform photon
-```
-
-`hermes photon setup` runs the RFC 8628 device-code login as its first
-step — it opens `https://app.photon.codes/` for approval, then
-provisions the Spectrum project + iMessage line. There is no separate
-`login` command; like every other Hermes channel, onboarding goes
-through one setup surface. Re-running `setup` reuses an existing token
-and project, so it's safe to run again to finish a partial setup.
-
-## Credentials
-
-Stored in `~/.hermes/auth.json` under `credential_pool`:
-
-```jsonc
-{
-  "credential_pool": {
-    "photon": [
-      { "access_token": "<dashboard-bearer>", "issued_at": ... }
-    ],
-    "photon_project": [
-      { "project_id": "...", "project_secret": "...", "name": "Hermes Agent" }
-    ]
-  }
-}
-```
-
-The per-URL webhook signing secret is treated like an API key and
-lives in `~/.hermes/.env` as `PHOTON_WEBHOOK_SECRET`.
-
-## Configuration knobs
-
-All env vars are documented in `plugin.yaml`. The most important are:
-
-| Env var                  | Default            | Meaning                                 |
-|--------------------------|--------------------|-----------------------------------------|
-| `PHOTON_PROJECT_ID`      | from auth.json     | Spectrum project ID                     |
-| `PHOTON_PROJECT_SECRET`  | from auth.json     | Spectrum project secret (HTTP Basic)    |
-| `PHOTON_WEBHOOK_SECRET`  | (unset)            | Signing secret returned at register     |
-| `PHOTON_WEBHOOK_PORT`    | 8788               | Local port for the aiohttp listener     |
-| `PHOTON_WEBHOOK_PATH`    | /photon/webhook    | Path under which the listener mounts    |
-| `PHOTON_SIDECAR_PORT`    | 8789               | Loopback port for sidecar control      |
-| `PHOTON_HOME_CHANNEL`    | (unset)            | Default space ID for cron delivery     |
-| `PHOTON_ALLOWED_USERS`   | (unset)            | Comma-separated E.164 allowlist        |
-
-## Limitations (current Photon API)
-
-- **Inbound attachments are metadata only.** Inbound webhooks include the
-  filename + MIME type but no download URL. The plugin surfaces a
-  text marker (`[Photon attachment received: …]`) so the agent knows
-  something arrived, but cannot read the bytes.  Photon's docs note
-  an attachment retrieval endpoint is on the roadmap.
-- **Outbound attachments are supported.** Images, voice notes, video,
-  and documents are sent via `space.send(attachment(...))` /
-  `space.send(voice(...))` through the sidecar's `/send-attachment`
-  endpoint. A caption is delivered as a separate text bubble after the
-  media.
-- **Reactions, message effects, polls** — not exposed yet; the
-  `spectrum-ts` SDK supports them, and the sidecar is the natural
-  place to add them when the agent has reason to use them.
-
-[photon]: https://photon.codes/

plugins/platforms/photon/__init__.py

@@ -1,4 +0,0 @@
-"""Photon Spectrum (iMessage) platform plugin entry point."""
-from .adapter import register
-
-__all__ = ["register"]

plugins/platforms/photon/auth.py

@@ -1,581 +0,0 @@
-"""
-Photon Dashboard + Spectrum API client and device-code login flow.
-
-This module is pure Python — it intentionally does not depend on
-``spectrum-ts``.  All management-plane operations (login, create
-project, create user, register webhook) talk to Photon's HTTP API
-directly:
-
-    Dashboard API   https://app.photon.codes/api/...
-                    OAuth bearer token from device flow
-
-    Spectrum API    https://spectrum.photon.codes/projects/{id}/...
-                    HTTP Basic with (projectId, projectSecret)
-
-The webhook receiver + Node sidecar in ``adapter.py`` consume the
-credentials this module persists to ``~/.hermes/auth.json``.
-
-Reference docs (read at integration time):
-  https://photon.codes/docs/api-reference/introduction
-  https://photon.codes/docs/api-reference/device-login/request-device-+-user-code
-  https://photon.codes/docs/api-reference/device-login/exchange-device-code-for-token
-  https://photon.codes/docs/api-reference/projects/create-project
-  https://photon.codes/docs/api-reference/users/create-user
-  https://photon.codes/docs/webhooks/overview
-"""
-from __future__ import annotations
-
-import json
-import logging
-import os
-import re
-import time
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Any, Callable, Dict, Optional, Tuple
-
-try:
-    import httpx
-except ImportError:  # pragma: no cover - httpx is a hermes dependency
-    httpx = None  # type: ignore[assignment]
-
-logger = logging.getLogger(__name__)
-
-# ---------------------------------------------------------------------------
-# Constants
-
-# Photon's published OAuth device-client identifier for first-party CLIs.
-# We use a fixed "hermes-agent" client_id string — Photon's device endpoint
-# accepts any opaque client_id and ties the bearer token to the approving
-# user, not to the client.  If Photon later requires registered clients,
-# this is the one knob to update.
-DEFAULT_CLIENT_ID = "hermes-agent"
-
-DEFAULT_DASHBOARD_HOST = "https://app.photon.codes"
-DEFAULT_SPECTRUM_HOST = "https://spectrum.photon.codes"
-
-# Polling defaults per RFC 8628.  Photon may override via `interval` /
-# `expires_in` fields in the device-code response — those win.
-DEFAULT_POLL_INTERVAL = 5
-DEFAULT_POLL_TIMEOUT = 900  # 15 minutes is conservative; Photon returns expires_in
-
-E164_RE = re.compile(r"^\+[1-9]\d{6,14}$")
-
-
-# ---------------------------------------------------------------------------
-# auth.json helpers — share the file with the rest of hermes-agent.
-
-def _auth_json_path() -> Path:
-    """Resolve ``~/.hermes/auth.json`` honouring the active Hermes profile."""
-    try:
-        from hermes_constants import get_hermes_home
-        return Path(get_hermes_home()) / "auth.json"
-    except Exception:
-        return Path(os.path.expanduser("~/.hermes")) / "auth.json"
-
-
-def _load_auth() -> Dict[str, Any]:
-    path = _auth_json_path()
-    if not path.exists():
-        return {}
-    try:
-        with path.open("r", encoding="utf-8") as fh:
-            return json.load(fh) or {}
-    except (OSError, json.JSONDecodeError) as e:
-        logger.warning("photon: could not read %s: %s", path, e)
-        return {}
-
-
-def _save_auth(data: Dict[str, Any]) -> None:
-    path = _auth_json_path()
-    path.parent.mkdir(parents=True, exist_ok=True)
-    tmp = path.with_suffix(".json.tmp")
-    with tmp.open("w", encoding="utf-8") as fh:
-        json.dump(data, fh, indent=2, sort_keys=True)
-    try:
-        os.chmod(tmp, 0o600)
-    except OSError:
-        pass
-    tmp.replace(path)
-
-
-def load_photon_token() -> Optional[str]:
-    """Return the bearer token stored by ``login()`` or ``None``."""
-    auth = _load_auth()
-    pool = auth.get("credential_pool", {}).get("photon") or []
-    if isinstance(pool, list) and pool:
-        token = pool[0].get("access_token") or pool[0].get("token")
-        if token:
-            return str(token)
-    # Backwards-compat shape: providers.photon.access_token
-    legacy = auth.get("providers", {}).get("photon", {})
-    if legacy.get("access_token"):
-        return str(legacy["access_token"])
-    return None
-
-
-def store_photon_token(token: str) -> None:
-    """Persist a dashboard bearer token under ``credential_pool.photon``."""
-    auth = _load_auth()
-    auth.setdefault("credential_pool", {})["photon"] = [
-        {"access_token": token, "issued_at": int(time.time())}
-    ]
-    _save_auth(auth)
-
-
-def load_project_credentials() -> Tuple[Optional[str], Optional[str]]:
-    """Return ``(project_id, project_secret)`` from auth.json + env override."""
-    env_id = os.getenv("PHOTON_PROJECT_ID")
-    env_sec = os.getenv("PHOTON_PROJECT_SECRET")
-    if env_id and env_sec:
-        return env_id, env_sec
-    auth = _load_auth()
-    proj = auth.get("credential_pool", {}).get("photon_project") or []
-    if isinstance(proj, list) and proj:
-        entry = proj[0]
-        return (
-            env_id or entry.get("project_id"),
-            env_sec or entry.get("project_secret"),
-        )
-    return env_id, env_sec
-
-
-def store_project_credentials(project_id: str, project_secret: str, **extra: Any) -> None:
-    """Persist the Spectrum project's id+secret under ``credential_pool.photon_project``."""
-    auth = _load_auth()
-    record = {
-        "project_id": project_id,
-        "project_secret": project_secret,
-        "issued_at": int(time.time()),
-    }
-    record.update(extra)
-    auth.setdefault("credential_pool", {})["photon_project"] = [record]
-    _save_auth(auth)
-
-
-# ---------------------------------------------------------------------------
-# Device login flow (RFC 8628)
-
-@dataclass
-class DeviceCode:
-    device_code: str
-    user_code: str
-    verification_uri: str
-    verification_uri_complete: Optional[str]
-    expires_in: int
-    interval: int
-
-
-def _dashboard_host() -> str:
-    return (os.getenv("PHOTON_DASHBOARD_HOST") or DEFAULT_DASHBOARD_HOST).rstrip("/")
-
-
-def _spectrum_host() -> str:
-    return (os.getenv("PHOTON_API_HOST") or DEFAULT_SPECTRUM_HOST).rstrip("/")
-
-
-def request_device_code(
-    *, client_id: str = DEFAULT_CLIENT_ID, scope: Optional[str] = None,
-) -> DeviceCode:
-    """POST ``/api/auth/device/code`` and return the device + user codes."""
-    if httpx is None:
-        raise RuntimeError("httpx is required for Photon device login")
-    url = f"{_dashboard_host()}/api/auth/device/code"
-    body: Dict[str, Any] = {"client_id": client_id}
-    if scope:
-        body["scope"] = scope
-    resp = httpx.post(url, json=body, timeout=30.0)
-    resp.raise_for_status()
-    data = resp.json()
-    return DeviceCode(
-        device_code=data["device_code"],
-        user_code=data["user_code"],
-        verification_uri=data["verification_uri"],
-        verification_uri_complete=data.get("verification_uri_complete"),
-        expires_in=int(data.get("expires_in") or DEFAULT_POLL_TIMEOUT),
-        interval=int(data.get("interval") or DEFAULT_POLL_INTERVAL),
-    )
-
-
-def poll_for_token(
-    code: DeviceCode,
-    *,
-    client_id: str = DEFAULT_CLIENT_ID,
-    timeout: Optional[int] = None,
-    interval: Optional[int] = None,
-    on_pending: Optional[Callable[[], None]] = None,
-) -> str:
-    """Poll ``/api/auth/device/token`` until the user approves.
-
-    Returns the bearer token from the ``set-auth-token`` response header
-    (Photon's documented mechanism).  Falls back to ``session.access_token``
-    in the JSON body if the header is absent — see the API spec.
-    """
-    if httpx is None:
-        raise RuntimeError("httpx is required for Photon device login")
-    url = f"{_dashboard_host()}/api/auth/device/token"
-    deadline = time.time() + (timeout or code.expires_in or DEFAULT_POLL_TIMEOUT)
-    sleep = interval or code.interval or DEFAULT_POLL_INTERVAL
-    while time.time() < deadline:
-        try:
-            resp = httpx.post(
-                url,
-                json={
-                    "grant_type": "urn:ietf:params:oauth:grant-type:device_code",
-                    "device_code": code.device_code,
-                    "client_id": client_id,
-                },
-                timeout=30.0,
-            )
-        except httpx.RequestError as e:
-            logger.warning("photon: device-token poll failed: %s", e)
-            time.sleep(sleep)
-            continue
-        if resp.status_code == 200:
-            token = resp.headers.get("set-auth-token")
-            if not token:
-                body = resp.json() or {}
-                session = body.get("session") or {}
-                token = session.get("access_token") or body.get("access_token")
-            if not token:
-                raise RuntimeError(
-                    "Photon returned 200 but no token in headers or body"
-                )
-            return token
-        if resp.status_code == 400:
-            # RFC 8628 §3.5 — error codes are returned with 400.
-            body: Dict[str, Any] = {}
-            try:
-                body = resp.json() or {}
-            except json.JSONDecodeError:
-                pass
-            err = body.get("error") or body.get("message") or ""
-            if err in ("authorization_pending", "slow_down"):
-                if on_pending:
-                    try:
-                        on_pending()
-                    except Exception:
-                        pass
-                if err == "slow_down":
-                    sleep += 5
-                time.sleep(sleep)
-                continue
-            if err in ("expired_token", "access_denied"):
-                raise RuntimeError(f"Photon login failed: {err}")
-            # Unknown error — surface it
-            raise RuntimeError(f"Photon device token error: {err or resp.text}")
-        # Unexpected status; log and retry
-        logger.warning(
-            "photon: device-token unexpected status %s: %s",
-            resp.status_code, resp.text[:200],
-        )
-        time.sleep(sleep)
-    raise TimeoutError("Photon device login timed out")
-
-
-def login_device_flow(
-    *,
-    client_id: str = DEFAULT_CLIENT_ID,
-    open_browser: bool = True,
-    on_user_code: Optional[Callable[["DeviceCode"], None]] = None,
-) -> str:
-    """Run the full device-code login flow and persist the token.
-
-    Returns the bearer token.  ``on_user_code`` is a callback receiving the
-    :class:`DeviceCode` so callers can print + optionally open the browser.
-    """
-    code = request_device_code(client_id=client_id)
-    if on_user_code:
-        try:
-            on_user_code(code)
-        except Exception:
-            pass
-    if open_browser:
-        try:
-            import webbrowser
-            target = code.verification_uri_complete or code.verification_uri
-            webbrowser.open(target, new=2)
-        except Exception:
-            pass
-    token = poll_for_token(code, client_id=client_id)
-    store_photon_token(token)
-    return token
-
-
-# ---------------------------------------------------------------------------
-# Dashboard API: create project
-
-def create_project(
-    token: str,
-    *,
-    name: str,
-    location: str = "United States",
-    platforms: Optional[list] = None,
-) -> Dict[str, Any]:
-    """POST ``/api/projects/`` with ``spectrum: true`` and return the response.
-
-    The response includes ``spectrumProjectId`` and ``projectSecret`` — those
-    are the HTTP Basic credentials for the Spectrum API.  Photon only
-    returns ``projectSecret`` to project owners at creation time.
-    """
-    if httpx is None:
-        raise RuntimeError("httpx is required for Photon project creation")
-    url = f"{_dashboard_host()}/api/projects/"
-    body: Dict[str, Any] = {
-        "name": name,
-        "location": location,
-        "spectrum": True,
-        "platforms": platforms or ["imessage"],
-    }
-    resp = httpx.post(
-        url,
-        json=body,
-        headers={"Authorization": f"Bearer {token}"},
-        timeout=30.0,
-    )
-    resp.raise_for_status()
-    return resp.json()
-
-
-# ---------------------------------------------------------------------------
-# Spectrum API: create user
-
-def create_user(
-    project_id: str,
-    project_secret: str,
-    *,
-    phone_number: str,
-    user_type: str = "shared",
-    first_name: Optional[str] = None,
-    last_name: Optional[str] = None,
-    email: Optional[str] = None,
-    assigned_phone_number: Optional[str] = None,
-) -> Dict[str, Any]:
-    """POST ``/projects/{id}/users/`` on the Spectrum API.
-
-    For free users we always pass ``type=shared``; Photon's Cosmos pool
-    assigns the iMessage line.  ``assigned_phone_number`` is only valid
-    for the paid ``dedicated`` mode.
-    """
-    if httpx is None:
-        raise RuntimeError("httpx is required for Photon user creation")
-    if not E164_RE.match(phone_number):
-        raise ValueError(
-            f"phone_number must be E.164 (e.g. +15551234567); got {phone_number!r}"
-        )
-    url = f"{_spectrum_host()}/projects/{project_id}/users/"
-    body: Dict[str, Any] = {"type": user_type, "phoneNumber": phone_number}
-    if first_name:
-        body["firstName"] = first_name
-    if last_name:
-        body["lastName"] = last_name
-    if email:
-        body["email"] = email
-    if assigned_phone_number:
-        body["assignedPhoneNumber"] = assigned_phone_number
-    resp = httpx.post(
-        url,
-        json=body,
-        auth=(project_id, project_secret),
-        timeout=30.0,
-    )
-    resp.raise_for_status()
-    data = resp.json() or {}
-    if not data.get("succeed"):
-        raise RuntimeError(
-            f"Photon create-user failed: {data.get('message') or data}"
-        )
-    return data.get("data") or {}
-
-
-# ---------------------------------------------------------------------------
-# Spectrum API: webhook registration
-#
-# Endpoints from https://photon.codes/docs/webhooks/overview:
-#   POST   /projects/{id}/webhooks/          register, returns signing secret ONCE
-#   GET    /projects/{id}/webhooks/          list
-#   DELETE /projects/{id}/webhooks/{wid}     remove
-
-def register_webhook(
-    project_id: str, project_secret: str, *, webhook_url: str,
-) -> Dict[str, Any]:
-    """Register a webhook URL with Photon and return the API response.
-
-    Photon returns the per-URL signing secret exactly once in this
-    response, so callers who need to persist it should hand the
-    response to :func:`persist_webhook_signing_secret` immediately —
-    that helper writes the value into ``~/.hermes/.env`` (mode 0o600,
-    existing entries preserved) without the secret value ever needing
-    to leave this module.
-    """
-    if httpx is None:
-        raise RuntimeError("httpx is required for Photon webhook registration")
-    url = f"{_spectrum_host()}/projects/{project_id}/webhooks/"
-    resp = httpx.post(
-        url,
-        json={"webhookUrl": webhook_url},
-        auth=(project_id, project_secret),
-        timeout=30.0,
-    )
-    resp.raise_for_status()
-    data = resp.json() or {}
-    if not data.get("succeed"):
-        raise RuntimeError(
-            f"Photon register-webhook failed: {data.get('message') or data}"
-        )
-    return data.get("data") or {}
-
-
-def print_credential_summary(emit: Any = print) -> None:
-    """Pretty-print the credential status table via the *emit* callback.
-
-    Same isolation rationale as :func:`persist_webhook_signing_secret`:
-    all secret-bearing reads happen inside this function; the *emit*
-    callback only ever receives display literals like ``"✓ stored"``
-    or a project UUID. No tainted variable ever escapes into the
-    caller's scope. Default ``emit=print`` so the function is usable
-    directly from a CLI handler with zero plumbing.
-    """
-    # Resolve every credential read into a plain display string FIRST,
-    # in a tight block. The intermediate `labels` dict only ever stores
-    # literals from a finite set ("✓ stored" / "✗ missing" / "✓ set" /
-    # "⚠ unset — verification disabled" / a project UUID) — never a
-    # credential's raw bytes. We then assemble the whole banner into
-    # one string and call emit() exactly once with that string, so the
-    # static taint analyzer sees a single sink that consumes only a
-    # joined literal blob.
-    labels: Dict[str, str] = {}
-    if load_photon_token():
-        labels["device_token"] = "✓ stored"
-    else:
-        labels["device_token"] = "✗ missing (run `hermes photon setup`)"
-    pid, sec = load_project_credentials()
-    labels["project_id"] = pid if pid else "✗ missing"
-    labels["project_key"] = "✓ stored" if sec else "✗ missing"
-    if os.getenv("PHOTON_WEBHOOK_SECRET"):
-        labels["webhook_key"] = "✓ set"
-    else:
-        labels["webhook_key"] = "⚠ unset — verification disabled"
-
-    rows = [
-        "Photon iMessage status",
-        "──────────────────────",
-        "  device token        : " + labels["device_token"],
-        "  project id          : " + labels["project_id"],
-        "  project key         : " + labels["project_key"],
-        "  webhook key         : " + labels["webhook_key"],
-    ]
-    emit("\n".join(rows))
-
-
-def credential_summary() -> Dict[str, str]:
-    """Return a fully pre-formatted credential status dict.
-
-    Caller-safe: every value is one of ``"✓ stored"`` / ``"✗ missing"``
-    / ``"⚠ unset — verification disabled"`` / ``"✓ set"`` literals, or a
-    UUID for the project id. No secret-bearing string ever leaves this
-    function — read-and-bool-cast happens entirely inside the closure.
-    """
-    def _present_token() -> str:
-        return "✓ stored" if load_photon_token() else "✗ missing (run `hermes photon setup`)"
-
-    def _present_project_id() -> str:
-        pid, _sec = load_project_credentials()
-        return pid or "✗ missing"
-
-    def _present_project_secret() -> str:
-        _pid, sec = load_project_credentials()
-        return "✓ stored" if sec else "✗ missing"
-
-    def _present_webhook_secret() -> str:
-        return "✓ set" if os.getenv("PHOTON_WEBHOOK_SECRET") else "⚠ unset — verification disabled"
-
-    return {
-        "device_token": _present_token(),
-        "project_id": _present_project_id(),
-        "project_key": _present_project_secret(),
-        "webhook_key": _present_webhook_secret(),
-    }
-
-
-def persist_webhook_signing_secret(
-    webhook_data: Dict[str, Any],
-    *,
-    on_summary: Optional[Any] = None,
-) -> bool:
-    """Persist a webhook signing secret via Hermes' canonical .env writer.
-
-    Delegates to :func:`hermes_cli.config.save_env_value` — the same
-    helper that backs every other API-key persistence path in Hermes
-    Agent (OpenAI key, Anthropic key, Telegram token, ...). The secret
-    value is read directly from ``webhook_data['signingSecret']`` (or
-    ``['secret']`` fallback) and handed to that helper without ever
-    being bound to a local in any module that prints or logs.
-
-    Returns ``True`` on success, ``False`` if the response had no
-    secret OR the write failed. The optional ``on_summary`` callable
-    receives a plain string with no credential material, suitable for
-    printing — e.g. ``"Wrote to /home/u/.hermes/.env"`` or
-    ``"register response: {redacted dict json}"``.  We do the
-    formatting here so callers stay clear of the taint flow CodeQL
-    tracks through functions that touch secrets.
-    """
-    if not isinstance(webhook_data, dict):
-        return False
-    has_secret = bool(webhook_data.get("signingSecret") or webhook_data.get("secret"))
-    redacted = {
-        k: ("<redacted>" if k in ("signingSecret", "secret") else v)
-        for k, v in webhook_data.items()
-    }
-    if on_summary is not None:
-        try:
-            on_summary("webhook registration response (redacted):")
-            on_summary(json.dumps(redacted, indent=2))
-        except Exception:
-            pass
-    if not has_secret:
-        return False
-    try:
-        from hermes_cli.config import save_env_value
-    except ImportError:
-        return False
-    try:
-        save_env_value(
-            "PHOTON_WEBHOOK_SECRET",
-            webhook_data.get("signingSecret") or webhook_data.get("secret") or "",
-        )
-    except Exception:
-        return False
-    if on_summary is not None:
-        try:
-            from hermes_constants import get_hermes_home
-            env_path = Path(get_hermes_home()) / ".env"
-        except Exception:
-            env_path = Path(os.path.expanduser("~/.hermes")) / ".env"
-        try:
-            on_summary(f"signing key saved to {env_path}")
-            on_summary("(Photon only returns this once — keep the file safe)")
-        except Exception:
-            pass
-    return True
-
-
-def list_webhooks(project_id: str, project_secret: str) -> list:
-    if httpx is None:
-        raise RuntimeError("httpx is required for Photon webhook listing")
-    url = f"{_spectrum_host()}/projects/{project_id}/webhooks/"
-    resp = httpx.get(url, auth=(project_id, project_secret), timeout=30.0)
-    resp.raise_for_status()
-    data = resp.json() or {}
-    return data.get("data") or []
-
-
-def delete_webhook(
-    project_id: str, project_secret: str, *, webhook_id: str,
-) -> None:
-    if httpx is None:
-        raise RuntimeError("httpx is required for Photon webhook deletion")
-    url = f"{_spectrum_host()}/projects/{project_id}/webhooks/{webhook_id}"
-    resp = httpx.delete(url, auth=(project_id, project_secret), timeout=30.0)
-    if resp.status_code not in (200, 204, 404):
-        resp.raise_for_status()

plugins/platforms/photon/cli.py

@@ -1,340 +0,0 @@
-"""
-``hermes photon ...`` CLI subcommands — registered by the plugin via
-``ctx.register_cli_command()``.
-
-Subcommands:
-
-    setup              full first-time setup (device login + project + user + sidecar)
-    status             show login + project + sidecar dep state
-    install-sidecar    npm install inside plugins/platforms/photon/sidecar/
-    webhook register   register the local webhook URL with Photon
-    webhook list       list registered webhooks
-    webhook delete     delete a webhook by id
-
-The device-code login runs automatically as the first step of ``setup``;
-there is no standalone ``login`` verb (matching how every other Hermes
-gateway channel onboards through a single setup surface).
-"""
-from __future__ import annotations
-
-import argparse
-import getpass
-import json
-import os
-import shutil
-import subprocess
-import sys
-from pathlib import Path
-
-from . import auth as photon_auth
-
-_SIDECAR_DIR = Path(__file__).parent / "sidecar"
-
-
-# ---------------------------------------------------------------------------
-# argparse wiring
-
-def register_cli(parser: argparse.ArgumentParser) -> None:
-    """Wire up `hermes photon ...` subcommands."""
-    subs = parser.add_subparsers(dest="photon_command", required=False)
-
-    p_setup = subs.add_parser("setup", help="First-time setup (device login + project + user + sidecar)")
-    p_setup.add_argument("--project-name", default=None, help="Project name (default: 'Hermes Agent')")
-    p_setup.add_argument("--phone", default=None, help="Your E.164 phone number (e.g. +15551234567)")
-    p_setup.add_argument("--first-name", default=None)
-    p_setup.add_argument("--last-name", default=None)
-    p_setup.add_argument("--email", default=None)
-    p_setup.add_argument("--no-browser", action="store_true",
-                         help="Don't try to open a browser for device login; print the URL only")
-    p_setup.add_argument("--skip-sidecar-install", action="store_true",
-                         help="Skip `npm install` inside the sidecar directory")
-
-    subs.add_parser("status", help="Show login + project + sidecar dep state")
-    subs.add_parser("install-sidecar", help="Run npm install inside the sidecar directory")
-
-    p_hook = subs.add_parser("webhook", help="Manage Photon webhook registrations")
-    hook_subs = p_hook.add_subparsers(dest="photon_webhook_command", required=True)
-    p_hook_reg = hook_subs.add_parser("register", help="Register a webhook URL")
-    p_hook_reg.add_argument("url", help="Publicly reachable URL Photon should POST to")
-    hook_subs.add_parser("list", help="List registered webhooks for the current project")
-    p_hook_del = hook_subs.add_parser("delete", help="Delete a webhook by id")
-    p_hook_del.add_argument("webhook_id")
-
-    parser.set_defaults(func=dispatch)
-
-
-# ---------------------------------------------------------------------------
-# Dispatch
-
-def dispatch(args: argparse.Namespace) -> int:
-    sub = getattr(args, "photon_command", None)
-    if sub is None:
-        # No subcommand given — show status by default.
-        return _cmd_status(args)
-    if sub == "setup":
-        return _cmd_setup(args)
-    if sub == "status":
-        return _cmd_status(args)
-    if sub == "install-sidecar":
-        return _cmd_install_sidecar(args)
-    if sub == "webhook":
-        return _cmd_webhook(args)
-    print(f"unknown subcommand: {sub}", file=sys.stderr)
-    return 2
-
-
-# ---------------------------------------------------------------------------
-# Subcommand handlers
-
-def _run_device_login(args: argparse.Namespace) -> int:
-    """Run the RFC 8628 device-code login flow and persist the token.
-
-    Internal helper — invoked as the first step of ``setup``. There is
-    no standalone ``hermes photon login`` command; Photon onboards
-    through the single ``setup`` surface like every other channel.
-    """
-    def _print_code(code):
-        target = code.verification_uri_complete or code.verification_uri
-        print()
-        print("┌─ Photon device login ────────────────────────────────────────")
-        print(f"│  Open this URL:  {target}")
-        print(f"│  Enter the code: {code.user_code}")
-        print("│  (waiting for approval — Ctrl-C to cancel)")
-        print("└──────────────────────────────────────────────────────────────")
-        print()
-
-    try:
-        token = photon_auth.login_device_flow(
-            open_browser=not args.no_browser,
-            on_user_code=_print_code,
-        )
-    except Exception as e:
-        print(f"login failed: {e}", file=sys.stderr)
-        return 1
-    # Don't print any portion of the token — even a prefix can help a
-    # shoulder-surfer or accidentally leak into a screen recording.
-    _ = token
-    print(f"✓ logged in — token saved to {photon_auth._auth_json_path()}")
-    return 0
-
-
-def _cmd_setup(args: argparse.Namespace) -> int:
-    # 1. Login (skip if we already have a token).
-    token = photon_auth.load_photon_token()
-    if not token:
-        print("[1/4] No Photon token found — running device login...")
-        rc = _run_device_login(args)
-        if rc != 0:
-            return rc
-        token = photon_auth.load_photon_token()
-        if not token:
-            print("login completed but token was not stored", file=sys.stderr)
-            return 1
-    else:
-        print("[1/4] Reusing existing Photon token")
-
-    # 2. Create (or surface existing) project.
-    existing_id, existing_secret = photon_auth.load_project_credentials()
-    project_id: str
-    project_secret: str
-    if existing_id and existing_secret:
-        project_id, project_secret = existing_id, existing_secret
-        # `project_id` is a Photon-assigned UUID, not a secret — but we
-        # keep the print terse to avoid CodeQL flow noise.
-        print("[2/4] Reusing existing Photon project")
-    else:
-        name = args.project_name or "Hermes Agent"
-        print(f"[2/4] Creating Photon project '{name}' (spectrum=true, imessage)...")
-        try:
-            data = photon_auth.create_project(token, name=name)
-        except Exception as e:
-            print(f"create-project failed: {e}", file=sys.stderr)
-            return 1
-        project_id = data.get("spectrumProjectId") or data.get("id") or ""
-        project_secret = data.get("projectSecret") or ""
-        if not project_id or not project_secret:
-            print(
-                "create-project did not return spectrumProjectId + "
-                "projectSecret. Re-run after enabling Spectrum on the "
-                "project, or open https://app.photon.codes/ to fetch the "
-                "secret manually.",
-                file=sys.stderr,
-            )
-            return 1
-        photon_auth.store_project_credentials(project_id, project_secret, name=name)
-        print("  ✓ project provisioned (run `hermes photon status` to see the id)")
-
-    # 3. Create a Spectrum user for the operator.
-    phone = args.phone or _prompt(
-        "Your iMessage phone number (E.164, e.g. +15551234567): "
-    )
-    if not phone:
-        print("[3/4] Skipped user creation (no phone given). Re-run with --phone later.")
-    else:
-        print("[3/4] Creating shared Spectrum user...")
-        try:
-            photon_auth.create_user(
-                project_id, project_secret,
-                phone_number=phone,
-                first_name=args.first_name,
-                last_name=args.last_name,
-                email=args.email,
-            )
-        except Exception as e:
-            print(f"create-user failed: {e}", file=sys.stderr)
-            return 1
-        print("  ✓ user created — check `hermes photon status` or the dashboard for the assigned iMessage line")
-
-    # 4. Sidecar deps.
-    if args.skip_sidecar_install:
-        print("[4/4] Skipping sidecar npm install (--skip-sidecar-install)")
-    else:
-        print("[4/4] Installing Node sidecar deps (spectrum-ts)...")
-        rc = _install_sidecar()
-        if rc != 0:
-            return rc
-
-    print()
-    print("✓ Photon setup complete.")
-    print("  Next: register a webhook URL Photon can reach:")
-    print("        hermes photon webhook register https://YOUR-PUBLIC-URL/photon/webhook")
-    print("  Then start the gateway:")
-    print("        hermes gateway start --platform photon")
-    return 0
-
-
-def _cmd_status(_args: argparse.Namespace) -> int:
-    # Defer the whole table to auth.print_credential_summary — its emit
-    # callback is the only sink that sees credential-derived strings, so
-    # cli.py keeps zero taint flow according to CodeQL.
-    photon_auth.print_credential_summary(print)
-    # The two non-credential rows live here so the helper stays purely
-    # about credentials.
-    node_bin = os.getenv("PHOTON_NODE_BIN") or shutil.which("node")
-    sidecar_installed = (_SIDECAR_DIR / "node_modules").exists()
-    print(f"  node binary         : {node_bin or '✗ missing (install Node 18+)'}")
-    print(f"  sidecar deps        : {'✓ installed' if sidecar_installed else '✗ run `hermes photon install-sidecar`'}")
-    return 0
-
-
-def _cmd_install_sidecar(_args: argparse.Namespace) -> int:
-    rc = _install_sidecar()
-    return rc
-
-
-def _install_sidecar() -> int:
-    npm = shutil.which("npm") or "npm"
-    if not shutil.which(npm):
-        print(
-            "npm is not on PATH. Install Node.js 18+ (https://nodejs.org/) "
-            "and re-run.",
-            file=sys.stderr,
-        )
-        return 1
-    print(f"  $ cd {_SIDECAR_DIR} && {npm} install")
-    proc = subprocess.run(  # noqa: S603
-        [npm, "install"],
-        cwd=str(_SIDECAR_DIR),
-        check=False,
-    )
-    if proc.returncode != 0:
-        print("npm install failed", file=sys.stderr)
-    return proc.returncode
-
-
-def _cmd_webhook(args: argparse.Namespace) -> int:
-    sub = getattr(args, "photon_webhook_command", None)
-    project_id, project_secret = photon_auth.load_project_credentials()
-    if not (project_id and project_secret):
-        print(
-            "no Photon project configured — run `hermes photon setup` first",
-            file=sys.stderr,
-        )
-        return 1
-
-    if sub == "register":
-        try:
-            data = photon_auth.register_webhook(
-                project_id, project_secret, webhook_url=args.url
-            )
-        except Exception as e:
-            print(f"register failed: {e}", file=sys.stderr)
-            return 1
-        # The helper does all the formatting + writing; cli.py never
-        # touches the signing-secret value, the path it was written
-        # to, or even the redacted-response dict. on_summary is a
-        # plain printer callback.
-        ok = photon_auth.persist_webhook_signing_secret(data, on_summary=print)
-        if not ok:
-            print(
-                "‼  Photon returned no signing secret in the response, "
-                "or the file write failed. Inspect your home directory "
-                "permissions and re-run; do not retry without first "
-                "deleting the orphaned webhook from the Photon dashboard.",
-                file=sys.stderr,
-            )
-            return 1
-        return 0
-
-    if sub == "list":
-        try:
-            data = photon_auth.list_webhooks(project_id, project_secret)
-        except Exception as e:
-            print(f"list failed: {e}", file=sys.stderr)
-            return 1
-        print(json.dumps(data, indent=2))
-        return 0
-
-    if sub == "delete":
-        try:
-            photon_auth.delete_webhook(
-                project_id, project_secret, webhook_id=args.webhook_id
-            )
-        except Exception as e:
-            print(f"delete failed: {e}", file=sys.stderr)
-            return 1
-        print(f"deleted webhook {args.webhook_id}")
-        return 0
-
-    print(f"unknown webhook subcommand: {sub}", file=sys.stderr)
-    return 2
-
-
-# ---------------------------------------------------------------------------
-# Gateway-setup entry point
-#
-# `hermes gateway setup` discovers platforms via the registry and calls each
-# entry's zero-arg ``setup_fn``. Photon registers this function so it appears
-# in the unified setup wizard alongside every other channel — same onboarding
-# surface, no Photon-specific detour. It runs the identical device-login +
-# project + user + sidecar flow as ``hermes photon setup`` with interactive
-# defaults (phone is prompted when stdin is a TTY).
-
-def gateway_setup() -> None:
-    """Run Photon first-time setup from the `hermes gateway setup` wizard."""
-    args = argparse.Namespace(
-        photon_command="setup",
-        project_name=None,
-        phone=None,
-        first_name=None,
-        last_name=None,
-        email=None,
-        no_browser=False,
-        skip_sidecar_install=False,
-    )
-    _cmd_setup(args)
-
-
-# ---------------------------------------------------------------------------
-# Small interactive helpers
-
-def _prompt(prompt: str, *, secret: bool = False) -> str:
-    if not sys.stdin.isatty():
-        return ""
-    try:
-        if secret:
-            return getpass.getpass(prompt).strip()
-        return input(prompt).strip()
-    except (KeyboardInterrupt, EOFError):
-        print()
-        return ""

plugins/platforms/photon/plugin.yaml

@@ -1,91 +0,0 @@
-name: photon-platform
-label: Photon iMessage
-kind: platform
-version: 0.1.0
-description: >
-  Photon Spectrum gateway adapter for Hermes Agent.
-  Connects to iMessage (and other Spectrum interfaces) through Photon's
-  managed Spectrum platform. Inbound messages arrive as signed webhooks
-  on a local aiohttp server; outbound messages are sent via a small
-  supervised Node sidecar that runs the `spectrum-ts` SDK (Photon does
-  not currently expose a public HTTP send endpoint).
-
-  The plugin ships with a `hermes photon` CLI for the one-time login
-  + project + user setup, persists Spectrum credentials to
-  ``~/.hermes/auth.json`` under ``credential_pool.photon`` (token) and
-  ``credential_pool.photon_project`` (project id + secret), and exposes
-  Photon's free shared-line model so users can get started without a
-  paid plan.
-author: NousResearch
-requires_env:
-  - name: PHOTON_PROJECT_ID
-    description: "Spectrum project ID (set by `hermes photon setup`)"
-    prompt: "Photon Spectrum project ID"
-    url: "https://app.photon.codes/"
-    password: false
-  - name: PHOTON_PROJECT_SECRET
-    description: "Spectrum project secret (set by `hermes photon setup`)"
-    prompt: "Photon Spectrum project secret"
-    url: "https://app.photon.codes/"
-    password: true
-optional_env:
-  - name: PHOTON_WEBHOOK_SECRET
-    description: "Per-URL HMAC-SHA256 signing secret returned at webhook registration"
-    prompt: "Photon webhook signing secret"
-    password: true
-  - name: PHOTON_WEBHOOK_PORT
-    description: "Local port the webhook receiver listens on (default 8788)"
-    prompt: "Webhook receiver port"
-    password: false
-  - name: PHOTON_WEBHOOK_PATH
-    description: "Path the webhook receiver listens on (default /photon/webhook)"
-    prompt: "Webhook receiver path"
-    password: false
-  - name: PHOTON_WEBHOOK_BIND
-    description: "Bind address for the webhook receiver (default 0.0.0.0)"
-    prompt: "Webhook bind address"
-    password: false
-  - name: PHOTON_SIDECAR_PORT
-    description: "Loopback port for the Node sidecar control channel (default 8789)"
-    prompt: "Sidecar control port"
-    password: false
-  - name: PHOTON_SIDECAR_AUTOSTART
-    description: "Spawn the Node sidecar on connect (true/false, default true)"
-    prompt: "Auto-start the sidecar?"
-    password: false
-  - name: PHOTON_NODE_BIN
-    description: "Path to the node binary (default: shutil.which('node'))"
-    prompt: "Node executable path"
-    password: false
-  - name: PHOTON_API_HOST
-    description: "Spectrum management API host (default https://spectrum.photon.codes)"
-    prompt: "Spectrum API host"
-    password: false
-  - name: PHOTON_DASHBOARD_HOST
-    description: "Dashboard API host (default https://app.photon.codes)"
-    prompt: "Dashboard host"
-    password: false
-  - name: PHOTON_ALLOWED_USERS
-    description: "Comma-separated E.164 phone numbers allowed to talk to the bot"
-    prompt: "Allowed users (comma-separated)"
-    password: false
-  - name: PHOTON_ALLOW_ALL_USERS
-    description: "Allow any sender to trigger the bot (dev only — disables allowlist)"
-    prompt: "Allow all users? (true/false)"
-    password: false
-  - name: PHOTON_REQUIRE_MENTION
-    description: "Ignore group-chat messages unless they match a mention wake word (true/false, default false)"
-    prompt: "Require a mention in group chats?"
-    password: false
-  - name: PHOTON_MENTION_PATTERNS
-    description: "Mention wake-word regexes for group chats (JSON list or comma/newline-separated; defaults to Hermes wake words)"
-    prompt: "Group mention patterns"
-    password: false
-  - name: PHOTON_HOME_CHANNEL
-    description: "Default Spectrum space ID for cron / notification delivery"
-    prompt: "Home space ID"
-    password: false
-  - name: PHOTON_HOME_CHANNEL_NAME
-    description: "Human label for the home channel"
-    prompt: "Home channel display name"
-    password: false

plugins/platforms/photon/sidecar/README.md

@@ -1,52 +0,0 @@
-# Photon sidecar
-
-Small Node helper that bridges Hermes Agent to Photon's Spectrum SDK
-(`spectrum-ts`).  Hermes is Python; Photon has no public HTTP
-send-message endpoint today; replies therefore go through this sidecar.
-
-The sidecar:
-
-- runs `Spectrum({ projectId, projectSecret, providers: [imessage.config()] })`
-- exposes a loopback-only HTTP control channel for the Python adapter
-  to push send/typing requests (auth via `X-Hermes-Sidecar-Token`)
-- drains the inbound message stream so `spectrum-ts` keeps its
-  reconnect/heartbeat machinery alive (real inbound delivery is via
-  Photon's signed webhook hitting our Python aiohttp server)
-
-## Install
-
-```bash
-cd plugins/platforms/photon/sidecar
-npm install
-```
-
-The Hermes plugin's `hermes photon setup` command runs `npm install`
-here automatically.
-
-## Run standalone
-
-For debugging:
-
-```bash
-PHOTON_PROJECT_ID=... PHOTON_PROJECT_SECRET=... \
-PHOTON_SIDECAR_PORT=8789 PHOTON_SIDECAR_TOKEN=$(openssl rand -hex 16) \
-node index.mjs
-```
-
-In normal use, the Python adapter supervises this process — start,
-restart on crash, kill on shutdown — and never asks the user to run
-it by hand.
-
-## Why a sidecar at all?
-
-Photon publishes webhooks (inbound) but their docs state explicitly:
-
-> Pass `space.id` to `Space.send(...)` from a separate `spectrum-ts`
-> SDK instance to reply.  No public HTTP send endpoint exists today.
-
-— https://photon.codes/docs/webhooks/events
-
-When Photon ships an HTTP send endpoint, the plan is to retire this
-sidecar entirely and call it directly from Python.  The plugin's
-outbound code path is already isolated behind a single helper
-(`_sidecar_send` in `adapter.py`) to make that swap a one-file change.

plugins/platforms/photon/sidecar/index.mjs

@@ -1,268 +0,0 @@
-// Hermes Agent — Photon Spectrum sidecar
-//
-// Spawned by `plugins/platforms/photon/adapter.py` to bridge outbound
-// messaging to Photon's Spectrum platform. Inbound messages go directly
-// from Photon's webhook to Hermes' Python aiohttp receiver — this
-// sidecar handles ONLY outbound calls (which require the spectrum-ts
-// SDK because Photon has no public HTTP send endpoint today).
-//
-// Protocol:
-//   - The sidecar listens on http://127.0.0.1:${PORT} (loopback only)
-//   - Each request must include `X-Hermes-Sidecar-Token: ${TOKEN}`
-//   - POST /healthz                     -> {"ok": true}
-//   - POST /send                        -> {"ok": true, "messageId": "..."}
-//       body: {"spaceId": "...", "text": "...", "replyTo": "..." | null}
-//   - POST /send-attachment             -> {"ok": true, "messageId": "..."}
-//       body: {"spaceId": "...", "path": "...", "name": "..." | null,
-//              "mimeType": "..." | null, "caption": "..." | null,
-//              "kind": "attachment" | "voice", "replyTo": "..." | null}
-//   - POST /typing                      -> {"ok": true}
-//       body: {"spaceId": "..."}
-//   - POST /shutdown                    -> {"ok": true}; then process exits
-//
-// On SIGINT/SIGTERM the sidecar calls `app.stop()` (3s graceful) before
-// exiting. Errors are logged to stderr; Python supervises restart.
-//
-// Env vars (all required):
-//   PHOTON_PROJECT_ID
-//   PHOTON_PROJECT_SECRET
-//   PHOTON_SIDECAR_PORT
-//   PHOTON_SIDECAR_TOKEN
-//
-// Optional:
-//   PHOTON_SIDECAR_BIND  (default 127.0.0.1)
-//   PHOTON_API_HOST      (passed through to spectrum-ts if its config
-//                         honours it)
-
-import http from "node:http";
-
-const projectId = process.env.PHOTON_PROJECT_ID;
-const projectSecret = process.env.PHOTON_PROJECT_SECRET;
-const port = parseInt(process.env.PHOTON_SIDECAR_PORT || "8789", 10);
-const bind = process.env.PHOTON_SIDECAR_BIND || "127.0.0.1";
-const sharedToken = process.env.PHOTON_SIDECAR_TOKEN;
-
-if (!projectId || !projectSecret || !sharedToken) {
-  console.error(
-    "photon-sidecar: PHOTON_PROJECT_ID, PHOTON_PROJECT_SECRET and " +
-      "PHOTON_SIDECAR_TOKEN must all be set."
-  );
-  process.exit(2);
-}
-
-// Lazy-load spectrum-ts so a missing install fails with a clear message
-// instead of a cryptic module-resolution error during import.
-let Spectrum, imessage, attachment, voice;
-try {
-  ({ Spectrum, attachment, voice } = await import("spectrum-ts"));
-  ({ imessage } = await import("spectrum-ts/providers/imessage"));
-} catch (e) {
-  console.error(
-    "photon-sidecar: spectrum-ts is not installed. Run `npm install` " +
-      "inside plugins/platforms/photon/sidecar/. Original error: " +
-      (e && e.stack ? e.stack : String(e))
-  );
-  process.exit(3);
-}
-
-const app = await Spectrum({
-  projectId,
-  projectSecret,
-  providers: [imessage.config()],
-});
-
-// Drain the inbound stream — Photon's webhook is the canonical inbound
-// path, but we still consume `app.messages` so spectrum-ts' internal
-// reconnect/heartbeat logic keeps running.  Each event is logged at
-// debug level; everything else is a no-op here.
-(async () => {
-  try {
-    for await (const [, message] of app.messages) {
-      console.error(
-        `photon-sidecar: drained inbound from ${message.platform} ` +
-          `space=${message.space?.id}`
-      );
-    }
-  } catch (e) {
-    console.error(
-      "photon-sidecar: inbound stream errored: " +
-        (e && e.stack ? e.stack : String(e))
-    );
-  }
-})();
-
-async function readBody(req) {
-  const chunks = [];
-  for await (const chunk of req) chunks.push(chunk);
-  const raw = Buffer.concat(chunks).toString("utf-8");
-  if (!raw) return {};
-  try {
-    return JSON.parse(raw);
-  } catch (e) {
-    throw new Error("invalid JSON body");
-  }
-}
-
-function unauthorized(res) {
-  res.statusCode = 401;
-  res.setHeader("Content-Type", "application/json");
-  res.end(JSON.stringify({ ok: false, error: "unauthorized" }));
-}
-
-function badRequest(res, msg) {
-  res.statusCode = 400;
-  res.setHeader("Content-Type", "application/json");
-  res.end(JSON.stringify({ ok: false, error: msg }));
-}
-
-function serverError(res) {
-  res.statusCode = 500;
-  res.setHeader("Content-Type", "application/json");
-  // Don't leak stack traces or raw exception text to the caller — even
-  // though we listen on loopback, the supervisor logs the real error
-  // and the client only needs a generic failure signal.
-  res.end(JSON.stringify({ ok: false, error: "internal sidecar error" }));
-}
-
-function ok(res, data) {
-  res.statusCode = 200;
-  res.setHeader("Content-Type", "application/json");
-  res.end(JSON.stringify({ ok: true, ...data }));
-}
-
-async function resolveSpace(spaceId) {
-  // spectrum-ts exposes the same Space methods via `app.space(spaceId)` /
-  // narrowed helpers; we fall back through a few accessor shapes to
-  // tolerate small SDK API drift.
-  if (typeof app.space === "function") {
-    return await app.space(spaceId);
-  }
-  if (app.spaces && typeof app.spaces.get === "function") {
-    return await app.spaces.get(spaceId);
-  }
-  // Last resort — the platform-narrowed helper.
-  if (imessage) {
-    const im = imessage(app);
-    if (typeof im.space === "function") {
-      try {
-        return await im.space({ id: spaceId });
-      } catch {
-        /* fall through */
-      }
-    }
-  }
-  throw new Error(`unable to resolve space id ${spaceId}`);
-}
-
-const server = http.createServer(async (req, res) => {
-  if (req.headers["x-hermes-sidecar-token"] !== sharedToken) {
-    return unauthorized(res);
-  }
-  if (req.method !== "POST") {
-    res.statusCode = 405;
-    return res.end();
-  }
-  try {
-    if (req.url === "/healthz") {
-      return ok(res, {});
-    }
-    if (req.url === "/shutdown") {
-      ok(res, {});
-      setTimeout(() => process.kill(process.pid, "SIGTERM"), 50);
-      return;
-    }
-    const body = await readBody(req);
-    if (req.url === "/send") {
-      const { spaceId, text, replyTo } = body || {};
-      if (!spaceId || typeof text !== "string") {
-        return badRequest(res, "spaceId and text are required");
-      }
-      const space = await resolveSpace(spaceId);
-      const result = replyTo
-        ? await space.send(text, { replyTo })
-        : await space.send(text);
-      return ok(res, { messageId: result?.id || result?.messageId || null });
-    }
-    if (req.url === "/send-attachment") {
-      const { spaceId, path, name, mimeType, caption, kind, replyTo } =
-        body || {};
-      if (!spaceId || typeof path !== "string" || !path) {
-        return badRequest(res, "spaceId and path are required");
-      }
-      const space = await resolveSpace(spaceId);
-
-      // spectrum-ts infers name + MIME from the file extension; pass
-      // overrides only when Hermes supplied them so a known-good
-      // inference isn't clobbered with an empty string.
-      const opts = {};
-      if (name) opts.name = name;
-      if (mimeType) opts.mimeType = mimeType;
-      const builder =
-        kind === "voice"
-          ? voice(path, Object.keys(opts).length ? opts : undefined)
-          : attachment(path, Object.keys(opts).length ? opts : undefined);
-
-      const sendOpts = replyTo ? { replyTo } : undefined;
-      const result = sendOpts
-        ? await space.send(builder, sendOpts)
-        : await space.send(builder);
-
-      // iMessage delivers the caption as a separate bubble; send it
-      // after the media so the attachment renders first.
-      if (caption && typeof caption === "string") {
-        try {
-          await space.send(caption);
-        } catch (e) {
-          console.error(
-            "photon-sidecar: attachment sent but caption failed: " +
-              (e && e.stack ? e.stack : String(e))
-          );
-        }
-      }
-      return ok(res, { messageId: result?.id || result?.messageId || null });
-    }
-    if (req.url === "/typing") {
-      const { spaceId } = body || {};
-      if (!spaceId) return badRequest(res, "spaceId is required");
-      const space = await resolveSpace(spaceId);
-      if (typeof space.typing === "function") {
-        await space.typing();
-      } else if (typeof space.setTyping === "function") {
-        await space.setTyping(true);
-      }
-      return ok(res, {});
-    }
-    res.statusCode = 404;
-    res.setHeader("Content-Type", "application/json");
-    return res.end(JSON.stringify({ ok: false, error: "not found" }));
-  } catch (e) {
-    console.error(
-      "photon-sidecar: handler error: " +
-        (e && e.stack ? e.stack : String(e))
-    );
-    // serverError() intentionally returns a generic message — see its
-    // body for the rationale.
-    return serverError(res);
-  }
-});
-
-server.listen(port, bind, () => {
-  console.error(`photon-sidecar: listening on ${bind}:${port}`);
-});
-
-async function shutdown(signal) {
-  console.error(`photon-sidecar: received ${signal}, stopping...`);
-  try {
-    await Promise.race([
-      app.stop(),
-      new Promise((resolve) => setTimeout(resolve, 3000)),
-    ]);
-  } catch (e) {
-    console.error("photon-sidecar: app.stop() failed: " + String(e));
-  }
-  server.close(() => process.exit(0));
-  setTimeout(() => process.exit(1), 500).unref();
-}
-
-process.on("SIGINT", () => shutdown("SIGINT"));
-process.on("SIGTERM", () => shutdown("SIGTERM"));

plugins/platforms/photon/sidecar/package.json

@@ -1,17 +0,0 @@
-{
-  "name": "@hermes-agent/photon-sidecar",
-  "private": true,
-  "version": "0.1.0",
-  "description": "Spectrum-ts bridge for the Hermes Agent Photon platform plugin.",
-  "type": "module",
-  "main": "index.mjs",
-  "scripts": {
-    "start": "node index.mjs"
-  },
-  "engines": {
-    "node": ">=18.17"
-  },
-  "dependencies": {
-    "spectrum-ts": "^0.1.0"
-  }
-}

plugins/plugin_utils.py

@@ -1,135 +0,0 @@
-"""Shared concurrency helpers for plugin authors.
-
-The most common plugin footgun is the lazy process-wide singleton:
-
-    _client = None
-
-    def get_client():
-        global _client
-        if _client is not None:
-            return _client
-        _client = ExpensiveClient(...)   # <-- TOCTOU: two threads both run this
-        return _client
-
-When two threads call ``get_client()`` before the singleton is set, both pass
-the ``is not None`` guard, both run the expensive initialization, and the
-second write clobbers the first — leaking whatever resource the first client
-opened (connections, file handles, background threads).
-
-Multi-threaded agent sessions share one process (delegated tool calls,
-background workers, the self-improvement fork), so this race is reachable in
-practice. Rather than make every plugin author remember to hand-roll
-double-checked locking, this module gives them two thread-safe primitives:
-
-* :func:`lazy_singleton` — decorator for the zero-arg accessor case.
-* :class:`SingletonSlot` — manual slot for accessors that build different
-  instances depending on a config/key argument.
-
-Both are import-light (stdlib ``threading`` only) so any plugin can import
-them without dragging in heavyweight host modules.
-"""
-
-from __future__ import annotations
-
-import functools
-import threading
-from typing import Callable, Generic, Optional, TypeVar
-
-__all__ = ["lazy_singleton", "SingletonSlot"]
-
-T = TypeVar("T")
-
-
-def lazy_singleton(factory: Callable[[], T]) -> Callable[[], T]:
-    """Wrap a zero-argument factory into a thread-safe lazy singleton accessor.
-
-    The wrapped callable returns the same instance on every call; the factory
-    runs exactly once even under concurrent first calls, using double-checked
-    locking. A ``.reset()`` attribute is attached for tests/teardown.
-
-    Example::
-
-        @lazy_singleton
-        def get_client():
-            return ExpensiveClient(load_config())
-
-        client = get_client()   # built once, safe across threads
-        get_client.reset()      # drop the instance (next call rebuilds)
-
-    Note: if the factory raises, no instance is cached and the next call
-    retries (the lock is released either way).
-    """
-    lock = threading.Lock()
-    box: list = []  # one-element [instance]; empty == not yet built
-
-    @functools.wraps(factory)
-    def accessor() -> T:
-        if box:
-            return box[0]
-        with lock:
-            if box:  # re-check inside the lock
-                return box[0]
-            instance = factory()
-            box.append(instance)
-            return instance
-
-    def reset() -> None:
-        with lock:
-            box.clear()
-
-    accessor.reset = reset  # type: ignore[attr-defined]
-    return accessor
-
-
-class SingletonSlot(Generic[T]):
-    """Thread-safe lazy slot for accessors that take a build argument.
-
-    Use this when the cached instance depends on a config/key passed to the
-    accessor (so a bare zero-arg :func:`lazy_singleton` doesn't fit). The slot
-    caches the first successfully-built instance and ignores the argument on
-    subsequent calls — matching the established "first config wins" singleton
-    semantics most plugins already rely on.
-
-    Example::
-
-        _slot: SingletonSlot[Honcho] = SingletonSlot()
-
-        def get_honcho_client(config=None):
-            return _slot.get(lambda: Honcho(**resolve(config)))
-
-        def reset_honcho_client():
-            _slot.reset()
-
-    The factory runs at most once even under concurrent first calls. If the
-    factory raises, nothing is cached and the next call retries.
-    """
-
-    __slots__ = ("_lock", "_value", "_set")
-
-    def __init__(self) -> None:
-        self._lock = threading.Lock()
-        self._value: Optional[T] = None
-        self._set = False
-
-    def get(self, factory: Callable[[], T]) -> T:
-        # Fast path: already built, no lock needed (a set bool + ref read is
-        # atomic under CPython's GIL).
-        if self._set:
-            return self._value  # type: ignore[return-value]
-        with self._lock:
-            if self._set:  # re-check inside the lock
-                return self._value  # type: ignore[return-value]
-            value = factory()
-            self._value = value
-            self._set = True
-            return value
-
-    def peek(self) -> Optional[T]:
-        """Return the cached instance without building it (None if unset)."""
-        return self._value if self._set else None
-
-    def reset(self) -> None:
-        """Drop the cached instance so the next ``get()`` rebuilds it."""
-        with self._lock:
-            self._value = None
-            self._set = False

plugins/video_gen/fal/__init__.py

@@ -291,7 +291,6 @@ def _build_payload(
 # ---------------------------------------------------------------------------
 
 _fal_client: Any = None
-_fal_client_lock = threading.Lock()
 
 
 def _load_fal_client() -> Any:
@@ -299,19 +298,13 @@ def _load_fal_client() -> Any:
 
     Delegates the actual import to :func:`tools.fal_common.import_fal_client`
     so the ``lazy_deps`` ensure-install handling stays in one place.
-
-    Thread-safe via double-checked locking: concurrent first calls import
-    the SDK exactly once instead of each racing thread re-running the import.
     """
     global _fal_client
     if _fal_client is not None:
         return _fal_client
-    with _fal_client_lock:
-        if _fal_client is not None:  # re-check inside the lock
-            return _fal_client
-        from tools.fal_common import import_fal_client
-        _fal_client = import_fal_client()
-        return _fal_client
+    from tools.fal_common import import_fal_client
+    _fal_client = import_fal_client()
+    return _fal_client
 
 
 # ---------------------------------------------------------------------------

pyproject.toml

@@ -104,11 +104,12 @@ dependencies = [
 [project.optional-dependencies]
 # Native Anthropic provider — only needed when provider=anthropic (not via
 # OpenRouter or other aggregators).
-anthropic = ["anthropic==0.87.0"]  # CVE-2026-34450, CVE-2026-34452
+anthropic = ["anthropic==0.86.0"]
 # Web search backends — each only loaded when the user picks it as their
 # search provider (configured via `hermes tools` or config.yaml).
 exa = ["exa-py==2.10.2"]
 firecrawl = ["firecrawl-py==4.17.0"]
+apify = ["apify-client==3.0.1"]
 parallel-web = ["parallel-web==0.4.2"]
 # Image generation backends
 fal = ["fal-client==0.13.1"]
@@ -119,9 +120,9 @@ modal = ["modal==1.3.4"]
 daytona = ["daytona==0.155.0"]
 hindsight = ["hindsight-client==0.6.1"]
 dev = ["debugpy==1.8.20", "pytest==9.0.2", "pytest-asyncio==1.3.0", "pytest-timeout==2.4.0", "mcp==1.26.0", "starlette==1.0.1", "ty==0.0.21", "ruff==0.15.10", "setuptools==82.0.1"]  # starlette: CVE-2026-48710
-messaging = ["python-telegram-bot[webhooks]==22.6", "discord.py[voice]==2.7.1", "aiohttp==3.13.4", "brotlicffi==1.2.0.1", "slack-bolt==1.27.0", "slack-sdk==3.40.1", "qrcode==7.4.2"]  # aiohttp: CVE-2026-34513/34518/34519/34520/34525
+messaging = ["python-telegram-bot[webhooks]==22.6", "discord.py[voice]==2.7.1", "aiohttp==3.13.3", "brotlicffi==1.2.0.1", "slack-bolt==1.27.0", "slack-sdk==3.40.1", "qrcode==7.4.2"]
 cron = []  # croniter is now a core dependency; this extra kept for back-compat
-slack = ["slack-bolt==1.27.0", "slack-sdk==3.40.1", "aiohttp==3.13.4"]
+slack = ["slack-bolt==1.27.0", "slack-sdk==3.40.1", "aiohttp==3.13.3"]
 matrix = ["mautrix[encryption]==0.21.0", "aiosqlite==0.22.1", "asyncpg==0.31.0", "aiohttp-socks==0.11.0"]
 # WeCom callback-mode adapter — parses untrusted XML POST bodies from
 # WeCom-controlled callback endpoints, so we use defusedxml (drop-in
@@ -160,8 +161,8 @@ vision = []
 # a vulnerable pre-1.0.1 transitive. Bump in lockstep with uv.lock.
 mcp = ["mcp==1.26.0", "starlette==1.0.1"]  # starlette: CVE-2026-48710
 nemo-relay = ["nemo-relay==0.3"]
-homeassistant = ["aiohttp==3.13.4"]
-sms = ["aiohttp==3.13.4"]
+homeassistant = ["aiohttp==3.13.3"]
+sms = ["aiohttp==3.13.3"]
 # Computer use — macOS background desktop control via cua-driver (MCP stdio).
 # The cua-driver binary itself is installed via `hermes tools` post-setup
 # (curl install script); this extra just pins the MCP client used to talk

run_agent.py

@@ -358,7 +358,6 @@ class AIAgent:
         save_trajectories: bool = False,
         verbose_logging: bool = False,
         quiet_mode: bool = False,
-        tool_progress_mode: str = "all",
         ephemeral_system_prompt: str = None,
         log_prefix_chars: int = 100,
         log_prefix: str = "",
@@ -431,7 +430,6 @@ class AIAgent:
             save_trajectories=save_trajectories,
             verbose_logging=verbose_logging,
             quiet_mode=quiet_mode,
-            tool_progress_mode=tool_progress_mode,
             ephemeral_system_prompt=ephemeral_system_prompt,
             log_prefix_chars=log_prefix_chars,
             log_prefix=log_prefix,
@@ -3089,17 +3087,6 @@ class AIAgent:
         except Exception:
             pass
 
-        # 6. Free conversation history.  Mirrors _release_evicted_agent_soft's
-        # soft-eviction clear — close() is the hard teardown for true session
-        # boundaries (/new, /reset, session expiry), so the message list won't
-        # be reused.  Drops the reference proactively rather than waiting for
-        # the agent object itself to be collected, which matters when a caller
-        # still holds the closed agent (e.g. a draining background task).
-        try:
-            self._session_messages = []
-        except Exception:
-            pass
-
     def _hydrate_todo_store(self, history: List[Dict[str, Any]]) -> None:
         """
         Recover todo state from conversation history.
@@ -3917,13 +3904,6 @@ class AIAgent:
     def _anthropic_messages_create(self, api_kwargs: dict):
         if self.api_mode == "anthropic_messages":
             self._try_refresh_anthropic_client_credentials()
-        # Defensive: strip Responses-only kwargs that can leak in under an
-        # api_mode-flip race (the Anthropic SDK raises a non-retryable
-        # TypeError on them). See #31673.
-        from agent.anthropic_adapter import sanitize_anthropic_kwargs
-        sanitize_anthropic_kwargs(
-            api_kwargs, log_prefix=getattr(self, "log_prefix", "")
-        )
         return self._anthropic_client.messages.create(**api_kwargs)
 
     def _rebuild_anthropic_client(self) -> None:

scripts/build_skills_index.py

@@ -297,21 +297,6 @@ def main():
     # Batch resolve GitHub paths for skills.sh entries
     all_skills = batch_resolve_paths(all_skills, auth)
 
-    # Collect which sources hit a GitHub API rate limit during the crawl.
-    # github / claude-marketplace / well-known all read api.github.com, so a
-    # rate-limited token zeroes all three at once — surfaced below so the
-    # failure message names the real cause instead of "source returned 0".
-    rate_limited_sources = {
-        name for name, source in sources.items()
-        if getattr(source, "is_rate_limited", False)
-    }
-    if rate_limited_sources:
-        print(
-            "  WARNING: GitHub API rate limit hit for: "
-            + ", ".join(sorted(rate_limited_sources)),
-            file=sys.stderr,
-        )
-
     # Deduplicate by identifier
     seen: dict[str, dict] = {}
     for skill in all_skills:
@@ -326,9 +311,25 @@ def main():
                     "browse-sh": 5, "claude-marketplace": 6, "lobehub": 7}
     deduped.sort(key=lambda s: (source_order.get(s["source"], 99), s["name"]))
 
+    # Build index
+    index = {
+        "version": INDEX_VERSION,
+        "generated_at": datetime.now(timezone.utc).isoformat(),
+        "skill_count": len(deduped),
+        "skills": deduped,
+    }
+
+    os.makedirs(os.path.dirname(OUTPUT_PATH), exist_ok=True)
+    with open(OUTPUT_PATH, "w", encoding="utf-8") as f:
+        json.dump(index, f, separators=(",", ":"), ensure_ascii=False)
+
+    elapsed = time.time() - overall_start
+    file_size = os.path.getsize(OUTPUT_PATH)
+    print(f"\nDone! {len(deduped)} skills indexed in {elapsed:.0f}s")
+    print(f"Output: {OUTPUT_PATH} ({file_size / 1024:.0f} KB)")
+
     from collections import Counter
     by_source = Counter(s["source"] for s in deduped)
-    print(f"\nCrawled {len(deduped)} skills in {time.time() - overall_start:.0f}s")
     for src, count in sorted(by_source.items(), key=lambda x: -x[1]):
         resolved = sum(1 for s in deduped
                        if s["source"] == src and s.get("resolved_github_id"))
@@ -379,46 +380,14 @@ def main():
         )
         for line in health_errors:
             print(line, file=sys.stderr)
-        if rate_limited_sources:
-            print(
-                "\nGitHub API rate limit was hit during this crawl for: "
-                + ", ".join(sorted(rate_limited_sources))
-                + ". This is the usual cause of an all-GitHub-tap collapse "
-                "(github / claude-marketplace / well-known dropping to zero "
-                "together). Re-run with a higher-quota GITHUB_TOKEN.",
-                file=sys.stderr,
-            )
         print(
             "\nIf the drop is expected (e.g. a hub is genuinely shutting "
             "down), lower the floor in scripts/build_skills_index.py "
             "EXPECTED_FLOORS in the same PR.",
             file=sys.stderr,
         )
-        # IMPORTANT: do NOT write OUTPUT_PATH on failure. The index file is
-        # gitignored, so a fresh deploy checkout has no copy on disk — leaving
-        # it absent lets website/scripts/extract-skills.py fall back to the
-        # legacy snapshot cache (or skip the unified index) instead of reading
-        # a degenerate file. Writing-then-exiting-2 was the bug that shipped an
-        # index with every GitHub-API source dropped to zero: deploy-site.yml
-        # swallows the exit code with `|| echo non-fatal`, and the partial file
-        # was already on disk for extract-skills to pick up.
         sys.exit(2)
 
-    # Healthy — only now write the index out for the docs build to consume.
-    index = {
-        "version": INDEX_VERSION,
-        "generated_at": datetime.now(timezone.utc).isoformat(),
-        "skill_count": len(deduped),
-        "skills": deduped,
-    }
-    os.makedirs(os.path.dirname(OUTPUT_PATH), exist_ok=True)
-    with open(OUTPUT_PATH, "w", encoding="utf-8") as f:
-        json.dump(index, f, separators=(",", ":"), ensure_ascii=False)
-    file_size = os.path.getsize(OUTPUT_PATH)
-    print(f"\nDone! {len(deduped)} skills indexed in "
-          f"{time.time() - overall_start:.0f}s")
-    print(f"Output: {OUTPUT_PATH} ({file_size / 1024:.0f} KB)")
-
 
 if __name__ == "__main__":
     main()

scripts/install.ps1

@@ -1130,7 +1130,7 @@ function Install-Repository {
                     git -c windows.appendAtomically=false stash push --include-untracked -m "$stashName"
                     if ($LASTEXITCODE -eq 0) { $autostashRef = "stash@{0}" }
                 }
-                git -c windows.appendAtomically=false fetch origin $Branch
+                git -c windows.appendAtomically=false fetch origin
                 if ($LASTEXITCODE -ne 0) { throw "git fetch failed (exit $LASTEXITCODE)" }
                 # Precedence: Commit > Tag > Branch.  Commit and Tag check
                 # out as detached HEAD intentionally -- they're meant to be

scripts/install.sh

@@ -1118,12 +1118,7 @@ clone_repo() {
                 autostash_ref="stash@{0}"
             fi
 
-            # Fetch only the target branch. A bare `git fetch origin` pulls
-            # every ref, and this repo carries thousands of auto-generated
-            # branches — on a non-single-branch checkout that turns each update
-            # into a multi-minute download that can stall the installer.
-            git remote set-branches origin "$BRANCH" 2>/dev/null || true
-            git fetch origin "$BRANCH"
+            git fetch origin
             git checkout "$BRANCH"
             git pull --ff-only origin "$BRANCH"
 

scripts/release.py

@@ -52,7 +52,6 @@ AUTHOR_MAP = {
     "804436395@qq.com": "LaPhilosophie",
     "maxmitcham@mac.home": "maxtrigify",
     "ccook@nvms.com": "ccook1963",
-    "kristian@agrointel.no": "kristianvast",
     "thomas.paquette@gmail.com": "RyTsYdUp",
     "techxacm@gmail.com": "ProgramCaiCai",
     "266365592+bmoore210@users.noreply.github.com": "bmoore210",
@@ -66,10 +65,8 @@ AUTHOR_MAP = {
     "129007007+HeLLGURD@users.noreply.github.com": "HeLLGURD",
     "290859878+synapsesx@users.noreply.github.com": "synapsesx",
     "dirtyren@users.noreply.github.com": "dirtyren",
-    "ted.malone@outlook.com": "temalo",
     "adityamalik2833@gmail.com": "alarcritty",
     "islam666@users.noreply.github.com": "islam666",
-    "mnajafian@nvidia.com": "mnajafian-nv",
     "25539605+lsaether@users.noreply.github.com": "lsaether",
     "30080538+JimStenstrom@users.noreply.github.com": "JimStenstrom",
     "rod.boev@gmail.com": "rodboev",
@@ -135,6 +132,7 @@ AUTHOR_MAP = {
     "tillfalko@gmail.com": "tillfalko",
     "hi@fesalfayed.com": "fesalfayed",
     "marek.les@seznam.cz": "maxcz79",
+    "jan.hranicky@seznam.cz": "JanHranicky",
     # teknium (multiple emails)
     "teknium1@gmail.com": "teknium1",
     "kenyon1977@gmail.com": "kenyonxu",
@@ -1091,7 +1089,6 @@ AUTHOR_MAP = {
     "holynn@placeholder.local": "holynn-q",
     "agent@hermes.local": "jacdevos",
     "sunsky.lau@gmail.com": "liuhao1024",
-    "rob@rbrtbn.com": "rbrtbn",
     "haaasined@gmail.com": "VinciZhu",
     "fabianoeq@gmail.com": "rodrigoeqnit",
     "178342791+sgtworkman@users.noreply.github.com": "sgtworkman",
@@ -1263,7 +1260,6 @@ AUTHOR_MAP = {
     "leon@sgp43.com": "LeonSGP43",  # PR #18739 salvage of #14570
     "miniding@miniding.home": "Foolafroos",  # PR #20329 French locale
     "montbra@gmail.com": "Montbra",  # PR #20897 salvage of #16189 (TUI voice PTT)
-    "275835513+paulb26@users.noreply.github.com": "paulb26",  # PR #24135 salvage (pty-bridge killpg)
     "promptsiren@gmail.com": "firefly",  # PR #18123 salvage of #16660 (ContextVars)
     "wtyopenclaw@gmail.com": "WuTianyi123",  # PR #20275 salvage of #13723 (feishu markdown)
     "zhicheng.han@mathematik.uni-goettingen.de": "hanzckernel",  # PR #20311 (api-server approval events)
@@ -1492,8 +1488,6 @@ AUTHOR_MAP = {
     "leonard@sellem.me": "leonardsellem",  # PR #37405 (desktop WS origin guard on remote/Tailscale binds)
     "42903577+ohMyJason@users.noreply.github.com": "ohMyJason",  # PR #29810 (discover_models in custom_providers section 4)
     "singhsanidhya741@gmail.com": "sanidhyasin",  # PR #40403 salvage (model.default_headers for custom OpenAI-compatible providers, #40033)
-    "josephjohnson.joel@gmail.com": "JoelJJohnson",  # PR #39913 salvage (Windows ConPTY dashboard chat bridge)
-    "andreas@schwarz-ketsch.de": "Nea74",  # PR #40022 co-author credit (same Windows ConPTY bridge design)
 }
 
 

scripts/run_tests_parallel.py

@@ -335,50 +335,6 @@ def _run_one_file(
         # dead processes are a no-op.
         _kill_tree(proc, pgid=pgid)
 
-    if rc == 4 and Path(file).exists():
-        # pytest exit 4 = "file or directory not found" at exec time, yet the
-        # file is present on disk now. On loaded shared CI runners we have seen
-        # the planner enumerate a file (its tests counted via --collect-only)
-        # but the per-file subprocess fail to stat it moments later — a
-        # transient the deterministic LPT slicer otherwise reproduces on every
-        # rerun (same file set → same shard). Retry the file ONCE before
-        # surfacing it as a hard failure. We do NOT widen the exit-5 rule:
-        # exit 4 on a file that genuinely does not exist must still fail.
-        retry_proc = subprocess.Popen(
-            cmd,
-            cwd=repo_root,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT,
-            text=True,
-            start_new_session=True,
-        )
-        retry_pgid: int | None = None
-        if sys.platform != "win32":
-            try:
-                retry_pgid = os.getpgid(retry_proc.pid)
-            except (ProcessLookupError, PermissionError):
-                retry_pgid = None
-        try:
-            retry_output, _ = retry_proc.communicate(timeout=file_timeout)
-            retry_rc = retry_proc.returncode
-        except subprocess.TimeoutExpired:
-            _kill_tree(retry_proc, pgid=retry_pgid)
-            try:
-                retry_output, _ = retry_proc.communicate(timeout=10)
-            except subprocess.TimeoutExpired:
-                retry_output = "(file timeout exceeded on retry; output unavailable)"
-            retry_rc = 124
-            retry_output = (
-                f"(per-file timeout on exit-4 retry: {file_timeout:.0f}s exceeded; "
-                f"process tree SIGKILL'd)\n{retry_output}"
-            )
-        except BaseException:
-            _kill_tree(retry_proc, pgid=retry_pgid)
-            raise
-        else:
-            _kill_tree(retry_proc, pgid=retry_pgid)
-        rc, output = retry_rc, retry_output
-
     if rc == 5:
         # No tests collected — every test in the file was filtered out.
         # Treat as a pass; surface info in a slightly distinct status

tests/agent/test_anthropic_kwargs_sanitize.py

@@ -1,94 +0,0 @@
-"""Tests for sanitize_anthropic_kwargs (#31673).
-
-Guards the Anthropic Messages dispatch boundary against Responses-API-only
-kwargs (``instructions``, ``input``, ``store``, ``parallel_tool_calls``)
-leaking in under an api_mode-flip race. The Anthropic SDK raises a
-non-retryable ``TypeError`` on any of them, killing the whole turn.
-"""
-
-import logging
-
-import pytest
-
-from agent.anthropic_adapter import (
-    _RESPONSES_ONLY_KWARGS,
-    sanitize_anthropic_kwargs,
-)
-
-
-def _fake_anthropic_call(**kwargs):
-    """Mimic the Anthropic SDK's strict kwarg signature."""
-    allowed = {
-        "model", "messages", "max_tokens", "system", "tools", "tool_choice",
-        "extra_body", "extra_headers", "temperature", "top_p", "top_k",
-        "thinking", "timeout",
-    }
-    bad = set(kwargs) - allowed
-    if bad:
-        raise TypeError(
-            "Messages.stream() got an unexpected keyword argument "
-            f"{sorted(bad)[0]!r}"
-        )
-    return "OK"
-
-
-def test_bare_leaked_payload_reproduces_the_typeerror():
-    """Without the guard, a Responses-shaped payload raises the issue's error."""
-    with pytest.raises(TypeError, match="unexpected keyword argument"):
-        _fake_anthropic_call(model="claude-sonnet-4-6", instructions="sys")
-
-
-def test_strips_all_responses_only_keys():
-    payload = {
-        "model": "claude-sonnet-4-6",
-        "instructions": "You are Hermes.",
-        "input": [{"role": "user", "content": "hi"}],
-        "store": False,
-        "parallel_tool_calls": True,
-    }
-    out = sanitize_anthropic_kwargs(payload)
-    assert out is payload  # mutates in place and returns same dict
-    assert payload == {"model": "claude-sonnet-4-6"}
-    assert _fake_anthropic_call(**payload) == "OK"
-
-
-def test_clean_anthropic_payload_is_untouched():
-    payload = {
-        "model": "claude-sonnet-4-6",
-        "messages": [{"role": "user", "content": "hi"}],
-        "max_tokens": 1024,
-        "system": "sys",
-        "tools": [{"name": "x"}],
-    }
-    snapshot = dict(payload)
-    sanitize_anthropic_kwargs(payload)
-    assert payload == snapshot
-    assert _fake_anthropic_call(**payload) == "OK"
-
-
-def test_warns_when_keys_are_stripped(caplog):
-    with caplog.at_level(logging.WARNING, logger="agent.anthropic_adapter"):
-        sanitize_anthropic_kwargs(
-            {"model": "m", "instructions": "sys"}, log_prefix="[pfx] "
-        )
-    assert any(
-        "31673" in r.message and "[pfx] " in r.message
-        for r in caplog.records
-    ), caplog.records
-
-
-def test_no_warning_on_clean_payload(caplog):
-    with caplog.at_level(logging.WARNING, logger="agent.anthropic_adapter"):
-        sanitize_anthropic_kwargs({"model": "m", "messages": []})
-    assert not caplog.records
-
-
-def test_non_dict_input_is_noop():
-    assert sanitize_anthropic_kwargs(None) is None
-    assert sanitize_anthropic_kwargs("not a dict") == "not a dict"
-
-
-def test_responses_only_kwargs_membership():
-    # Contract: instructions (the reported symptom) plus the sibling
-    # Responses-shape keys are all covered.
-    assert {"instructions", "input", "store", "parallel_tool_calls"} <= _RESPONSES_ONLY_KWARGS

tests/gateway/test_42039_duplicate_user_message.py

@@ -1,241 +0,0 @@
-"""Tests for #42039 — user messages stored twice in state.db.
-
-When the agent has its own SessionDB reference (``_session_db is not None``),
-``_flush_messages_to_session_db()`` persists messages to SQLite during the
-agent run.  The gateway's ``append_to_transcript()`` must then use
-``skip_db=True`` on all fallback paths to prevent writing a second copy
-to the same SQLite file.
-
-This test covers the two fallback paths that previously lacked
-``skip_db=agent_persisted``:
-
-1. ``agent_failed_early`` path — transient 429/timeout failures
-2. ``not new_messages`` path — edge case where ``history_offset`` exceeds
-   the actual message count
-"""
-
-import sys
-import types
-from datetime import datetime
-from unittest.mock import AsyncMock, MagicMock
-
-import pytest
-
-import gateway.run as gateway_run
-from gateway.config import GatewayConfig, Platform
-from gateway.platforms.base import MessageEvent
-from gateway.session import SessionEntry, SessionSource
-
-
-def _bootstrap(monkeypatch, tmp_path):
-    """Minimal GatewayRunner setup shared by all tests in this module."""
-    fake_dotenv = types.ModuleType("dotenv")
-    fake_dotenv.load_dotenv = lambda *args, **kwargs: None
-    monkeypatch.setitem(sys.modules, "dotenv", fake_dotenv)
-
-    config = GatewayConfig()
-    runner = gateway_run.GatewayRunner(config)
-    runner.adapters = {}
-    runner._running_agents = {}
-    runner._running_agents_ts = {}
-    runner._pending_messages = {}
-    runner._pending_approvals = {}
-    runner._is_user_authorized = lambda _source: True
-    runner._set_session_env = lambda _context: None
-    runner._handle_active_session_busy_message = AsyncMock(return_value=False)
-    runner._session_db = MagicMock()
-    runner._recover_telegram_topic_thread_id = lambda _source: None
-    runner._cache_session_source = lambda _key, _source: None
-    runner._is_session_run_current = lambda _key, _gen: True
-    runner._begin_session_run_generation = lambda _key: 1
-    runner._reply_anchor_for_event = lambda _event: None
-    runner._get_guild_id = lambda _event: None
-    runner._should_send_voice_reply = lambda *_a, **_kw: False
-    runner.hooks = MagicMock()
-    runner.hooks.emit = AsyncMock()
-
-    runner.session_store = MagicMock()
-    runner.session_store.get_or_create_session.return_value = SessionEntry(
-        session_key="agent:main:telegram:group:-1001:12345",
-        session_id="sess-dedup",
-        created_at=datetime.now(),
-        updated_at=datetime.now(),
-        platform=Platform.TELEGRAM,
-        chat_type="group",
-    )
-    runner.session_store.load_transcript.return_value = []
-    runner.session_store.append_to_transcript = MagicMock()
-    runner.session_store.update_session = MagicMock()
-
-    monkeypatch.setattr(gateway_run, "_hermes_home", tmp_path)
-    monkeypatch.setattr(
-        gateway_run, "_resolve_runtime_agent_kwargs", lambda: {"api_key": "fake"}
-    )
-    monkeypatch.setattr(
-        "agent.model_metadata.get_model_context_length",
-        lambda *_args, **_kwargs: 100_000,
-    )
-    return runner
-
-
-def _event():
-    return MessageEvent(
-        text="hello world",
-        source=SessionSource(
-            platform=Platform.TELEGRAM,
-            chat_id="-1001",
-            chat_type="group",
-            user_id="12345",
-        ),
-        message_id="msg-42",
-    )
-
-
-def _source():
-    return SessionSource(
-        platform=Platform.TELEGRAM,
-        chat_id="-1001",
-        chat_type="group",
-        user_id="12345",
-    )
-
-
-def _assert_user_call_has_skip_db(calls, expected_skip_db: bool):
-    """Find append_to_transcript calls with role='user' and check skip_db."""
-    user_calls = []
-    for call in calls:
-        args = call.args
-        if len(args) >= 2 and isinstance(args[1], dict):
-            if args[1].get("role") == "user":
-                user_calls.append(call)
-    assert len(user_calls) >= 1, (
-        f"Expected at least one user-role append_to_transcript call, "
-        f"got calls: {[c.args for c in calls if len(c.args)>=2]}"
-    )
-    for call in user_calls:
-        actual = call.kwargs.get("skip_db", False)
-        assert actual == expected_skip_db, (
-            f"Expected skip_db={expected_skip_db} for user-role call, "
-            f"got skip_db={actual}. kwargs={call.kwargs}"
-        )
-
-
-# ── Test 1: agent_failed_early path uses skip_db=True ─────────────────
-
-
-@pytest.mark.asyncio
-async def test_agent_failed_early_skip_db_when_agent_has_session_db(
-    monkeypatch, tmp_path
-):
-    runner = _bootstrap(monkeypatch, tmp_path)
-
-    # Agent fails with transient 429
-    runner._run_agent = AsyncMock(
-        return_value={
-            "failed": True,
-            "final_response": None,
-            "error": "429 Too Many Requests — rate limit exceeded",
-            "messages": [],
-            "history_offset": 0,
-            "last_prompt_tokens": 0,
-        }
-    )
-
-    await runner._handle_message_with_agent(
-        _event(), _source(), "agent:main:telegram:group:-1001:12345", 1
-    )
-
-    _assert_user_call_has_skip_db(
-        runner.session_store.append_to_transcript.call_args_list, True
-    )
-
-
-# ── Test 2: agent_failed_early with no _session_db → skip_db not True ─
-
-
-@pytest.mark.asyncio
-async def test_agent_failed_early_no_skip_db_when_no_session_db(
-    monkeypatch, tmp_path
-):
-    runner = _bootstrap(monkeypatch, tmp_path)
-    runner._session_db = None  # No agent DB → agent_persisted=False
-
-    runner._run_agent = AsyncMock(
-        return_value={
-            "failed": True,
-            "final_response": None,
-            "error": "ReadTimeout: timed out",
-            "messages": [],
-            "history_offset": 0,
-            "last_prompt_tokens": 0,
-        }
-    )
-
-    await runner._handle_message_with_agent(
-        _event(), _source(), "agent:main:telegram:group:-1001:12345", 1
-    )
-
-    _assert_user_call_has_skip_db(
-        runner.session_store.append_to_transcript.call_args_list, False
-    )
-
-
-# ── Test 3: not-new-messages path uses skip_db=True ───────────────────
-
-
-@pytest.mark.asyncio
-async def test_not_new_messages_skip_db_when_agent_has_session_db(
-    monkeypatch, tmp_path
-):
-    runner = _bootstrap(monkeypatch, tmp_path)
-
-    # Agent succeeds but history_offset equals messages length → no new messages
-    runner._run_agent = AsyncMock(
-        return_value={
-            "final_response": "Hello!",
-            "messages": [{"role": "user", "content": "hi"}],
-            "tools": [],
-            "history_offset": 1,  # equals len(messages) → new_messages=[]
-            "last_prompt_tokens": 0,
-        }
-    )
-
-    await runner._handle_message_with_agent(
-        _event(), _source(), "agent:main:telegram:group:-1001:12345", 1
-    )
-
-    _assert_user_call_has_skip_db(
-        runner.session_store.append_to_transcript.call_args_list, True
-    )
-
-
-# ── Test 4: normal path (new_messages found) uses skip_db=True ────────
-
-
-@pytest.mark.asyncio
-async def test_normal_path_skip_db_when_agent_has_session_db(
-    monkeypatch, tmp_path
-):
-    runner = _bootstrap(monkeypatch, tmp_path)
-
-    # Agent succeeds with new messages
-    runner._run_agent = AsyncMock(
-        return_value={
-            "final_response": "Hello!",
-            "messages": [
-                {"role": "user", "content": "hi"},
-                {"role": "assistant", "content": "Hello!"},
-            ],
-            "tools": [],
-            "history_offset": 0,
-            "last_prompt_tokens": 0,
-        }
-    )
-
-    await runner._handle_message_with_agent(
-        _event(), _source(), "agent:main:telegram:group:-1001:12345", 1
-    )
-
-    _assert_user_call_has_skip_db(
-        runner.session_store.append_to_transcript.call_args_list, True
-    )

tests/gateway/test_compression_concurrent_sessions.py

@@ -146,30 +146,6 @@ def test_concurrent_compressions_same_session_serialize(tmp_path: Path) -> None:
     agent_a = _build_agent_with_db(db, shared_sid)
     agent_b = _build_agent_with_db(db, shared_sid)
 
-    # Force genuine simultaneous lock contention instead of relying on a
-    # ``time.sleep`` inside the compressor stub to make the threads overlap.
-    # Under CI CPU starvation that sleep is not enough: one thread could
-    # acquire → compress → rotate → RELEASE the lock before the other even
-    # reaches ``try_acquire``, so both would acquire on the shared id and
-    # both would compress (the historical "got 2" flake). A two-party
-    # barrier in front of the real acquire guarantees both threads are
-    # contending for the lock at the same instant, which is exactly the
-    # condition this test means to assert — with zero timing dependency.
-    barrier = threading.Barrier(2, timeout=15)
-    _real_acquire = db.try_acquire_compression_lock
-
-    def _barriered_acquire(*args, **kwargs):
-        # Rendezvous both callers, then let the real (atomic) acquire decide
-        # the single winner. Tolerate a broken barrier so a test-side timeout
-        # never masquerades as a lock-logic failure.
-        try:
-            barrier.wait()
-        except threading.BrokenBarrierError:
-            pass
-        return _real_acquire(*args, **kwargs)
-
-    db.try_acquire_compression_lock = _barriered_acquire
-
     results: dict[str, list | None] = {"a": None, "b": None}
     errors: list[Exception] = []
 
@@ -187,10 +163,6 @@ def test_concurrent_compressions_same_session_serialize(tmp_path: Path) -> None:
     t_a.join(timeout=15)
     t_b.join(timeout=15)
 
-    # Restore the real method so the post-join lock-leak assertion below
-    # (and any future call) hits the unwrapped implementation.
-    db.try_acquire_compression_lock = _real_acquire
-
     assert not errors, f"Compression raised exceptions: {errors}"
 
     # Count which agents actually compressed (returned fewer messages than input)

tests/gateway/test_config.py

@@ -1,6 +1,5 @@
 """Tests for gateway configuration management."""
 
-import logging
 import os
 from unittest.mock import patch
 
@@ -214,43 +213,6 @@ class TestGatewayConfigRoundtrip:
         assert restored.group_sessions_per_user is False
         assert restored.thread_sessions_per_user is True
 
-    def test_max_concurrent_sessions_from_dict_normalizes_disabled_values(self):
-        assert GatewayConfig.from_dict({}).max_concurrent_sessions is None
-        assert GatewayConfig.from_dict({"max_concurrent_sessions": None}).max_concurrent_sessions is None
-        assert GatewayConfig.from_dict({"max_concurrent_sessions": 0}).max_concurrent_sessions is None
-        assert GatewayConfig.from_dict({"max_concurrent_sessions": -1}).max_concurrent_sessions is None
-
-    def test_max_concurrent_sessions_from_dict_accepts_positive_integer(self):
-        config = GatewayConfig.from_dict({"max_concurrent_sessions": "3"})
-
-        assert config.max_concurrent_sessions == 3
-
-    def test_max_concurrent_sessions_from_dict_ignores_invalid_values(self, caplog):
-        caplog.set_level(logging.WARNING, logger="gateway.config")
-
-        config = GatewayConfig.from_dict({"max_concurrent_sessions": "many"})
-
-        assert config.max_concurrent_sessions is None
-        assert any(
-            "Ignoring invalid max_concurrent_sessions='many'" in record.message
-            for record in caplog.records
-        )
-
-    def test_max_concurrent_sessions_from_dict_accepts_nested_fallback(self):
-        config = GatewayConfig.from_dict({"gateway": {"max_concurrent_sessions": 4}})
-
-        assert config.max_concurrent_sessions == 4
-
-    def test_max_concurrent_sessions_top_level_overrides_nested(self):
-        config = GatewayConfig.from_dict(
-            {
-                "gateway": {"max_concurrent_sessions": 4},
-                "max_concurrent_sessions": 2,
-            }
-        )
-
-        assert config.max_concurrent_sessions == 2
-
     def test_roundtrip_preserves_unauthorized_dm_behavior(self):
         config = GatewayConfig(
             unauthorized_dm_behavior="ignore",
@@ -347,51 +309,6 @@ class TestLoadGatewayConfig:
 
         assert config.thread_sessions_per_user is False
 
-    def test_bridges_top_level_max_concurrent_sessions_from_config_yaml(self, tmp_path, monkeypatch):
-        hermes_home = tmp_path / ".hermes"
-        hermes_home.mkdir()
-        config_path = hermes_home / "config.yaml"
-        config_path.write_text("max_concurrent_sessions: 2\n", encoding="utf-8")
-
-        monkeypatch.setenv("HERMES_HOME", str(hermes_home))
-
-        config = load_gateway_config()
-
-        assert config.max_concurrent_sessions == 2
-
-    def test_bridges_nested_max_concurrent_sessions_from_config_yaml(self, tmp_path, monkeypatch):
-        hermes_home = tmp_path / ".hermes"
-        hermes_home.mkdir()
-        config_path = hermes_home / "config.yaml"
-        config_path.write_text(
-            "gateway:\n"
-            "  max_concurrent_sessions: 3\n",
-            encoding="utf-8",
-        )
-
-        monkeypatch.setenv("HERMES_HOME", str(hermes_home))
-
-        config = load_gateway_config()
-
-        assert config.max_concurrent_sessions == 3
-
-    def test_top_level_max_concurrent_sessions_overrides_nested_config_yaml(self, tmp_path, monkeypatch):
-        hermes_home = tmp_path / ".hermes"
-        hermes_home.mkdir()
-        config_path = hermes_home / "config.yaml"
-        config_path.write_text(
-            "max_concurrent_sessions: 2\n"
-            "gateway:\n"
-            "  max_concurrent_sessions: 3\n",
-            encoding="utf-8",
-        )
-
-        monkeypatch.setenv("HERMES_HOME", str(hermes_home))
-
-        config = load_gateway_config()
-
-        assert config.max_concurrent_sessions == 2
-
     def test_bridges_discord_thread_require_mention_from_config_yaml(self, tmp_path, monkeypatch):
         """discord.thread_require_mention in config.yaml should reach the runtime env var."""
         hermes_home = tmp_path / ".hermes"

tests/gateway/test_max_concurrent_sessions.py

@@ -1,208 +0,0 @@
-"""Tests for the gateway max_concurrent_sessions active-session cap."""
-
-import asyncio
-import time
-from unittest.mock import AsyncMock, MagicMock, patch
-
-import pytest
-
-from gateway.config import GatewayConfig, Platform, PlatformConfig
-from gateway.platforms.base import MessageEvent, MessageType
-from gateway.run import GatewayRunner, _AGENT_PENDING_SENTINEL
-from gateway.session import SessionSource, build_session_key
-
-
-@pytest.fixture(autouse=True)
-def _isolated_active_session_registry(tmp_path, monkeypatch):
-    monkeypatch.setenv("HERMES_HOME", str(tmp_path / ".hermes"))
-
-
-class _FakeAdapter:
-    def __init__(self):
-        self._pending_messages = {}
-        self._active_sessions = {}
-
-    async def send(self, chat_id, text, **kwargs):
-        return None
-
-    async def interrupt_session_activity(self, session_key, chat_id):
-        event = self._active_sessions.get(session_key)
-        if event is not None:
-            event.set()
-
-
-def _make_source(chat_id: str = "chat-1") -> SessionSource:
-    return SessionSource(
-        platform=Platform.TELEGRAM,
-        chat_id=chat_id,
-        chat_type="dm",
-        user_id=f"user-{chat_id}",
-    )
-
-
-def _make_event(text: str = "hello", chat_id: str = "chat-1") -> MessageEvent:
-    return MessageEvent(
-        text=text,
-        message_type=MessageType.TEXT,
-        source=_make_source(chat_id),
-    )
-
-
-def _make_runner(max_concurrent_sessions: int | None = None) -> GatewayRunner:
-    runner = object.__new__(GatewayRunner)
-    runner.config = GatewayConfig(
-        platforms={Platform.TELEGRAM: PlatformConfig(enabled=True, token="***")},
-        max_concurrent_sessions=max_concurrent_sessions,
-    )
-    runner.adapters = {Platform.TELEGRAM: _FakeAdapter()}
-    runner._running_agents = {}
-    runner._running_agents_ts = {}
-    runner._active_session_leases = {}
-    runner._session_run_generation = {}
-    runner._pending_messages = {}
-    runner._pending_approvals = {}
-    runner._voice_mode = {}
-    runner._background_tasks = set()
-    runner._draining = False
-    runner._restart_requested = False
-    runner._restart_task_started = False
-    runner._restart_detached = False
-    runner._restart_via_service = False
-    runner._restart_drain_timeout = 0.0
-    runner._stop_task = None
-    runner._exit_code = None
-    runner._busy_ack_ts = {}
-    runner._busy_input_mode = "interrupt"
-    runner._busy_text_mode = "interrupt"
-    runner._queued_events = {}
-    runner._update_runtime_status = MagicMock()
-    runner._is_user_authorized = lambda _source: True
-    runner.hooks = MagicMock()
-    runner.hooks.emit = AsyncMock()
-    runner.session_store = MagicMock()
-    runner.delivery_router = MagicMock()
-    return runner
-
-
-def _occupy_session(runner: GatewayRunner, chat_id: str = "busy"):
-    source = _make_source(chat_id)
-    session_key = build_session_key(source)
-    runner._running_agents[session_key] = MagicMock()
-    runner._running_agents_ts[session_key] = time.time()
-    return session_key
-
-
-def _silence_global_gateway_hooks(monkeypatch):
-    monkeypatch.setattr("hermes_cli.plugins.invoke_hook", lambda *args, **kwargs: [])
-    monkeypatch.setattr("tools.slash_confirm.get_pending", lambda *args, **kwargs: None)
-    monkeypatch.setattr("tools.slash_confirm.clear_if_stale", lambda *args, **kwargs: None)
-    monkeypatch.setattr("tools.approval.has_blocking_approval", lambda *args, **kwargs: False)
-
-
-def test_new_session_gets_clean_error_at_active_session_limit(monkeypatch):
-    _silence_global_gateway_hooks(monkeypatch)
-    runner = _make_runner(max_concurrent_sessions=1)
-    _occupy_session(runner, "busy")
-    event = _make_event(chat_id="new")
-    new_key = build_session_key(event.source)
-
-    async def fail_if_agent_runs(self_inner, ev, src, qk, generation):
-        raise AssertionError("_handle_message_with_agent should not run at capacity")
-
-    with patch.object(GatewayRunner, "_handle_message_with_agent", fail_if_agent_runs):
-        result = asyncio.run(runner._handle_message(event))
-
-    assert result == (
-        "Hermes is at the active session limit (1/1). "
-        "Try again when another session finishes."
-    )
-    assert new_key not in runner._running_agents
-    runner.session_store.get_or_create_session.assert_not_called()
-
-
-def test_existing_active_session_uses_busy_handling_at_limit(monkeypatch):
-    _silence_global_gateway_hooks(monkeypatch)
-    runner = _make_runner(max_concurrent_sessions=1)
-    runner._busy_input_mode = "queue"
-    event = _make_event(chat_id="busy")
-    session_key = build_session_key(event.source)
-    runner._running_agents[session_key] = MagicMock()
-    runner._running_agents_ts[session_key] = 0
-
-    async def fail_if_agent_runs(self_inner, ev, src, qk, generation):
-        raise AssertionError("_handle_message_with_agent should not run for busy follow-up")
-
-    with patch.object(GatewayRunner, "_handle_message_with_agent", fail_if_agent_runs):
-        result = asyncio.run(runner._handle_message(event))
-
-    assert result is None
-    assert runner.adapters[Platform.TELEGRAM]._pending_messages[session_key] is event
-
-
-def test_new_session_can_start_after_active_session_released(monkeypatch):
-    _silence_global_gateway_hooks(monkeypatch)
-    runner = _make_runner(max_concurrent_sessions=1)
-    busy_key = _occupy_session(runner, "busy")
-    runner._release_running_agent_state(busy_key)
-    event = _make_event(chat_id="new")
-
-    sentinel_seen = False
-
-    async def mock_agent_run(self_inner, ev, src, qk, generation):
-        nonlocal sentinel_seen
-        sentinel_seen = runner._running_agents.get(qk) is _AGENT_PENDING_SENTINEL
-        return "ok"
-
-    with patch.object(GatewayRunner, "_handle_message_with_agent", mock_agent_run):
-        result = asyncio.run(runner._handle_message(event))
-
-    assert result == "ok"
-    assert sentinel_seen is True
-
-
-def test_status_command_bypasses_active_session_limit(monkeypatch):
-    _silence_global_gateway_hooks(monkeypatch)
-    runner = _make_runner(max_concurrent_sessions=1)
-    _occupy_session(runner, "busy")
-    runner._handle_status_command = AsyncMock(return_value="status ok")
-
-    result = asyncio.run(runner._handle_message(_make_event("/status", chat_id="new")))
-
-    assert result == "status ok"
-    runner._handle_status_command.assert_awaited_once()
-
-
-def test_skill_command_that_would_start_agent_is_blocked_at_limit(monkeypatch):
-    _silence_global_gateway_hooks(monkeypatch)
-    runner = _make_runner(max_concurrent_sessions=1)
-    _occupy_session(runner, "busy")
-
-    monkeypatch.setattr(
-        "agent.skill_commands.get_skill_commands",
-        lambda: {"demo": {"name": "demo-skill"}},
-    )
-    monkeypatch.setattr(
-        "agent.skill_commands.resolve_skill_command_key",
-        lambda command: "demo" if command == "demo" else None,
-    )
-    monkeypatch.setattr(
-        "agent.skill_commands.build_skill_invocation_message",
-        lambda *args, **kwargs: "invoke demo skill",
-    )
-    monkeypatch.setattr(
-        "agent.skill_utils.get_disabled_skill_names",
-        lambda *args, **kwargs: [],
-    )
-
-    async def fail_if_agent_runs(self_inner, ev, src, qk, generation):
-        raise AssertionError("_handle_message_with_agent should not run at capacity")
-
-    with patch.object(GatewayRunner, "_handle_message_with_agent", fail_if_agent_runs):
-        result = asyncio.run(
-            runner._handle_message(_make_event("/demo please", chat_id="new"))
-        )
-
-    assert result == (
-        "Hermes is at the active session limit (1/1). "
-        "Try again when another session finishes."
-    )

tests/gateway/test_shutdown_cache_cleanup.py

@@ -84,12 +84,6 @@ class _FakeGateway:
     def _evict_cached_agent(self, key):
         pass
 
-    def _release_running_agent_state(self, session_key, **_kwargs):
-        agent = self._running_agents.pop(session_key, None)
-        self._running_agents_ts.pop(session_key, None)
-        self._cleanup_agent_resources(agent)
-        return agent is not None
-
 
 def _make_mock_agent():
     a = MagicMock()

tests/gateway/test_stt_config.py

@@ -47,7 +47,7 @@ async def test_enrich_message_with_transcription_surfaces_path_when_stt_disabled
         "gateway.run._probe_audio_duration",
         new=AsyncMock(return_value="0:12"),
     ):
-        result, transcripts = await runner._enrich_message_with_transcription(
+        result = await runner._enrich_message_with_transcription(
             "caption",
             ["/tmp/voice.ogg"],
         )
@@ -56,7 +56,6 @@ async def test_enrich_message_with_transcription_surfaces_path_when_stt_disabled
     assert "voice message" in result.lower()
     assert "(duration: 0:12)" in result
     assert "caption" in result
-    assert transcripts == []
 
 
 @pytest.mark.asyncio
@@ -70,14 +69,13 @@ async def test_enrich_message_with_transcription_omits_duration_on_probe_failure
         "gateway.run._probe_audio_duration",
         new=AsyncMock(return_value=None),
     ):
-        result, transcripts = await runner._enrich_message_with_transcription(
+        result = await runner._enrich_message_with_transcription(
             "",
             ["/tmp/voice.ogg"],
         )
 
     assert "/tmp/voice.ogg" in result
     assert "duration" not in result.lower()
-    assert transcripts == []
 
 
 @pytest.mark.asyncio
@@ -91,7 +89,7 @@ async def test_enrich_message_with_transcription_avoids_bogus_no_provider_messag
         "tools.transcription_tools.transcribe_audio",
         return_value={"success": False, "error": "VOICE_TOOLS_OPENAI_KEY not set"},
     ):
-        result, transcripts = await runner._enrich_message_with_transcription(
+        result = await runner._enrich_message_with_transcription(
             "caption",
             ["/tmp/voice.ogg"],
         )
@@ -99,7 +97,6 @@ async def test_enrich_message_with_transcription_avoids_bogus_no_provider_messag
     assert "No STT provider is configured" not in result
     assert "trouble transcribing" in result
     assert "caption" in result
-    assert transcripts == []
 
 
 @pytest.mark.asyncio

tests/hermes_cli/test_active_sessions.py

@@ -1,313 +0,0 @@
-import logging
-import os
-import subprocess
-import sys
-import time
-from concurrent.futures import ThreadPoolExecutor
-from pathlib import Path
-
-from hermes_cli import active_sessions
-
-
-def test_resolve_max_concurrent_sessions_values(caplog):
-    assert active_sessions.resolve_max_concurrent_sessions({}) is None
-    assert active_sessions.resolve_max_concurrent_sessions({"max_concurrent_sessions": None}) is None
-    assert active_sessions.resolve_max_concurrent_sessions({"max_concurrent_sessions": 0}) is None
-    assert active_sessions.resolve_max_concurrent_sessions({"max_concurrent_sessions": -1}) is None
-    assert active_sessions.resolve_max_concurrent_sessions({"max_concurrent_sessions": "3"}) == 3
-    assert (
-        active_sessions.resolve_max_concurrent_sessions(
-            {"gateway": {"max_concurrent_sessions": 4}}
-        )
-        == 4
-    )
-    assert (
-        active_sessions.resolve_max_concurrent_sessions(
-            {"max_concurrent_sessions": 2, "gateway": {"max_concurrent_sessions": 4}}
-        )
-        == 2
-    )
-
-    caplog.set_level(logging.WARNING)
-    assert active_sessions.resolve_max_concurrent_sessions({"max_concurrent_sessions": "many"}) is None
-    assert any(
-        "Ignoring invalid max_concurrent_sessions='many'" in record.message
-        for record in caplog.records
-    )
-
-
-def test_active_session_lease_blocks_until_release(tmp_path, monkeypatch):
-    home = tmp_path / ".hermes"
-    monkeypatch.setenv("HERMES_HOME", str(home))
-    cfg = {"max_concurrent_sessions": 1}
-
-    lease, message = active_sessions.try_acquire_active_session(
-        session_id="session-1",
-        surface="cli",
-        config=cfg,
-    )
-
-    assert message is None
-    assert lease is not None
-
-    blocked_lease, blocked_message = active_sessions.try_acquire_active_session(
-        session_id="session-2",
-        surface="tui",
-        config=cfg,
-    )
-
-    assert blocked_lease is None
-    assert blocked_message == (
-        "Hermes is at the active session limit (1/1). "
-        "Try again when another session finishes."
-    )
-
-    lease.release()
-
-    next_lease, next_message = active_sessions.try_acquire_active_session(
-        session_id="session-3",
-        surface="gateway:telegram",
-        config=cfg,
-    )
-
-    assert next_message is None
-    assert next_lease is not None
-    next_lease.release()
-    assert active_sessions.active_session_registry_snapshot() == []
-
-
-def test_active_session_registry_prunes_dead_pids(tmp_path, monkeypatch):
-    home = tmp_path / ".hermes"
-    monkeypatch.setenv("HERMES_HOME", str(home))
-    monkeypatch.setattr(
-        "gateway.status._pid_exists",
-        lambda pid: int(pid) != 99999999,
-    )
-    runtime = home / "runtime"
-    runtime.mkdir(parents=True)
-    active_sessions._write_entries(
-        runtime / "active_sessions.json",
-        [
-            {
-                "lease_id": "stale",
-                "session_id": "stale-session",
-                "surface": "cli",
-                "pid": 99999999,
-                "started_at": 1,
-                "updated_at": 1,
-            }
-        ],
-    )
-
-    lease, message = active_sessions.try_acquire_active_session(
-        session_id="session-1",
-        surface="cli",
-        config={"max_concurrent_sessions": 1},
-    )
-
-    assert message is None
-    assert lease is not None
-    assert [entry["session_id"] for entry in active_sessions.active_session_registry_snapshot()] == [
-        "session-1"
-    ]
-    lease.release()
-
-
-def test_pid_alive_uses_safe_pid_exists_without_signalling(monkeypatch):
-    checked: list[int] = []
-
-    monkeypatch.setattr(
-        active_sessions.os,
-        "kill",
-        lambda *_args, **_kwargs: (_ for _ in ()).throw(AssertionError("os.kill used")),
-    )
-    monkeypatch.setattr(
-        "gateway.status._pid_exists",
-        lambda pid: checked.append(int(pid)) or True,
-    )
-
-    assert active_sessions._pid_alive(12345) is True
-    assert checked == [12345]
-
-
-def test_active_session_hard_exit_is_reclaimed(tmp_path, monkeypatch):
-    home = tmp_path / ".hermes"
-    monkeypatch.setenv("HERMES_HOME", str(home))
-    repo_root = Path(__file__).resolve().parents[2]
-    env = os.environ.copy()
-    env["HERMES_HOME"] = str(home)
-    env["PYTHONPATH"] = str(repo_root)
-    child = subprocess.run(
-        [
-            sys.executable,
-            "-c",
-            (
-                "import os\n"
-                "from hermes_cli.active_sessions import try_acquire_active_session\n"
-                "lease, message = try_acquire_active_session("
-                "session_id='crash-session', surface='cli', "
-                "config={'max_concurrent_sessions': 1})\n"
-                "assert message is None, message\n"
-                "print(os.getpid(), flush=True)\n"
-                "os._exit(0)\n"
-            ),
-        ],
-        env=env,
-        text=True,
-        capture_output=True,
-        timeout=10,
-        check=True,
-    )
-    child_pid = int(child.stdout.strip())
-
-    lease, message = active_sessions.try_acquire_active_session(
-        session_id="next-session",
-        surface="cli",
-        config={"max_concurrent_sessions": 1},
-    )
-
-    assert child_pid > 0
-    assert message is None
-    assert lease is not None
-    assert [entry["session_id"] for entry in active_sessions.active_session_registry_snapshot()] == [
-        "next-session"
-    ]
-    lease.release()
-
-
-def test_concurrent_acquire_claims_only_one_last_slot(tmp_path, monkeypatch):
-    home = tmp_path / ".hermes"
-    monkeypatch.setenv("HERMES_HOME", str(home))
-    cfg = {"max_concurrent_sessions": 1}
-
-    def _claim(index: int):
-        return active_sessions.try_acquire_active_session(
-            session_id=f"session-{index}",
-            surface="cli",
-            config=cfg,
-        )
-
-    with ThreadPoolExecutor(max_workers=8) as pool:
-        results = list(pool.map(_claim, range(8)))
-
-    leases = [lease for lease, message in results if lease is not None and message is None]
-    blocked = [message for lease, message in results if lease is None and message]
-
-    try:
-        assert len(leases) == 1
-        assert len(blocked) == 7
-        assert active_sessions.active_session_registry_snapshot()[0]["session_id"].startswith("session-")
-    finally:
-        for lease in leases:
-            lease.release()
-
-
-def test_cross_process_acquire_claims_only_one_last_slot(tmp_path, monkeypatch):
-    home = tmp_path / ".hermes"
-    monkeypatch.setenv("HERMES_HOME", str(home))
-    repo_root = Path(__file__).resolve().parents[2]
-    ready_dir = tmp_path / "ready"
-    ready_dir.mkdir()
-    go_file = tmp_path / "go"
-    env = os.environ.copy()
-    env["HERMES_HOME"] = str(home)
-    env["PYTHONPATH"] = str(repo_root)
-    script = (
-        "import os, time\n"
-        "from pathlib import Path\n"
-        "from hermes_cli.active_sessions import try_acquire_active_session\n"
-        "idx = os.environ['WORKER_INDEX']\n"
-        "ready_dir = Path(os.environ['READY_DIR'])\n"
-        "go_file = Path(os.environ['GO_FILE'])\n"
-        "(ready_dir / idx).write_text('ready', encoding='utf-8')\n"
-        "deadline = time.time() + 10\n"
-        "while not go_file.exists():\n"
-        "    if time.time() > deadline:\n"
-        "        raise RuntimeError('timed out waiting for go file')\n"
-        "    time.sleep(0.01)\n"
-        "lease, message = try_acquire_active_session(\n"
-        "    session_id=f'process-{idx}',\n"
-        "    surface='cli',\n"
-        "    config={'max_concurrent_sessions': 1},\n"
-        ")\n"
-        "if lease is None:\n"
-        "    print('BLOCK', flush=True)\n"
-        "else:\n"
-        "    print('OK', flush=True)\n"
-        "    time.sleep(2.0)\n"
-        "    lease.release()\n"
-    )
-    workers: list[subprocess.Popen[str]] = []
-    try:
-        for index in range(6):
-            worker_env = env.copy()
-            worker_env["WORKER_INDEX"] = str(index)
-            worker_env["READY_DIR"] = str(ready_dir)
-            worker_env["GO_FILE"] = str(go_file)
-            workers.append(
-                subprocess.Popen(
-                    [sys.executable, "-c", script],
-                    env=worker_env,
-                    text=True,
-                    stdout=subprocess.PIPE,
-                    stderr=subprocess.PIPE,
-                )
-            )
-
-        deadline = time.time() + 10
-        while len(list(ready_dir.iterdir())) < len(workers):
-            if time.time() > deadline:
-                raise AssertionError("workers did not become ready")
-            time.sleep(0.01)
-        go_file.write_text("go", encoding="utf-8")
-
-        outputs = []
-        for worker in workers:
-            stdout, stderr = worker.communicate(timeout=10)
-            assert worker.returncode == 0, stderr
-            outputs.append(stdout.strip())
-    finally:
-        for worker in workers:
-            if worker.poll() is None:
-                worker.kill()
-                worker.communicate()
-
-    assert outputs.count("OK") == 1
-    assert outputs.count("BLOCK") == len(workers) - 1
-    assert active_sessions.active_session_registry_snapshot() == []
-
-
-def test_pid_start_time_mismatch_prunes_reused_pid(tmp_path, monkeypatch):
-    home = tmp_path / ".hermes"
-    monkeypatch.setenv("HERMES_HOME", str(home))
-    monkeypatch.setattr("gateway.status._pid_exists", lambda _pid: True)
-    monkeypatch.setattr(active_sessions, "_process_start_time", lambda _pid: 200.0)
-    runtime = home / "runtime"
-    runtime.mkdir(parents=True)
-    active_sessions._write_entries(
-        runtime / "active_sessions.json",
-        [
-            {
-                "lease_id": "stale-reused-pid",
-                "session_id": "stale-session",
-                "surface": "cli",
-                "pid": os.getpid(),
-                "process_start_time": 100.0,
-                "started_at": 1,
-                "updated_at": 1,
-            }
-        ],
-    )
-
-    lease, message = active_sessions.try_acquire_active_session(
-        session_id="new-session",
-        surface="cli",
-        config={"max_concurrent_sessions": 1},
-    )
-
-    assert message is None
-    assert lease is not None
-    assert [entry["session_id"] for entry in active_sessions.active_session_registry_snapshot()] == [
-        "new-session"
-    ]
-    lease.release()

tests/hermes_cli/test_auth_codex_provider.py

@@ -301,23 +301,19 @@ def test_save_codex_tokens_syncs_credential_pool(tmp_path, monkeypatch):
 
 
 def test_save_codex_tokens_syncs_manual_device_code_entries(tmp_path, monkeypatch):
-    """Re-auth must refresh ``manual:device_code`` entries that are true
-    aliases of the singleton, while leaving INDEPENDENT entries alone.
+    """Re-auth must also refresh ``manual:device_code`` pool entries.
 
-    Original regression for #33538: a user who hit #33000 before the #33164
-    fix landed would have run ``hermes auth add openai-codex`` as a
-    workaround, leaving a pool entry with ``source="manual:device_code"``.
-    On every subsequent re-auth via setup/model picker, the singleton-seeded
-    ``device_code`` entry got refreshed but the ``manual:device_code`` entry
-    stayed stale, recreating the same 401 token_invalidated symptom that
-    #33164 was supposed to fix.
+    Regression for #33538: a user who hit #33000 before the #33164 fix landed
+    would have run ``hermes auth add openai-codex`` as a workaround, leaving
+    a pool entry with ``source="manual:device_code"``.  On every subsequent
+    re-auth via setup/model picker, the singleton-seeded ``device_code`` entry
+    got refreshed but the ``manual:device_code`` entry stayed stale, recreating
+    the same 401 token_invalidated symptom that #33164 was supposed to fix.
 
-    Narrowed for #39236: the original fix treated every ``manual:device_code``
-    entry as a singleton-alias and refreshed them all, which silently
-    clobbered independent accounts added via ``hermes auth add openai-codex``.
-    The current behavior refreshes only entries whose access_token matches
-    the *previous* singleton access_token (true legacy aliases), and leaves
-    distinct-token entries alone (independent accounts).
+    An interactive Codex device-code re-auth proves the user owns the ChatGPT
+    account, so it is safe to refresh every device-code-backed entry in the
+    pool — but NOT independent ``manual:api_key`` entries (separate accounts /
+    explicit API keys).
     """
     hermes_home = tmp_path / "hermes"
     hermes_home.mkdir(parents=True, exist_ok=True)
@@ -339,30 +335,16 @@ def test_save_codex_tokens_syncs_manual_device_code_entries(tmp_path, monkeypatc
                     "access_token": "old-at",
                     "refresh_token": "old-rt",
                 },
-                # Legacy alias from the #33000 workaround era — its tokens
-                # match the singleton, so it is a true alias and SHOULD be
-                # refreshed (preserves #33538 behavior).
                 {
-                    "id": "legacy-alias",
+                    "id": "auth-add",
                     "source": "manual:device_code",
                     "auth_type": "oauth",
-                    "access_token": "old-at",
-                    "refresh_token": "old-rt",
+                    "access_token": "stale-manual-at",
+                    "refresh_token": "stale-manual-rt",
                     "last_status": "exhausted",
                     "last_error_code": 401,
                     "last_error_reason": "token_invalidated",
                 },
-                # Independent account from `hermes auth add openai-codex` —
-                # its tokens are distinct from the singleton.  Must NOT be
-                # overwritten by a re-auth that targeted a different account
-                # (#39236).
-                {
-                    "id": "independent",
-                    "source": "manual:device_code",
-                    "auth_type": "oauth",
-                    "access_token": "independent-at",
-                    "refresh_token": "independent-rt",
-                },
                 {
                     "id": "api-key",
                     "source": "manual:api_key",
@@ -381,23 +363,18 @@ def test_save_codex_tokens_syncs_manual_device_code_entries(tmp_path, monkeypatc
     pool = auth["credential_pool"]["openai-codex"]
 
     # Singleton-seeded device_code entry: refreshed and error markers cleared.
-    seeded = next(e for e in pool if e["id"] == "seeded")
+    seeded = next(e for e in pool if e["source"] == "device_code")
     assert seeded["access_token"] == "fresh-at"
     assert seeded["refresh_token"] == "fresh-rt"
 
-    # Legacy alias (tokens matched previous singleton): ALSO refreshed.
-    legacy = next(e for e in pool if e["id"] == "legacy-alias")
-    assert legacy["access_token"] == "fresh-at"
-    assert legacy["refresh_token"] == "fresh-rt"
-    assert legacy["last_refresh"] == "2026-05-28T00:00:00Z"
-    assert legacy["last_status"] is None
-    assert legacy["last_error_code"] is None
-    assert legacy["last_error_reason"] is None
-
-    # Independent manual:device_code entry: NOT overwritten (#39236).
-    independent = next(e for e in pool if e["id"] == "independent")
-    assert independent["access_token"] == "independent-at"
-    assert independent["refresh_token"] == "independent-rt"
+    # manual:device_code entry: ALSO refreshed (the new behavior).
+    manual_dc = next(e for e in pool if e["source"] == "manual:device_code")
+    assert manual_dc["access_token"] == "fresh-at"
+    assert manual_dc["refresh_token"] == "fresh-rt"
+    assert manual_dc["last_refresh"] == "2026-05-28T00:00:00Z"
+    assert manual_dc["last_status"] is None
+    assert manual_dc["last_error_code"] is None
+    assert manual_dc["last_error_reason"] is None
 
     # manual:api_key entry: untouched — independent credential.
     api_key = next(e for e in pool if e["source"] == "manual:api_key")
@@ -405,333 +382,6 @@ def test_save_codex_tokens_syncs_manual_device_code_entries(tmp_path, monkeypatc
     assert "refresh_token" not in api_key or api_key.get("refresh_token") is None
 
 
-def test_save_codex_tokens_does_not_overwrite_independent_manual_entries(tmp_path, monkeypatch):
-    """Re-auth must NOT overwrite ``manual:device_code`` entries that hold
-    independent token material (different OpenAI/ChatGPT accounts).
-
-    Regression for #39236: ``hermes auth add openai-codex`` for accounts B and C
-    routes through ``_save_codex_tokens`` because the singleton path is the
-    only Codex OAuth save flow.  The #33538 fix refreshed every
-    ``manual:device_code`` entry on every re-auth, which works fine for the
-    one-account/legacy-workaround case but silently overwrote distinct
-    independent accounts with the latest-authenticated tokens (labels
-    preserved, token material clobbered, status/quota readings then lie).
-
-    The safe invariant: an entry is a singleton-alias only when its current
-    access_token matches the *previous* singleton access_token.  Manual
-    entries whose tokens never matched the singleton are independent accounts
-    and must be left alone.
-    """
-    hermes_home = tmp_path / "hermes"
-    hermes_home.mkdir(parents=True, exist_ok=True)
-    (hermes_home / "auth.json").write_text(json.dumps({
-        "version": 1,
-        "providers": {
-            "openai-codex": {
-                # Old singleton tokens — represent "account A" which the user
-                # logged in with via setup originally.
-                "tokens": {"access_token": "acctA-at", "refresh_token": "acctA-rt"},
-                "last_refresh": "2026-01-01T00:00:00Z",
-                "auth_mode": "chatgpt",
-                "label": "account-A",
-            },
-        },
-        "credential_pool": {
-            "openai-codex": [
-                # The seeded singleton mirror of account A.
-                {
-                    "id": "seeded",
-                    "label": "account-A",
-                    "source": "device_code",
-                    "auth_type": "oauth",
-                    "access_token": "acctA-at",
-                    "refresh_token": "acctA-rt",
-                },
-                # Two INDEPENDENT manual entries added later via
-                # ``hermes auth add openai-codex`` (account B and account C).
-                # Each has its OWN distinct token material, unrelated to the
-                # singleton.
-                {
-                    "id": "acctB",
-                    "label": "account-B",
-                    "source": "manual:device_code",
-                    "auth_type": "oauth",
-                    "access_token": "acctB-at",
-                    "refresh_token": "acctB-rt",
-                },
-                {
-                    "id": "acctC",
-                    "label": "account-C",
-                    "source": "manual:device_code",
-                    "auth_type": "oauth",
-                    "access_token": "acctC-at",
-                    "refresh_token": "acctC-rt",
-                },
-            ],
-        },
-    }))
-    monkeypatch.setenv("HERMES_HOME", str(hermes_home))
-
-    # User re-authenticates account A — fresh device-code login produces new
-    # tokens.  The legitimate update is the seeded singleton mirror; the
-    # independent acctB/acctC entries must be untouched.
-    _save_codex_tokens(
-        {"access_token": "acctA-new-at", "refresh_token": "acctA-new-rt"},
-        last_refresh="2026-06-05T00:00:00Z",
-    )
-
-    auth = json.loads((hermes_home / "auth.json").read_text())
-    pool = auth["credential_pool"]["openai-codex"]
-
-    # Singleton-seeded entry: refreshed (legitimate sync).
-    seeded = next(e for e in pool if e["source"] == "device_code")
-    assert seeded["access_token"] == "acctA-new-at"
-    assert seeded["refresh_token"] == "acctA-new-rt"
-    assert seeded["last_refresh"] == "2026-06-05T00:00:00Z"
-
-    # acctB: INDEPENDENT entry — must NOT be overwritten.
-    acctB = next(e for e in pool if e["id"] == "acctB")
-    assert acctB["access_token"] == "acctB-at", (
-        "acctB was clobbered by acctA re-auth (#39236 regression)"
-    )
-    assert acctB["refresh_token"] == "acctB-rt"
-
-    # acctC: INDEPENDENT entry — must NOT be overwritten.
-    acctC = next(e for e in pool if e["id"] == "acctC")
-    assert acctC["access_token"] == "acctC-at", (
-        "acctC was clobbered by acctA re-auth (#39236 regression)"
-    )
-    assert acctC["refresh_token"] == "acctC-rt"
-
-
-def test_save_codex_tokens_still_refreshes_legacy_manual_alias(tmp_path, monkeypatch):
-    """The #33538 legacy use case must keep working.
-
-    A user who hit #33000 before the #33164 fix landed might have run
-    ``hermes auth add openai-codex`` as a workaround when there was no
-    singleton entry — that created a ``manual:device_code`` pool entry that
-    holds the SAME token material as the (later) singleton.  This entry is a
-    true alias of the singleton and SHOULD still be refreshed on subsequent
-    re-auths, otherwise it goes stale and recreates the #33538 symptom.
-
-    The distinguishing signal: a legacy alias has access_token == previous
-    singleton access_token; an independent account does not.
-    """
-    hermes_home = tmp_path / "hermes"
-    hermes_home.mkdir(parents=True, exist_ok=True)
-    (hermes_home / "auth.json").write_text(json.dumps({
-        "version": 1,
-        "providers": {
-            "openai-codex": {
-                "tokens": {"access_token": "shared-at", "refresh_token": "shared-rt"},
-                "last_refresh": "2026-01-01T00:00:00Z",
-                "auth_mode": "chatgpt",
-            },
-        },
-        "credential_pool": {
-            "openai-codex": [
-                {
-                    "id": "seeded",
-                    "source": "device_code",
-                    "auth_type": "oauth",
-                    "access_token": "shared-at",
-                    "refresh_token": "shared-rt",
-                },
-                {
-                    "id": "legacy",
-                    "label": "legacy-alias",
-                    "source": "manual:device_code",
-                    "auth_type": "oauth",
-                    # Token material matches the singleton — this is a true
-                    # alias from the #33000 workaround era.
-                    "access_token": "shared-at",
-                    "refresh_token": "shared-rt",
-                    "last_status": "exhausted",
-                    "last_error_code": 401,
-                    "last_error_reason": "token_invalidated",
-                },
-            ],
-        },
-    }))
-    monkeypatch.setenv("HERMES_HOME", str(hermes_home))
-
-    _save_codex_tokens(
-        {"access_token": "fresh-at", "refresh_token": "fresh-rt"},
-        last_refresh="2026-06-05T00:00:00Z",
-    )
-
-    auth = json.loads((hermes_home / "auth.json").read_text())
-    pool = auth["credential_pool"]["openai-codex"]
-
-    # Singleton: refreshed.
-    seeded = next(e for e in pool if e["source"] == "device_code")
-    assert seeded["access_token"] == "fresh-at"
-
-    # Legacy alias: still refreshed (preserves #33538 fix).
-    legacy = next(e for e in pool if e["id"] == "legacy")
-    assert legacy["access_token"] == "fresh-at"
-    assert legacy["refresh_token"] == "fresh-rt"
-    assert legacy["last_refresh"] == "2026-06-05T00:00:00Z"
-    # Error markers cleared on the refreshed entry.
-    assert legacy["last_status"] is None
-    assert legacy["last_error_code"] is None
-    assert legacy["last_error_reason"] is None
-
-
-def test_save_codex_tokens_handles_missing_previous_singleton_tokens(tmp_path, monkeypatch):
-    """First-ever Codex save (no prior singleton tokens) must not crash.
-
-    Edge case: a user has only pool entries (e.g. via direct auth.json edit
-    or a partial state from a corrupted upgrade), no `providers.openai-codex.tokens`
-    block at all.  The previous-singleton-tokens guard must handle missing
-    state gracefully — fall back to "no previous tokens", which means no
-    pool entry can be a true alias and only the singleton-seeded entry gets
-    written.
-    """
-    hermes_home = tmp_path / "hermes"
-    hermes_home.mkdir(parents=True, exist_ok=True)
-    (hermes_home / "auth.json").write_text(json.dumps({
-        "version": 1,
-        "providers": {},
-        "credential_pool": {
-            "openai-codex": [
-                {
-                    "id": "preexisting",
-                    "label": "pre-existing-manual",
-                    "source": "manual:device_code",
-                    "auth_type": "oauth",
-                    "access_token": "preexisting-at",
-                    "refresh_token": "preexisting-rt",
-                },
-            ],
-        },
-    }))
-    monkeypatch.setenv("HERMES_HOME", str(hermes_home))
-
-    _save_codex_tokens(
-        {"access_token": "first-at", "refresh_token": "first-rt"},
-        last_refresh="2026-06-05T00:00:00Z",
-    )
-
-    auth = json.loads((hermes_home / "auth.json").read_text())
-    pool = auth["credential_pool"]["openai-codex"]
-    # Pre-existing independent entry with no relationship to a (now-new)
-    # singleton MUST be preserved.
-    pre = next(e for e in pool if e["id"] == "preexisting")
-    assert pre["access_token"] == "preexisting-at"
-    assert pre["refresh_token"] == "preexisting-rt"
-
-
-def test_save_codex_tokens_alias_match_uses_access_token_only(tmp_path, monkeypatch):
-    """A manual entry counts as an alias if its access_token matches the
-    previous singleton access_token, regardless of refresh_token presence.
-
-    Some legacy entries (older auth.json schemas, pre-refresh-token versions)
-    have access_token but no refresh_token.  These should still be treated as
-    aliases when the access_token matches.
-    """
-    hermes_home = tmp_path / "hermes"
-    hermes_home.mkdir(parents=True, exist_ok=True)
-    (hermes_home / "auth.json").write_text(json.dumps({
-        "version": 1,
-        "providers": {
-            "openai-codex": {
-                "tokens": {"access_token": "shared-at", "refresh_token": "shared-rt"},
-                "auth_mode": "chatgpt",
-            },
-        },
-        "credential_pool": {
-            "openai-codex": [
-                {
-                    "id": "alias-no-refresh",
-                    "source": "manual:device_code",
-                    "auth_type": "oauth",
-                    "access_token": "shared-at",
-                    # No refresh_token at all — legacy schema.
-                },
-            ],
-        },
-    }))
-    monkeypatch.setenv("HERMES_HOME", str(hermes_home))
-
-    _save_codex_tokens(
-        {"access_token": "new-at", "refresh_token": "new-rt"},
-        last_refresh="2026-06-05T00:00:00Z",
-    )
-
-    auth = json.loads((hermes_home / "auth.json").read_text())
-    pool = auth["credential_pool"]["openai-codex"]
-    alias = next(e for e in pool if e["id"] == "alias-no-refresh")
-    # Treated as alias → refreshed with new tokens.
-    assert alias["access_token"] == "new-at"
-    assert alias["refresh_token"] == "new-rt"
-
-
-def test_save_codex_tokens_clears_error_markers_only_on_refreshed_entries(tmp_path, monkeypatch):
-    """Error markers must be cleared only on entries that were actually
-    refreshed by this re-auth.  Independent ``manual:device_code`` entries
-    with their own stale-error markers must be left alone (their stale state
-    is not the current re-auth's business).
-    """
-    hermes_home = tmp_path / "hermes"
-    hermes_home.mkdir(parents=True, exist_ok=True)
-    (hermes_home / "auth.json").write_text(json.dumps({
-        "version": 1,
-        "providers": {
-            "openai-codex": {
-                "tokens": {"access_token": "acctA-at", "refresh_token": "acctA-rt"},
-                "auth_mode": "chatgpt",
-            },
-        },
-        "credential_pool": {
-            "openai-codex": [
-                {
-                    "id": "seeded",
-                    "source": "device_code",
-                    "auth_type": "oauth",
-                    "access_token": "acctA-at",
-                    "refresh_token": "acctA-rt",
-                    "last_status": "exhausted",
-                    "last_error_code": 401,
-                },
-                {
-                    "id": "acctB",
-                    "source": "manual:device_code",
-                    "auth_type": "oauth",
-                    "access_token": "acctB-at",
-                    "refresh_token": "acctB-rt",
-                    "last_status": "exhausted",
-                    "last_error_code": 429,
-                    "last_error_reason": "quota_exhausted",
-                },
-            ],
-        },
-    }))
-    monkeypatch.setenv("HERMES_HOME", str(hermes_home))
-
-    _save_codex_tokens(
-        {"access_token": "fresh-at", "refresh_token": "fresh-rt"},
-        last_refresh="2026-06-05T00:00:00Z",
-    )
-
-    auth = json.loads((hermes_home / "auth.json").read_text())
-    pool = auth["credential_pool"]["openai-codex"]
-
-    # Singleton: refreshed AND error markers cleared.
-    seeded = next(e for e in pool if e["id"] == "seeded")
-    assert seeded["access_token"] == "fresh-at"
-    assert seeded["last_status"] is None
-    assert seeded["last_error_code"] is None
-
-    # Independent acctB: NOT refreshed AND error markers NOT cleared.
-    # (Its 429 quota state belongs to acctB's own account, not acctA's re-auth.)
-    acctB = next(e for e in pool if e["id"] == "acctB")
-    assert acctB["access_token"] == "acctB-at"  # not overwritten
-    assert acctB["last_status"] == "exhausted"  # not cleared
-    assert acctB["last_error_code"] == 429
-    assert acctB["last_error_reason"] == "quota_exhausted"
-
-
 def test_import_codex_cli_tokens(tmp_path, monkeypatch):
     codex_home = tmp_path / "codex-cli"
     codex_home.mkdir(parents=True, exist_ok=True)

tests/hermes_cli/test_auth_commands.py

@@ -397,92 +397,15 @@ def test_auth_add_codex_oauth_persists_pool_entry(tmp_path, monkeypatch):
 
     payload = json.loads((tmp_path / "hermes" / "auth.json").read_text())
     entries = payload["credential_pool"]["openai-codex"]
-    # The add path now creates a distinct, self-contained ``manual:device_code``
-    # pool entry per account instead of routing through the singleton save path
-    # (which collapsed multiple accounts into the latest login — #39236).
-    entry = next(item for item in entries if item["source"] == "manual:device_code")
+    entry = next(item for item in entries if item["source"] == "device_code")
     assert payload["active_provider"] == "openai-codex"
-    # No singleton ``providers.openai-codex`` block is written by the add path.
-    assert "openai-codex" not in payload.get("providers", {})
+    assert payload["providers"]["openai-codex"]["tokens"]["access_token"] == token
     assert entry["label"] == "codex@example.com"
-    assert entry["source"] == "manual:device_code"
-    assert entry["access_token"] == token
+    assert entry["source"] == "device_code"
     assert entry["refresh_token"] == "refresh-token"
     assert entry["base_url"] == "https://chatgpt.com/backend-api/codex"
 
 
-def test_auth_add_codex_oauth_keeps_distinct_pool_accounts(tmp_path, monkeypatch):
-    """Two ``hermes auth add openai-codex`` runs for different ChatGPT
-    accounts must produce two independent pool entries with distinct tokens.
-
-    Regression for #39236: the add path used to route through the singleton
-    ``_save_codex_tokens`` save, so the second login overwrote the first
-    account's singleton-mirrored ``device_code`` entry instead of adding a
-    second independent one. ``hermes auth list`` showed two labels sharing
-    one token pair, and rotation silently always used the latest account.
-    """
-    monkeypatch.setenv("HERMES_HOME", str(tmp_path / "hermes"))
-    _write_auth_store(tmp_path, {"version": 1, "providers": {}})
-    first_token = _jwt_with_email("first-codex@example.com")
-    second_token = _jwt_with_email("second-codex@example.com")
-    logins = iter(
-        [
-            {
-                "tokens": {
-                    "access_token": first_token,
-                    "refresh_token": "first-refresh-token",
-                },
-                "base_url": "https://chatgpt.com/backend-api/codex",
-                "last_refresh": "2026-03-23T10:00:00Z",
-            },
-            {
-                "tokens": {
-                    "access_token": second_token,
-                    "refresh_token": "second-refresh-token",
-                },
-                "base_url": "https://chatgpt.com/backend-api/codex",
-                "last_refresh": "2026-03-23T10:05:00Z",
-            },
-        ]
-    )
-    monkeypatch.setattr("hermes_cli.auth._codex_device_code_login", lambda: next(logins))
-
-    from hermes_cli.auth_commands import auth_add_command
-    from agent.credential_pool import load_pool
-
-    class _Args:
-        provider = "openai-codex"
-        auth_type = "oauth"
-        api_key = None
-        label = None
-
-    auth_add_command(_Args())
-    auth_add_command(_Args())
-
-    pool = load_pool("openai-codex")
-    entries = pool.entries()
-
-    assert [entry.source for entry in entries] == [
-        "manual:device_code",
-        "manual:device_code",
-    ]
-    assert [entry.label for entry in entries] == [
-        "first-codex@example.com",
-        "second-codex@example.com",
-    ]
-    assert [entry.access_token for entry in entries] == [first_token, second_token]
-    assert [entry.refresh_token for entry in entries] == [
-        "first-refresh-token",
-        "second-refresh-token",
-    ]
-
-    payload = json.loads((tmp_path / "hermes" / "auth.json").read_text())
-    # No singleton block — the add path is now pool-only.
-    assert "openai-codex" not in payload.get("providers", {})
-    # First add activated the provider; second add left it as-is.
-    assert payload["active_provider"] == "openai-codex"
-
-
 def test_auth_add_xai_oauth_sets_active_provider(tmp_path, monkeypatch):
     """hermes auth add xai-oauth must write providers singleton and set active_provider.
 
@@ -1390,9 +1313,9 @@ def test_auth_add_codex_clears_suppression_marker(tmp_path, monkeypatch):
     payload = json.loads((hermes_home / "auth.json").read_text())
     # Suppression marker must be cleared
     assert "openai-codex" not in payload.get("suppressed_sources", {})
-    # New pool entry must be present (distinct manual:device_code entry — #39236)
+    # New pool entry must be present
     entries = payload["credential_pool"]["openai-codex"]
-    assert any(e["source"] == "manual:device_code" for e in entries)
+    assert any(e["source"] == "device_code" for e in entries)
     assert payload["active_provider"] == "openai-codex"
 
 

tests/hermes_cli/test_cli_active_session_limit.py

@@ -1,41 +0,0 @@
-from cli import HermesCLI
-from hermes_cli.active_sessions import (
-    active_session_registry_snapshot,
-    try_acquire_active_session,
-)
-
-
-def test_cli_claim_active_session_respects_global_limit(tmp_path, monkeypatch):
-    monkeypatch.setenv("HERMES_HOME", str(tmp_path / ".hermes"))
-    cfg = {"max_concurrent_sessions": 1}
-    held, message = try_acquire_active_session(
-        session_id="held-session",
-        surface="tui",
-        config=cfg,
-    )
-    assert message is None
-    assert held is not None
-
-    cli = object.__new__(HermesCLI)
-    cli.session_id = "new-cli-session"
-    cli.config = cfg
-    cli._active_session_lease = None
-    printed: list[str] = []
-    cli._console_print = lambda text: printed.append(text)
-
-    try:
-        assert cli._claim_active_session("cli") is False
-        assert printed == [
-            "[bold red]Hermes is at the active session limit (1/1). "
-            "Try again when another session finishes.[/]"
-        ]
-
-        held.release()
-
-        assert cli._claim_active_session("cli") is True
-        assert [entry["session_id"] for entry in active_session_registry_snapshot()] == [
-            "new-cli-session"
-        ]
-    finally:
-        held.release()
-        cli._release_active_session()

tests/hermes_cli/test_dashboard_admin_endpoints.py

@@ -701,37 +701,6 @@ class TestUpdateCheckEndpoint:
         assert body["update_available"] is False
         assert body["message"]
 
-    def test_git_behind_includes_commits(self, monkeypatch):
-        import hermes_cli.web_server as ws
-        import hermes_cli.banner as banner
-
-        monkeypatch.setattr(ws, "detect_install_method", lambda *a, **k: "git")
-        monkeypatch.setattr(banner, "check_for_updates", lambda: 3)
-        monkeypatch.setattr(
-            ws,
-            "_recent_upstream_commits",
-            lambda n=20: [
-                {"sha": "abc1234", "summary": "feat: x", "author": "a", "at": 1},
-            ],
-        )
-
-        body = self.client.get("/api/hermes/update/check").json()
-        # The desktop overlay renders this as the "what's changed" list.
-        assert isinstance(body["commits"], list)
-        assert body["commits"][0]["sha"] == "abc1234"
-        assert body["commits"][0]["summary"] == "feat: x"
-
-    def test_up_to_date_omits_commits(self, monkeypatch):
-        import hermes_cli.web_server as ws
-        import hermes_cli.banner as banner
-
-        monkeypatch.setattr(ws, "detect_install_method", lambda *a, **k: "git")
-        monkeypatch.setattr(banner, "check_for_updates", lambda: 0)
-
-        body = self.client.get("/api/hermes/update/check").json()
-        # No commits list when there's nothing to show (additive, non-breaking).
-        assert body.get("commits", []) == []
-
 
 class TestDebugShareEndpoint:
     """POST /api/ops/debug-share returns the paste URLs synchronously so the

tests/hermes_cli/test_gui_command.py

@@ -519,78 +519,3 @@ def test_gui_does_not_retry_when_purge_finds_nothing(tmp_path, monkeypatch, caps
     mock_purge.assert_called_once()
     assert mock_run.call_count == 1
     assert "Desktop GUI build failed" in capsys.readouterr().out
-
-
-class _FakeProc:
-    """Minimal psutil.Process stand-in for the lock-breaker tests."""
-
-    def __init__(self, pid: int, exe: str | None):
-        self.pid = pid
-        self.info = {"pid": pid, "exe": exe}
-        self.terminated = False
-        self.killed = False
-
-    def terminate(self):
-        self.terminated = True
-
-    def kill(self):
-        self.killed = True
-
-
-def test_stop_desktop_build_lock_noop_off_windows(tmp_path, monkeypatch):
-    """POSIX can unlink a running binary, so the helper is a no-op there."""
-    desktop_dir = tmp_path / "apps" / "desktop"
-    exe = desktop_dir / "release" / "linux-unpacked" / "hermes"
-    exe.parent.mkdir(parents=True)
-    exe.write_text("", encoding="utf-8")
-    monkeypatch.setattr(cli_main.sys, "platform", "linux")
-
-    proc = _FakeProc(4321, str(exe))
-    with patch("psutil.process_iter", return_value=[proc]) as it:
-        assert cli_main._stop_desktop_processes_locking_build(desktop_dir) == []
-    it.assert_not_called()
-    assert proc.terminated is False
-
-
-def test_stop_desktop_build_lock_terminates_only_release_procs(tmp_path, monkeypatch):
-    desktop_dir = tmp_path / "apps" / "desktop"
-    release = desktop_dir / "release" / "win-unpacked"
-    release.mkdir(parents=True)
-    locker_exe = release / "Hermes.exe"
-    locker_exe.write_text("", encoding="utf-8")
-    other_exe = tmp_path / "elsewhere" / "Hermes.exe"
-    other_exe.parent.mkdir(parents=True)
-    other_exe.write_text("", encoding="utf-8")
-
-    monkeypatch.setattr(cli_main.sys, "platform", "win32")
-    monkeypatch.setattr(cli_main.os, "getpid", lambda: 999)
-
-    locker = _FakeProc(101, str(locker_exe))
-    unrelated = _FakeProc(102, str(other_exe))
-    selfish = _FakeProc(999, str(locker_exe))  # our own PID — never killed
-    no_exe = _FakeProc(103, None)
-
-    captured = {}
-
-    def _wait(procs, timeout=None):
-        captured["waited"] = list(procs)
-        return procs, []
-
-    with patch("psutil.process_iter", return_value=[locker, unrelated, selfish, no_exe]), \
-         patch("psutil.wait_procs", side_effect=_wait):
-        stopped = cli_main._stop_desktop_processes_locking_build(desktop_dir)
-
-    assert stopped == [101]
-    assert locker.terminated is True
-    assert unrelated.terminated is False
-    assert selfish.terminated is False
-    assert captured["waited"] == [locker]
-
-
-def test_stop_desktop_build_lock_no_release_dir(tmp_path, monkeypatch):
-    desktop_dir = tmp_path / "apps" / "desktop"
-    desktop_dir.mkdir(parents=True)
-    monkeypatch.setattr(cli_main.sys, "platform", "win32")
-    with patch("psutil.process_iter") as it:
-        assert cli_main._stop_desktop_processes_locking_build(desktop_dir) == []
-    it.assert_not_called()

tests/hermes_cli/test_plugins_cmd.py

@@ -3,8 +3,6 @@
 from __future__ import annotations
 
 import logging
-import os
-import shutil
 from pathlib import Path
 from unittest.mock import MagicMock, patch
 
@@ -18,7 +16,6 @@ from hermes_cli.plugins_cmd import (
     _repo_name_from_url,
     _resolve_git_executable,
     _resolve_git_url,
-    _resolve_subdir_within,
     _sanitize_plugin_name,
 )
 
@@ -100,127 +97,35 @@ class TestSanitizePluginName:
 
 
 class TestResolveGitUrl:
-    """Shorthand and full-URL resolution, with optional subdirectory."""
+    """Shorthand and full-URL resolution."""
 
     def test_owner_repo_shorthand(self):
-        url, subdir = _resolve_git_url("owner/repo")
+        url = _resolve_git_url("owner/repo")
         assert url == "https://github.com/owner/repo.git"
-        assert subdir is None
 
     def test_https_url_passthrough(self):
-        url, subdir = _resolve_git_url("https://github.com/x/y.git")
+        url = _resolve_git_url("https://github.com/x/y.git")
         assert url == "https://github.com/x/y.git"
-        assert subdir is None
 
     def test_ssh_url_passthrough(self):
-        url, subdir = _resolve_git_url("git@github.com:x/y.git")
+        url = _resolve_git_url("git@github.com:x/y.git")
         assert url == "git@github.com:x/y.git"
-        assert subdir is None
 
     def test_http_url_passthrough(self):
-        url, subdir = _resolve_git_url("http://example.com/repo.git")
+        url = _resolve_git_url("http://example.com/repo.git")
         assert url == "http://example.com/repo.git"
-        assert subdir is None
 
     def test_file_url_passthrough(self):
-        url, subdir = _resolve_git_url("file:///tmp/repo")
+        url = _resolve_git_url("file:///tmp/repo")
         assert url == "file:///tmp/repo"
-        assert subdir is None
 
     def test_invalid_single_word_raises(self):
         with pytest.raises(ValueError, match="Invalid plugin identifier"):
             _resolve_git_url("justoneword")
 
-    def test_shorthand_with_subdir(self):
-        url, subdir = _resolve_git_url("owner/repo/my-plugin")
-        assert url == "https://github.com/owner/repo.git"
-        assert subdir == "my-plugin"
-
-    def test_shorthand_with_nested_subdir(self):
-        url, subdir = _resolve_git_url("owner/repo/path/to/plugin")
-        assert url == "https://github.com/owner/repo.git"
-        assert subdir == "path/to/plugin"
-
-    def test_shorthand_with_subdir_trailing_slash(self):
-        url, subdir = _resolve_git_url("owner/repo/my-plugin/")
-        assert url == "https://github.com/owner/repo.git"
-        assert subdir == "my-plugin"
-
-    def test_https_url_with_subdir(self):
-        url, subdir = _resolve_git_url("https://github.com/owner/repo.git/my-plugin")
-        assert url == "https://github.com/owner/repo.git"
-        assert subdir == "my-plugin"
-
-    def test_https_url_with_nested_subdir(self):
-        url, subdir = _resolve_git_url(
-            "https://github.com/owner/repo.git/path/to/plugin"
-        )
-        assert url == "https://github.com/owner/repo.git"
-        assert subdir == "path/to/plugin"
-
-    def test_url_with_fragment_subdir(self):
-        url, subdir = _resolve_git_url("https://github.com/owner/repo.git#my-plugin")
-        assert url == "https://github.com/owner/repo.git"
-        assert subdir == "my-plugin"
-
-    def test_file_url_with_fragment_subdir(self):
-        url, subdir = _resolve_git_url("file:///tmp/repo#path/to/plugin")
-        assert url == "file:///tmp/repo"
-        assert subdir == "path/to/plugin"
-
-    def test_ssh_url_with_fragment_subdir(self):
-        url, subdir = _resolve_git_url("git@github.com:owner/repo.git#sub")
-        assert url == "git@github.com:owner/repo.git"
-        assert subdir == "sub"
-
-
-# ── _resolve_subdir_within ──────────────────────────────────────────────────
-
-
-class TestResolveSubdirWithin:
-    """Subdirectory resolution stays within the clone and rejects traversal."""
-
-    def test_valid_subdir(self, tmp_path):
-        (tmp_path / "my-plugin").mkdir()
-        result = _resolve_subdir_within(tmp_path, "my-plugin")
-        assert result == (tmp_path / "my-plugin").resolve()
-
-    def test_valid_nested_subdir(self, tmp_path):
-        (tmp_path / "a" / "b" / "c").mkdir(parents=True)
-        result = _resolve_subdir_within(tmp_path, "a/b/c")
-        assert result == (tmp_path / "a" / "b" / "c").resolve()
-
-    def test_rejects_dot_dot_escape(self, tmp_path):
-        clone = tmp_path / "clone"
-        clone.mkdir()
-        (tmp_path / "secret").mkdir()
-        with pytest.raises(PluginOperationError, match="escapes the repository"):
-            _resolve_subdir_within(clone, "../secret")
-
-    def test_rejects_absolute_path_escape(self, tmp_path):
-        clone = tmp_path / "clone"
-        clone.mkdir()
-        # An absolute path resolves outside the clone root.
-        with pytest.raises(PluginOperationError, match="escapes the repository"):
-            _resolve_subdir_within(clone, "/etc")
-
-    def test_rejects_symlink_escape(self, tmp_path):
-        clone = tmp_path / "clone"
-        clone.mkdir()
-        outside = tmp_path / "outside"
-        outside.mkdir()
-        (clone / "link").symlink_to(outside)
-        with pytest.raises(PluginOperationError, match="escapes the repository"):
-            _resolve_subdir_within(clone, "link")
-
-    def test_rejects_missing_subdir(self, tmp_path):
-        with pytest.raises(PluginOperationError, match="does not exist"):
-            _resolve_subdir_within(tmp_path, "nope")
-
-    def test_rejects_file_not_dir(self, tmp_path):
-        (tmp_path / "afile").write_text("x")
-        with pytest.raises(PluginOperationError, match="not a directory"):
-            _resolve_subdir_within(tmp_path, "afile")
+    def test_invalid_three_parts_raises(self):
+        with pytest.raises(ValueError, match="Invalid plugin identifier"):
+            _resolve_git_url("a/b/c")
 
 
 # ── _resolve_git_executable ─────────────────────────────────────────────────
@@ -793,90 +698,3 @@ class TestNoAutoActivation:
         # The old code had: "Even with default config, check if a plugin registered one"
         # The fix removes this. Verify it's gone.
         assert "Even with default config, check if a plugin registered one" not in source
-
-
-# ── End-to-end subdirectory install ──────────────────────────────────────────
-
-
-class TestSubdirInstallE2E:
-    """Install a plugin that lives in a subdirectory of a real local git repo."""
-
-    @staticmethod
-    def _make_repo_with_subdir_plugin(repo_root: Path) -> None:
-        """Create a git repo where the plugin lives in ``./my-plugin/`` and the
-        repo root holds unrelated docs/tests."""
-        import subprocess as sp
-
-        repo_root.mkdir(parents=True, exist_ok=True)
-        # Root-level noise: docs + tests that should NOT be installed.
-        (repo_root / "README.md").write_text("# Monorepo docs\n")
-        (repo_root / "tests").mkdir()
-        (repo_root / "tests" / "test_x.py").write_text("def test_x():\n    pass\n")
-        # The actual plugin in a subdirectory.
-        plugin_dir = repo_root / "my-plugin"
-        plugin_dir.mkdir()
-        (plugin_dir / "plugin.yaml").write_text(
-            "name: my-plugin\nmanifest_version: 1\ndescription: A subdir plugin\n"
-        )
-        (plugin_dir / "__init__.py").write_text("# plugin entry\n")
-
-        env = {
-            **os.environ,
-            "GIT_AUTHOR_NAME": "t",
-            "GIT_AUTHOR_EMAIL": "t@t",
-            "GIT_COMMITTER_NAME": "t",
-            "GIT_COMMITTER_EMAIL": "t@t",
-        }
-        sp.run(["git", "init", "-q"], cwd=repo_root, check=True, env=env)
-        sp.run(["git", "add", "-A"], cwd=repo_root, check=True, env=env)
-        sp.run(
-            ["git", "commit", "-q", "-m", "init"],
-            cwd=repo_root,
-            check=True,
-            env=env,
-        )
-
-    def test_installs_only_the_subdir_plugin(self, tmp_path, monkeypatch):
-        if shutil.which("git") is None:
-            pytest.skip("git not available")
-
-        from hermes_cli import plugins_cmd as pc
-
-        repo_root = tmp_path / "monorepo"
-        self._make_repo_with_subdir_plugin(repo_root)
-
-        plugins_dir = tmp_path / "installed"
-        plugins_dir.mkdir()
-        monkeypatch.setattr(pc, "_plugins_dir", lambda: plugins_dir)
-
-        identifier = f"file://{repo_root}#my-plugin"
-        target, manifest, name = pc._install_plugin_core(identifier, force=False)
-
-        # Installed under the plugin's own name, not the repo name.
-        assert name == "my-plugin"
-        assert manifest.get("name") == "my-plugin"
-        assert target == (plugins_dir / "my-plugin").resolve()
-
-        # The plugin's files are present...
-        assert (target / "plugin.yaml").exists()
-        assert (target / "__init__.py").exists()
-        # ...and the repo-root noise is NOT.
-        assert not (target / "README.md").exists()
-        assert not (target / "tests").exists()
-
-    def test_missing_subdir_raises(self, tmp_path, monkeypatch):
-        if shutil.which("git") is None:
-            pytest.skip("git not available")
-
-        from hermes_cli import plugins_cmd as pc
-
-        repo_root = tmp_path / "monorepo"
-        self._make_repo_with_subdir_plugin(repo_root)
-
-        plugins_dir = tmp_path / "installed"
-        plugins_dir.mkdir()
-        monkeypatch.setattr(pc, "_plugins_dir", lambda: plugins_dir)
-
-        identifier = f"file://{repo_root}#does-not-exist"
-        with pytest.raises(PluginOperationError, match="does not exist"):
-            pc._install_plugin_core(identifier, force=False)

tests/hermes_cli/test_plugins_cmd_category_discovery.py

@@ -1,355 +0,0 @@
-"""Tests for the nested category plugin discovery fix (issue #41066).
-
-Verifies that _discover_all_plugins() recurses into category directories
-(up to 2 levels deep) and that _plugin_status() checks both manifest name
-and path-derived key against the enabled/disabled sets.
-"""
-
-import json
-import sys
-from pathlib import Path
-from unittest.mock import MagicMock, patch
-
-import pytest
-
-
-# ---------------------------------------------------------------------------
-# Helpers
-# ---------------------------------------------------------------------------
-
-
-def _make_plugin_dir(parent: Path, name: str, manifest: dict) -> Path:
-    """Create a minimal plugin directory with a plugin.yaml."""
-    d = parent / name
-    d.mkdir(parents=True, exist_ok=True)
-    import yaml
-    (d / "plugin.yaml").write_text(yaml.dump(manifest), encoding="utf-8")
-    (d / "__init__.py").write_text("def register(ctx): pass\n", encoding="utf-8")
-    return d
-
-
-def _make_category_plugin(
-    parent: Path, category: str, name: str, manifest: dict
-) -> Path:
-    """Create a category-namespaced plugin: <parent>/<category>/<name>/plugin.yaml."""
-    return _make_plugin_dir(parent / category, name, manifest)
-
-
-# ---------------------------------------------------------------------------
-# _read_manifest_info
-# ---------------------------------------------------------------------------
-
-
-class TestReadManifestInfo:
-    def test_flat_plugin(self, tmp_path):
-        from hermes_cli.plugins_cmd import _read_manifest_info
-
-        d = _make_plugin_dir(tmp_path, "my-plugin", {
-            "name": "my-plugin", "version": "1.0.0", "description": "test"
-        })
-        result = _read_manifest_info(d, "")
-        assert result is not None
-        name, version, description, key = result
-        assert name == "my-plugin"
-        assert version == "1.0.0"
-        assert description == "test"
-        assert key == "my-plugin"  # flat: key == name
-
-    def test_category_plugin(self, tmp_path):
-        from hermes_cli.plugins_cmd import _read_manifest_info
-
-        d = _make_category_plugin(tmp_path, "web", "tavily", {
-            "name": "web-tavily", "version": "2.0.0", "description": "search"
-        })
-        result = _read_manifest_info(d, "web")
-        assert result is not None
-        name, version, description, key = result
-        assert name == "web-tavily"  # manifest name
-        assert key == "web/tavily"  # path-derived key
-
-    def test_no_manifest(self, tmp_path):
-        from hermes_cli.plugins_cmd import _read_manifest_info
-
-        d = tmp_path / "empty-dir"
-        d.mkdir()
-        assert _read_manifest_info(d, "") is None
-
-    def test_yml_extension(self, tmp_path):
-        from hermes_cli.plugins_cmd import _read_manifest_info
-
-        d = tmp_path / "my-plugin"
-        d.mkdir()
-        import yaml
-        (d / "plugin.yml").write_text(yaml.dump({"name": "my-plugin"}), encoding="utf-8")
-        result = _read_manifest_info(d, "")
-        assert result is not None
-        assert result[0] == "my-plugin"
-
-
-# ---------------------------------------------------------------------------
-# _discover_all_plugins — recursive discovery
-# ---------------------------------------------------------------------------
-
-
-class TestDiscoverAllPlugins:
-    @patch("hermes_cli.plugins.get_bundled_plugins_dir")
-    @patch("hermes_cli.plugins_cmd._plugins_dir")
-    def test_flat_plugins_still_discovered(self, mock_user_dir, mock_bundled_dir, tmp_path):
-        from hermes_cli.plugins_cmd import _discover_all_plugins
-
-        _make_plugin_dir(tmp_path, "disk-cleanup", {
-            "name": "disk-cleanup", "version": "1.0.0"
-        })
-        mock_user_dir.return_value = tmp_path
-        mock_bundled_dir.return_value = tmp_path / "nonexistent"
-
-        entries = _discover_all_plugins()
-        keys = [e[5] for e in entries]
-        assert "disk-cleanup" in keys
-
-    @patch("hermes_cli.plugins.get_bundled_plugins_dir")
-    @patch("hermes_cli.plugins_cmd._plugins_dir")
-    def test_category_plugins_discovered(self, mock_user_dir, mock_bundled_dir, tmp_path):
-        from hermes_cli.plugins_cmd import _discover_all_plugins
-
-        _make_category_plugin(tmp_path, "web", "tavily", {
-            "name": "web-tavily", "version": "1.0.0"
-        })
-        _make_category_plugin(tmp_path, "image_gen", "openai", {
-            "name": "image-gen-openai", "version": "2.0.0"
-        })
-        mock_user_dir.return_value = tmp_path
-        mock_bundled_dir.return_value = tmp_path / "nonexistent"
-
-        entries = _discover_all_plugins()
-        keys = [e[5] for e in entries]
-        assert "web/tavily" in keys
-        assert "image_gen/openai" in keys
-
-    @patch("hermes_cli.plugins.get_bundled_plugins_dir")
-    @patch("hermes_cli.plugins_cmd._plugins_dir")
-    def test_mixed_flat_and_category(self, mock_user_dir, mock_bundled_dir, tmp_path):
-        from hermes_cli.plugins_cmd import _discover_all_plugins
-
-        _make_plugin_dir(tmp_path, "disk-cleanup", {
-            "name": "disk-cleanup", "version": "1.0.0"
-        })
-        _make_category_plugin(tmp_path, "web", "tavily", {
-            "name": "web-tavily", "version": "1.0.0"
-        })
-        _make_category_plugin(tmp_path, "web", "exa", {
-            "name": "web-exa", "version": "1.0.0"
-        })
-        mock_user_dir.return_value = tmp_path
-        mock_bundled_dir.return_value = tmp_path / "nonexistent"
-
-        entries = _discover_all_plugins()
-        keys = [e[5] for e in entries]
-        assert "disk-cleanup" in keys
-        assert "web/tavily" in keys
-        assert "web/exa" in keys
-        assert len(entries) == 3
-
-    @patch("hermes_cli.plugins.get_bundled_plugins_dir")
-    @patch("hermes_cli.plugins_cmd._plugins_dir")
-    def test_depth_cap_at_two(self, mock_user_dir, mock_bundled_dir, tmp_path):
-        """Plugins nested 3 levels deep should NOT be discovered."""
-        from hermes_cli.plugins_cmd import _discover_all_plugins
-
-        # 2 levels: should be found
-        _make_category_plugin(tmp_path, "web", "tavily", {
-            "name": "web-tavily", "version": "1.0.0"
-        })
-        # 3 levels: should NOT be found
-        deep = tmp_path / "a" / "b" / "c"
-        deep.mkdir(parents=True)
-        import yaml
-        (deep / "plugin.yaml").write_text(
-            yaml.dump({"name": "too-deep"}), encoding="utf-8"
-        )
-        mock_user_dir.return_value = tmp_path
-        mock_bundled_dir.return_value = tmp_path / "nonexistent"
-
-        entries = _discover_all_plugins()
-        keys = [e[5] for e in entries]
-        assert "web/tavily" in keys
-        assert "a/b/c" not in keys
-
-    @patch("hermes_cli.plugins.get_bundled_plugins_dir")
-    @patch("hermes_cli.plugins_cmd._plugins_dir")
-    def test_tuple_has_six_elements(self, mock_user_dir, mock_bundled_dir, tmp_path):
-        from hermes_cli.plugins_cmd import _discover_all_plugins
-
-        _make_category_plugin(tmp_path, "web", "tavily", {
-            "name": "web-tavily", "version": "1.0.0", "description": "search"
-        })
-        mock_user_dir.return_value = tmp_path
-        mock_bundled_dir.return_value = tmp_path / "nonexistent"
-
-        entries = _discover_all_plugins()
-        assert len(entries) == 1
-        entry = entries[0]
-        assert len(entry) == 6
-        name, version, description, source, dir_path, key = entry
-        assert name == "web-tavily"
-        assert key == "web/tavily"
-        assert source == "user"
-
-    @patch("hermes_cli.plugins.get_bundled_plugins_dir")
-    @patch("hermes_cli.plugins_cmd._plugins_dir")
-    def test_user_overrides_bundled_on_key_collision(self, mock_user_dir, mock_bundled_dir, tmp_path):
-        """User plugin with same key as bundled should win."""
-        from hermes_cli.plugins_cmd import _discover_all_plugins
-
-        # Simulate a bundled plugin
-        bundled_dir = tmp_path / "bundled"
-        bundled_dir.mkdir()
-        _make_plugin_dir(bundled_dir, "my-plugin", {
-            "name": "my-plugin", "version": "1.0.0"
-        })
-        # User plugin with same key
-        _make_plugin_dir(tmp_path, "my-plugin", {
-            "name": "my-plugin", "version": "2.0.0"
-        })
-        mock_user_dir.return_value = tmp_path
-        mock_bundled_dir.return_value = bundled_dir
-
-        entries = _discover_all_plugins()
-        keys = [e[5] for e in entries]
-        assert keys.count("my-plugin") == 1
-        # User version should win
-        entry = [e for e in entries if e[5] == "my-plugin"][0]
-        assert entry[1] == "2.0.0"
-
-
-# ---------------------------------------------------------------------------
-# _plugin_status — key-aware status
-# ---------------------------------------------------------------------------
-
-
-class TestPluginStatus:
-    def test_name_in_enabled(self):
-        from hermes_cli.plugins_cmd import _plugin_status
-        assert _plugin_status("my-plugin", {"my-plugin"}, set()) == "enabled"
-
-    def test_key_in_enabled(self):
-        from hermes_cli.plugins_cmd import _plugin_status
-        assert _plugin_status("web-tavily", {"web/tavily"}, set(), key="web/tavily") == "enabled"
-
-    def test_name_in_disabled(self):
-        from hermes_cli.plugins_cmd import _plugin_status
-        assert _plugin_status("my-plugin", set(), {"my-plugin"}) == "disabled"
-
-    def test_key_in_disabled(self):
-        from hermes_cli.plugins_cmd import _plugin_status
-        assert _plugin_status("web-tavily", set(), {"web/tavily"}, key="web/tavily") == "disabled"
-
-    def test_neither_name_nor_key(self):
-        from hermes_cli.plugins_cmd import _plugin_status
-        assert _plugin_status("unknown", {"other"}, set(), key="cat/unknown") == "not enabled"
-
-    def test_disabled_takes_precedence_over_enabled(self):
-        from hermes_cli.plugins_cmd import _plugin_status
-        assert _plugin_status("my-plugin", {"my-plugin"}, {"my-plugin"}) == "disabled"
-
-    def test_key_disabled_takes_precedence(self):
-        from hermes_cli.plugins_cmd import _plugin_status
-        assert _plugin_status("web-tavily", {"web/tavily"}, {"web/tavily"}, key="web/tavily") == "disabled"
-
-
-# ---------------------------------------------------------------------------
-# Integration: _filter_plugin_entries with category plugins
-# ---------------------------------------------------------------------------
-
-
-class TestFilterPluginEntries:
-    def test_enabled_filter_uses_key(self):
-        from hermes_cli.plugins_cmd import _filter_plugin_entries
-
-        entries = [
-            ("web-tavily", "1.0.0", "search", "user", Path("/tmp"), "web/tavily"),
-            ("disk-cleanup", "1.0.0", "cleanup", "bundled", Path("/tmp"), "disk-cleanup"),
-        ]
-        args = MagicMock()
-        args.no_bundled = False
-        args.user = False
-        args.enabled = True
-
-        result = _filter_plugin_entries(entries, args, {"web/tavily"}, set())
-        assert len(result) == 1
-        assert result[0][5] == "web/tavily"
-
-    def test_enabled_filter_by_name_still_works(self):
-        from hermes_cli.plugins_cmd import _filter_plugin_entries
-
-        entries = [
-            ("disk-cleanup", "1.0.0", "cleanup", "bundled", Path("/tmp"), "disk-cleanup"),
-        ]
-        args = MagicMock()
-        args.no_bundled = False
-        args.user = False
-        args.enabled = True
-
-        result = _filter_plugin_entries(entries, args, {"disk-cleanup"}, set())
-        assert len(result) == 1
-
-
-# ---------------------------------------------------------------------------
-# Integration: cmd_list JSON output includes category plugins
-# ---------------------------------------------------------------------------
-
-
-class TestCmdListJson:
-    @patch("hermes_cli.plugins.get_bundled_plugins_dir")
-    @patch("hermes_cli.plugins_cmd._plugins_dir")
-    def test_json_output_includes_category_plugins(self, mock_user_dir, mock_bundled_dir, tmp_path, capsys):
-        from hermes_cli.plugins_cmd import cmd_list
-
-        _make_category_plugin(tmp_path, "web", "tavily", {
-            "name": "web-tavily", "version": "1.0.0", "description": "search"
-        })
-        _make_plugin_dir(tmp_path, "disk-cleanup", {
-            "name": "disk-cleanup", "version": "2.0.0", "description": "cleanup"
-        })
-        mock_user_dir.return_value = tmp_path
-        mock_bundled_dir.return_value = tmp_path / "nonexistent"
-
-        args = MagicMock()
-        args.json = True
-        args.plain = False
-        args.no_bundled = False
-        args.user = False
-        args.enabled = False
-
-        cmd_list(args)
-        captured = capsys.readouterr()
-        payload = json.loads(captured.out)
-        names = [p["name"] for p in payload]
-        assert "web-tavily" in names
-        assert "disk-cleanup" in names
-
-    @patch("hermes_cli.plugins.get_bundled_plugins_dir")
-    @patch("hermes_cli.plugins_cmd._plugins_dir")
-    def test_json_status_uses_key(self, mock_user_dir, mock_bundled_dir, tmp_path, capsys):
-        from hermes_cli.plugins_cmd import cmd_list
-
-        _make_category_plugin(tmp_path, "web", "tavily", {
-            "name": "web-tavily", "version": "1.0.0"
-        })
-        mock_user_dir.return_value = tmp_path
-        mock_bundled_dir.return_value = tmp_path / "nonexistent"
-
-        # Patch config to return web/tavily as enabled
-        with patch("hermes_cli.plugins_cmd._get_enabled_set", return_value={"web/tavily"}):
-            args = MagicMock()
-            args.json = True
-            args.plain = False
-            args.no_bundled = False
-            args.user = False
-            args.enabled = False
-
-            cmd_list(args)
-            captured = capsys.readouterr()
-            payload = json.loads(captured.out)
-            assert len(payload) == 1
-            assert payload[0]["status"] == "enabled"

tests/hermes_cli/test_plugins_cmd_enable_disable_nested.py

@@ -1,193 +0,0 @@
-"""Tests for nested/alias-normalized enable & disable flows.
-
-Companion to test_plugins_cmd_category_discovery.py. That file covers the
-*listing* side of nested category plugins (issue #41066). These tests cover
-the *mutation* side: `hermes plugins enable/disable` must resolve a bare name
-OR a full path-derived key (e.g. `observability/nemo_relay`) to the canonical
-registry key and write THAT — the same string PluginManager gates on — so a
-nested bundled plugin can actually be toggled.
-"""
-
-import sys  # noqa: F401
-from pathlib import Path
-from unittest.mock import patch
-
-import pytest
-
-
-def _make_plugin_dir(parent: Path, name: str, manifest: dict) -> Path:
-    d = parent / name
-    d.mkdir(parents=True, exist_ok=True)
-    import yaml
-    (d / "plugin.yaml").write_text(yaml.dump(manifest), encoding="utf-8")
-    (d / "__init__.py").write_text("def register(ctx): pass\n", encoding="utf-8")
-    return d
-
-
-def _make_category_plugin(parent: Path, category: str, name: str, manifest: dict) -> Path:
-    return _make_plugin_dir(parent / category, name, manifest)
-
-
-@pytest.fixture
-def nested_plugin_env(tmp_path):
-    """A user-plugins dir containing one nested and one flat plugin, with the
-    bundled dir pointed at an empty path. Returns the tmp_path."""
-    _make_category_plugin(tmp_path, "observability", "nemo_relay", {
-        "name": "nemo_relay", "version": "1.0.0", "description": "relay obs"
-    })
-    _make_plugin_dir(tmp_path, "disk-cleanup", {
-        "name": "disk-cleanup", "version": "1.0.0"
-    })
-    return tmp_path
-
-
-# ---------------------------------------------------------------------------
-# _resolve_plugin_key
-# ---------------------------------------------------------------------------
-
-
-class TestResolvePluginKey:
-    @patch("hermes_cli.plugins.get_bundled_plugins_dir")
-    @patch("hermes_cli.plugins_cmd._plugins_dir")
-    def test_full_key_resolves_to_itself(self, mock_user, mock_bundled, nested_plugin_env):
-        from hermes_cli.plugins_cmd import _resolve_plugin_key
-        mock_user.return_value = nested_plugin_env
-        mock_bundled.return_value = nested_plugin_env / "nonexistent"
-        assert _resolve_plugin_key("observability/nemo_relay") == "observability/nemo_relay"
-
-    @patch("hermes_cli.plugins.get_bundled_plugins_dir")
-    @patch("hermes_cli.plugins_cmd._plugins_dir")
-    def test_bare_leaf_name_resolves_to_key(self, mock_user, mock_bundled, nested_plugin_env):
-        from hermes_cli.plugins_cmd import _resolve_plugin_key
-        mock_user.return_value = nested_plugin_env
-        mock_bundled.return_value = nested_plugin_env / "nonexistent"
-        # "nemo_relay" (bare) must normalize to the path-derived key.
-        assert _resolve_plugin_key("nemo_relay") == "observability/nemo_relay"
-
-    @patch("hermes_cli.plugins.get_bundled_plugins_dir")
-    @patch("hermes_cli.plugins_cmd._plugins_dir")
-    def test_flat_plugin_resolves_to_name(self, mock_user, mock_bundled, nested_plugin_env):
-        from hermes_cli.plugins_cmd import _resolve_plugin_key
-        mock_user.return_value = nested_plugin_env
-        mock_bundled.return_value = nested_plugin_env / "nonexistent"
-        assert _resolve_plugin_key("disk-cleanup") == "disk-cleanup"
-
-    @patch("hermes_cli.plugins.get_bundled_plugins_dir")
-    @patch("hermes_cli.plugins_cmd._plugins_dir")
-    def test_unknown_returns_none(self, mock_user, mock_bundled, nested_plugin_env):
-        from hermes_cli.plugins_cmd import _resolve_plugin_key
-        mock_user.return_value = nested_plugin_env
-        mock_bundled.return_value = nested_plugin_env / "nonexistent"
-        assert _resolve_plugin_key("does-not-exist") is None
-
-    @patch("hermes_cli.plugins.get_bundled_plugins_dir")
-    @patch("hermes_cli.plugins_cmd._plugins_dir")
-    def test_ambiguous_leaf_name_returns_none(self, mock_user, mock_bundled, tmp_path):
-        """Same leaf name under two categories must NOT silently pick one."""
-        from hermes_cli.plugins_cmd import _resolve_plugin_key
-        _make_category_plugin(tmp_path, "image_gen", "openai", {"name": "image-gen-openai"})
-        _make_category_plugin(tmp_path, "model-providers", "openai", {"name": "mp-openai"})
-        mock_user.return_value = tmp_path
-        mock_bundled.return_value = tmp_path / "nonexistent"
-        # Bare "openai" is ambiguous -> None; the full key still resolves.
-        assert _resolve_plugin_key("openai") is None
-        assert _resolve_plugin_key("image_gen/openai") == "image_gen/openai"
-
-
-# ---------------------------------------------------------------------------
-# cmd_enable / cmd_disable — write the canonical key
-# ---------------------------------------------------------------------------
-
-
-class TestEnableDisableNested:
-    @patch("hermes_cli.plugins.get_bundled_plugins_dir")
-    @patch("hermes_cli.plugins_cmd._plugins_dir")
-    @patch("hermes_cli.plugins_cmd._save_disabled_set")
-    @patch("hermes_cli.plugins_cmd._save_enabled_set")
-    @patch("hermes_cli.plugins_cmd._get_disabled_set", return_value=set())
-    @patch("hermes_cli.plugins_cmd._get_enabled_set", return_value=set())
-    def test_enable_bare_name_writes_key(
-        self, mock_en, mock_dis, mock_save_en, mock_save_dis,
-        mock_user, mock_bundled, nested_plugin_env,
-    ):
-        from hermes_cli.plugins_cmd import cmd_enable
-        mock_user.return_value = nested_plugin_env
-        mock_bundled.return_value = nested_plugin_env / "nonexistent"
-
-        cmd_enable("nemo_relay")  # bare name
-
-        saved = mock_save_en.call_args[0][0]
-        # The canonical key — NOT the bare name — must be persisted, because
-        # that is what PluginManager matches when deciding to load.
-        assert "observability/nemo_relay" in saved
-        assert "nemo_relay" not in saved or "observability/nemo_relay" in saved
-
-    @patch("hermes_cli.plugins.get_bundled_plugins_dir")
-    @patch("hermes_cli.plugins_cmd._plugins_dir")
-    @patch("hermes_cli.plugins_cmd._save_disabled_set")
-    @patch("hermes_cli.plugins_cmd._save_enabled_set")
-    @patch("hermes_cli.plugins_cmd._get_disabled_set", return_value=set())
-    @patch("hermes_cli.plugins_cmd._get_enabled_set", return_value=set())
-    def test_enable_full_key_writes_key(
-        self, mock_en, mock_dis, mock_save_en, mock_save_dis,
-        mock_user, mock_bundled, nested_plugin_env,
-    ):
-        from hermes_cli.plugins_cmd import cmd_enable
-        mock_user.return_value = nested_plugin_env
-        mock_bundled.return_value = nested_plugin_env / "nonexistent"
-
-        cmd_enable("observability/nemo_relay")
-        saved = mock_save_en.call_args[0][0]
-        assert "observability/nemo_relay" in saved
-
-    @patch("hermes_cli.plugins.get_bundled_plugins_dir")
-    @patch("hermes_cli.plugins_cmd._plugins_dir")
-    @patch("hermes_cli.plugins_cmd._save_disabled_set")
-    @patch("hermes_cli.plugins_cmd._save_enabled_set")
-    @patch("hermes_cli.plugins_cmd._get_disabled_set", return_value=set())
-    @patch("hermes_cli.plugins_cmd._get_enabled_set", return_value=set())
-    def test_disable_bare_name_writes_key_and_clears_alias(
-        self, mock_en, mock_dis, mock_save_en, mock_save_dis,
-        mock_user, mock_bundled, nested_plugin_env,
-    ):
-        from hermes_cli.plugins_cmd import cmd_disable
-        mock_user.return_value = nested_plugin_env
-        mock_bundled.return_value = nested_plugin_env / "nonexistent"
-        # Simulate an existing config where the plugin was enabled under the
-        # legacy bare name — disabling must clear that too, or the plugin would
-        # keep loading (PluginManager accepts the bare name as well).
-        mock_en.return_value = {"nemo_relay"}
-
-        cmd_disable("nemo_relay")
-        saved_dis = mock_save_dis.call_args[0][0]
-        saved_en = mock_save_en.call_args[0][0]
-        assert "observability/nemo_relay" in saved_dis
-        assert "nemo_relay" not in saved_en  # stale bare alias dropped
-
-    @patch("hermes_cli.plugins.get_bundled_plugins_dir")
-    @patch("hermes_cli.plugins_cmd._plugins_dir")
-    def test_enable_unknown_plugin_exits(self, mock_user, mock_bundled, nested_plugin_env):
-        from hermes_cli.plugins_cmd import cmd_enable
-        mock_user.return_value = nested_plugin_env
-        mock_bundled.return_value = nested_plugin_env / "nonexistent"
-        with pytest.raises(SystemExit):
-            cmd_enable("does-not-exist")
-
-    @patch("hermes_cli.plugins.get_bundled_plugins_dir")
-    @patch("hermes_cli.plugins_cmd._plugins_dir")
-    @patch("hermes_cli.plugins_cmd._save_disabled_set")
-    @patch("hermes_cli.plugins_cmd._save_enabled_set")
-    @patch("hermes_cli.plugins_cmd._get_disabled_set", return_value=set())
-    @patch("hermes_cli.plugins_cmd._get_enabled_set", return_value=set())
-    def test_enable_flat_plugin_unchanged(
-        self, mock_en, mock_dis, mock_save_en, mock_save_dis,
-        mock_user, mock_bundled, nested_plugin_env,
-    ):
-        """Flat plugins keep writing their bare name (key == name) — no regression."""
-        from hermes_cli.plugins_cmd import cmd_enable
-        mock_user.return_value = nested_plugin_env
-        mock_bundled.return_value = nested_plugin_env / "nonexistent"
-
-        cmd_enable("disk-cleanup")
-        saved = mock_save_en.call_args[0][0]
-        assert "disk-cleanup" in saved

tests/hermes_cli/test_plugins_cmd_list.py

@@ -18,9 +18,9 @@ def _args(**kwargs):
 
 def test_filter_plugin_entries_enabled_only():
     entries = [
-        ("disk-cleanup", "2.0.0", "Bundled", "bundled", None, "disk-cleanup"),
-        ("web-search-plus", "2.2.0", "Search", "git", None, "web-search-plus"),
-        ("old-plugin", "1.0.0", "Old", "user", None, "old-plugin"),
+        ("disk-cleanup", "2.0.0", "Bundled", "bundled", None),
+        ("web-search-plus", "2.2.0", "Search", "git", None),
+        ("old-plugin", "1.0.0", "Old", "user", None),
     ]
 
     filtered = plugins_cmd._filter_plugin_entries(
@@ -35,9 +35,9 @@ def test_filter_plugin_entries_enabled_only():
 
 def test_filter_plugin_entries_no_bundled():
     entries = [
-        ("disk-cleanup", "2.0.0", "Bundled", "bundled", None, "disk-cleanup"),
-        ("drawthings-grpc", "0.3.0", "Draw Things", "user", None, "drawthings-grpc"),
-        ("web-search-plus", "2.2.0", "Search", "git", None, "web-search-plus"),
+        ("disk-cleanup", "2.0.0", "Bundled", "bundled", None),
+        ("drawthings-grpc", "0.3.0", "Draw Things", "user", None),
+        ("web-search-plus", "2.2.0", "Search", "git", None),
     ]
 
     filtered = plugins_cmd._filter_plugin_entries(
@@ -52,8 +52,8 @@ def test_filter_plugin_entries_no_bundled():
 
 def test_cmd_list_plain_compact_output(monkeypatch, capsys):
     entries = [
-        ("disk-cleanup", "2.0.0", "Bundled", "bundled", None, "disk-cleanup"),
-        ("web-search-plus", "2.2.0", "Search", "git", None, "web-search-plus"),
+        ("disk-cleanup", "2.0.0", "Bundled", "bundled", None),
+        ("web-search-plus", "2.2.0", "Search", "git", None),
     ]
     monkeypatch.setattr(plugins_cmd, "_discover_all_plugins", lambda: entries)
     monkeypatch.setattr(plugins_cmd, "_get_enabled_set", lambda: {"web-search-plus"})
@@ -69,7 +69,7 @@ def test_cmd_list_plain_compact_output(monkeypatch, capsys):
 
 
 def test_cmd_list_json_output(monkeypatch, capsys):
-    entries = [("web-search-plus", "2.2.0", "Search", "git", None, "web-search-plus")]
+    entries = [("web-search-plus", "2.2.0", "Search", "git", None)]
     monkeypatch.setattr(plugins_cmd, "_discover_all_plugins", lambda: entries)
     monkeypatch.setattr(plugins_cmd, "_get_enabled_set", lambda: {"web-search-plus"})
     monkeypatch.setattr(plugins_cmd, "_get_disabled_set", lambda: set())

tests/hermes_cli/test_pty_bridge.py

@@ -8,7 +8,6 @@ from __future__ import annotations
 
 import os
 import shutil
-import signal
 import sys
 import time
 
@@ -212,75 +211,6 @@ class TestPtyBridgeClose:
                 break
         assert reaped, f"pid {pid} still running after close()"
 
-    def test_close_signals_child_process_group(self, monkeypatch):
-        sent: list[tuple[int, signal.Signals]] = []
-
-        class _FakeProc:
-            pid = 12345
-            fd = -1
-
-            def __init__(self):
-                self.alive = True
-
-            def isalive(self):
-                return self.alive
-
-            def kill(self, sig):
-                raise AssertionError(f"single-process kill used: {sig}")
-
-            def close(self, force=False):
-                self.closed = force
-
-        fake = _FakeProc()
-
-        def fake_killpg(pgid, sig):
-            sent.append((pgid, sig))
-            fake.alive = False
-
-        monkeypatch.setattr(os, "getpgid", lambda pid: 67890)
-        monkeypatch.setattr(os, "killpg", fake_killpg)
-
-        bridge = PtyBridge.__new__(PtyBridge)
-        bridge._proc = fake
-        bridge._fd = -1
-        bridge._closed = False
-
-        bridge.close()
-
-        assert sent == [(67890, signal.SIGHUP)]
-        assert bridge._closed is True
-
-    def test_close_falls_back_to_single_process_signal_when_group_unknown(self, monkeypatch):
-        sent: list[signal.Signals] = []
-
-        class _FakeProc:
-            pid = 12345
-            fd = -1
-
-            def __init__(self):
-                self.alive = True
-
-            def isalive(self):
-                return self.alive
-
-            def kill(self, sig):
-                sent.append(sig)
-                self.alive = False
-
-            def close(self, force=False):
-                self.closed = force
-
-        monkeypatch.setattr(os, "getpgid", lambda pid: (_ for _ in ()).throw(OSError()))
-
-        bridge = PtyBridge.__new__(PtyBridge)
-        bridge._proc = _FakeProc()
-        bridge._fd = -1
-        bridge._closed = False
-
-        bridge.close()
-
-        assert sent == [signal.SIGHUP]
-
 
 @skip_on_windows
 class TestPtyBridgeEnv:

tests/hermes_cli/test_resolve_provider_openrouter_pool.py

@@ -1,76 +0,0 @@
-"""Regression tests for issue #42130.
-
-A credential added via `hermes auth add openrouter` lives in the credential
-pool, NOT as an OPENROUTER_API_KEY env var. Before the fix, resolve_provider()
-auto-detection only checked env vars, so such a credential was invisible:
-the provider failed to resolve (AuthError) or resolved without a key, and
-requests went out with no Authorization header — OpenRouter's
-"HTTP 401: Missing Authentication header".
-
-These tests lock in that auto-detection consults the OpenRouter pool.
-"""
-
-import uuid
-
-import pytest
-
-
-@pytest.fixture(autouse=True)
-def _clean_inference_env(monkeypatch):
-    """Strip credential-shaped env vars so the pool is the only source."""
-    for key in (
-        "OPENROUTER_API_KEY",
-        "OPENAI_API_KEY",
-        "ANTHROPIC_API_KEY",
-        "ANTHROPIC_TOKEN",
-        "CLAUDE_CODE_OAUTH_TOKEN",
-        "NOUS_API_KEY",
-        "HERMES_INFERENCE_PROVIDER",
-    ):
-        monkeypatch.delenv(key, raising=False)
-
-
-def _seed_openrouter_pool(token: str = "sk-or-FAKEKEY123") -> None:
-    """Mimic `hermes auth add openrouter <token>` — a manual pool entry."""
-    from agent.credential_pool import (
-        AUTH_TYPE_API_KEY,
-        SOURCE_MANUAL,
-        PooledCredential,
-        load_pool,
-    )
-
-    pool = load_pool("openrouter")
-    pool.add_entry(
-        PooledCredential(
-            provider="openrouter",
-            id=uuid.uuid4().hex[:6],
-            label="api-key-1",
-            auth_type=AUTH_TYPE_API_KEY,
-            priority=0,
-            source=SOURCE_MANUAL,
-            access_token=token,
-            base_url="https://openrouter.ai/api/v1",
-        )
-    )
-
-
-def test_auto_detects_openrouter_from_pool(tmp_path, monkeypatch):
-    """With only a pool credential (no env var), auto-detection finds it."""
-    monkeypatch.setenv("HERMES_HOME", str(tmp_path / "hermes"))
-    (tmp_path / "hermes").mkdir(parents=True, exist_ok=True)
-    _seed_openrouter_pool()
-
-    from hermes_cli.auth import resolve_provider
-
-    assert resolve_provider("auto") == "openrouter"
-
-
-def test_no_credentials_still_raises(tmp_path, monkeypatch):
-    """Empty pool + no env var must still fail to resolve — no false positive."""
-    monkeypatch.setenv("HERMES_HOME", str(tmp_path / "hermes"))
-    (tmp_path / "hermes").mkdir(parents=True, exist_ok=True)
-
-    from hermes_cli.auth import AuthError, resolve_provider
-
-    with pytest.raises(AuthError):
-        resolve_provider("auto")

tests/hermes_cli/test_setup_ollama_cloud_force_refresh.py

@@ -9,13 +9,10 @@ from __future__ import annotations
 
 def test_setup_ollama_cloud_passes_force_refresh(monkeypatch):
     """The provider-setup model-fetch for ollama-cloud must pass ``force_refresh=True``."""
-    # The ollama-cloud branch lives in ``_model_flow_api_key_provider``, which was
-    # extracted from main.py into hermes_cli/model_setup_flows.py (god-file
-    # decomposition Phase 2). Inspect the module the code now lives in.
-    import hermes_cli.model_setup_flows as flows_mod
+    import hermes_cli.main as main_mod
     import inspect
 
-    src = inspect.getsource(flows_mod)
+    src = inspect.getsource(main_mod)
 
     # Locate the ollama-cloud branch in the provider setup flow.
     marker = 'provider_id == "ollama-cloud"'