diff --git a/.github/scripts/run-workspace-checks.mjs b/.github/scripts/run-workspace-checks.mjs
index eabc479877..0daa01d246 100644
--- a/.github/scripts/run-workspace-checks.mjs
+++ b/.github/scripts/run-workspace-checks.mjs
@@ -133,7 +133,9 @@ async function main() {
   if (failed.length > 0) {
     for (const r of failed) console.error(`::error::${r.unit.pkg} :: ${r.unit.script} failed`)
     console.error(`::error::${failed.length} of ${results.length} checks failed`)
-    process.exit(1)
+    // Not process.exit(): it drops what stdout still buffers, which is the failing check's output.
+    process.exitCode = 1
+    return
   }
   console.log(`\nall ${results.length} checks passed`)
 }
diff --git a/.github/workflows/docker.yml b/.github/workflows/docker.yml
index b7882e7bda..3c131afce9 100644
--- a/.github/workflows/docker.yml
+++ b/.github/workflows/docker.yml
@@ -204,9 +204,10 @@ jobs:
       # ---------------------------------------------------------------------
       # The stamp above marks the checkout as a docker distribution, and PM
       # then expects the image's packaged runtime. The runner is not the
-      # image: drop it before provisioning the test toolchain.
-      - name: Remove the image install stamp from the checkout
-        run: rm -f install-stamp.json
+      # image: park the stamp while the test toolchain is provisioned, then
+      # put it back — tests/docker compares the image's provenance against it.
+      - name: Park the image install stamp while provisioning the runner toolchain
+        run: mv install-stamp.json "$RUNNER_TEMP/install-stamp.json"
 
       - name: Set up locked Python and test dependencies
         uses: ./.github/actions/setup-pm
@@ -214,6 +215,9 @@ jobs:
           extras: '["dev"]'
           prune-python-cache: true
 
+      - name: Restore the image install stamp for the docker tests
+        run: mv "$RUNNER_TEMP/install-stamp.json" install-stamp.json
+
       - name: Run docker integration tests
         env:
           # Skip rebuild; use the image already loaded by the build step.
diff --git a/agent/agent_init.py b/agent/agent_init.py
index 7c842f3620..b45914fe46 100644
--- a/agent/agent_init.py
+++ b/agent/agent_init.py
@@ -1910,6 +1910,11 @@ def _enforce_minimum_context(agent):
     # Reject windows below the 64K floor needed for reliable tool-calling; an explicit
     # positive model.context_length on LM Studio is allowed below the floor.
     _ctx = getattr(agent.context_compressor, "context_length", 0)
+    # A local Ollama server serves num_ctx, not the GGUF's advertised window: a Modelfile or
+    # model.ollama_num_ctx at 64K+ is a usable window even when the metadata says 40K (#100437).
+    # Only a local endpoint can honour num_ctx, so a stale override never admits a hosted model.
+    if agent._ollama_num_ctx and agent.base_url and is_local_endpoint(agent.base_url):
+        _ctx = max(_ctx or 0, agent._ollama_num_ctx)
     _allow_lmstudio_explicit_below_floor = (
         str(agent.provider or "").strip().lower() == "lmstudio"
         and isinstance(agent._config_context_length, int)
@@ -2036,6 +2041,9 @@ def _configure_ollama_num_ctx(agent, _model_cfg, _config_context_length):
             "Ollama num_ctx: will request %d tokens (model max from /api/show)",
             agent._ollama_num_ctx,
         )
+
+
+def _clamp_compressor_to_ollama_num_ctx(agent):
     # Recalibrate the compressor to the served window: every request runs at num_ctx, so a
     # trigger derived from the probed model window could sit above it and never fire.
     # A config that sets only model.ollama_num_ctx (without model.context_length) previously left the
@@ -2324,11 +2332,12 @@ def init_agent(
         agent, _agent_cfg, base_url
     )
     _build_context_engine(agent, _agent_cfg, cs, _custom_providers, _effective_context_length, session_db)
+    _configure_ollama_num_ctx(agent, _model_cfg, _config_context_length)
     _enforce_minimum_context(agent)
     _warn_nonagentic_hermes_model(agent)
     _inject_context_engine_tools(agent)
     _init_usage_state(agent)
-    _configure_ollama_num_ctx(agent, _model_cfg, _config_context_length)
+    _clamp_compressor_to_ollama_num_ctx(agent)
     _emit_compression_summary(agent, cs)
     _snapshot_primary_runtime(agent)
 
diff --git a/agent/agent_runtime_helpers.py b/agent/agent_runtime_helpers.py
index 02f298bcde..093c9d5338 100644
--- a/agent/agent_runtime_helpers.py
+++ b/agent/agent_runtime_helpers.py
@@ -2961,6 +2961,58 @@ def looks_like_codex_intermediate_ack(
     )
 
 
+# Degenerate-final detector (#103483): after real tool work a text stop whose ENTIRE answer is a
+# fragment — a stray wrong-script word ("пар" in an English conversation), a token starting
+# mid-punctuation ("?warming up") — is a provider-side collapse, not an answer, yet the loop
+# accepted it and the turn reported completed. Shape alone cannot PROVE a collapse, so this is
+# deliberately narrower than "short": a terse legitimate answer ("42", "SQLite", "report.csv",
+# "€12.50", "你好。", "Done.", ":8080", "да" to a Russian prompt) never matches, English-script
+# fragments ("the", "ing") are knowingly not covered, and the re-prompt it triggers asks for the
+# same answer again if it was complete. ``turn_finalizer._SENTENCE_END`` encodes a sibling
+# "≤ 24 chars, no terminal" heuristic for the finish explainer.
+_DEGENERATE_FINAL_MAX_CHARS = 24
+_SENTENCE_TERMINALS = (".", "!", "?", "\u3002", "\uff01", "\uff1f")
+# Punctuation no answer begins with when a letter follows ("?warming"); "$5", "#123", "-1",
+# "/tmp", ".env", "(a)", ":8080", ":)", ";;" all stay answers.
+_DEGENERATE_LEADING_PUNCT = "?!,;:)]}"
+
+
+def looks_like_degenerate_final(text: str, user_message: Any = None) -> bool:
+    """Whether a text stop reads as a collapsed fragment rather than a (terse) answer.
+
+    "Wrong script" is judged against the conversation: when the user's own message carries
+    non-ASCII letters, a terse non-Latin reply ("是", "Готово") is an answer, not a collapse.
+    """
+    t = (text or "").strip()
+    if not t or len(t) > _DEGENERATE_FINAL_MAX_CHARS or t.endswith(_SENTENCE_TERMINALS):
+        return False
+    if t[0] in _DEGENERATE_LEADING_PUNCT and len(t) > 1 and t[1].isalpha():
+        return True
+    if not any(ch.isalpha() for ch in t) or any(ch.isascii() and ch.isalnum() for ch in t):
+        return False
+    from agent.codex_responses_adapter import _summarize_user_message_for_log
+    user_text = _summarize_user_message_for_log(user_message) if user_message else ""
+    return not any(ch.isalpha() and not ch.isascii() for ch in user_text)
+
+
+def tool_results_this_turn(messages: List[Dict[str, Any]]) -> int:
+    """Tool-result rows after the most recent user row — whether the turn did real tool work.
+
+    ANY user row ends the window, the continuation nudges included: that is what bounds the
+    degenerate-final guard to one re-prompt per collapse. Skipping synthetic user rows here
+    would turn it into a two-nudge loop.
+    """
+    count = 0
+    for msg in reversed(messages or ()):
+        if not isinstance(msg, dict):
+            continue
+        if msg.get("role") == "user":
+            break
+        if msg.get("role") == "tool":
+            count += 1
+    return count
+
+
 # Narrow "trailing continue-intent" detector for the stall guard (agent.stall_guards): only the
 # message TAIL announcing a next action, so mid-sentence "I will" never trips it.
 _TRAILING_CONTINUE_INTENT_RE = re.compile(
diff --git a/agent/anthropic_credentials.py b/agent/anthropic_credentials.py
index 27de5c798e..f56651c774 100644
--- a/agent/anthropic_credentials.py
+++ b/agent/anthropic_credentials.py
@@ -17,6 +17,7 @@ import json
 import logging
 import os
 import platform
+import re
 import secrets
 import subprocess
 import threading
@@ -41,6 +42,10 @@ _OAUTH_TOKEN_URLS = [
 _OAUTH_TOKEN_USER_AGENT = "axios/1.7.9"
 _OAUTH_REDIRECT_URI = "https://console.anthropic.com/oauth/code/callback"
 _OAUTH_SCOPES = "org:create_api_key user:profile user:inference"
+# Claude Code's macOS Keychain entry (generic password). Hermes reads it
+# (_read_claude_code_credentials_from_keychain) and, since #98334, mirrors the
+# refresh write into it so the two stores stop diverging on a single-use rotation.
+_CLAUDE_CODE_KEYCHAIN_SERVICE = "Claude Code-credentials"
 
 
 def _getenv(name: str, default: str = "") -> str:
@@ -206,27 +211,103 @@ def _claude_oauth_record(data: Any, source: str) -> Optional[Dict[str, Any]]:
     }
 
 
-def _read_claude_code_credentials_from_keychain() -> Optional[Dict[str, Any]]:
-    """Read the "Claude Code-credentials" macOS Keychain entry (Claude Code >=2.1.114)."""
+_KEYCHAIN_ATTR = r'(?:0x(?P<hex>[0-9A-Fa-f]+)\b.*|"(?P<text>.*)")'
+
+
+def _decode_keychain_attr(match: Optional["re.Match[str]"]) -> str:
+    """``security`` prints an attribute as ``"text"`` when it is plain printable ASCII and as
+    ``0x<HEX>  "<octal-escaped echo>"`` otherwise; the quoted form is NOT escaped (an embedded
+    ``"`` appears raw), so the text group must run to the last quote on the line."""
+    if match is None:
+        return ""
+    if match.group("hex"):
+        try:
+            return bytes.fromhex(match.group("hex")).decode("utf-8")
+        except ValueError:
+            return ""
+    return match.group("text") or ""
+
+
+def _find_claude_code_keychain_item() -> Optional[tuple[str, Dict[str, Any]]]:
+    """``(account, payload)`` of the ``Claude Code-credentials`` login Keychain item, or None.
+
+    One ``find-generic-password -g`` call: attributes on stdout, ``password: …`` on stderr. The
+    account matters because ``add-generic-password -U`` matches on account AND service — writing
+    under another account would create a second item instead of updating the one Claude Code reads.
+    """
     if platform.system() != "Darwin":
         return None
     try:
         result = subprocess.run(
-            ["security", "find-generic-password", "-s", "Claude Code-credentials", "-w"],
+            ["security", "find-generic-password", "-s", _CLAUDE_CODE_KEYCHAIN_SERVICE, "-g"],
+            capture_output=True, text=True, encoding="utf-8", errors="replace", timeout=5, stdin=subprocess.DEVNULL,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    if result.returncode != 0:
+        return None
+    account = _decode_keychain_attr(re.search(r'^\s*"acct"<blob>=' + _KEYCHAIN_ATTR + r"\s*$", result.stdout, re.M))
+    raw = _decode_keychain_attr(re.search(r"^password: " + _KEYCHAIN_ATTR + r"\s*$", result.stderr, re.M))
+    if not account or not raw:
+        return None
+    try:
+        payload = json.loads(raw)
+    except ValueError:
+        return None
+    return (account, payload) if isinstance(payload, dict) else None
+
+
+def _read_claude_code_keychain_payload() -> Optional[Dict[str, Any]]:
+    """Raw ``{"claudeAiOauth": {...}, ...}`` payload from the macOS Keychain, or None.
+
+    Returns the full entry (not the normalised credential record) so a refresh
+    write can merge the rotated token triple over the existing metadata
+    (``subscriptionType`` / ``rateLimitTier`` / ``scopes``) instead of clobbering it.
+    """
+    if platform.system() != "Darwin":
+        return None
+    try:
+        result = subprocess.run(
+            ["security", "find-generic-password", "-s", _CLAUDE_CODE_KEYCHAIN_SERVICE, "-w"],
             capture_output=True, text=True, encoding='utf-8', errors='replace', timeout=5, stdin=subprocess.DEVNULL,
         )
     except (OSError, subprocess.TimeoutExpired):
         logger.debug("Keychain: security command not available or timed out")
         return None
     if result.returncode != 0:
-        logger.debug("Keychain: no entry found for 'Claude Code-credentials'")
+        logger.debug("Keychain: no entry found for %r", _CLAUDE_CODE_KEYCHAIN_SERVICE)
         return None
     raw = result.stdout.strip()
+    if not raw:
+        return None
     try:
-        return _claude_oauth_record(json.loads(raw), "macos_keychain") if raw else None
+        payload = json.loads(raw)
     except json.JSONDecodeError:
         logger.debug("Keychain: credentials payload is not valid JSON")
         return None
+    return payload if isinstance(payload, dict) else None
+
+
+def _keychain_mirror_command(account: str, payload: Dict[str, Any]) -> tuple[list[str], str]:
+    """``(argv, stdin)`` that updates the Claude Code Keychain item with ``payload``.
+
+    The command line goes to ``security -i`` on stdin, with the secret hex-encoded (``-X``):
+    a bare ``-w`` prompts twice on /dev/tty when a terminal exists (hangs the CLI) and, with
+    no terminal, reads only the first line and stores an EMPTY password when the confirmation
+    read hits EOF — either way the live token must never sit on argv.
+    """
+    def quoted(value: str) -> str:  # the ``security -i`` tokenizer: double quotes, backslash escapes
+        return '"' + value.replace("\\", "\\\\").replace('"', '\\"') + '"'
+
+    encoded = json.dumps(payload, separators=(",", ":"), ensure_ascii=True).encode("utf-8").hex()
+    line = f"add-generic-password -U -a {quoted(account)} -s {quoted(_CLAUDE_CODE_KEYCHAIN_SERVICE)} -X {encoded}\n"
+    return ["security", "-i"], line
+
+
+def _read_claude_code_credentials_from_keychain() -> Optional[Dict[str, Any]]:
+    """Read the "Claude Code-credentials" macOS Keychain entry (Claude Code >=2.1.114)."""
+    payload = _read_claude_code_keychain_payload()
+    return _claude_oauth_record(payload, "macos_keychain") if payload else None
 
 
 def claude_code_credentials_path() -> Path:
@@ -403,7 +484,10 @@ def _refresh_oauth_token(creds: Dict[str, Any]) -> Optional[str]:
             # The POST spent ``refresh_token``; this write is the commit step. On failure, fail closed and
             # mark the pre-rotation pair as spent.
             try:
-                _write_claude_code_credentials(refreshed["access_token"], refreshed["refresh_token"], refreshed["expires_at_ms"])
+                _write_claude_code_credentials(
+                    refreshed["access_token"], refreshed["refresh_token"], refreshed["expires_at_ms"],
+                    spent_refresh_token=refresh_token,
+                )
             except Exception as e:
                 logger.error(
                     "Anthropic OAuth refresh rotated the single-use token but could not "
@@ -425,7 +509,8 @@ def _refresh_oauth_token(creds: Dict[str, Any]) -> Optional[str]:
 
 
 def _write_claude_code_credentials(
-    access_token: str, refresh_token: str, expires_at_ms: int, *, scopes: Optional[list] = None
+    access_token: str, refresh_token: str, expires_at_ms: int, *, scopes: Optional[list] = None,
+    spent_refresh_token: str = "",
 ) -> None:
     """Commit refreshed credentials to ~/.claude/.credentials.json; ``CredentialPersistError`` on any failure (a
     corrupt existing file included). *scopes* (or the previously stored scopes) are persisted because Claude Code
@@ -443,6 +528,57 @@ def _write_claude_code_credentials(
         oauth_data["scopes"] = existing["claudeAiOauth"]["scopes"]
     existing["claudeAiOauth"] = oauth_data
     _commit_private_json(cred_path, existing, "credentials")
+    _mirror_claude_code_credentials_to_keychain(
+        access_token, refresh_token, expires_at_ms, spent_refresh_token=spent_refresh_token)
+
+
+def _merge_keychain_credential_payload(
+    existing_payload: Dict[str, Any], access_token: str, refresh_token: str, expires_at_ms: int
+) -> Dict[str, Any]:
+    """Rotate the ``claudeAiOauth`` token triple over the existing Keychain payload,
+    preserving its metadata (``subscriptionType`` / ``rateLimitTier`` / ``scopes``).
+
+    Pure and host-agnostic so the merge semantics are unit-testable without a Keychain.
+    """
+    merged = dict(existing_payload)
+    oauth = dict(existing_payload.get("claudeAiOauth") or {})
+    oauth.update({"accessToken": access_token, "refreshToken": refresh_token, "expiresAt": expires_at_ms})
+    merged["claudeAiOauth"] = oauth
+    return merged
+
+
+def _mirror_claude_code_credentials_to_keychain(
+    access_token: str, refresh_token: str, expires_at_ms: int, *, spent_refresh_token: str
+) -> None:
+    """After a Hermes refresh, write the rotated pair into the Claude Code Keychain item too (#98334).
+
+    Claude Code on macOS reads the login Keychain first. Refresh tokens are single-use, so a refresh
+    that only updates the file leaves the Keychain holding a spent token and Claude Code logs itself
+    out. Only the item that held the pair we just spent is updated — a different pair there means a
+    different login (``CLAUDE_CONFIG_DIR``) or a rotation Claude Code already made, and clobbering it
+    would be the bug in the other direction. Best-effort: never raises, never creates an item.
+    """
+    if platform.system() != "Darwin":
+        return
+    try:
+        item = _find_claude_code_keychain_item()
+        if item is None:
+            return
+        account, existing = item
+        oauth = existing.get("claudeAiOauth")
+        if not isinstance(oauth, dict) or oauth.get("refreshToken") != spent_refresh_token:
+            logger.debug("Keychain mirror skipped: item does not hold the pair that was just rotated")
+            return
+        argv, line = _keychain_mirror_command(
+            account, _merge_keychain_credential_payload(existing, access_token, refresh_token, expires_at_ms))
+        result = subprocess.run(
+            argv, input=line, capture_output=True, text=True, encoding="utf-8", errors="replace", timeout=10,
+        )
+    except Exception as e:  # the file commit already succeeded; a Keychain hiccup must not fail the rotation
+        logger.debug("Keychain mirror skipped (%s)", e)
+        return
+    if result.returncode != 0:
+        logger.debug("Keychain mirror failed (rc=%s): %s", result.returncode, (result.stderr or "").strip()[:200])
 
 
 # ── Resolution ──
diff --git a/agent/context_compressor.py b/agent/context_compressor.py
index e2750fc09d..6c03642e49 100644
--- a/agent/context_compressor.py
+++ b/agent/context_compressor.py
@@ -3771,15 +3771,15 @@ Write only the summary body. Do not include any preamble or prefix."""
         text = _content_text_for_contains(message.get("content")).strip()
         # Recovery nudges are scaffolding, not human turns; lazy import avoids an import cycle.
         from agent.conversation_loop import (
-            _CODEX_ACK_CONTINUATION_NUDGE, _CODEX_INCOMPLETE_NUDGE, _DROPPED_TOOLCALL_NUDGE_CONTENT,
-            _EMPTY_TOOL_RESPONSE_NUDGE, _LENGTH_CONTINUATION_DROPPED_TOOLS_PREFIX, _LENGTH_CONTINUATION_NETWORK_STUB,
-            _LENGTH_CONTINUATION_OUTPUT_LIMIT,
+            _CODEX_ACK_CONTINUATION_NUDGE, _CODEX_INCOMPLETE_NUDGE, _DEGENERATE_FINAL_NUDGE,
+            _DROPPED_TOOLCALL_NUDGE_CONTENT, _EMPTY_TOOL_RESPONSE_NUDGE, _LENGTH_CONTINUATION_DROPPED_TOOLS_PREFIX,
+            _LENGTH_CONTINUATION_NETWORK_STUB, _LENGTH_CONTINUATION_OUTPUT_LIMIT,
         )
         return text in {
             COMPRESSION_CONTINUATION_USER_CONTENT, _LEGACY_COMPRESSION_CONTINUATION_USER_CONTENT,
             MAX_ITERATIONS_SUMMARY_REQUEST, _CODEX_INCOMPLETE_NUDGE, _CODEX_ACK_CONTINUATION_NUDGE,
-            _DROPPED_TOOLCALL_NUDGE_CONTENT, _EMPTY_TOOL_RESPONSE_NUDGE, _LENGTH_CONTINUATION_NETWORK_STUB,
-            _LENGTH_CONTINUATION_OUTPUT_LIMIT,
+            _DEGENERATE_FINAL_NUDGE, _DROPPED_TOOLCALL_NUDGE_CONTENT, _EMPTY_TOOL_RESPONSE_NUDGE,
+            _LENGTH_CONTINUATION_NETWORK_STUB, _LENGTH_CONTINUATION_OUTPUT_LIMIT,
         } or text.startswith((
             _BACKGROUND_PROCESS_NOTIFICATION_PREFIX, TODO_INJECTION_HEADER + "\n", _LENGTH_CONTINUATION_DROPPED_TOOLS_PREFIX,
         ))
diff --git a/agent/conversation_loop.py b/agent/conversation_loop.py
index 4ce7008935..2343c74547 100644
--- a/agent/conversation_loop.py
+++ b/agent/conversation_loop.py
@@ -870,6 +870,14 @@ _CODEX_ACK_CONTINUATION_NUDGE = (
     "after completing the task.]"
 )
 
+# Re-prompt after a collapsed fragment ended a turn that had done real tool work (#103483). Asks
+# for the same answer again when it WAS complete, so a false positive costs one call, never the answer.
+_DEGENERATE_FINAL_NUDGE = (
+    "[System: Your previous message ended the turn with a fragment that is not a usable answer. "
+    "If the task is unfinished, continue it and then give the complete answer. If that fragment "
+    "WAS your complete answer, send it again exactly as before.]"
+)
+
 # Re-prompt for finish_reason="tool_calls" with empty tool_calls (an interrupt mid-retry can persist it).
 _DROPPED_TOOLCALL_NUDGE_CONTENT = (
     "Your previous turn indicated a tool call but none was included. Do not narrate a plan or "
diff --git a/agent/credential_pool.py b/agent/credential_pool.py
index ede5f7d0e1..4eee11c0e3 100644
--- a/agent/credential_pool.py
+++ b/agent/credential_pool.py
@@ -1372,7 +1372,7 @@ class CredentialPool(CredentialPoolAdminMixin, CredentialPoolModelCooldownMixin)
             from agent import anthropic_credentials as ac
             args = (refreshed["access_token"], refreshed["refresh_token"], refreshed["expires_at_ms"])
             if entry.source == "claude_code":
-                ac._write_claude_code_credentials(*args)
+                ac._write_claude_code_credentials(*args, spent_refresh_token=entry.refresh_token or "")
             else:
                 ac._write_hermes_oauth_credentials(*args)
         except Exception as wexc:
diff --git a/agent/lsp/__init__.py b/agent/lsp/__init__.py
index 933655b00f..7468e131ab 100644
--- a/agent/lsp/__init__.py
+++ b/agent/lsp/__init__.py
@@ -63,6 +63,20 @@ def get_service() -> Optional[LSPService]:
     return _active(_service)
 
 
+def release_workspace(path: str) -> int:
+    """Shut down the LSP clients serving ``path`` (a worktree about to be removed) in every started
+    service, without shutting down unrelated workspaces.  Never creates a service.  Returns the count."""
+    with _service_lock:
+        services = [svc for svc in (_service, *_services_by_home.values()) if svc is not None]
+    released = 0
+    for svc in services:
+        try:
+            released += svc.release_workspace(path)
+        except Exception as e:  # noqa: BLE001
+            logger.debug("LSP workspace release failed for %s: %s", path, e)
+    return released
+
+
 def shutdown_service() -> None:
     """Tear down every LSP service that was started.  Idempotent."""
     global _service
@@ -86,4 +100,4 @@ def _atexit_shutdown() -> None:
         logger.debug("atexit LSP shutdown failed: %s", e)
 
 
-__all__ = ["get_service", "shutdown_service", "LSPService"]
+__all__ = ["get_service", "release_workspace", "shutdown_service", "LSPService"]
diff --git a/agent/lsp/cli.py b/agent/lsp/cli.py
index bc03021ed5..6fcb2bd91e 100644
--- a/agent/lsp/cli.py
+++ b/agent/lsp/cli.py
@@ -56,20 +56,37 @@ def run_lsp_command(args: argparse.Namespace) -> int:
         return 130
 
 
+def _all_servers() -> list:
+    """Config-declared servers (``lsp.servers.<id>.extensions``) ahead of the built-in registry."""
+    from agent.lsp.servers import SERVERS, custom_servers
+    from hermes_cli.config import load_config_readonly
+    try:
+        lsp_cfg = load_config_readonly().get("lsp") or {}
+    except Exception:  # noqa: BLE001 — a broken config still lists the built-ins
+        lsp_cfg = {}
+    return [*custom_servers(lsp_cfg.get("servers") if isinstance(lsp_cfg, dict) else None), *SERVERS]
+
+
 def _status_for(server_id: str) -> str:
+    import os
     from agent.lsp.install import detect_status
+    from agent.lsp.servers import SERVERS, ServerContext
+    custom = next((s for s in _all_servers() if s.server_id == server_id and s not in SERVERS), None)
+    if custom is not None:  # no install recipe: installed iff the configured command resolves
+        cwd = os.getcwd()
+        return "installed" if custom.build_spawn(cwd, ServerContext(cwd, install_strategy="manual")) else "manual-only"
     return detect_status(_recipe_pkg_for(server_id))
 
 
 def _cmd_status(emit_json: bool) -> int:
     from agent.lsp import get_service
-    from agent.lsp.servers import SERVERS
+    servers = _all_servers()
     svc = get_service()
     info = svc.get_status() if svc is not None else {"enabled": False}
     if emit_json:
         import json
         registry = [{"server_id": s.server_id, "extensions": list(s.extensions), "description": s.description,
-                     "binary_status": _status_for(s.server_id)} for s in SERVERS]
+                     "binary_status": _status_for(s.server_id)} for s in servers]
         sys.stdout.write(json.dumps({"service": info, "registry": registry}, indent=2) + "\n")
         return 0
 
@@ -91,7 +108,7 @@ def _cmd_status(emit_json: bool) -> int:
     if backend_warnings := _backend_warnings():
         out += ["", "Backend warnings", "================"] + [f"  ! {line}" for line in backend_warnings]
     out += ["", "Registered Servers", "=================="]
-    for s in SERVERS:
+    for s in servers:
         status = _status_for(s.server_id)
         ext_summary = ", ".join(list(s.extensions)[:5])
         if len(s.extensions) > 5:
@@ -104,8 +121,7 @@ def _cmd_status(emit_json: bool) -> int:
 
 
 def _cmd_list(installed_only: bool) -> int:
-    from agent.lsp.servers import SERVERS
-    for s in SERVERS:
+    for s in _all_servers():
         status = _status_for(s.server_id)
         if not (installed_only and status != "installed"):
             sys.stdout.write(f"{s.server_id:24s} [{status:11s}] {','.join(s.extensions)}\n")
diff --git a/agent/lsp/client.py b/agent/lsp/client.py
index ebc14cb682..eda3bc8b02 100644
--- a/agent/lsp/client.py
+++ b/agent/lsp/client.py
@@ -10,6 +10,7 @@ it), and ``ContentModified`` (-32801) errors are retried with exponential backof
 from __future__ import annotations
 
 import asyncio
+import contextlib
 import logging
 import os
 import sys
@@ -33,10 +34,15 @@ DIAGNOSTICS_DOCUMENT_WAIT = 5.0
 DIAGNOSTICS_FULL_WAIT = 10.0
 DIAGNOSTICS_REQUEST_TIMEOUT = 3.0
 PUSH_DEBOUNCE = 0.15
-SHUTDOWN_GRACE = 1.0  # seconds between SIGTERM and SIGKILL
+SHUTDOWN_GRACE = 1.0  # seconds after `exit` before SIGTERM, and between SIGTERM and SIGKILL
 # Retry policy for transient ContentModified errors: 0.5, 1.0, 2.0s.
 MAX_CONTENT_MODIFIED_RETRIES = 3
 RETRY_BASE_DELAY = 0.5
+# Cap on tracked documents: each _DocState pins the file's full text here AND the server mirrors
+# every open document, so an uncapped dict pins everything a long session ever touched on both
+# sides of the pipe until the idle reaper kills the whole client (#62950).  64 covers an active
+# edit loop's working set; evicted files are didClose'd and re-didOpen'ed on their next touch.
+MAX_TRACKED_FILES = 64
 
 _WRITE_ERRORS = (BrokenPipeError, ConnectionResetError, OSError)
 _LIVE_STATES = {"starting", "running"}
@@ -283,6 +289,16 @@ class LSPClient:
             "workspace/didChangeWorkspaceFolders", {"event": {"added": [_folder(root)], "removed": []}},
         )
 
+    async def remove_workspace_folder(self, root: str) -> None:
+        """Detach ``root`` from a running multi-root server (a removed worktree) so the process keeps
+        serving its sibling roots instead of being torn down with them.  Idempotent."""
+        if root not in self.workspace_folders:
+            return
+        self.workspace_folders.remove(root)
+        await self._send_notification(
+            "workspace/didChangeWorkspaceFolders", {"event": {"added": [], "removed": [_folder(root)]}},
+        )
+
     async def _initialize(self) -> None:
         params = {
             "rootUri": file_uri(self.workspace_root), "rootPath": self.workspace_root, "processId": os.getpid(),
@@ -299,7 +315,8 @@ class LSPClient:
             await self._send_notification("workspace/didChangeConfiguration", {"settings": self._init_options})
 
     async def shutdown(self) -> None:
-        """Best-effort graceful shutdown: ``shutdown`` + ``exit``, then SIGTERM/SIGKILL.  Idempotent."""
+        """Best-effort graceful shutdown: ``shutdown`` + ``exit``, wait ``SHUTDOWN_GRACE`` for the
+        server to honour ``exit``, then SIGTERM/SIGKILL.  Idempotent."""
         if self._stopping:
             return
         self._stopping = True
@@ -313,6 +330,11 @@ class LSPClient:
                     await self._send_notification("exit", None)
                 except Exception:  # noqa: BLE001
                     pass
+                # Signalling right after ``exit`` races the server's own exit: needless SIGTERM
+                # noise for well-behaved servers and, on Darwin, a reaped-and-reused PID target.
+                if (proc := self._proc) is not None and proc.returncode is None:
+                    with contextlib.suppress(asyncio.TimeoutError):
+                        await asyncio.wait_for(proc.wait(), timeout=SHUTDOWN_GRACE)
         finally:
             self._state = "stopped"
             await self._cleanup_process()
@@ -491,12 +513,16 @@ class LSPClient:
         )
         if doc is None:
             # Fresh state: anything a pre-open push stashed under this path (relatedDocuments spillover) is discarded.
+            self._docs.pop(abs_path, None)
             self._docs[abs_path] = _DocState(version=0, text=text)
             await self._send_notification(
                 "textDocument/didOpen",
                 {"textDocument": {"uri": uri, "languageId": language_id, "version": 0, "text": text}},
             )
+            await self._evict_lru_docs()
             return 0
+        # pop + reinsert refreshes LRU recency (dicts are insertion-ordered).
+        self._docs[abs_path] = self._docs.pop(abs_path)
         change: Dict[str, Any] = {"text": text}
         if self._sync_kind == 2:
             change["range"] = {"start": {"line": 0, "character": 0}, "end": _end_position(doc.text)}
@@ -513,6 +539,15 @@ class LSPClient:
         )
         return new_version
 
+    async def _evict_lru_docs(self) -> None:
+        """Drop least-recently-touched documents beyond MAX_TRACKED_FILES; didClose the ones the server
+        has open so it releases its mirror too (version -1 entries were never opened)."""
+        while len(self._docs) > MAX_TRACKED_FILES:
+            old_path, old = next(iter(self._docs.items()))
+            del self._docs[old_path]
+            if old.version >= 0:
+                await self._send_notification("textDocument/didClose", {"textDocument": {"uri": file_uri(old_path)}})
+
     async def save_file(self, path: str) -> None:
         """Send didSave for ``path``.  Some linters re-scan only on save."""
         if self.is_running:
diff --git a/agent/lsp/eventlog.py b/agent/lsp/eventlog.py
index 69d0b9f22a..ef9cad99c6 100644
--- a/agent/lsp/eventlog.py
+++ b/agent/lsp/eventlog.py
@@ -6,7 +6,9 @@ skipped, repeat "no project root" / "server unavailable"); INFO for once-per-ses
 transitions (first ``active for <root>``, first ``no project root`` per file) and every
 diagnostic event; WARNING for action-required failures (first ``server unavailable`` per
 (server_id, binary), every timeout / unexpected error).  Dedup uses module-level sets bounded
-by the distinct pairs touched in one process — a bounded LRU would re-fire suppressed lines.
+by the distinct pairs touched in one process, each capped at ``_ANNOUNCE_CAP`` keys: past it the
+bucket resets and the first-seen line re-fires once, so per-file keys can't grow for the life of
+a gateway process (#62950).
 """
 from __future__ import annotations
 
@@ -20,6 +22,7 @@ from typing import List, Tuple
 event_log = logging.getLogger("hermes.lint.lsp")
 
 _announce_lock = threading.Lock()
+_ANNOUNCE_CAP = 512
 _announced_active: set = set()        # keys: (server_id, workspace_root)
 _announced_unavailable: set = set()   # keys: (server_id, binary_path_or_name)
 _announced_no_root: set = set()       # keys: (server_id, file_path)
@@ -32,7 +35,9 @@ def _short_path(file_path: str) -> str:
         return file_path
     try:
         rel = os.path.relpath(file_path)
-    except ValueError:
+    except (ValueError, OSError):
+        # Different drive (ValueError) or the process cwd was removed (OSError from getcwd):
+        # a log-line shortener must never turn a delivered diagnostic into a swallowed error.
         return file_path
     return file_path if rel.startswith(".." + os.sep) or rel == ".." else rel
 
@@ -45,6 +50,8 @@ def _emit_once(bucket: set, key: Tuple, server_id: str, level: int, first: str,
     """Log *first* at *level* the first time *key* is seen, *repeat* at DEBUG thereafter."""
     with _announce_lock:
         is_first = key not in bucket
+        if is_first and len(bucket) >= _ANNOUNCE_CAP:
+            bucket.clear()
         bucket.add(key)
     _emit(server_id, level if is_first else logging.DEBUG, first if is_first else repeat)
 
@@ -116,6 +123,15 @@ def log_reaped(keys: List[Tuple[str, str]], idle_timeout: float) -> None:
     _emit("reaper", logging.INFO, f"reaped {len(keys)} idle client(s) after {idle_timeout:.0f}s: {summary}")
 
 
+def log_released(keys: List[Tuple[str, str]], reason: str) -> None:
+    """Clients were shut down because their workspace went away (worktree released or root deleted).
+    INFO, one line per event; forgets the ``log_active`` announcement like :func:`log_reaped`."""
+    with _announce_lock:
+        _announced_active.difference_update(keys)
+    summary = ", ".join(f"{sid} ({root})" for sid, root in keys)
+    _emit("reaper", logging.INFO, f"released {len(keys)} client(s) ({reason}): {summary}")
+
+
 def reset_announce_caches() -> None:
     """Test-only: clear the dedup caches.  Production code never calls this."""
     with _announce_lock:
diff --git a/agent/lsp/install.py b/agent/lsp/install.py
index 30913854ff..6710bf94c2 100644
--- a/agent/lsp/install.py
+++ b/agent/lsp/install.py
@@ -36,6 +36,10 @@ def _manual(bin_name: str) -> Dict[str, Any]:
     return _recipe("manual", "", bin_name)
 
 
+# TypeScript 7+ is the Go-native port and ships no ``lib/tsserver.js`` /
+# ``lib/typescript.js``, so JS-based servers cannot load it as their SDK.
+TYPESCRIPT_SDK_PKG = "typescript@6"
+
 # Recipe key → {strategy, pkg, bin[, extra_pkgs]}.  After install we look for
 # ``bin`` in ``<HERMES_HOME>/lsp/bin/`` first, then on PATH.  ``extra_pkgs``
 # are sibling npm packages a server needs in the same node_modules tree.
@@ -43,8 +47,12 @@ INSTALL_RECIPES: Dict[str, Dict[str, Any]] = {
     "pyright": _npm("pyright", "pyright-langserver"),
     # tsserver must be importable from the same node_modules tree or
     # initialize() fails with "Could not find a valid TypeScript installation".
-    "typescript-language-server": _npm("typescript-language-server", "typescript-language-server", extra_pkgs=["typescript"]),
-    "@vue/language-server": _npm("@vue/language-server", "vue-language-server"),
+    "typescript-language-server": _npm("typescript-language-server", "typescript-language-server", extra_pkgs=[TYPESCRIPT_SDK_PKG]),
+    # 3.x forwards every TypeScript request to a client-hosted tsserver
+    # (``tsserver/request`` tunnel) that a generic LSP client does not run, so
+    # it never publishes diagnostics; 2.x self-hosts TypeScript from
+    # ``initializationOptions.typescript.tsdk`` (see servers._spawn_vue).
+    "@vue/language-server": _npm("@vue/language-server@2", "vue-language-server", extra_pkgs=[TYPESCRIPT_SDK_PKG]),
     "svelte-language-server": _npm("svelte-language-server", "svelteserver"),
     "@astrojs/language-server": _npm("@astrojs/language-server", "astro-ls"),
     "yaml-language-server": _npm("yaml-language-server", "yaml-language-server"),
@@ -57,6 +65,8 @@ INSTALL_RECIPES: Dict[str, Dict[str, Any]] = {
     "rust-analyzer": _manual("rust-analyzer"),
     "clangd": _manual("clangd"),
     "lua-language-server": _manual("lua-language-server"),
+    # laravel-lsp ships via composer (`composer global require laravel/lsp`), not npm.
+    "laravel-lsp": _manual("laravel-lsp"),
     # PowerShellEditorServices is a release-zip bundle driven by pwsh; we probe
     # the host so `hermes lsp status` reports its presence.
     "powershell": _manual("pwsh"),
@@ -81,24 +91,40 @@ def hermes_lsp_bin_dir() -> Path:
     return p
 
 
-def _native_binary_candidates(base: Path) -> list[Path]:
-    """Return platform-native executable candidates for a staged binary (``base`` plus Windows wrappers)."""
-    if not _is_windows():
+def _native_binary_candidates(base: Path, *, is_windows: Optional[bool] = None) -> list[Path]:
+    """Return platform-native executable candidates for a staged binary, most runnable first.
+
+    On Windows the ``.cmd``/``.exe``/``.bat`` wrappers come BEFORE the bare name: npm writes a
+    POSIX ``#!/bin/sh`` shim under the bare name next to its ``.cmd``, ``os.access(X_OK)`` is
+    always true there, and ``CreateProcess`` on the shim fails with WinError 193.  The bare name
+    stays as a last resort for genuinely extension-less executables.
+    """
+    if not (_is_windows() if is_windows is None else is_windows):
         return [base]
     cands: Dict[str, Path] = {}
-    for c in (base, *(Path(str(base) + s) for s in _WINDOWS_WRAPPER_SUFFIXES)):
+    for c in (*(Path(str(base) + s) for s in _WINDOWS_WRAPPER_SUFFIXES), base):
         cands.setdefault(str(c).lower(), c)
     return list(cands.values())
 
 
-def _first_existing(*bases: Path) -> Optional[Path]:
+def _first_existing(*bases: Path, is_windows: Optional[bool] = None) -> Optional[Path]:
     """First platform-native candidate of any ``base`` that exists on disk."""
-    return next((c for base in bases for c in _native_binary_candidates(base) if c.exists()), None)
+    return next((c for base in bases for c in _native_binary_candidates(base, is_windows=is_windows) if c.exists()), None)
 
 
-def _existing_binary(name: str) -> Optional[str]:
-    """Probe the staging dir + PATH for a binary named ``name``."""
-    for staged in _native_binary_candidates(hermes_lsp_bin_dir() / name):
+def _npm_bin_dir() -> Path:
+    """npm's own ``node_modules/.bin`` under the staging tree, where its ``%~dp0``-relative wrappers work."""
+    return hermes_lsp_bin_dir().parent / "node_modules" / ".bin"
+
+
+def _existing_binary(name: str, *, is_windows: Optional[bool] = None) -> Optional[str]:
+    """Probe the staging dir (+ npm's bin dir on Windows) then PATH for a binary named ``name``.
+
+    ``is_windows`` overrides the host check so the Windows resolution is testable as data on every lane.
+    """
+    win = _is_windows() if is_windows is None else is_windows
+    bases = [hermes_lsp_bin_dir() / name] + ([_npm_bin_dir() / name] if win else [])
+    for staged in (c for base in bases for c in _native_binary_candidates(base, is_windows=win)):
         if staged.exists() and os.access(staged, os.X_OK):
             return str(staged)
     if any(r.get("strategy") == "pip" and r.get("bin") == name for r in INSTALL_RECIPES.values()):
@@ -111,7 +137,7 @@ def _existing_binary(name: str) -> Optional[str]:
         else:
             if binary is not None:
                 return str(binary)
-    suffixes = ("", *_WINDOWS_WRAPPER_SUFFIXES) if _is_windows() else ("",)
+    suffixes = (*_WINDOWS_WRAPPER_SUFFIXES, "") if win else ("",)
     return next((p for s in suffixes if (p := shutil.which(f"{name}{s}"))), None)
 
 
@@ -159,7 +185,9 @@ def _run_installer(tool: str, pkg: str, cmd: list, *, timeout: int, env: Optiona
             timeout=timeout, env=env, stdin=subprocess.DEVNULL, creationflags=windows_hide_flags(),
         )
         if proc.returncode != 0:
-            logger.warning("[install] %s install failed for %s: %s", tool, pkg, proc.stderr.strip()[:500])
+            # pnpm reports ERR_PNPM_* on stdout with an empty stderr; log whichever stream carries the reason.
+            detail = (proc.stderr.strip() or proc.stdout.strip())[:500]
+            logger.warning("[install] %s install failed for %s: %s", tool, pkg, detail)
             return False
     except (subprocess.TimeoutExpired, OSError) as e:
         logger.warning("[install] %s install errored for %s: %s", tool, pkg, e)
@@ -182,22 +210,58 @@ def _link_into_bin(target: Path) -> str:
     return str(link if link.exists() else target)
 
 
+# Node package manager → argv that installs into ``<staging>/node_modules`` (``lsp.package_manager``).
+# Every manager keeps the staging-dir semantics: nothing touches the user's project or global tree.
+_NODE_PM_ARGV: Dict[str, Callable[[str], list]] = {
+    "npm": lambda staging: ["install", "--prefix", staging, "--silent", "--no-fund", "--no-audit"],
+    "pnpm": lambda staging: ["add", "--dir", staging],
+    # Global ``--cwd`` (before the command) is accepted by both Yarn Classic and Yarn Berry; Berry's
+    # default PnP linker writes no ``node_modules/.bin``, so the staging dir needs ``nodeLinker: node-modules``.
+    "yarn": lambda staging: ["--cwd", staging, "add"],
+}
+
+
+def _node_package_manager() -> Optional[str]:
+    """``lsp.package_manager`` from config (npm default); an unknown value fails closed (``None``)."""
+    try:
+        from hermes_cli.config import load_config_readonly
+        lsp_cfg = load_config_readonly().get("lsp") or {}
+    except Exception:  # noqa: BLE001 — installer must not die on a broken config; npm is the historical default
+        return "npm"
+    pm = str(lsp_cfg.get("package_manager") or "npm").strip().lower() if isinstance(lsp_cfg, dict) else "npm"
+    if pm not in _NODE_PM_ARGV:
+        # Fail closed: a typo must not silently bypass a pnpm/yarn supply-chain policy by running npm.
+        logger.warning("[install] lsp.package_manager=%r is not one of %s; skipping install", pm, sorted(_NODE_PM_ARGV))
+        return None
+    return pm
+
+
 def _install_npm(pkg: str, bin_name: str, extra_pkgs: Optional[list] = None) -> Optional[str]:
-    """``npm install --prefix <staging>`` then link ``node_modules/.bin/<bin_name>`` into ``lsp/bin/``."""
-    npm = find_node_executable("npm")
-    if npm is None:
-        logger.info("[install] cannot install %s: no usable npm found", pkg)
+    """Install with the configured Node package manager into ``<staging>`` and link
+    ``node_modules/.bin/<bin_name>`` into ``lsp/bin/``."""
+    pm = _node_package_manager()
+    if pm is None:
+        return None
+    # Managed Node first: $HERMES_HOME/node isn't on an arbitrary process's
+    # PATH, so a bare which() would miss the Node that Hermes installed.
+    pm_bin = find_node_executable(pm)
+    if pm_bin is None:
+        # Deliberately no silent fallback to npm: a pnpm/yarn choice is usually a supply-chain policy.
+        logger.warning("[install] cannot install %s: lsp.package_manager is %r but no usable %s was found "
+                       "(install it, or set lsp.package_manager: npm)", pkg, pm, pm)
         return None
     staging = hermes_lsp_bin_dir().parent  # <HERMES_HOME>/lsp/
     install_targets = [pkg] + list(extra_pkgs or [])
-    logger.info("[install] npm install --prefix %s %s", staging, " ".join(install_targets))
-    cmd = [npm, "install", "--prefix", str(staging), "--silent", "--no-fund", "--no-audit", *install_targets]
-    if not _run_installer("npm", pkg, cmd, timeout=300, env=with_hermes_node_path()):
+    cmd = [pm_bin, *_NODE_PM_ARGV[pm](str(staging)), *install_targets]
+    logger.info("[install] %s %s", pm, " ".join(cmd[1:]))
+    if not _run_installer(pm, pkg, cmd, timeout=300, env=with_hermes_node_path()):
         return None
     found = _first_existing(staging / "node_modules" / ".bin" / bin_name)
     if found is not None:
-        return _link_into_bin(found)
-    logger.warning("[install] npm install for %s succeeded but bin %s not found", pkg, bin_name)
+        # npm's Windows wrappers resolve their payload via ``%~dp0\..\<pkg>``, so a copy or symlink
+        # in ``lsp/bin/`` points at nothing; use them where npm put them (``_existing_binary`` probes there).
+        return str(found) if _is_windows() and found.suffix.lower() in (".cmd", ".bat") else _link_into_bin(found)
+    logger.warning("[install] %s install for %s succeeded but bin %s not found", pm, pkg, bin_name)
     return None
 
 
diff --git a/agent/lsp/manager.py b/agent/lsp/manager.py
index 60021afab8..754ae82031 100644
--- a/agent/lsp/manager.py
+++ b/agent/lsp/manager.py
@@ -20,12 +20,13 @@ from typing import Any, Callable, Dict, List, Optional, Tuple
 
 from agent.lsp import eventlog
 from agent.lsp.client import DIAGNOSTICS_DOCUMENT_WAIT, LSPClient, _diagnostic_key as _diag_key
-from agent.lsp.servers import ServerContext, ServerDef, find_server_for_file, language_id_for
+from agent.lsp.servers import SERVERS, ServerContext, ServerDef, custom_servers, find_server_for_file, language_id_for
 from agent.lsp.workspace import clear_cache, resolve_workspace_for_file
 
 logger = logging.getLogger("agent.lsp.manager")
 
 DEFAULT_IDLE_TIMEOUT = 600  # seconds; servers idle for >10min get reaped
+_DELTA_BASELINE_CAP = 256  # per-file pre-write snapshots; paths never written again would otherwise live forever (#62950)
 MIN_IDLE_TIMEOUT = 30  # floor for config values; must exceed any per-op wait budget
 
 _Key = Tuple[str, str]
@@ -103,6 +104,7 @@ class LSPService:
         init_overrides: Optional[Dict[str, Dict[str, Any]]] = None,
         disabled_servers: Optional[List[str]] = None,
         idle_timeout: float = DEFAULT_IDLE_TIMEOUT,
+        extra_servers: Optional[List[ServerDef]] = None,
     ) -> None:
         self._enabled = enabled
         self._wait_mode = wait_mode if wait_mode in {"document", "full"} else "document"
@@ -113,6 +115,7 @@ class LSPService:
         self._init_overrides = init_overrides or {}
         self._disabled_servers = set(disabled_servers or [])
         self._idle_timeout = idle_timeout
+        self._extra_servers: List[ServerDef] = list(extra_servers or [])
 
         self._loop = _BackgroundLoop()
         if self._enabled:
@@ -165,8 +168,18 @@ class LSPService:
                             if isinstance(c.get("initialization_options"), dict)},
             disabled_servers=[n for n, c in servers.items() if c.get("disabled")],
             idle_timeout=idle_timeout,
+            extra_servers=custom_servers(servers),
         )
 
+    def _server_for(self, file_path: str) -> Optional[ServerDef]:
+        """Config-declared servers first (they may claim an extension ahead of a built-in), then the registry."""
+        extra = find_server_for_file(file_path, self._extra_servers) if self._extra_servers else None
+        return extra or find_server_for_file(file_path)
+
+    def handles_extension(self, ext: str) -> bool:
+        """True iff a config-declared or built-in server claims ``ext`` (pre-write capture decision)."""
+        return any(ext.lower() in s.extensions for s in (*self._extra_servers, *SERVERS))
+
     # ---- public API ----
 
     def is_active(self) -> bool:
@@ -190,7 +203,7 @@ class LSPService:
     def enabled_for(self, file_path: str) -> bool:
         """True iff LSP should run for this file: registered non-disabled server, git workspace,
         and pair not broken (a failed server costs nothing until ``hermes lsp restart`` / exit)."""
-        srv = find_server_for_file(file_path) if self._enabled else None
+        srv = self._server_for(file_path) if self._enabled else None
         if srv is None or srv.server_id in self._disabled_servers:
             return False
         key = self._broken_key(srv, file_path)
@@ -202,14 +215,24 @@ class LSPService:
         if not self.enabled_for(file_path):
             return
         try:
-            # Outer budget must exceed the inner wait or a slow-but-alive server gets falsely marked broken.
-            t = max(8.0, self._wait_timeout + 3.0)
+            # Outer join budget must exceed the inner wait or a slow-but-alive server gets falsely
+            # marked broken; it is a ceiling only — the inner wait returns as soon as it completes.
+            t = max(DIAGNOSTICS_DOCUMENT_WAIT + 3.0, self._wait_timeout + 3.0)
             diags = self._loop.run(self._snapshot_async(file_path), timeout=t)
         except Exception as e:  # noqa: BLE001
             logger.debug("baseline snapshot failed for %s: %s", file_path, e)
             self._mark_broken_for_file(file_path, e)
             diags = []
-        self._delta_baseline[os.path.abspath(file_path)] = diags or []
+        self._set_delta_baseline(os.path.abspath(file_path), diags or [])
+
+    def _set_delta_baseline(self, abs_path: str, diags: _Diags) -> None:
+        """Store a baseline, refreshing recency (pop + reinsert) so eviction tracks write order.
+        Callers run on arbitrary threads; the multi-step mutation needs the lock (callers don't hold it)."""
+        with self._state_lock:
+            self._delta_baseline.pop(abs_path, None)
+            self._delta_baseline[abs_path] = diags
+            while len(self._delta_baseline) > _DELTA_BASELINE_CAP:
+                del self._delta_baseline[next(iter(self._delta_baseline))]
 
     def get_diagnostics_sync(
         self, file_path: str, *, delta: bool = True, timeout: Optional[float] = None,
@@ -224,7 +247,7 @@ class LSPService:
         """
         if not self.enabled_for(file_path):
             return []
-        server_id = find_server_for_file(file_path).server_id  # enabled_for guarantees a match
+        server_id = self._server_for(file_path).server_id  # enabled_for guarantees a match
         try:
             t = timeout if timeout is not None else self._wait_timeout + 2.0
             diags = self._loop.run(self._open_and_wait_async(file_path), timeout=t)
@@ -268,7 +291,7 @@ class LSPService:
         except Exception:  # noqa: BLE001
             fresh = []
         if fresh:
-            self._delta_baseline[abs_path] = fresh
+            self._set_delta_baseline(abs_path, fresh)
         return diags
 
     def _mark_broken_for_file(self, file_path: str, exc: BaseException) -> None:
@@ -276,7 +299,7 @@ class LSPService:
         The outer ``_loop.run`` timeout cancels the in-flight spawn before ``_get_or_spawn`` could record
         the failure; without this every later write would re-pay the full timeout.  Also kills any
         half-initialized client and logs the failure once."""
-        srv = find_server_for_file(file_path)
+        srv = self._server_for(file_path)
         key = self._broken_key(srv, file_path) if srv is not None else None
         if key is None:
             return
@@ -332,17 +355,18 @@ class LSPService:
         """Open + wait for FRESH diagnostics: ``[]`` = checked clean, ``None`` = no verdict in budget.
 
         Callers must not substitute stale data for either.  ``snapshot`` mode
-        (pre-write baseline) skips didSave and uses the default wait budget.
+        (pre-write baseline) skips didSave; both modes wait at most ``lsp.wait_timeout``.
         """
         client = await self._get_or_spawn(file_path)
         if client is None:
             return None
         try:
-            version = await client.open_file(file_path, language_id=language_id_for(file_path))
+            srv = self._server_for(file_path)
+            version = await client.open_file(file_path, language_id=language_id_for(file_path, srv))
             if not snapshot:
                 await client.save_file(file_path)
             fresh = await client.wait_for_diagnostics(
-                file_path, version, mode=self._wait_mode, timeout=None if snapshot else self._wait_timeout,
+                file_path, version, mode=self._wait_mode, timeout=self._wait_timeout,
             )
         except Exception as e:  # noqa: BLE001
             if snapshot:
@@ -355,7 +379,7 @@ class LSPService:
 
     async def _current_diags_async(self, file_path: str) -> _Diags:
         ws, gated = resolve_workspace_for_file(file_path)
-        srv = find_server_for_file(file_path)
+        srv = self._server_for(file_path)
         if not (ws and gated and srv):
             return []
         # Same key _get_or_spawn() stored under: single-root servers live under their
@@ -368,7 +392,7 @@ class LSPService:
         return list(client.diagnostics_for(file_path, fresh_only=True)) if client else []
 
     async def _get_or_spawn(self, file_path: str) -> Optional[LSPClient]:
-        srv = find_server_for_file(file_path)
+        srv = self._server_for(file_path)
         if srv is None:
             return None
         if srv.server_id in self._disabled_servers:
@@ -481,6 +505,66 @@ class LSPService:
         if clients:
             eventlog.log_reaped([(c.server_id, c.workspace_root) for c in clients], self._idle_timeout)
             await asyncio.gather(*(client.shutdown() for client in clients), return_exceptions=True)
+        # Externally deleted project roots (rm -rf, a worktree removed by another process) never go
+        # idle from the server's point of view — tsserver keeps its multi-GiB heap for a tree that is gone.
+        await self._detach_roots(lambda folder: not os.path.isdir(folder), reason="workspace root deleted")
+
+    def release_workspace(self, workspace_root: str) -> int:
+        """Shut down the clients serving ``workspace_root`` or any root beneath it; returns how many.
+
+        Called by the worktree cleanup paths BEFORE ``git worktree remove`` so a gateway that outlives the
+        session does not keep the language server (and its stdio pipes) alive for a tree that no longer
+        exists.  Multi-root servers only drop the folder.  Idempotent; best-effort — never blocks removal.
+        """
+        if not self._enabled:
+            return 0
+        root = os.path.abspath(workspace_root)
+        try:
+            return self._loop.run(self._release_async(root), timeout=15.0)
+        except Exception as e:  # noqa: BLE001
+            logger.debug("LSP release of %s failed: %s", root, e)
+            return 0
+
+    async def _release_async(self, root: str) -> int:
+        def _under(path: str) -> bool:
+            return path == root or path.startswith(root + os.sep)
+
+        # A spawn in flight would insert its client AFTER we detach; let it land first (same loop, so
+        # once the future resolves the client is in ``_clients`` and the pass below sees it).
+        with self._state_lock:
+            pending = [fut for fut in self._spawning.values() if not fut.done()]
+            self._broken = {key for key in self._broken if not _under(key[1])}
+            for path in [p for p in self._delta_baseline if _under(p)]:
+                del self._delta_baseline[path]
+        if pending:
+            await asyncio.wait(pending, timeout=10.0)
+        released = await self._detach_roots(_under, reason="workspace released")
+        clear_cache()
+        return released
+
+    async def _detach_roots(self, is_gone: Callable[[str], bool], *, reason: str) -> int:
+        """Shared teardown primitive for :meth:`release_workspace` and the reaper.
+
+        Clients whose every workspace folder ``is_gone`` are detached under ``_state_lock`` and shut down;
+        multi-root clients that still serve other folders only drop the gone ones.  Returns the number of
+        clients shut down.
+        """
+        with self._state_lock:
+            dead_keys = [key for key, c in self._clients.items() if all(map(is_gone, c.workspace_folders))]
+            clients = [self._clients.pop(key) for key in dead_keys]
+            for key in dead_keys:
+                self._last_used.pop(key, None)
+            trims = [(c, [f for f in c.workspace_folders if is_gone(f)]) for c in self._clients.values()]
+        for client, folders in trims:
+            for folder in folders:
+                try:
+                    await client.remove_workspace_folder(folder)
+                except Exception as e:  # noqa: BLE001
+                    logger.debug("LSP folder removal for %s failed: %s", folder, e)
+        if clients:
+            eventlog.log_released([(c.server_id, c.workspace_root) for c in clients], reason)
+            await asyncio.gather(*(client.shutdown() for client in clients), return_exceptions=True)
+        return len(clients)
 
     async def _shutdown_async(self) -> None:
         if (reaper := self._idle_reaper_task) is not None:
diff --git a/agent/lsp/servers.py b/agent/lsp/servers.py
index 1bb93d8f75..32dc3b134a 100644
--- a/agent/lsp/servers.py
+++ b/agent/lsp/servers.py
@@ -34,7 +34,7 @@ _EXTS_BY_LANGUAGE: Dict[str, Sequence[str]] = {
     "csharp": (".cs", ".csx"), "fsharp": (".fs", ".fsi", ".fsx"),
     "swift": (".swift",), "java": (".java",), "kotlin": (".kt", ".kts"),
     "yaml": (".yaml", ".yml"), "json": (".json",), "jsonc": (".jsonc",),
-    "lua": (".lua",), "php": (".php",), "prisma": (".prisma",), "dart": (".dart",),
+    "lua": (".lua",), "php": (".php",), "blade": (".blade.php",), "prisma": (".prisma",), "dart": (".dart",),
     "ocaml": (".ml", ".mli"),
     "shellscript": (".sh", ".bash", ".zsh"),
     "terraform": (".tf", ".tfvars"),
@@ -75,6 +75,8 @@ class ServerDef:
     # Server handles ``workspace/didChangeWorkspaceFolders``: one process serves every project root
     # (git worktrees included) as extra workspaceFolders instead of one process per root.
     multi_root: bool = False
+    # didOpen languageId; "" = derive from LANGUAGE_BY_EXT (custom servers name theirs in config).
+    language_id: str = ""
 
     def matches(self, file_path: str) -> bool:
         return _file_ext_or_basename(file_path) in self.extensions
@@ -92,10 +94,16 @@ class ServerContext:
 
 # ---- helpers ----
 
+# Multi-part extensions that name a different language than their last segment: ``os.path.splitext``
+# would reduce ``home.blade.php`` to ``.php`` and hand Blade templates to the plain-PHP server.
+_COMPOUND_EXTS = (".blade.php",)
+
+
 def _file_ext_or_basename(path: str) -> str:
-    """Lower-cased extension, or the full basename for extensionless files (``Dockerfile``)."""
+    """Lower-cased extension (compound ones first), or the full basename for extensionless files (``Dockerfile``)."""
     base = os.path.basename(path)
-    return os.path.splitext(base)[1].lower() or base
+    lower = base.lower()
+    return next((c for c in _COMPOUND_EXTS if lower.endswith(c)), None) or os.path.splitext(base)[1].lower() or base
 
 
 def _which(*names: str) -> Optional[str]:
@@ -158,9 +166,11 @@ def _spawn_pyright(root: str, ctx: ServerContext) -> Optional[SpawnSpec]:
     bin_path = _find_binary(ctx, "pyright", ("pyright-langserver", "pyright"), "pyright")
     if bin_path is None:
         return None
-    # If we got the cli ``pyright``, the langserver is its sibling.
-    if os.path.basename(bin_path) in {"pyright", "pyright.exe"}:
-        sibling = os.path.join(os.path.dirname(bin_path), "pyright-langserver")
+    # If we got the cli ``pyright``, the langserver is its sibling — same suffix, since on Windows
+    # the bare sibling is npm's unrunnable POSIX shim.
+    stem, suffix = os.path.splitext(os.path.basename(bin_path))
+    if stem == "pyright":
+        sibling = os.path.join(os.path.dirname(bin_path), f"pyright-langserver{suffix}")
         if os.path.exists(sibling):
             bin_path = sibling
     # Point pyright at the project venv; its default "python on PATH" rarely is.
@@ -203,6 +213,67 @@ def _spawn_bash_ls(root: str, ctx: ServerContext) -> Optional[SpawnSpec]:
     return _make_spec(root, ctx, "bash-language-server", [bin_path, "start"])
 
 
+_VUE_REINSTALL = (
+    "delete <HERMES_HOME>/lsp/node_modules/@vue and <HERMES_HOME>/lsp/bin/vue-language-server*, "
+    "then run: hermes lsp install vue-language-server"
+)
+_VUE_TUNNEL_MSG = (
+    "vue-language-server: the installed @vue/language-server is 3.x, which only works behind a client-hosted "
+    f"tsserver tunnel Hermes does not run — no diagnostics will arrive. Reinstall the self-hosting 2.x line: {_VUE_REINSTALL}"
+)
+_VUE_TSDK_MSG = (
+    "vue-language-server: no JavaScript TypeScript SDK (typescript/lib/typescript.js) next to the server or under "
+    f"the project's node_modules — diagnostics are skipped. Reinstall (the recipe co-installs one): {_VUE_REINSTALL}"
+)
+
+
+def _node_modules_trees(bin_path: str, root: str) -> List[str]:
+    """``node_modules`` trees that may hold the Vue server and its TypeScript SDK:
+    the launcher's own tree (symlinks resolved), Hermes staging, then the project's."""
+    from agent.lsp.install import hermes_lsp_bin_dir
+    trees = [str(hermes_lsp_bin_dir().parent / "node_modules"), os.path.join(root, "node_modules")]
+    real = os.path.realpath(bin_path)
+    marker = f"{os.sep}node_modules{os.sep}"
+    if (idx := real.rfind(marker)) >= 0:
+        trees.insert(0, real[: idx + len(marker) - 1])
+    return trees
+
+
+def _vue_server_major(trees: Sequence[str]) -> int:
+    """Major version of the first ``@vue/language-server`` found in ``trees``; 0 when unreadable."""
+    import json
+    for tree in trees:
+        try:
+            with open(os.path.join(tree, "@vue", "language-server", "package.json"), encoding="utf-8") as fh:
+                return int(str(json.load(fh).get("version", "")).split(".")[0])
+        except (OSError, ValueError):
+            continue
+    return 0
+
+
+def _typescript_sdk_dir(trees: Sequence[str]) -> Optional[str]:
+    """First ``typescript/lib`` in ``trees`` holding a JS ``typescript.js`` (TypeScript 7+ ships none)."""
+    cands = (os.path.join(tree, "typescript", "lib") for tree in trees)
+    return next((c for c in cands if os.path.isfile(os.path.join(c, "typescript.js"))), None)
+
+
+def _spawn_vue(root: str, ctx: ServerContext) -> Optional[SpawnSpec]:
+    """Spawn @vue/language-server 2.x self-hosting TypeScript (``hybridMode`` off, explicit ``tsdk``)."""
+    bin_path = _find_binary(ctx, "vue-language-server", ("vue-language-server",), "@vue/language-server")
+    if bin_path is None:
+        return None
+    trees = _node_modules_trees(bin_path, root)
+    if _vue_server_major(trees) >= 3:
+        _warn_once("vue-tunnel", _VUE_TUNNEL_MSG)
+        return None
+    tsdk = _typescript_sdk_dir(trees)
+    if tsdk is None:
+        _warn_once("vue-tsdk", _VUE_TSDK_MSG)
+        return None
+    return _make_spec(root, ctx, "vue-language-server", [bin_path, "--stdio"],
+                      {"typescript": {"tsdk": tsdk}, "vue": {"hybridMode": False}})
+
+
 def _find_pses_bundle(ctx: ServerContext) -> Optional[str]:
     """Locate the PowerShellEditorServices bundle dir (release zip, manual install).  Resolution order:
     ``lsp.servers.powershell.command[0]`` when a directory, ``init_overrides["powershell"]["bundlePath"]``,
@@ -296,7 +367,7 @@ SERVERS: List[ServerDef] = [
             "JavaScript/TypeScript — typescript-language-server", resolve_root=_root_typescript,
             which=("typescript-language-server",), args=("--stdio",), install_pkg="typescript-language-server", seed=True),
     _server("vue-language-server", (".vue",), "Vue.js — @vue/language-server", resolve_root=_root_typescript,
-            args=("--stdio",), install_pkg="@vue/language-server"),
+            build_spawn=_spawn_vue),
     _server("svelte-language-server", (".svelte",), "Svelte — svelte-language-server", resolve_root=_root_typescript,
             which=("svelteserver", "svelte-language-server"), args=("--stdio",), install_pkg="svelte-language-server"),
     _server("astro-language-server", (".astro",), "Astro — @astrojs/language-server", resolve_root=_root_typescript,
@@ -312,6 +383,9 @@ SERVERS: List[ServerDef] = [
     _server("lua-language-server", (".lua",), "Lua — lua-language-server",
             markers=[".luarc.json", ".luarc.jsonc", ".luacheckrc", ".stylua.toml", "stylua.toml", "selene.toml", "selene.yml"],
             install_pkg="lua-language-server"),
+    # Before intelephense: Blade templates are Laravel's, plain .php stays with intelephense.
+    _server("laravel-lsp", (".blade.php",), "Laravel Blade — laravel-lsp (manual: composer global require laravel/lsp)",
+            markers=["artisan", "composer.json", "composer.lock"], args=("lsp",)),
     _server("intelephense", (".php",), "PHP — intelephense", markers=["composer.json", "composer.lock", ".php-version"],
             args=("--stdio",), install_pkg="intelephense", base_init={"telemetry": {"enabled": False}}),
     _server("ocaml-lsp", (".ml", ".mli"), "OCaml — ocaml-lsp", markers=["dune-project", "dune-workspace", ".merlin", "opam"],
@@ -348,14 +422,54 @@ SERVERS: List[ServerDef] = [
 ]
 
 
-def find_server_for_file(file_path: str) -> Optional[ServerDef]:
-    """Return the registry entry that handles ``file_path``, or None."""
-    return next((srv for srv in SERVERS if srv.matches(file_path)), None)
+def find_server_for_file(file_path: str, servers: Optional[Sequence[ServerDef]] = None) -> Optional[ServerDef]:
+    """Return the first entry of ``servers`` (default: the built-in registry) that handles ``file_path``."""
+    return next((srv for srv in (SERVERS if servers is None else servers) if srv.matches(file_path)), None)
 
 
-def language_id_for(path: str) -> str:
-    """Return the LSP languageId to send in didOpen for ``path``."""
+def language_id_for(path: str, srv: Optional[ServerDef] = None) -> str:
+    """Return the LSP languageId to send in didOpen for ``path`` (a custom server's own id wins)."""
+    if srv is not None and srv.language_id:
+        return srv.language_id
     return LANGUAGE_BY_EXT.get(_file_ext_or_basename(path), "plaintext")
 
 
-__all__ = ["ServerDef", "ServerContext", "SpawnSpec", "SERVERS", "find_server_for_file", "language_id_for", "LANGUAGE_BY_EXT"]
+def _custom_spawn(server_id: str, command: Sequence[str]) -> _SpawnFn:
+    """Spawn builder for a config-declared server: ``command[0]`` is a path or a PATH lookup, no auto-install."""
+    def build(root: str, ctx: ServerContext) -> Optional[SpawnSpec]:
+        bin_path = _which(os.path.expanduser(command[0]))
+        if bin_path is None:
+            _warn_once(f"custom:{server_id}", f"lsp.servers.{server_id}: command {command[0]!r} not found on PATH — server skipped")
+            return None
+        return _make_spec(root, ctx, server_id, [bin_path, *command[1:]])
+    return build
+
+
+def custom_servers(servers_cfg: Any) -> List[ServerDef]:
+    """``lsp.servers`` entries that declare ``extensions`` and name no built-in server are user-declared
+    servers (issue #100257).  They go AHEAD of the built-ins so a custom entry can claim an extension;
+    malformed entries are logged and skipped so one typo never disables the rest of the subsystem."""
+    if not isinstance(servers_cfg, dict):
+        return []
+    builtin = {s.server_id for s in SERVERS}
+    out: List[ServerDef] = []
+    for server_id, cfg in servers_cfg.items():
+        if server_id in builtin or not isinstance(cfg, dict) or "extensions" not in cfg:
+            continue
+        command, exts, markers = cfg.get("command"), cfg.get("extensions"), cfg.get("root_markers")
+        if not (isinstance(command, list) and command and all(isinstance(c, str) and c for c in command)
+                and isinstance(exts, list) and exts and all(isinstance(e, str) and e for e in exts)):
+            logger.warning("lsp.servers.%s: custom server needs command: [bin, ...args] and extensions: [.ext, ...] — ignored", server_id)
+            continue
+        out.append(ServerDef(
+            str(server_id), tuple(e.lower() if e.startswith(".") else e for e in exts),
+            _markers_root([str(m) for m in markers] if isinstance(markers, list) and markers else None),
+            _custom_spawn(str(server_id), command),
+            description=str(cfg.get("description") or f"{server_id} — custom (lsp.servers)"),
+            language_id=str(cfg.get("language_id") or ""),
+        ))
+    return out
+
+
+__all__ = ["ServerDef", "ServerContext", "SpawnSpec", "SERVERS", "custom_servers", "find_server_for_file",
+           "language_id_for", "LANGUAGE_BY_EXT"]
diff --git a/agent/lsp/workspace.py b/agent/lsp/workspace.py
index 799798cae6..b1115d5ec9 100644
--- a/agent/lsp/workspace.py
+++ b/agent/lsp/workspace.py
@@ -15,8 +15,10 @@ from typing import Iterable, Iterator, Optional, Tuple
 
 logger = logging.getLogger("agent.lsp.workspace")
 
-# Cache: start dir → (worktree_root, is_git) so repeated calls don't re-stat.  Cleared on shutdown.
+# Cache: start dir → (worktree_root, is_git) so repeated calls don't re-stat.  Cleared on shutdown; capped
+# because every distinct file dir a long gateway session touches lands here (#62950).
 _workspace_cache: dict = {}
+_WORKSPACE_CACHE_CAP = 512
 
 # Walk cap: the deepest reasonable monorepo is well under 64 levels; bounds a
 # pathological cwd or symlink cycle even though parent-equality normally stops us.
@@ -60,16 +62,18 @@ def find_git_worktree(start: str) -> Optional[str]:
     cached = _workspace_cache.get(str(start_path))
     if cached is not None:
         return cached[0]
+    resolved = None
     for cur in _walk_up(start_path):
         try:
             if (cur / ".git").exists():
                 resolved = str(cur)
-                _workspace_cache[str(start_path)] = (resolved, True)
-                return resolved
+                break
         except OSError:
             break  # permission error on a parent dir — bail out cleanly
-    _workspace_cache[str(start_path)] = (None, False)
-    return None
+    _workspace_cache[str(start_path)] = (resolved, resolved is not None)
+    if len(_workspace_cache) > _WORKSPACE_CACHE_CAP:
+        _workspace_cache.clear()  # a stat cache: resetting is a few re-stats, and one atomic op is thread-safe
+    return resolved
 
 
 def is_inside_workspace(path: str, workspace_root: str) -> bool:
@@ -133,7 +137,14 @@ def resolve_workspace_for_file(file_path: str, *, cwd: Optional[str] = None) ->
     """Return ``(workspace_root, gated_in)`` for a file.  The cwd's worktree wins when the file is
     inside it; otherwise the file's own worktree is the fallback anchor (monorepos / unrelated
     checkouts).  ``(None, False)`` when neither is in a git worktree."""
-    cwd_root = find_git_worktree(cwd or os.getcwd())
+    try:
+        cwd_anchor = cwd or os.getcwd()
+    except OSError:
+        # The process cwd was removed underneath us (a scratch workspace cleaned up at
+        # card completion); getcwd keeps raising even after the path is recreated, so
+        # there is simply no cwd anchor — fall through to the file's own worktree.
+        cwd_anchor = None
+    cwd_root = find_git_worktree(cwd_anchor) if cwd_anchor else None
     if cwd_root is not None and is_inside_workspace(file_path, cwd_root):
         return cwd_root, True
     file_root = find_git_worktree(file_path)
diff --git a/agent/turn_final_response.py b/agent/turn_final_response.py
index ecda17c965..af36bc717f 100644
--- a/agent/turn_final_response.py
+++ b/agent/turn_final_response.py
@@ -56,7 +56,8 @@ def finish_text_response(
     iteration-limit summarization; the final message is appended and flushed only after the
     stop gates accept it."""
     from agent.conversation_loop import (
-        _CODEX_ACK_CONTINUATION_NUDGE, _DROPPED_TOOLCALL_NUDGE_CONTENT, _join_truncated_parts
+        _CODEX_ACK_CONTINUATION_NUDGE, _DEGENERATE_FINAL_NUDGE, _DROPPED_TOOLCALL_NUDGE_CONTENT,
+        _join_truncated_parts
     )
 
     def _verdict(action: str, result: Optional[Dict[str, Any]] = None) -> FinalResponseVerdict:
@@ -142,7 +143,8 @@ def finish_text_response(
     # delivery channel (gateway status message / CLI print). NEVER appended to messages/api_messages:
     # conversation context and the cached prompt prefix stay byte-identical.
     from agent.agent_runtime_helpers import (
-        intent_ack_continuation_mode, promoted_reasoning_announces_action, trailing_continue_intent
+        intent_ack_continuation_mode, looks_like_degenerate_final, promoted_reasoning_announces_action,
+        tool_results_this_turn, trailing_continue_intent,
     )
 
     _ack_mode = intent_ack_continuation_mode(agent)
@@ -162,7 +164,23 @@ def finish_text_response(
             or (bool(_promoted) and promoted_reasoning_announces_action(_stall_text))
         )
     )
-    if _stall_continue_intent or (
+    # Degenerate-final guard (#103483): the turn did real tool work and then stopped on a
+    # fragment. Same scope knob and the SAME bounded counter as the ack continuation; the nudge
+    # row itself closes the tool-work window, so a second fragment ends the turn as the answer.
+    _tool_rows = tool_results_this_turn(messages)
+    _degenerate_final = (
+        bool(getattr(agent, "_stall_guards", True))
+        and _ack_mode != "off"
+        and codex_ack_continuations < 2
+        and _tool_rows > 0
+        and looks_like_degenerate_final(_stall_text, user_message=user_message)
+    )
+    # Precedence: an announced next action outranks the fragment shape; the codex ack is last.
+    if _stall_continue_intent:
+        _continuation_kind = "stall"
+    elif _degenerate_final:
+        _continuation_kind = "degenerate"
+    elif (
         _ack_mode != "off"
         and agent.valid_tool_names
         and codex_ack_continuations < 2
@@ -171,12 +189,22 @@ def finish_text_response(
             require_workspace=(_ack_mode == "codex_only"),
         )
     ):
-        if _stall_continue_intent:
+        _continuation_kind = "ack"
+    else:
+        _continuation_kind = None
+    if _continuation_kind:
+        if _continuation_kind == "stall":
             logger.info(
                 "Stall guard: turn ending on trailing continue-"
                 "intent with no tool calls — re-prompting to act "
                 "(%d/2)", codex_ack_continuations + 1,
             )
+        elif _continuation_kind == "degenerate":
+            logger.warning(
+                "Degenerate final: %d-char fragment %r ended the turn after %d tool result(s) — "
+                "re-prompting (%d/2)", len(_stall_text), _stall_text[:40], _tool_rows,
+                codex_ack_continuations + 1,
+            )
         codex_ack_continuations += 1
         interim_msg = agent._build_assistant_message(assistant_message, "incomplete")
         if _promoted:
@@ -185,7 +213,13 @@ def finish_text_response(
             interim_msg["api_content"] = final_response
         append_message(messages, interim_msg)
         agent._emit_interim_assistant_message(interim_msg)
-        append_message(messages, {"role": "user", "content": _CODEX_ACK_CONTINUATION_NUDGE})
+        append_message(messages, {
+            "role": "user",
+            "content": (
+                _DEGENERATE_FINAL_NUDGE if _continuation_kind == "degenerate"
+                else _CODEX_ACK_CONTINUATION_NUDGE
+            ),
+        })
         agent._session_messages = messages
         # An acknowledgment is non-final: its text must not suppress iteration-limit
         # summarization if the continuation exhausts budget.
diff --git a/apps/desktop/DESIGN.md b/apps/desktop/DESIGN.md
index b00c4eadc7..82c6aeb667 100644
--- a/apps/desktop/DESIGN.md
+++ b/apps/desktop/DESIGN.md
@@ -232,8 +232,7 @@ blurred backdrop.
   Empty lists hide their search field.
 - **`SegmentedControl`** — the choice control for small mutually-exclusive sets
   (color mode, tool-call display, usage period). Replaces radio piles and
-  pill rows. `iconOnly` renders compact icon buttons with label tooltips and
-  accessible names; use `codiconIcon()` for Codicon options.
+  pill rows.
 - **`Switch`** (`size="xs"`) — bare, with `aria-label`. No bordered text wrapper.
 - **`FanMenu`** (`src/components/ui/fan-menu.tsx`) — one hub control that
   fans sibling toggles out on hover: `direction` `vertical` | `horizontal`
diff --git a/apps/desktop/electron/main.ts b/apps/desktop/electron/main.ts
index 8aafaf431f..109d8f7370 100644
--- a/apps/desktop/electron/main.ts
+++ b/apps/desktop/electron/main.ts
@@ -6128,7 +6128,7 @@ async function showPluginCompatNoticeOnce() {
     })
 
     if (response === 0) {
-      handleDeepLink(`${HERMES_PROTOCOL}://open/skills?tab=plugins`)
+      handleDeepLink(`${HERMES_PROTOCOL}://open/capabilities?tab=plugins`)
     }
   } finally {
     try {
diff --git a/apps/desktop/src/api/client.ts b/apps/desktop/src/api/client.ts
index 3c55f20fcd..4ec63e9376 100644
--- a/apps/desktop/src/api/client.ts
+++ b/apps/desktop/src/api/client.ts
@@ -147,7 +147,7 @@ export function hermesApi<T>(request: HermesApiRequest): Promise<T> {
 //
 // A profile is not a machine-global name — it belongs to ONE gateway. The
 // Capabilities surface can be pointed at any (connection, profile) pair
-// (SkillsView's scope selector, Bot Mode's fixedProfile/fixedConnection), so
+// (CapabilitiesView's scope selector, Bot Mode's fixedProfile/fixedConnection), so
 // its REST helpers accept either the legacy string form or an explicit scope
 // object:
 //
diff --git a/apps/desktop/src/app/skills/index.test.tsx b/apps/desktop/src/app/capabilities/index.test.tsx
similarity index 57%
rename from apps/desktop/src/app/skills/index.test.tsx
rename to apps/desktop/src/app/capabilities/index.test.tsx
index a99f14dd13..e397d1e849 100644
--- a/apps/desktop/src/app/skills/index.test.tsx
+++ b/apps/desktop/src/app/capabilities/index.test.tsx
@@ -1,6 +1,6 @@
 // @vitest-environment jsdom
 import { QueryClientProvider } from '@tanstack/react-query'
-import { act, cleanup, fireEvent, render, screen, waitFor, within } from '@testing-library/react'
+import { act, cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react'
 import { MemoryRouter } from 'react-router'
 import type * as ReactRouterDom from 'react-router'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
@@ -9,10 +9,6 @@ import type * as HermesApi from '@/hermes'
 import { queryClient } from '@/lib/query-client'
 import type * as HubActions from '@/store/hub-actions'
 
-import { parseCatalog } from './catalog-data'
-import { SkillCatalog } from './skill-catalog'
-import { $catalogCardView } from './store'
-
 const getSkills = vi.fn()
 const getToolsets = vi.fn()
 const setSkillEnabled = vi.fn()
@@ -22,8 +18,9 @@ const selectToolsetProvider = vi.fn()
 const getUsageAnalytics = vi.fn()
 const getProfiles = vi.fn()
 const getSkillContent = vi.fn()
+const getOfficialSkills = vi.fn()
 
-// Partial mock: keep the real module (SkillsView pulls in @/store/profile,
+// Partial mock: keep the real module (CapabilitiesView pulls in @/store/profile,
 // whose import-time subscription calls setApiRequestProfile) and stub only the
 // calls we assert on. Args are forwarded so the per-profile scope arg is
 // observable.
@@ -38,7 +35,8 @@ vi.mock('@/hermes', async importOriginal => ({
   selectToolsetProvider: (toolset: string, provider: string) => selectToolsetProvider(toolset, provider),
   getUsageAnalytics: (days: number, profile?: null | string) => getUsageAnalytics(days, profile),
   getProfiles: () => getProfiles(),
-  getSkillContent: (name: string, profile?: null | string) => getSkillContent(name, profile)
+  getSkillContent: (name: string, profile?: null | string) => getSkillContent(name, profile),
+  getOfficialSkills: (profile?: null | string) => getOfficialSkills(profile)
 }))
 
 // Notifications hit nanostores/timers we don't care about here.
@@ -48,7 +46,7 @@ vi.mock('@/store/notifications', () => ({
 }))
 
 // The catalog Install button routes through the hub action pipeline — stub the
-// action entrypoint (real module kept: SkillsView reads $hubActions and the
+// action entrypoint (real module kept: CapabilitiesView reads $hubActions and the
 // query keys from it).
 vi.mock('@/store/hub-actions', async importOriginal => ({
   ...(await importOriginal<typeof HubActions>()),
@@ -67,7 +65,7 @@ vi.mock('react-router', async importOriginal => ({
 // Import at module scope (after the hoisted vi.mock calls) so the heavy
 // component-tree transform is paid during collection, not billed against the
 // first test's testTimeout — same flake class as messaging/index.test.tsx.
-const { SkillsView } = await import('./index')
+const { CapabilitiesView } = await import('./index')
 
 function toolset(overrides: Record<string, unknown> = {}) {
   return {
@@ -86,10 +84,10 @@ async function renderSkills() {
   let result: ReturnType<typeof render>
   await act(async () => {
     result = render(
-      // SkillsView reads skills/toolsets via useQuery, so it needs a provider.
+      // CapabilitiesView reads skills/toolsets via useQuery, so it needs a provider.
       <QueryClientProvider client={queryClient}>
-        <MemoryRouter initialEntries={['/skills?tab=toolsets']}>
-          <SkillsView />
+        <MemoryRouter initialEntries={['/capabilities?tab=toolsets']}>
+          <CapabilitiesView />
         </MemoryRouter>
       </QueryClientProvider>
     )
@@ -99,13 +97,12 @@ async function renderSkills() {
 }
 
 beforeEach(() => {
-  // Scope/install cases exercise the retained list layout; cards have dedicated coverage.
-  $catalogCardView.set(false)
   getSkills.mockResolvedValue([])
   getToolsets.mockResolvedValue([toolset()])
   setToolsetEnabled.mockResolvedValue({ ok: true, name: 'web', enabled: false })
   getToolsetConfig.mockResolvedValue({ has_category: true, active_provider: null, providers: [] })
   getUsageAnalytics.mockResolvedValue({ tools: [] })
+  getOfficialSkills.mockResolvedValue({ skills: [] })
   getSkillContent.mockResolvedValue({
     name: 'web-research',
     path: '/skills/web-research/SKILL.md',
@@ -119,17 +116,16 @@ beforeEach(() => {
 afterEach(() => {
   cleanup()
   vi.clearAllMocks()
-  vi.unstubAllGlobals()
   // Shared singleton client — drop cached skills/toolsets so each test refetches.
   queryClient.clear()
 })
 
-// SkillsView is a heavy module (import cost now paid at module scope above,
+// CapabilitiesView is a heavy module (import cost now paid at module scope above,
 // during collection) but the file still legitimately runs ~14s on CI runners —
 // right against the global 15s per-test budget, so slow runners cascade-fail
 // all 11 tests (2× in a row on PR #93612, plus a main run the same hour).
 // Give this file headroom; the tests are not slow individually.
-describe('SkillsView toolset management', { timeout: 60_000 }, () => {
+describe('CapabilitiesView toolset management', { timeout: 60_000 }, () => {
   it('renders a switch for each toolset and toggles it off', async () => {
     await renderSkills()
 
@@ -184,8 +180,8 @@ describe('SkillsView toolset management', { timeout: 60_000 }, () => {
     await act(async () => {
       render(
         <QueryClientProvider client={queryClient}>
-          <MemoryRouter initialEntries={['/skills?tab=toolsets']}>
-            <SkillsView />
+          <MemoryRouter initialEntries={['/capabilities?tab=toolsets']}>
+            <CapabilitiesView />
           </MemoryRouter>
         </QueryClientProvider>
       )
@@ -229,8 +225,8 @@ describe('SkillsView toolset management', { timeout: 60_000 }, () => {
     await act(async () => {
       render(
         <QueryClientProvider client={queryClient}>
-          <MemoryRouter initialEntries={['/skills?tab=skills']}>
-            <SkillsView />
+          <MemoryRouter initialEntries={['/capabilities?tab=skills']}>
+            <CapabilitiesView />
           </MemoryRouter>
         </QueryClientProvider>
       )
@@ -272,8 +268,8 @@ describe('SkillsView toolset management', { timeout: 60_000 }, () => {
     await act(async () => {
       render(
         <QueryClientProvider client={queryClient}>
-          <MemoryRouter initialEntries={['/skills?tab=skills']}>
-            <SkillsView />
+          <MemoryRouter initialEntries={['/capabilities?tab=skills']}>
+            <CapabilitiesView />
           </MemoryRouter>
         </QueryClientProvider>
       )
@@ -288,190 +284,65 @@ describe('SkillsView toolset management', { timeout: 60_000 }, () => {
     expect(await screen.findByText(/Deep research steps/)).toBeTruthy()
   })
 
-  it.each(['web-research', 'official/research/web-research'])(
-    'disables catalog installation when the installed list contains %s',
-    async installedName => {
-      const { installHubSkill } = await import('@/store/hub-actions')
-      queryClient.setQueryData(['public-catalog', 'skills'], parseCatalog('skills', [{
-        name: 'web-research',
-        identifier: 'official/research/web-research',
-        source: 'official',
-        category: 'research',
-        description: 'Research the web'
-      }]))
+  it('hub picker refuses to reinstall an already-installed skill', async () => {
+    const { notify } = await import('@/store/notifications')
+    const { EmbeddedHubPicker } = await import('./skills/embedded-hub-picker')
 
-      render(
-        <QueryClientProvider client={queryClient}>
-          <SkillCatalog installedNames={new Set([installedName])} profile="researcher" />
-        </QueryClientProvider>
-      )
+    render(<EmbeddedHubPicker installedNames={new Set(['web-research'])} profile={null} />)
 
-      fireEvent.click(screen.getByRole('button', { name: /^web-research/ }))
-      const installed = screen.getByRole('button', { name: 'Installed' })
-      expect((installed as HTMLButtonElement).disabled).toBe(true)
-      fireEvent.click(installed)
-      expect(installHubSkill).not.toHaveBeenCalled()
-    }
-  )
-
-  it.each([
-    {
-      source: 'github',
-      identifier: 'github:example/skills/research/community-research',
-      expectedIdentifier: 'github:example/skills/research/community-research'
-    },
-    {
-      source: 'clawhub',
-      identifier: 'community-research',
-      expectedIdentifier: 'clawhub/community-research'
-    },
-    {
-      source: 'clawhub',
-      identifier: 'clawhub/community-research',
-      expectedIdentifier: 'clawhub/community-research'
-    }
-  ])('installs $identifier with its source-qualified target in the pinned connection and profile', async ({ source, identifier, expectedIdentifier }) => {
-    const { installHubSkill } = await import('@/store/hub-actions')
-    const entry = {
-      name: 'community-research',
-      identifier,
-      source,
-      category: 'research',
-      description: 'Community research workflow'
-    }
-    queryClient.setQueryData(['public-catalog', 'skills'], parseCatalog('skills', [
-      { ...entry, name: 'other-skill', source: 'github', identifier: 'github:example/skills/other-skill' },
-      entry
-    ]))
+    // The picker is expanded by default — the hub iframe is live on mount.
+    expect(document.querySelector('iframe')).toBeTruthy()
 
     await act(async () => {
-      render(
-        <QueryClientProvider client={queryClient}>
-          <MemoryRouter initialEntries={['/skills']}>
-            <SkillsView embedded fixedConnection="homelab" fixedProfile="researcher" />
-          </MemoryRouter>
-        </QueryClientProvider>
+      window.dispatchEvent(
+        new MessageEvent('message', {
+          data: { type: 'hermes-skill-pick', name: 'web-research', identifier: 'web-research' },
+          origin: 'https://hermes-agent.nousresearch.com'
+        })
       )
     })
 
-    fireEvent.click(screen.getByRole('button', { name: 'Browse' }))
-    fireEvent.click(await screen.findByRole('button', { name: /^community-research/ }))
-    expect(screen.getByRole('heading', { name: entry.name })).toBeTruthy()
-    await act(async () => {
-      fireEvent.click(screen.getByRole('button', { name: 'Install' }))
-    })
-
-    expect(installHubSkill).toHaveBeenCalledExactlyOnceWith(expectedIdentifier, {
-      connectionId: 'homelab', profile: 'researcher'
-    })
-  })
-
-  it('keeps a pending install tied to its entry and scope when the pinned target changes', async () => {
-    const { installHubSkill } = await import('@/store/hub-actions')
-    const identifier = 'clawhub/community-research'
-    queryClient.setQueryData(['public-catalog', 'skills'], parseCatalog('skills', [
-      { name: 'community-research', identifier: 'community-research', source: 'clawhub' },
-      { name: 'other-skill', identifier: 'official/research/other-skill', source: 'optional' }
-    ]))
-    let finishFirst!: () => void
-    let finishSecond!: () => void
-    const firstInstall = new Promise<void>(resolve => { finishFirst = resolve })
-    const secondInstall = new Promise<void>(resolve => { finishSecond = resolve })
-    vi.mocked(installHubSkill)
-      .mockReturnValueOnce(firstInstall)
-      .mockReturnValueOnce(secondInstall)
-
-    const scopedView = (connectionId: string, profile: string) => (
-      <QueryClientProvider client={queryClient}>
-        <MemoryRouter initialEntries={['/skills']}>
-          <SkillsView embedded fixedConnection={connectionId} fixedProfile={profile} />
-        </MemoryRouter>
-      </QueryClientProvider>
+    // Refused with an informational toast, no install action spawned.
+    await waitFor(() =>
+      expect(vi.mocked(notify)).toHaveBeenCalledWith(
+        expect.objectContaining({ title: '"web-research" is already installed' })
+      )
     )
-    const view = render(scopedView('homelab', 'researcher'))
-    fireEvent.click(screen.getByRole('button', { name: 'Browse' }))
-    fireEvent.click(await screen.findByRole('button', { name: /^community-research/ }))
-    fireEvent.click(screen.getByRole('button', { name: 'Install' }))
-    const pending = screen.getByRole<HTMLButtonElement>('button', { name: 'Installing...' })
-    expect(pending.disabled).toBe(true)
-    expect(pending.querySelector('svg.animate-spin')).not.toBeNull()
-    fireEvent.click(pending)
-    expect(installHubSkill).toHaveBeenCalledExactlyOnceWith(identifier, {
-      connectionId: 'homelab', profile: 'researcher'
-    })
-
-    fireEvent.click(screen.getByRole('button', { name: /^other-skill/ }))
-    expect(screen.getByRole<HTMLButtonElement>('button', { name: 'Install' }).disabled).toBe(false)
-    fireEvent.click(screen.getByRole('button', { name: /^community-research/ }))
-    expect(screen.getByRole<HTMLButtonElement>('button', { name: 'Installing...' }).disabled).toBe(true)
-
-    view.rerender(scopedView('other-gateway', 'writer'))
-    fireEvent.click(await screen.findByRole('button', { name: /^community-research/ }))
-    const nextInstall = screen.getByRole<HTMLButtonElement>('button', { name: 'Install' })
-    expect(nextInstall.disabled).toBe(false)
-    fireEvent.click(nextInstall)
-    expect(installHubSkill).toHaveBeenNthCalledWith(2, identifier, {
-      connectionId: 'other-gateway', profile: 'writer'
-    })
-
-    await act(async () => {
-      finishFirst()
-      await firstInstall
-    })
-    expect(screen.getByRole<HTMLButtonElement>('button', { name: 'Installing...' }).disabled).toBe(true)
-    await act(async () => {
-      finishSecond()
-      await secondInstall
-    })
-    expect(screen.getByRole<HTMLButtonElement>('button', { name: 'Install' }).disabled).toBe(false)
-    expect(installHubSkill).toHaveBeenCalledTimes(2)
   })
 
-  it('loads the public catalog only on Browse and reuses it across skills and tools tab switches', async () => {
-    const fetchCatalog = vi.fn().mockResolvedValue({
-      ok: true,
-      json: async () => [{
-        name: 'catalog-research',
-        identifier: 'official/research/catalog-research',
-        source: 'official',
-        category: 'research',
-        description: 'Research from the public snapshot'
-      }]
-    })
-    vi.stubGlobal('fetch', fetchCatalog)
-
+  it('mounts the hub iframe lazily and keeps it (hidden) across tab switches', async () => {
+    // On a non-Skills tab the docs-site iframe must not exist at all — an
+    // eagerly mounted hub is exactly the Capabilities lag bug.
     await renderSkills() // ?tab=toolsets
     await screen.findByRole('switch', { name: 'Turn Web Search toolset off' })
-    expect(fetchCatalog).not.toHaveBeenCalled()
+    expect(document.querySelector('iframe')).toBeNull()
     cleanup()
 
+    // Embedded mode drives tabs through local state (the route hooks are
+    // mocked here), starting on Skills: the picker mounts with the tab.
     await act(async () => {
       render(
         <QueryClientProvider client={queryClient}>
-          <MemoryRouter initialEntries={['/skills']}>
-            <SkillsView embedded />
+          <MemoryRouter initialEntries={['/capabilities']}>
+            <CapabilitiesView embedded />
           </MemoryRouter>
         </QueryClientProvider>
       )
     })
 
-    expect(screen.queryByRole('heading', { name: 'catalog-research' })).toBeNull()
-    expect(fetchCatalog).not.toHaveBeenCalled()
-    fireEvent.click(screen.getByRole('button', { name: 'Browse' }))
-    expect(await screen.findByRole('heading', { name: 'catalog-research' })).toBeTruthy()
-    expect(fetchCatalog).toHaveBeenCalledTimes(1)
-    expect(fetchCatalog.mock.calls[0][0]).toMatch(/\/docs\/api\/skills\.json$/)
+    const iframe = document.querySelector('iframe')
+    expect(iframe).toBeTruthy()
+    expect(iframe!.closest('section')!.classList.contains('hidden')).toBe(false)
 
-    fireEvent.click(screen.getByRole('button', { name: 'Installed' }))
-    expect(screen.queryByRole('heading', { name: 'catalog-research' })).toBeNull()
-    fireEvent.click(screen.getByRole('button', { name: 'Browse' }))
-    expect(await screen.findByRole('heading', { name: 'catalog-research' })).toBeTruthy()
-    fireEvent.click(screen.getByRole('button', { name: /^Tools/ }))
-    await screen.findByRole('switch', { name: 'Turn Web Search toolset off' })
-    expect(screen.queryByRole('heading', { name: 'catalog-research' })).toBeNull()
-    fireEvent.click(screen.getByRole('button', { name: /^Skills/ }))
-    expect(await screen.findByRole('heading', { name: 'catalog-research' })).toBeTruthy()
-    expect(fetchCatalog).toHaveBeenCalledTimes(1)
+    // Switch to Tools → the iframe STAYS mounted (no docs-site reload on the
+    // next visit) but its section is fully hidden, so nothing from the hub
+    // can paint over the toolsets UI.
+    await act(async () => {
+      fireEvent.click(screen.getByRole('button', { name: /Tools/ }))
+    })
+    const kept = document.querySelector('iframe')
+    expect(kept).toBeTruthy()
+    expect(kept!.closest('section')!.classList.contains('hidden')).toBe(true)
   })
 
   it('shows a vision explainer that deep-links to Settings → Models', async () => {
@@ -510,8 +381,8 @@ describe('SkillsView toolset management', { timeout: 60_000 }, () => {
     await act(async () => {
       render(
         <QueryClientProvider client={queryClient}>
-          <MemoryRouter initialEntries={['/skills']}>
-            <SkillsView embedded fixedConnection="homelab" fixedProfile="inbox-bot" />
+          <MemoryRouter initialEntries={['/capabilities']}>
+            <CapabilitiesView embedded fixedConnection="homelab" fixedProfile="inbox-bot" />
           </MemoryRouter>
         </QueryClientProvider>
       )
@@ -574,8 +445,13 @@ describe('SkillsView toolset management', { timeout: 60_000 }, () => {
     }
   })
 
-  it('offers optional skills through Browse and guards installed skills using the scoped installed list', async () => {
+  it('lists the built-in optional-skills catalog with Install buttons that route through the hub pipeline', async () => {
+    // The full official catalog renders BELOW the installed list; each row
+    // carries an Install button (no toggle until installed) that routes
+    // through the standard hub action pipeline scoped to the Capabilities
+    // profile. Already-installed catalog entries are filtered out.
     const { installHubSkill } = await import('@/store/hub-actions')
+
     getSkills.mockResolvedValue([
       {
         name: 'web-research',
@@ -586,54 +462,62 @@ describe('SkillsView toolset management', { timeout: 60_000 }, () => {
         provenance: 'bundled'
       }
     ])
-    queryClient.setQueryData(['public-catalog', 'skills'], parseCatalog('skills', [
-      {
-        name: 'gif-search',
-        description: 'Search GIFs',
-        source: 'optional',
-        installIdentifier: 'official/gifs/gif-search',
-        category: 'gifs',
-        tags: ['gifs']
-      },
-      {
-        name: 'web-research',
-        description: 'Research the web',
-        source: 'optional',
-        identifier: 'official/research/web-research',
-        category: 'research'
-      }
-    ]))
+    getOfficialSkills.mockResolvedValue({
+      skills: [
+        {
+          name: 'gif-search',
+          description: 'Search GIFs',
+          identifier: 'official/gifs/gif-search',
+          category: 'gifs',
+          installed: false,
+          tags: ['gifs']
+        },
+        {
+          name: 'web-research',
+          description: 'already here under a different source',
+          identifier: 'official/research/web-research',
+          category: 'research',
+          installed: false,
+          tags: []
+        },
+        {
+          name: 'ascii-art',
+          description: 'ASCII art',
+          identifier: 'official/creative/ascii-art',
+          category: 'creative',
+          installed: true,
+          tags: []
+        }
+      ]
+    })
 
     await act(async () => {
       render(
         <QueryClientProvider client={queryClient}>
-          <MemoryRouter initialEntries={['/skills?tab=skills']}>
-            <SkillsView fixedProfile="researcher" />
+          <MemoryRouter initialEntries={['/capabilities?tab=skills']}>
+            <CapabilitiesView />
           </MemoryRouter>
         </QueryClientProvider>
       )
     })
 
-    expect(await screen.findByRole('switch', { name: 'web-research' })).toBeTruthy()
-    expect(screen.queryByRole('button', { name: /^gif-search/ })).toBeNull()
-    expect(screen.queryByRole('button', { name: 'Install' })).toBeNull()
-    fireEvent.click(screen.getByRole('button', { name: 'Browse' }))
-    fireEvent.click(await screen.findByRole('button', { name: /^web-research/ }))
+    // Catalog section header + the one genuinely-available row. Rows already
+    // installed (lock flag OR name collision with the installed list) are gone.
+    expect(await screen.findByText('Available to install')).toBeTruthy()
+    expect(await screen.findByText('gif-search')).toBeTruthy()
+    expect(screen.queryByText('ascii-art')).toBeNull()
 
-    // Browse keeps installed entries discoverable, but never reinstallable.
-    const detail = within(screen.getByRole('main'))
-    const installed = detail.getByRole<HTMLButtonElement>('button', { name: 'Installed' })
-    expect(installed.disabled).toBe(true)
-    fireEvent.click(installed)
-    expect(installHubSkill).not.toHaveBeenCalled()
-    fireEvent.click(screen.getByRole('button', { name: /^gif-search/ }))
-    expect(detail.getByRole('heading', { name: 'gif-search' })).toBeTruthy()
-    expect(screen.queryByRole('switch')).toBeNull()
+    // The installed skill still shows its toggle; the catalog row shows
+    // Install instead of a switch.
+    expect(screen.getByRole('switch', { name: 'web-research' })).toBeTruthy()
+    const install = screen.getByRole('button', { name: 'Install' })
 
     await act(async () => {
-      fireEvent.click(detail.getByRole('button', { name: 'Install' }))
+      fireEvent.click(install)
     })
 
-    expect(installHubSkill).toHaveBeenCalledExactlyOnceWith('official/gifs/gif-search', 'researcher')
+    await waitFor(() =>
+      expect(vi.mocked(installHubSkill)).toHaveBeenCalledWith('official/gifs/gif-search', expect.anything())
+    )
   })
 })
diff --git a/apps/desktop/src/app/capabilities/index.tsx b/apps/desktop/src/app/capabilities/index.tsx
new file mode 100644
index 0000000000..71105f4b81
--- /dev/null
+++ b/apps/desktop/src/app/capabilities/index.tsx
@@ -0,0 +1,217 @@
+import type * as React from 'react'
+import { useCallback, useMemo, useState } from 'react'
+
+import { PageLoader } from '@/components/page-loader'
+import { Button } from '@/components/ui/button'
+import { useI18n } from '@/i18n'
+import { queryClient } from '@/lib/query-client'
+import { invalidateSlashCompletions } from '@/lib/slash-completion-cache'
+import { useStoreSelector } from '@/lib/use-session-slice'
+import { $gateway } from '@/store/gateway'
+import { OFFICIAL_SKILLS_KEY } from '@/store/hub-actions'
+
+import { useRefreshHotkey } from '../hooks/use-refresh-hotkey'
+import { useRouteEnumParam } from '../hooks/use-route-enum-param'
+import { PanelEmpty } from '../overlays/panel'
+import { PageSearchShell } from '../page-search-shell'
+import type { SetStatusbarItemGroup } from '../shell/statusbar-controls'
+
+import { McpTab } from './mcp/mcp-tab'
+import { PluginsTab } from './plugins/plugins-tab'
+import { CapabilityScopeSelector, useCapabilityScope } from './scope-selector'
+import { EmbeddedHubPicker } from './skills/embedded-hub-picker'
+import { SKILLS_QUERY_KEY, skillSearchTerms, useSkillsQuery } from './skills/skills-data'
+import { SkillsTab } from './skills/skills-tab'
+import { refreshToolCalls } from './toolsets/tool-calls'
+import { TOOLSETS_QUERY_KEY, toolsetSearchTerms, useToolsetsQuery, visibleToolsetCount } from './toolsets/toolsets-data'
+import { ToolsetsTab } from './toolsets/toolsets-tab'
+
+// Skills Hub browsing lives inside the Skills tab. Legacy `?tab=hub`
+// links fall back to 'skills' via useRouteEnumParam.
+const CAPABILITY_MODES = ['skills', 'toolsets', 'mcp', 'plugins'] as const
+
+type CapabilityMode = (typeof CAPABILITY_MODES)[number]
+
+interface CapabilitiesViewProps extends React.ComponentProps<'section'> {
+  setStatusbarItemGroup?: SetStatusbarItemGroup
+  /** Embedded mode (plugin dialogs — e.g. Bot Mode's Advanced section): tab
+   *  state lives in local React state instead of the route's `?tab=` param,
+   *  so an embedding dialog never fights the page router. */
+  embedded?: boolean
+  /** Pin the WHOLE view to one profile: the scope selector is hidden and
+   *  every tab reads/writes THAT profile. This is the plugin door — Bot Mode
+   *  renders the real Capabilities surface pinned to a bot. */
+  fixedProfile?: string
+  /** Pin the view to a REGISTERED gateway connection alongside `fixedProfile`:
+   *  every read/write routes to that machine's backend instead of the active
+   *  gateway. `''`/`'local'` mean the local pool. This is Bot Mode's
+   *  remote-target door — a bot living on another registered gateway gets the
+   *  live surface pointed at ITS backend. Ignored without `fixedProfile`. */
+  fixedConnection?: string
+}
+
+/** The Capabilities page SHELL: tab selection, the search header, the profile /
+ *  connection scope, the refresh hotkey, and the dispatch to one tab component
+ *  per tab. Each tab owns its list, detail pane and writes; the two installed
+ *  lists are fetched here because the tab pills count them for the tab the user
+ *  is NOT on. */
+export function CapabilitiesView({
+  embedded = false,
+  fixedConnection,
+  fixedProfile,
+  setStatusbarItemGroup: _setStatusbarItemGroup,
+  ...props
+}: CapabilitiesViewProps) {
+  const { t } = useI18n()
+  // Both hooks run unconditionally (rules of hooks); embedded picks the local
+  // one so tab clicks inside a dialog don't rewrite the page URL.
+  const routeTab = useRouteEnumParam('tab', CAPABILITY_MODES, 'skills')
+  const localTab = useState<CapabilityMode>('skills')
+  const [mode, setMode] = embedded ? localTab : routeTab
+  // $gateway only feeds the MCP tab — gate the subscription so Skills/Toolsets
+  // tabs don't re-render on connect/disconnect/reconnect.
+  const gateway = useStoreSelector($gateway, g => (mode === 'mcp' ? g : null))
+
+  const [query, setQuery] = useState('')
+
+  // Keep the docs iframe alive after the first Skills visit.
+  const [hubMounted, setHubMounted] = useState(mode === 'skills')
+
+  if (mode === 'skills' && !hubMounted) {
+    setHubMounted(true)
+  }
+
+  const scope = useCapabilityScope({ fixedConnection, fixedProfile })
+
+  // The two installed lists the tab pills count. They are fetched here, as a
+  // pair, because the counts stay live for the tab the user is NOT on.
+  const { data: skills, isError: skillsFailed, error: skillsError } = useSkillsQuery(scope.profile)
+  const { data: toolsets, isError: toolsetsFailed } = useToolsetsQuery(scope.profile)
+  const installedSkillNames = useMemo(() => new Set((skills ?? []).map(skill => skill.name)), [skills])
+
+  const refreshCapabilities = useCallback(async () => {
+    await Promise.all([
+      queryClient.invalidateQueries({ queryKey: SKILLS_QUERY_KEY }),
+      queryClient.invalidateQueries({ queryKey: TOOLSETS_QUERY_KEY }),
+      queryClient.invalidateQueries({ queryKey: OFFICIAL_SKILLS_KEY })
+    ])
+
+    invalidateSlashCompletions()
+
+    void refreshToolCalls(scope.profile)
+  }, [scope.profile])
+
+  useRefreshHotkey(refreshCapabilities)
+
+  // Rotating placeholder nudges from the user's own data — teach that search
+  // understands categories and tool names, not just titles.
+  const searchHints = useMemo(() => {
+    if (mode === 'skills' && skills?.length) {
+      return skillSearchTerms(skills).map(term => t.common.tryHint(term))
+    }
+
+    if (mode === 'toolsets' && toolsets?.length) {
+      return toolsetSearchTerms(toolsets).map(term => t.common.tryHint(term))
+    }
+
+    return undefined
+  }, [mode, skills, t, toolsets])
+
+  // MCP and Plugins load independently of the installed Skills/Tools lists.
+  const gated = mode === 'toolsets' || mode === 'skills'
+  const pending = gated && !(skills && toolsets)
+
+  const loadGate = !pending ? null : skillsFailed || toolsetsFailed ? (
+      <PanelEmpty
+        action={
+          <Button onClick={() => void refreshCapabilities()} size="sm">
+            {t.skills.refresh}
+          </Button>
+        }
+        description={skillsError instanceof Error ? skillsError.message : undefined}
+        icon="error"
+        title={t.skills.skillsLoadFailed}
+      />
+    ) : (
+      <PageLoader label={t.skills.loading} />
+    )
+
+  // One entry per tab. Each is keyed on the scope so switching profile or
+  // connection is a fresh tab — never one profile's selection, open editor or
+  // pending install left standing over another profile's backend.
+  const tabContent = {
+    // The gateway instance backs ONLY the live `reload.mcp` RPC, and it is the
+    // ACTIVE gateway's socket — for a scope pinned to a different backend that
+    // RPC would hot-reload the wrong machine's MCP servers, so it is withheld
+    // (config edits still apply on that backend's next session).
+    mcp: () => (
+      <McpTab gateway={scope.crossBackend ? null : gateway} key={`mcp-${scope.key}`} profile={scope.profile} />
+    ),
+    // Agent plugins for the scoped profile (selector in the section header),
+    // app-level desktop plugins, and the docs catalog picker underneath.
+    plugins: () => (
+      <PluginsTab
+        key={`plugins-${scope.key}`}
+        profile={scope.profile}
+        scopeLabel={scope.label}
+        scopeSelector={scope.options.length > 1 ? <CapabilityScopeSelector compact scope={scope} /> : undefined}
+      />
+    ),
+    skills: () => (
+      <SkillsTab
+        key={`skills-${scope.key}`}
+        onRefresh={() => void refreshCapabilities()}
+        profile={scope.profile}
+        query={query}
+        skills={skills ?? []}
+      />
+    ),
+    toolsets: () => (
+      <ToolsetsTab key={`toolsets-${scope.key}`} profile={scope.profile} query={query} toolsets={toolsets ?? []} />
+    )
+  } satisfies Record<CapabilityMode, () => React.ReactNode>
+
+  return (
+    <PageSearchShell
+      {...props}
+      activeTab={mode}
+      onSearchChange={setQuery}
+      onTabChange={id => setMode(id as CapabilityMode)}
+      // MCP manages a handful of entries with the editor right there —
+      // searching it is noise.
+      searchHidden={mode === 'mcp' || mode === 'plugins'}
+      searchHints={searchHints}
+      searchPlaceholder={mode === 'skills' ? t.skills.searchSkills : t.skills.searchToolsets}
+      searchValue={query}
+      tabs={[
+        { id: 'skills', label: t.skills.tabSkills, meta: skills?.length ?? null },
+        { id: 'toolsets', label: t.skills.tabToolsets, meta: toolsets ? visibleToolsetCount(toolsets) : null },
+        { id: 'mcp', label: t.skills.tabMcp },
+        { id: 'plugins', label: t.skills.tabPlugins }
+      ]}
+    >
+      {/* One shared column: the scope selector sits above whichever tab is
+          active, so Skills / Tools / MCP all read and write the SAME selected
+          profile. */}
+      <div className="flex h-full flex-col">
+        {mode !== 'plugins' && <CapabilityScopeSelector scope={scope} />}
+        <div className="flex min-h-0 flex-1 flex-col">
+          <div className={mode === 'skills' ? 'min-h-40 flex-1 overflow-hidden' : 'min-h-0 flex-1'}>
+            {loadGate ?? tabContent[mode]()}
+          </div>
+          {hubMounted && (
+            <EmbeddedHubPicker hidden={mode !== 'skills'} installedNames={installedSkillNames} profile={scope.profile} />
+          )}
+        </div>
+      </div>
+    </PageSearchShell>
+  )
+}
+
+// Feature-detection flag for plugins (Bot Mode): TRUE means this build's
+// CapabilitiesView routes `fixedConnection` to the pinned connection's backend.
+// Older builds export CapabilitiesView WITHOUT the prop — passing it there would
+// silently read/write the ACTIVE gateway under the remote bot's profile name,
+// which is exactly the wrong-machine bug the prop exists to prevent. A static
+// property is probe-able without rendering.
+CapabilitiesView.supportsFixedConnection = true as const
diff --git a/apps/desktop/src/app/skills/mcp-tab.tsx b/apps/desktop/src/app/capabilities/mcp/mcp-tab.tsx
similarity index 99%
rename from apps/desktop/src/app/skills/mcp-tab.tsx
rename to apps/desktop/src/app/capabilities/mcp/mcp-tab.tsx
index 959405f0ee..719533452a 100644
--- a/apps/desktop/src/app/skills/mcp-tab.tsx
+++ b/apps/desktop/src/app/capabilities/mcp/mcp-tab.tsx
@@ -45,13 +45,13 @@ import { notify, notifyError } from '@/store/notifications'
 import { $activeGatewayProfile, normalizeProfileKey } from '@/store/profile'
 import { $activeSessionId } from '@/store/session'
 
-import { hermesConfigCacheWriter, useHermesConfigRecord } from '../hooks/use-config-record'
-import { useOnProfileSwitch } from '../hooks/use-on-profile-switch'
-import { useProfileSwitchLatch } from '../hooks/use-profile-switch-latch'
-import { DetailPane, ICON_BUTTON, MASTER_DETAIL_WIDE_COLS } from '../master-detail'
-import { PanelAddButton, PanelEmpty } from '../overlays/panel'
-import { prettyName } from '../settings/helpers'
-import { useDeepLinkHighlight } from '../settings/use-deep-link-highlight'
+import { hermesConfigCacheWriter, useHermesConfigRecord } from '../../hooks/use-config-record'
+import { useOnProfileSwitch } from '../../hooks/use-on-profile-switch'
+import { useProfileSwitchLatch } from '../../hooks/use-profile-switch-latch'
+import { DetailPane, ICON_BUTTON, MASTER_DETAIL_WIDE_COLS } from '../../master-detail'
+import { PanelAddButton, PanelEmpty } from '../../overlays/panel'
+import { prettyName } from '../../settings/helpers'
+import { useDeepLinkHighlight } from '../../settings/use-deep-link-highlight'
 
 // The editor always speaks the ecosystem's mcp.json document format — names
 // are the JSON keys, transport is inferred from `command` vs `url` — so any
diff --git a/apps/desktop/src/app/skills/plugin-packages.test.ts b/apps/desktop/src/app/capabilities/plugins/plugin-packages.test.ts
similarity index 100%
rename from apps/desktop/src/app/skills/plugin-packages.test.ts
rename to apps/desktop/src/app/capabilities/plugins/plugin-packages.test.ts
diff --git a/apps/desktop/src/app/skills/plugin-packages.ts b/apps/desktop/src/app/capabilities/plugins/plugin-packages.ts
similarity index 100%
rename from apps/desktop/src/app/skills/plugin-packages.ts
rename to apps/desktop/src/app/capabilities/plugins/plugin-packages.ts
diff --git a/apps/desktop/src/app/capabilities/plugins/plugins-tab.test.tsx b/apps/desktop/src/app/capabilities/plugins/plugins-tab.test.tsx
new file mode 100644
index 0000000000..219ea3686a
--- /dev/null
+++ b/apps/desktop/src/app/capabilities/plugins/plugins-tab.test.tsx
@@ -0,0 +1,456 @@
+import { cleanup, fireEvent, render, screen, waitFor, within } from '@testing-library/react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { $pluginRecords } from '@/contrib/plugins-store'
+import { $agentPlugins, $agentPluginsStatus } from '@/store/agent-plugins'
+import { $paneHeightOverride, setPaneHeightOverride } from '@/store/panes'
+import { $pluginInstallRequest, closePluginInstallRequest } from '@/store/plugin-install-request'
+import { $connection } from '@/store/session'
+
+import { PluginsTab } from './plugins-tab'
+
+const requestGateway = vi.fn(async () => ({ plugins: [] }))
+
+const connectionFixture = {
+  baseUrl: 'http://localhost',
+  isFullscreen: false,
+  logs: [],
+  nativeOverlayWidth: 0,
+  token: '',
+  windowButtonPosition: null,
+  wsUrl: ''
+}
+
+vi.mock('@/app/gateway/hooks/use-gateway-request', () => ({
+  useGatewayRequest: () => ({ requestGateway })
+}))
+
+describe('PluginsTab', () => {
+  beforeEach(() => {
+    $pluginRecords.set({})
+    $agentPlugins.set([])
+    $agentPluginsStatus.set('ready')
+    closePluginInstallRequest()
+    requestGateway.mockClear()
+  })
+
+  afterEach(() => {
+    cleanup()
+    $connection.set(null)
+  })
+
+  it('lists the scoped profile agent plugins with toggles', () => {
+    $agentPlugins.set([
+      {
+        description: 'A test plugin',
+        key: 'demo-plugin',
+        name: 'demo-plugin',
+        source: 'git',
+        status: 'enabled',
+        version: '1.0.0'
+      }
+    ])
+
+    render(<PluginsTab profile="workbot" />)
+
+    expect(screen.getByText('demo-plugin')).toBeTruthy()
+    expect(screen.getByRole('switch', { name: 'Agent: demo-plugin' }).getAttribute('aria-checked')).toBe('true')
+  })
+
+  it('hides bundled plugins (managed from their own surfaces)', () => {
+    $agentPlugins.set([
+      {
+        description: '',
+        key: 'image_gen/fal',
+        name: 'fal',
+        source: 'bundled',
+        status: 'enabled',
+        version: ''
+      }
+    ])
+
+    render(<PluginsTab profile={null} />)
+
+    expect(screen.queryByText('fal')).toBeNull()
+    expect(screen.getByText(/No plugins yet/)).toBeTruthy()
+  })
+
+  // A desktop half can only be copied out of a backend that runs on THIS
+  // machine; against a remote one the reconcile is a structural no-op, so the
+  // row must say so instead of pending forever (#114079).
+  it('marks a remote-backend desktop half unavailable instead of forever copying', () => {
+    $connection.set({ ...connectionFixture, mode: 'remote' })
+    $agentPlugins.set([
+      {
+        description: '',
+        has_desktop_half: true,
+        key: 'nous-prices',
+        name: 'nous-prices',
+        source: 'catalog',
+        status: 'enabled',
+        version: '1'
+      }
+    ])
+
+    render(<PluginsTab profile={null} />)
+
+    const detail = within(screen.getByRole('row', { name: /^nous-prices/ }))
+    expect(detail.getByText('unavailable (remote backend)')).toBeTruthy()
+    expect(detail.queryByText('copying…')).toBeNull()
+  })
+
+  it('keeps the pending desktop-half state on a local backend', () => {
+    $agentPlugins.set([
+      {
+        description: '',
+        has_desktop_half: true,
+        key: 'nous-prices',
+        name: 'nous-prices',
+        source: 'catalog',
+        status: 'enabled',
+        version: '1'
+      }
+    ])
+
+    render(<PluginsTab profile={null} />)
+
+    const detail = within(screen.getByRole('row', { name: /^nous-prices/ }))
+    expect(detail.getByText('copying…')).toBeTruthy()
+    expect(detail.queryByText('unavailable (remote backend)')).toBeNull()
+  })
+
+  it('renders a unified package as ONE row with a Desktop switch and an Agent switch', () => {
+    $pluginRecords.set({
+      media: { id: 'media', name: 'Media Studio', kind: 'disk', status: 'loaded', packageName: 'hermes-media-studio' }
+    })
+    $agentPlugins.set([
+      {
+        description: '',
+        key: 'hermes-media-studio',
+        name: 'hermes-media-studio',
+        source: 'git',
+        status: 'disabled',
+        version: '1'
+      }
+    ])
+
+    render(<PluginsTab profile="workbot" scopeLabel="workbot" />)
+
+    expect(screen.getAllByTestId(/^plugin-row-/)).toHaveLength(1)
+    expect(screen.getByText('Agent + Desktop')).toBeTruthy()
+    expect(screen.getByRole('switch', { name: 'Desktop: Media Studio' }).getAttribute('aria-checked')).toBe('true')
+    expect(screen.getByRole('switch', { name: 'Agent: Media Studio' }).getAttribute('aria-checked')).toBe('false')
+    expect(screen.getAllByText('Agent in workbot').length).toBeGreaterThan(0)
+  })
+
+  it('offers "Install here" for a desktop half whose agent half is not in the selected profile', async () => {
+    $pluginRecords.set({
+      media: {
+        id: 'media',
+        name: 'Media Studio',
+        kind: 'disk',
+        status: 'loaded',
+        packageName: 'hermes-media-studio',
+        packageOrigin: { repo: 'https://github.com/NousResearch/hermes-media-studio.git', sha: 'abc' }
+      }
+    })
+
+    render(<PluginsTab profile="workbot" scopeLabel="workbot" />)
+
+    expect(screen.queryByRole('switch', { name: /^Agent:/ })).toBeNull()
+    screen.getByRole('button', { name: 'Install here' }).click()
+    // Pre-filled from the package marker: repo + pinned sha, agent half only.
+    await waitFor(() => {
+      expect($pluginInstallRequest.get()).toMatchObject({
+        legacyHint: 'agent',
+        profile: 'workbot',
+        repo: 'https://github.com/NousResearch/hermes-media-studio.git',
+        sha: 'abc'
+      })
+    })
+  })
+
+  it('disables "Install here" when the package has no known origin (hand-copied folder)', () => {
+    $pluginRecords.set({
+      media: { id: 'media', name: 'Media Studio', kind: 'disk', status: 'loaded', packageName: 'hermes-media-studio' }
+    })
+
+    render(<PluginsTab profile="workbot" scopeLabel="workbot" />)
+
+    expect((screen.getByRole('button', { name: 'Install here' }) as HTMLButtonElement).disabled).toBe(true)
+  })
+
+  it('loads the plugin list scoped to the selected profile', () => {
+    render(<PluginsTab profile="workbot" />)
+
+    expect(requestGateway).toHaveBeenCalledWith(
+      'plugins.manage',
+      expect.objectContaining({ action: 'list', profile: 'workbot' })
+    )
+  })
+
+  it('opens the dual-target install modal from a catalog pick message', async () => {
+    render(<PluginsTab profile="workbot" />)
+
+    window.dispatchEvent(
+      new MessageEvent('message', {
+        data: {
+          name: 'weather-plugin',
+          repo: 'https://github.com/example/weather-plugin',
+          sha: 'a'.repeat(40),
+          subdir: '',
+          tier: 'community',
+          type: 'hermes-plugin-pick'
+        },
+        origin: 'https://hermes-agent.nousresearch.com'
+      })
+    )
+
+    await waitFor(() => {
+      const request = $pluginInstallRequest.get()
+
+      expect(request).not.toBeNull()
+      expect(request?.catalogName).toBe('weather-plugin')
+      expect(request?.repo).toBe('https://github.com/example/weather-plugin')
+      expect(request?.profile).toBe('workbot')
+      expect(request?.sha).toBe('a'.repeat(40))
+    })
+  })
+
+  it('ignores pick messages from foreign origins', () => {
+    render(<PluginsTab profile={null} />)
+
+    window.dispatchEvent(
+      new MessageEvent('message', {
+        data: {
+          name: 'evil-plugin',
+          repo: 'https://github.com/evil/evil-plugin',
+          type: 'hermes-plugin-pick'
+        },
+        origin: 'https://evil.example.com'
+      })
+    )
+
+    expect($pluginInstallRequest.get()).toBeNull()
+  })
+
+  it('toggles by canonical key through plugins.manage', async () => {
+    $agentPlugins.set([
+      {
+        description: '',
+        key: 'image_gen/legacy',
+        name: 'Legacy plugin',
+        source: 'user',
+        status: 'disabled',
+        version: '0.20.0'
+      }
+    ])
+    requestGateway.mockResolvedValueOnce({
+      ok: true,
+      plugin: { key: 'image_gen/legacy', name: 'Legacy plugin', status: 'enabled' }
+    } as never)
+
+    render(<PluginsTab profile={null} />)
+
+    screen.getByRole('switch', { name: 'Agent: Legacy plugin' }).click()
+
+    await waitFor(() =>
+      expect(requestGateway).toHaveBeenCalledWith(
+        'plugins.manage',
+        expect.objectContaining({ action: 'toggle', key: 'image_gen/legacy', enable: true })
+      )
+    )
+  })
+
+  it('renders keyless rows read-only (no name-addressed toggle RPC)', () => {
+    // Name-addressed toggles flip every same-named plugin across category
+    // dirs — pre-contract-v6 rows must never reach the RPC.
+    $agentPlugins.set([
+      {
+        description: 'Returned by a pre-key backend',
+        name: 'Legacy plugin',
+        source: 'user',
+        status: 'disabled',
+        version: '0.20.0'
+      }
+    ])
+
+    render(<PluginsTab profile={null} />)
+
+    const toggle = screen.getByRole('switch', { name: 'Agent: Legacy plugin' })
+
+    expect(toggle.hasAttribute('disabled') || toggle.getAttribute('aria-disabled') === 'true').toBe(true)
+
+    toggle.click()
+
+    expect(requestGateway).not.toHaveBeenCalledWith('plugins.manage', expect.objectContaining({ action: 'toggle' }))
+  })
+
+  it('appends the subdir fragment for multi-plugin repos', async () => {
+    render(<PluginsTab profile={null} />)
+
+    window.dispatchEvent(
+      new MessageEvent('message', {
+        data: {
+          name: 'nested-plugin',
+          repo: 'https://github.com/example/plugins-monorepo',
+          subdir: 'nested-plugin',
+          type: 'hermes-plugin-pick'
+        },
+        origin: 'https://hermes-agent.nousresearch.com'
+      })
+    )
+
+    await waitFor(() => {
+      expect($pluginInstallRequest.get()?.repo).toBe('https://github.com/example/plugins-monorepo#nested-plugin')
+    })
+  })
+})
+
+describe('PluginsTab catalog UX', () => {
+  beforeEach(() => {
+    $agentPlugins.set([])
+    $agentPluginsStatus.set('ready')
+    closePluginInstallRequest()
+    requestGateway.mockClear()
+    setPaneHeightOverride('capabilities-plugin-catalog', undefined)
+  })
+
+  afterEach(cleanup)
+
+  it('grows the catalog when its top-edge sash is dragged up, and resets on double-click', () => {
+    // jsdom has no layout: give the Capabilities column a real height so the
+    // "never crush the lists above" clamp has something to clamp against.
+    const clientHeight = vi.spyOn(HTMLElement.prototype, 'clientHeight', 'get').mockReturnValue(900)
+    Object.defineProperty(window, 'innerHeight', { configurable: true, value: 1000 })
+    render(<PluginsTab profile={null} />)
+    const sash = screen.getByTestId('plugin-catalog-sash')
+
+    fireEvent.pointerDown(sash, { button: 0, clientY: 600 })
+    fireEvent.pointerMove(window, { clientY: 400 })
+    fireEvent.pointerUp(window)
+
+    // Default 380px + 200px of upward drag (clamped only by window/column size).
+    expect($paneHeightOverride('capabilities-plugin-catalog').get()).toBe(580)
+
+    fireEvent.doubleClick(sash)
+    expect($paneHeightOverride('capabilities-plugin-catalog').get()).toBeUndefined()
+    clientHeight.mockRestore()
+  })
+
+  it('shows an Update chip when the catalog pin moved past the installed SHA', () => {
+    $agentPlugins.set([
+      {
+        catalog_name: 'demo-weather',
+        catalog_sha: 'b'.repeat(40),
+        catalog_tier: 'community',
+        description: '',
+        installed_sha: 'a'.repeat(40),
+        key: 'demo-weather',
+        name: 'demo-weather',
+        source: 'git',
+        status: 'enabled',
+        update_available: true,
+        version: '1.0.0'
+      }
+    ])
+
+    render(<PluginsTab profile={null} />)
+
+    expect(screen.getByRole('button', { name: `Update to ${'b'.repeat(8)}` })).toBeTruthy()
+  })
+
+  it('re-pins through plugins.manage update when the chip is clicked', async () => {
+    $agentPlugins.set([
+      {
+        catalog_name: 'demo-weather',
+        catalog_sha: 'b'.repeat(40),
+        catalog_tier: 'community',
+        description: '',
+        installed_sha: 'a'.repeat(40),
+        key: 'demo-weather',
+        name: 'demo-weather',
+        source: 'git',
+        status: 'enabled',
+        update_available: true,
+        version: '1.0.0'
+      }
+    ])
+    requestGateway.mockResolvedValue({ ok: true, unchanged: false, plugins: [] } as never)
+
+    render(<PluginsTab profile="workbot" />)
+
+    screen.getByRole('button', { name: `Update to ${'b'.repeat(8)}` }).click()
+
+    await waitFor(() =>
+      expect(requestGateway).toHaveBeenCalledWith(
+        'plugins.manage',
+        expect.objectContaining({ action: 'update', name: 'demo-weather', profile: 'workbot' })
+      )
+    )
+  })
+
+  it('refuses a catalog pick that is already installed and current', async () => {
+    $agentPlugins.set([
+      {
+        catalog_name: 'demo-weather',
+        description: '',
+        installed_sha: 'a'.repeat(40),
+        key: 'demo-weather',
+        name: 'demo-weather',
+        source: 'git',
+        status: 'enabled',
+        update_available: false,
+        version: '1.0.0'
+      }
+    ])
+
+    render(<PluginsTab profile={null} />)
+
+    window.dispatchEvent(
+      new MessageEvent('message', {
+        data: {
+          name: 'demo-weather',
+          repo: 'https://github.com/example/demo-weather',
+          type: 'hermes-plugin-pick'
+        },
+        origin: 'https://hermes-agent.nousresearch.com'
+      })
+    )
+
+    // The modal must NOT open — the pick is refused with a toast.
+    await new Promise(resolve => setTimeout(resolve, 20))
+    expect($pluginInstallRequest.get()).toBeNull()
+  })
+
+  it('still opens the modal for an installed pick when an update is available', async () => {
+    $agentPlugins.set([
+      {
+        catalog_name: 'demo-weather',
+        description: '',
+        installed_sha: 'a'.repeat(40),
+        key: 'demo-weather',
+        name: 'demo-weather',
+        source: 'git',
+        status: 'enabled',
+        update_available: true,
+        version: '1.0.0'
+      }
+    ])
+
+    render(<PluginsTab profile={null} />)
+
+    window.dispatchEvent(
+      new MessageEvent('message', {
+        data: {
+          name: 'demo-weather',
+          repo: 'https://github.com/example/demo-weather',
+          type: 'hermes-plugin-pick'
+        },
+        origin: 'https://hermes-agent.nousresearch.com'
+      })
+    )
+
+    await waitFor(() => expect($pluginInstallRequest.get()).not.toBeNull())
+  })
+})
diff --git a/apps/desktop/src/app/capabilities/plugins/plugins-tab.tsx b/apps/desktop/src/app/capabilities/plugins/plugins-tab.tsx
new file mode 100644
index 0000000000..8f96f3d26f
--- /dev/null
+++ b/apps/desktop/src/app/capabilities/plugins/plugins-tab.tsx
@@ -0,0 +1,655 @@
+import { useStore } from '@nanostores/react'
+import {
+  memo,
+  type ReactNode,
+  type PointerEvent as ReactPointerEvent,
+  useEffect,
+  useMemo,
+  useRef,
+  useState
+} from 'react'
+
+import { useGatewayRequest } from '@/app/gateway/hooks/use-gateway-request'
+import { Button } from '@/components/ui/button'
+import { Codicon } from '@/components/ui/codicon'
+import { Switch } from '@/components/ui/switch'
+import { Tip } from '@/components/ui/tooltip'
+import { $pluginRecords, type PluginRecord, setPluginEnabled } from '@/contrib/plugins-store'
+import { discoverRuntimePlugins } from '@/contrib/runtime-loader'
+import type { ProfileScope } from '@/hermes'
+import { useI18n } from '@/i18n'
+import { triggerHaptic } from '@/lib/haptics'
+import { FolderOpen, Loader2, Monitor, Package, RefreshCw } from '@/lib/icons'
+import { cn } from '@/lib/utils'
+import {
+  $agentPluginBusy,
+  $agentPlugins,
+  $agentPluginsError,
+  $agentPluginsStatus,
+  type AgentPluginRow,
+  type GatewayRequest,
+  isDesktopRelevantPlugin,
+  loadAgentPlugins,
+  toggleAgentPlugin,
+  updateAgentPlugin
+} from '@/store/agent-plugins'
+import { notify, notifyError } from '@/store/notifications'
+import { $paneHeightOverride, setPaneHeightOverride } from '@/store/panes'
+import { openPluginInstallRequest } from '@/store/plugin-install-request'
+import { $connection } from '@/store/session'
+
+import { PanelEmpty } from '../../overlays/panel'
+import { Pill } from '../../settings/primitives'
+import { useDeepLinkHighlight } from '../../settings/use-deep-link-highlight'
+
+import { mergePluginPackages, type PackageKind, type PluginPackage } from './plugin-packages'
+
+// The REAL Plugin Catalog page (docs site) embedded as a one-click picker —
+// the same pattern as the Skills tab's EmbeddedHubPicker. `?embed=picker`
+// hides the docs chrome and adds "+ Add to this Agent" per card, which posts
+//   { type: 'hermes-plugin-pick', name, repo, sha, subdir, tier, installCmd }
+// to the parent window. We validate the origin and open the shared
+// dual-target install modal (agent half → catalog-pinned install into the
+// scoped profile; desktop half → this app), so unified packages install both
+// halves in one flow.
+const CATALOG_ORIGIN = 'https://hermes-agent.nousresearch.com'
+const CATALOG_PICKER_URL = `${CATALOG_ORIGIN}/docs/plugins?embed=picker`
+
+// Catalog viewport: persisted through the shared pane store, dragged from the
+// section's TOP edge ("pull the catalog up"), clamped so neither the catalog
+// nor the plugin list above can vanish. Same contract as EmbeddedHubPicker.
+const CATALOG_PANE_ID = 'capabilities-plugin-catalog'
+const CATALOG_DEFAULT_PX = 380
+const CATALOG_MIN_PX = 120
+const CATALOG_MAX_VH = 0.75
+const CATALOG_COLLAPSED_PX = 4
+const CATALOG_LIST_RESERVED_PX = 176
+
+interface PluginPickMessage {
+  installCmd?: string
+  name?: string
+  repo?: string
+  sha?: string
+  subdir?: string
+  tier?: string
+  type?: string
+}
+
+/** Deep-link anchor for a package row (`/capabilities?tab=plugins&plugin=<key>`).
+ *  Accepts the agent key, the agent name, or the desktop record id. */
+export const pluginElementId = (target: string) => `plugin-${target}`
+
+/** Derive the bare profile name a `plugins.manage` call should target. */
+function profileParam(scope: ProfileScope): null | string {
+  if (!scope) {
+    return null
+  }
+
+  return typeof scope === 'string' ? scope : (scope.profile ?? null)
+}
+
+function reveal(file: string) {
+  void window.hermesDesktop?.revealPath?.(file)?.catch(() => undefined)
+}
+
+async function revealPluginsDir() {
+  try {
+    // Electron owns the app-level plugin root — deriving it from the backend's
+    // hermes_home breaks against a remote backend (#66899).
+    const dir = await window.hermesDesktop?.desktopPluginsRoot?.()
+
+    if (!dir) {
+      notifyError('Desktop plugins are unavailable', 'Could not resolve the plugins folder')
+
+      return
+    }
+
+    const result = await window.hermesDesktop?.openDir?.(dir)
+
+    if (result && !result.ok) {
+      notifyError(result.error ?? 'unknown error', 'Could not open the plugins folder')
+    }
+  } catch (err) {
+    notifyError(err, 'Could not resolve the plugins folder')
+  }
+}
+
+/** Copy any changed unified desktop halves into the app root FIRST, then
+ *  rescan the root — a concurrent scan would read the pre-copy state. */
+async function rescanAll(requestGateway: GatewayRequest, scope: null | string) {
+  await window.hermesDesktop?.reconcileDesktopPlugins?.().catch(() => undefined)
+  await discoverRuntimePlugins()
+  await loadAgentPlugins(requestGateway, scope)
+}
+
+/** Open the dual-target install modal pre-filled to install ONLY the agent
+ *  half of a unified package into the scoped profile (the desktop half is
+ *  already here). Provenance comes from the package marker Electron stamped
+ *  when it copied the half out (catalog sidecar or git remote). */
+function installAgentHalfHere(record: PluginRecord, profile: null | string) {
+  const origin = record.packageOrigin
+
+  if (!origin?.repo) {
+    return
+  }
+
+  openPluginInstallRequest({
+    catalogName: origin.catalogName,
+    legacyHint: 'agent',
+    profile,
+    repo: origin.repo,
+    sha: origin.sha
+  })
+}
+
+function KindBadge({ kind }: { kind: PackageKind }) {
+  const { t } = useI18n()
+  const p = t.skills.plugins
+
+  return (
+    <span className="inline-flex items-center gap-1 rounded border border-(--ui-stroke-tertiary) px-1.5 py-px text-[0.65rem] text-(--ui-text-tertiary)">
+      {kind !== 'desktop' && <Package aria-hidden className="size-3" />}
+      {kind !== 'agent' && <Monitor aria-hidden className="size-3" />}
+      {kind === 'both' ? p.kindBoth : kind === 'agent' ? p.kindAgent : p.kindDesktop}
+    </span>
+  )
+}
+
+/** Provenance pill: where the package came from. */
+function ProvenancePill({ pkg }: { pkg: PluginPackage }) {
+  const { t } = useI18n()
+  const p = t.skills.plugins
+
+  if (pkg.agent?.catalog_name) {
+    return (
+      <Tip label={p.catalogProvenance(pkg.agent.installed_sha?.slice(0, 8) ?? '')}>
+        <span>
+          <Pill>{pkg.agent.catalog_tier === 'official' ? p.tierOfficial : p.tierCommunity}</Pill>
+        </span>
+      </Tip>
+    )
+  }
+
+  if (pkg.agent?.pinned_sha) {
+    return (
+      <Tip label={p.pinnedProvenance(pkg.agent.pinned_sha.slice(0, 8))}>
+        <span>
+          <Pill>
+            <span className="font-mono">{p.pinnedBadge(pkg.agent.pinned_sha.slice(0, 8))}</span>
+          </Pill>
+        </span>
+      </Tip>
+    )
+  }
+
+  if (pkg.agent) {
+    return <Pill>{pkg.agent.source}</Pill>
+  }
+
+  if (pkg.desktop) {
+    return <Pill>{t.settings.plugins.kinds[pkg.desktop.kind]}</Pill>
+  }
+
+  return null
+}
+
+/** Column widths shared by the header and every row so the two control
+ *  columns line up down the page like a table. */
+const HALF_COL = 'flex w-36 shrink-0 items-center gap-1.5'
+
+/** One control cell; `label` is the accessible name for screen readers only
+ *  (the visible column label lives once, in the header). */
+function HalfCell({ label, children }: { label: string; children: ReactNode }) {
+  return (
+    <div aria-label={label} className={HALF_COL} role="cell">
+      {children}
+    </div>
+  )
+}
+
+function Dash() {
+  return (
+    <span aria-hidden className="w-9 text-center text-(--ui-text-quaternary)">
+      —
+    </span>
+  )
+}
+
+function PackageRow({
+  pkg,
+  scope,
+  scopeLabel,
+  busy,
+  onAgentToggle,
+  onAgentUpdate
+}: {
+  pkg: PluginPackage
+  scope: null | string
+  scopeLabel: string
+  busy: boolean
+  onAgentToggle: (row: AgentPluginRow, enable: boolean) => void
+  onAgentUpdate: (row: AgentPluginRow) => void
+}) {
+  const { t } = useI18n()
+  const p = t.skills.plugins
+  const d = t.settings.plugins
+  const desktop = pkg.desktop
+  const agent = pkg.agent
+  const desktopOn = desktop ? desktop.status !== 'disabled' : false
+  const agentOn = agent?.status === 'enabled'
+  const agentToggleable = Boolean(agent?.key)
+  // Electron's desktop-half reconcile only walks THIS machine's homes, so a
+  // package installed on a remote backend can never materialize here (#114079).
+  const remoteBackend = useStore($connection)?.mode === 'remote'
+
+  return (
+    <div
+      className="flex items-center gap-3 border-b border-(--ui-stroke-tertiary) px-3 py-2.5 last:border-b-0"
+      data-testid={`plugin-row-${pkg.key}`}
+      id={pluginElementId(agent?.key ?? agent?.name ?? desktop?.id ?? pkg.key)}
+      role="row"
+    >
+      <div className="flex min-w-0 flex-1 items-start gap-2" role="cell">
+        <div className="min-w-0 flex-1">
+          <div className="flex flex-wrap items-center gap-2 text-[length:var(--conversation-text-font-size)] font-medium text-foreground">
+            <span>{pkg.name}</span>
+            {agent?.version && <span className="text-(--ui-text-quaternary)">v{agent.version}</span>}
+            <KindBadge kind={pkg.kind} />
+            <ProvenancePill pkg={pkg} />
+            {agent?.portable && <Pill>{p.portableBadge}</Pill>}
+            {desktop?.status === 'error' && <Pill tone="primary">{d.failed}</Pill>}
+          </div>
+          {(desktop?.status === 'error' ? desktop.error : pkg.description) && (
+            <div
+              className={cn(
+                'mt-0.5 text-[length:var(--conversation-caption-font-size)] break-words',
+                desktop?.status === 'error' ? 'text-(--ui-danger,#f87171)' : 'text-(--ui-text-tertiary)'
+              )}
+            >
+              {desktop?.status === 'error' ? desktop.error : pkg.description}
+            </div>
+          )}
+        </div>
+        {/* Fixed slot so the switch column stays straight whether or not
+            this row has a folder to reveal (bundled plugins have none). */}
+        <span className="flex size-7 shrink-0 items-center justify-center">
+          {desktop?.file && (
+            <Tip label={d.reveal}>
+              <Button onClick={() => reveal(desktop.file!)} size="icon" variant="ghost">
+                <Codicon name="folder-opened" size="0.85rem" />
+              </Button>
+            </Tip>
+          )}
+        </span>
+      </div>
+
+      {/* The two halves. Desktop is app-level and reads the same whichever
+          profile is selected; Agent follows the selector. A half the package
+          lacks shows a dash; a half it has but which is missing on this side
+          shows the install affordance. */}
+      <HalfCell label={p.halfDesktop}>
+        {desktop ? (
+          <Switch
+            aria-label={`${p.halfDesktop}: ${pkg.name}`}
+            checked={desktopOn}
+            onCheckedChange={on => {
+              triggerHaptic('selection')
+              void setPluginEnabled(desktop.id, on)
+            }}
+          />
+        ) : pkg.desktopMissing ? (
+          <Tip label={remoteBackend ? p.desktopHalfRemoteTip : p.desktopHalfPendingTip}>
+            <span className="text-[0.65rem] text-(--ui-text-tertiary)">
+              {remoteBackend ? p.desktopHalfRemote : p.desktopHalfPending}
+            </span>
+          </Tip>
+        ) : (
+          <Dash />
+        )}
+      </HalfCell>
+
+      <HalfCell label={p.halfAgentIn(scopeLabel)}>
+        {agent ? (
+          <>
+            {agent.update_available && (
+              <Button
+                className="h-5 px-1.5 text-[0.65rem]"
+                disabled={busy}
+                onClick={() => onAgentUpdate(agent)}
+                size="xs"
+                variant="outline"
+              >
+                {p.updateToPin(agent.catalog_version ?? agent.catalog_sha?.slice(0, 8) ?? '')}
+              </Button>
+            )}
+            {busy && <Loader2 className="size-3.5 animate-spin text-(--ui-text-tertiary)" />}
+            {agentToggleable ? (
+              <Switch
+                aria-label={`${p.halfAgent}: ${pkg.name}`}
+                checked={agentOn}
+                disabled={busy}
+                onCheckedChange={on => onAgentToggle(agent, on)}
+              />
+            ) : (
+              <Tip label={p.legacyBackend}>
+                <span>
+                  <Switch aria-label={`${p.halfAgent}: ${pkg.name}`} checked={agentOn} disabled />
+                </span>
+              </Tip>
+            )}
+          </>
+        ) : pkg.agentMissingInProfile && desktop ? (
+          <Tip label={desktop.packageOrigin?.repo ? p.installAgentHereTip(scopeLabel) : p.installAgentHereNoOrigin}>
+            <span>
+              <Button
+                className="h-5 px-1.5 text-[0.65rem]"
+                disabled={!desktop.packageOrigin?.repo}
+                onClick={() => installAgentHalfHere(desktop, scope)}
+                size="xs"
+                variant="outline"
+              >
+                {p.installAgentHere}
+              </Button>
+            </span>
+          </Tip>
+        ) : (
+          <Dash />
+        )}
+      </HalfCell>
+    </div>
+  )
+}
+
+/** THE plugins surface: one row per package. Each row shows its Desktop half
+ *  (this app — the same for every profile, gateway, or machine) and its Agent
+ *  half (the selected profile's backend). Discovery sits underneath: the live
+ *  catalog picker plus Install from Git for anything not in the catalog. */
+export const PluginsTab = memo(function PluginsTab({
+  profile,
+  scopeSelector,
+  scopeLabel
+}: {
+  profile: ProfileScope
+  /** The Capabilities profile selector; rendered in the Agent column header so
+   *  it visibly governs only that column. */
+  scopeSelector?: ReactNode
+  /** Display name of the selected profile for the Agent column label. */
+  scopeLabel?: string
+}) {
+  const { t } = useI18n()
+  const p = t.skills.plugins
+  const d = t.settings.plugins
+  const { requestGateway } = useGatewayRequest()
+
+  const desktopRecords = useStore($pluginRecords)
+  const agentRows = useStore($agentPlugins)
+  const status = useStore($agentPluginsStatus)
+  const error = useStore($agentPluginsError)
+  const busyKey = useStore($agentPluginBusy)
+
+  const scope = profileParam(profile)
+  const label = scopeLabel ?? scope ?? t.skills.plugins.defaultProfile
+
+  useEffect(() => {
+    void loadAgentPlugins(requestGateway, scope)
+  }, [requestGateway, scope])
+
+  const packages = useMemo(
+    () => mergePluginPackages(Object.values(desktopRecords), agentRows.filter(isDesktopRelevantPlugin)),
+    [agentRows, desktopRecords]
+  )
+
+  useDeepLinkHighlight({ param: 'plugin', ready: () => true, elementId: pluginElementId })
+
+  // Catalog picker viewport (persisted height, collapse toggle, top-edge sash).
+  const heightOverride = useStore($paneHeightOverride(CATALOG_PANE_ID))
+  const height = heightOverride ?? CATALOG_DEFAULT_PX
+  const open = height > CATALOG_COLLAPSED_PX
+  const [pickerMounted, setPickerMounted] = useState(open)
+  const [dragging, setDragging] = useState(false)
+  const sectionRef = useRef<HTMLElement>(null)
+
+  if (open && !pickerMounted) {
+    setPickerMounted(true)
+  }
+
+  const startDrag = (event: ReactPointerEvent<HTMLDivElement>) => {
+    if (event.button !== 0) {
+      return
+    }
+
+    event.preventDefault()
+    const startY = event.clientY
+    const startHeight = height
+    const column = sectionRef.current?.parentElement
+    const columnMax = column ? column.clientHeight - CATALOG_LIST_RESERVED_PX : Number.POSITIVE_INFINITY
+    const max = Math.max(CATALOG_MIN_PX, Math.round(Math.min(window.innerHeight * CATALOG_MAX_VH, columnMax)))
+    setDragging(true)
+
+    const onMove = (move: globalThis.PointerEvent) => {
+      setPaneHeightOverride(
+        CATALOG_PANE_ID,
+        Math.round(Math.min(max, Math.max(CATALOG_MIN_PX, startHeight + (startY - move.clientY))))
+      )
+    }
+
+    const onUp = () => {
+      window.removeEventListener('pointermove', onMove)
+      setDragging(false)
+    }
+
+    window.addEventListener('pointermove', onMove)
+    window.addEventListener('pointerup', onUp, { once: true })
+  }
+
+  useEffect(() => {
+    if (!open) {
+      return undefined
+    }
+
+    const onMessage = (event: MessageEvent) => {
+      if (event.origin !== CATALOG_ORIGIN) {
+        return
+      }
+
+      const data = event.data as null | PluginPickMessage
+
+      if (!data || data.type !== 'hermes-plugin-pick' || !data.name || !data.repo) {
+        return
+      }
+
+      const existing = $agentPlugins.get().find(row => row.catalog_name === data.name || row.name === data.name)
+
+      if (existing && !existing.update_available) {
+        notify({ kind: 'success', message: p.alreadyInstalled(String(data.name)) })
+
+        return
+      }
+
+      openPluginInstallRequest({
+        catalogName: String(data.name),
+        profile: scope,
+        repo: data.subdir ? `${String(data.repo)}#${String(data.subdir)}` : String(data.repo),
+        sha: data.sha ? String(data.sha) : undefined
+      })
+    }
+
+    window.addEventListener('message', onMessage)
+
+    return () => window.removeEventListener('message', onMessage)
+  }, [open, p, scope])
+
+  const agentBusy = (row: AgentPluginRow) => busyKey === (row.key ?? row.name) || busyKey === row.name
+
+  return (
+    <div className="flex h-full min-h-0 flex-col">
+      <div className="min-h-32 flex-1 overflow-y-auto">
+        {/* Header: what the two columns mean, and the controls that act on
+            the whole page (install, folder, rescan). */}
+        <div className="flex flex-wrap items-start justify-between gap-3 px-3 pt-3 pb-2">
+          <p className="min-w-0 flex-1 text-[length:var(--conversation-caption-font-size)] text-(--ui-text-tertiary)">
+            {p.pageBlurb}
+          </p>
+          <div className="flex shrink-0 items-center gap-1">
+            <Button
+              onClick={() => openPluginInstallRequest({ profile: scope, repo: '' })}
+              size="sm"
+              type="button"
+              variant="secondary"
+            >
+              {d.installModal.installFromGit}
+            </Button>
+            <Tip label={d.openFolder}>
+              <Button
+                aria-label={d.openFolder}
+                onClick={() => void revealPluginsDir()}
+                size="icon"
+                type="button"
+                variant="ghost"
+              >
+                <FolderOpen className="size-3.5" />
+              </Button>
+            </Tip>
+            <Tip label={d.rescan}>
+              <Button
+                aria-label={d.rescan}
+                onClick={() => {
+                  triggerHaptic('selection')
+                  void rescanAll(requestGateway, scope)
+                }}
+                size="icon"
+                type="button"
+                variant="ghost"
+              >
+                <RefreshCw className="size-3.5" />
+              </Button>
+            </Tip>
+          </div>
+        </div>
+
+        {status === 'error' ? (
+          <PanelEmpty
+            action={
+              <Button onClick={() => void loadAgentPlugins(requestGateway, scope)} size="sm">
+                {t.skills.refresh}
+              </Button>
+            }
+            description={error ?? undefined}
+            icon="error"
+            title={p.loadFailed}
+          />
+        ) : packages.length === 0 && status === 'ready' ? (
+          <p className="px-3 py-3 text-[length:var(--conversation-caption-font-size)] text-(--ui-text-tertiary)">
+            {p.emptyAll} {p.emptyHint}
+          </p>
+        ) : (
+          <div className="flex flex-col" role="table">
+            {/* Column header: the visible labels for the two control columns,
+                aligned with the cells below. The profile selector sits INSIDE
+                the Agent header so it visibly governs only that column. */}
+            <div
+              className="flex items-center gap-3 border-y border-(--ui-stroke-tertiary) bg-(--ui-bg-quinary) px-3 py-1.5 text-[0.68rem] text-(--ui-text-tertiary)"
+              role="row"
+            >
+              <div className="min-w-0 flex-1" role="columnheader" />
+              <div className={HALF_COL} role="columnheader">
+                <Monitor aria-hidden className="size-3.5 shrink-0" />
+                <Tip label={p.halfDesktopHint}>
+                  <span className="font-medium">{p.halfDesktop}</span>
+                </Tip>
+              </div>
+              <div className={HALF_COL} role="columnheader">
+                <Package aria-hidden className="size-3.5 shrink-0" />
+                {scopeSelector ?? <span className="truncate font-medium">{p.halfAgentIn(label)}</span>}
+              </div>
+            </div>
+            {packages.map(pkg => (
+              <PackageRow
+                busy={pkg.agent ? agentBusy(pkg.agent) : false}
+                key={pkg.key}
+                onAgentToggle={(row, enable) => {
+                  if (!row.key) {
+                    return
+                  }
+
+                  void toggleAgentPlugin(requestGateway, row.key, enable, p.toggleFailed(row.name), scope)
+                }}
+                onAgentUpdate={row => {
+                  void updateAgentPlugin(requestGateway, row.name, p.updateFailed(row.name), scope).then(applied => {
+                    if (applied) {
+                      notify({ kind: 'success', message: p.updated(row.name) })
+                      void rescanAll(requestGateway, scope)
+                    }
+                  })
+                }}
+                pkg={pkg}
+                scope={scope}
+                scopeLabel={label}
+              />
+            ))}
+          </div>
+        )}
+      </div>
+
+      <section
+        className="relative flex min-h-9 flex-col overflow-hidden border-t border-(--ui-stroke-secondary)"
+        ref={sectionRef}
+      >
+        <div
+          className="group/catsash absolute inset-x-0 top-0 z-10 h-1 -translate-y-1/2 cursor-row-resize"
+          data-testid="plugin-catalog-sash"
+          onDoubleClick={() => setPaneHeightOverride(CATALOG_PANE_ID, undefined)}
+          onPointerDown={startDrag}
+        >
+          <div
+            className={cn(
+              'absolute inset-x-0 top-1/2 h-px -translate-y-1/2 transition-colors',
+              dragging ? 'bg-(--ui-stroke-secondary)' : 'group-hover/catsash:bg-(--ui-stroke-secondary)'
+            )}
+          />
+        </div>
+        <div className="flex shrink-0 items-center justify-between px-3 py-1.5">
+          <span className="text-[0.62rem] font-medium tracking-wide uppercase text-(--ui-text-quaternary)">
+            {p.catalogTitle}
+          </span>
+          <Button onClick={() => setPaneHeightOverride(CATALOG_PANE_ID, open ? 0 : undefined)} size="xs" variant="text">
+            {open ? p.catalogHide : p.catalogBrowse}
+          </Button>
+        </div>
+        {pickerMounted && (
+          <div className={cn('flex min-h-0 flex-col gap-1 px-3 pb-2', !open && 'hidden')}>
+            <div
+              style={{
+                border: '1px solid var(--ui-stroke-secondary)',
+                borderRadius: 8,
+                flex: `0 1 ${height}px`,
+                maxWidth: '100%',
+                minHeight: 0,
+                minWidth: 320,
+                overflow: 'hidden',
+                position: 'relative',
+                width: '100%'
+              }}
+            >
+              <iframe
+                sandbox="allow-scripts allow-same-origin"
+                src={CATALOG_PICKER_URL}
+                style={{
+                  background: 'transparent',
+                  border: 'none',
+                  height: '133.34%',
+                  pointerEvents: dragging ? 'none' : 'auto',
+                  transform: 'scale(0.75)',
+                  transformOrigin: 'top left',
+                  width: '133.34%'
+                }}
+                title={p.catalogTitle}
+              />
+            </div>
+            <p className="shrink-0 px-1 text-[0.65rem] leading-4 text-(--ui-text-quaternary)">{p.catalogHint}</p>
+          </div>
+        )}
+      </section>
+    </div>
+  )
+})
diff --git a/apps/desktop/src/app/capabilities/primitives.tsx b/apps/desktop/src/app/capabilities/primitives.tsx
new file mode 100644
index 0000000000..d6c5b2ad8f
--- /dev/null
+++ b/apps/desktop/src/app/capabilities/primitives.tsx
@@ -0,0 +1,60 @@
+import type { ReactNode } from 'react'
+
+import { useI18n } from '@/i18n'
+
+import { ListStripButton } from '../master-detail'
+import { PanelEmpty } from '../overlays/panel'
+
+// The chrome the Skills and Tools tabs share: one inspector header, one empty
+// state and one sort control, so switching between them never jumps.
+
+// Shared inspector header — mirrors Messaging's PlatformDetail so Skills and
+// Tools share one title/description block and tab switches don't jump.
+export function DetailHeader({
+  description,
+  pills,
+  title
+}: {
+  description: ReactNode
+  pills?: ReactNode
+  title: string
+}) {
+  return (
+    <header>
+      <div className="flex min-h-6 flex-wrap items-center gap-2">
+        <h3 className="min-w-0 truncate text-[0.9375rem] font-semibold tracking-tight">{title}</h3>
+        {pills}
+      </div>
+      <p className="mt-1 text-[length:var(--conversation-caption-font-size)] leading-(--conversation-caption-line-height) text-(--ui-text-tertiary)">
+        {description}
+      </p>
+    </header>
+  )
+}
+
+// Full-bleed empty state, matching the MCP tab (spans both columns, not a
+// cramped note in the left rail). Query-aware, and says "tools" not the
+// internal "toolsets".
+export function CapabilityEmpty({ noun, query }: { noun: string; query: string }) {
+  const { t } = useI18n()
+  const q = query.trim()
+
+  return (
+    <div className="flex h-full min-h-0 flex-1">
+      <PanelEmpty
+        description={q ? t.skills.emptyNothingMatches(q) : t.skills.emptyNoneAvailable(noun)}
+        icon="search"
+        title={t.skills.emptyNoneFound(noun)}
+      />
+    </div>
+  )
+}
+
+/** Most-used / least-used flip for a list strip. */
+export function SortButton({ desc, onFlip }: { desc: boolean; onFlip: () => void }) {
+  const { t } = useI18n()
+
+  return (
+    <ListStripButton onClick={onFlip}>{desc ? t.skills.sortMostUsedDesc : t.skills.sortLeastUsedAsc}</ListStripButton>
+  )
+}
diff --git a/apps/desktop/src/app/capabilities/scope-selector.tsx b/apps/desktop/src/app/capabilities/scope-selector.tsx
new file mode 100644
index 0000000000..a844ea0133
--- /dev/null
+++ b/apps/desktop/src/app/capabilities/scope-selector.tsx
@@ -0,0 +1,216 @@
+import { useStore } from '@nanostores/react'
+import { useQuery } from '@tanstack/react-query'
+import { useMemo, useState } from 'react'
+
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select'
+import type { DesktopRosterAgent } from '@/global'
+import { getProfiles, type ProfileScope, profileScopeKey } from '@/hermes'
+import { useI18n } from '@/i18n'
+import { cn } from '@/lib/utils'
+import { activeGatewayConnectionId } from '@/store/gateway'
+import { $activeGatewayProfile, normalizeProfileKey } from '@/store/profile'
+
+import { useOnProfileSwitch } from '../hooks/use-on-profile-switch'
+
+interface ScopeOption {
+  key: string
+  label: string
+  value: string
+}
+
+export interface CapabilityScope {
+  /** Which profile's Skills/Tools/MCP config every tab reads and writes — and
+   *  on WHICH gateway. */
+  profile: ProfileScope
+  /** Cache-key form of `profile`: every scoped query key ends with it, and the
+   *  tabs are keyed on it so a scope change is a fresh tab. */
+  key: string
+  /** Scoped to a DIFFERENT backend than the window's active gateway? The MCP
+   *  tab's live-reload RPC rides the active gateway socket, which would reload
+   *  the wrong machine — it is withheld for cross-backend scopes. */
+  crossBackend: boolean
+  /** Display name of the selected profile (the Plugins tab's Agent column). */
+  label?: string
+  options: ScopeOption[]
+  value: string
+  onChange: (value: string) => void
+}
+
+/**
+ * The Capabilities scope: which profile's config the page is editing, and on
+ * which gateway. A profile belongs to one gateway, so on a multi-connection
+ * desktop the selector offers every (connection, profile) pair from the union
+ * agent roster and an explicit pick routes every read/write to that machine's
+ * backend. Defaults to the app-wide active profile. A `fixedProfile` (+
+ * optional `fixedConnection`) pins the scope outright, selector hidden.
+ */
+export function useCapabilityScope({
+  fixedConnection,
+  fixedProfile
+}: {
+  fixedConnection?: string
+  fixedProfile?: string
+}): CapabilityScope {
+  const activeProfile = useStore($activeGatewayProfile)
+  const [scopeOverride, setScopeOverride] = useState<null | string | { connectionId: string; profile: string }>(null)
+
+  const scopeProfile: ProfileScope = useMemo(
+    () =>
+      fixedProfile
+        ? fixedConnection
+          ? { connectionId: fixedConnection, profile: fixedProfile }
+          : fixedProfile
+        : (scopeOverride ?? activeProfile ?? null),
+    [activeProfile, fixedConnection, fixedProfile, scopeOverride]
+  )
+
+  const scopeKey = profileScopeKey(scopeProfile)
+
+  // The registry connection an explicit override pins — null for the ambient
+  // active-profile path and for fixed-profile pins without a connection.
+  const scopeConnectionId =
+    scopeProfile && typeof scopeProfile === 'object' ? (scopeProfile.connectionId ?? '').trim() || 'local' : null
+
+  const { data: profilesData } = useQuery({
+    queryKey: ['capabilities-profiles'],
+    queryFn: () => getProfiles(),
+    staleTime: 60_000,
+    // Pinned scope never shows the selector, so don't fetch the roster for it.
+    enabled: !fixedProfile
+  })
+
+  // v2 multi-connection registry: cheap local IPC to learn whether more than
+  // one gateway is registered. Only then is the (heavier) union agent roster
+  // fetched to feed the selector — single-connection setups keep the exact
+  // legacy profiles list. Both feature-detected for older Electron mains.
+  const registryBridge = window.hermesDesktop?.connections
+  const rosterBridge = window.hermesDesktop?.getAgentRoster
+
+  const { data: registryData } = useQuery({
+    queryKey: ['capabilities-connections-registry'],
+    queryFn: () => registryBridge!.list(),
+    staleTime: 60_000,
+    enabled: !fixedProfile && Boolean(registryBridge) && Boolean(rosterBridge)
+  })
+
+  const multiConnection = (registryData?.connections.length ?? 0) > 1
+
+  const { data: rosterData } = useQuery({
+    queryKey: ['capabilities-agent-roster'],
+    queryFn: () => rosterBridge!(),
+    staleTime: 60_000,
+    enabled: !fixedProfile && multiConnection
+  })
+
+  // An app-wide profile switch drops any scope override — the user just
+  // changed what "here" means, and a stale override pointing at the previous
+  // selection would be surprising.
+  useOnProfileSwitch(() => setScopeOverride(null))
+
+  // Scope-selector rows. Multi-connection desktops list every reachable
+  // (connection, profile) agent from the union roster — the selected profile
+  // is configured ON ITS OWN GATEWAY. Otherwise the legacy per-profile list.
+  const options: ScopeOption[] = useMemo(() => {
+    if (multiConnection && rosterData?.agents?.length) {
+      const activeId = activeGatewayConnectionId() ?? 'local'
+
+      return rosterData.agents.map((agent: DesktopRosterAgent) => ({
+        key: `${agent.connectionId}::${agent.profile}`,
+        label:
+          agent.connectionId === activeId
+            ? `${agent.profile} — ${agent.connectionLabel} (current)`
+            : `${agent.profile} — ${agent.connectionLabel}`,
+        value: `${agent.connectionId}::${agent.profile}`
+      }))
+    }
+
+    return (profilesData?.profiles ?? []).map(p => ({
+      key: p.name,
+      label: p.is_default ? 'Hermes (default)' : p.name,
+      value: p.name
+    }))
+  }, [multiConnection, profilesData, rosterData])
+
+  // The selector's current value must match one option's value exactly. On the
+  // roster path an ambient (non-override) scope is the active gateway's
+  // profile, which lives at `activeConnectionId::profile`.
+  const value = useMemo(() => {
+    if (scopeProfile && typeof scopeProfile === 'object') {
+      return `${(scopeProfile.connectionId ?? '').trim() || 'local'}::${scopeProfile.profile ?? ''}`
+    }
+
+    if (multiConnection && rosterData?.agents?.length) {
+      return `${activeGatewayConnectionId() ?? 'local'}::${normalizeProfileKey(scopeProfile)}`
+    }
+
+    return scopeProfile ?? ''
+  }, [multiConnection, rosterData, scopeProfile])
+
+  // Selector option values are `connectionId::profile` on multi-connection
+  // desktops (the roster path) and bare profile names otherwise, so one
+  // handler decodes both.
+  const onChange = (picked: string) => {
+    const sep = picked.indexOf('::')
+
+    // Roster picks (`connectionId::profile`) stay objects — a `local::` pick
+    // must PIN the local pool even while a remote gateway is active. Legacy
+    // bare-name picks stay strings so cache keys and routing are unchanged.
+    const next: ProfileScope =
+      sep >= 0 ? { connectionId: picked.slice(0, sep), profile: picked.slice(sep + 2) } : picked
+
+    if (profileScopeKey(next) === scopeKey) {
+      return
+    }
+
+    setScopeOverride(next as string | { connectionId: string; profile: string })
+  }
+
+  return {
+    crossBackend: scopeConnectionId !== null && scopeConnectionId !== (activeGatewayConnectionId() ?? 'local'),
+    key: scopeKey,
+    label: options.find(option => option.value === value)?.label,
+    onChange,
+    options,
+    profile: scopeProfile,
+    value
+  }
+}
+
+/**
+ * Scope selector, shown above EVERY Capabilities tab (Skills, Tools, MCP,
+ * Plugins). Lets the user configure ANY profile's capabilities — on any
+ * registered gateway — without switching the whole app. Only meaningful with
+ * >1 option; hidden otherwise to avoid clutter.
+ */
+export function CapabilityScopeSelector({
+  compact = false,
+  scope
+}: {
+  /** In Plugins, the selector belongs only to the Agent column. */
+  compact?: boolean
+  scope: CapabilityScope
+}) {
+  const { t } = useI18n()
+
+  if (scope.options.length <= 1) {
+    return null
+  }
+
+  return (
+    <div className={cn('flex min-w-0 items-center gap-2', compact ? 'flex-1' : 'border-b border-(--ui-stroke-secondary) px-3 py-2')}>
+      {!compact && <span className="text-[0.7rem] font-medium text-(--ui-text-tertiary)">{t.skills.configuringProfile}</span>}
+      <Select onValueChange={scope.onChange} value={scope.value}>
+        <SelectTrigger className={cn('text-xs', compact ? 'h-6 w-full max-w-64 px-2' : 'h-7 w-56')}>
+          <SelectValue />
+        </SelectTrigger>
+        <SelectContent>
+          {scope.options.map(option => (
+            <SelectItem key={option.key} value={option.value}>
+              {option.label}
+            </SelectItem>
+          ))}
+        </SelectContent>
+      </Select>
+    </div>
+  )
+}
diff --git a/apps/desktop/src/app/capabilities/skills/embedded-hub-picker.tsx b/apps/desktop/src/app/capabilities/skills/embedded-hub-picker.tsx
new file mode 100644
index 0000000000..9139cecbe9
--- /dev/null
+++ b/apps/desktop/src/app/capabilities/skills/embedded-hub-picker.tsx
@@ -0,0 +1,249 @@
+import { useStore } from '@nanostores/react'
+import { memo, type PointerEvent as ReactPointerEvent, useEffect, useRef, useState } from 'react'
+
+import { Button } from '@/components/ui/button'
+import type { ProfileScope } from '@/hermes'
+import { useI18n } from '@/i18n'
+import { Loader2 } from '@/lib/icons'
+import { useStoreSelector } from '@/lib/use-session-slice'
+import { cn } from '@/lib/utils'
+import { $hubActions, installHubSkill, notifyHubActionFailed, UPDATE_ALL_KEY, updateHubSkills } from '@/store/hub-actions'
+import { notify, notifyError } from '@/store/notifications'
+import { $paneHeightOverride, setPaneHeightOverride } from '@/store/panes'
+
+// The REAL Skills Hub page (docs site) embedded as a one-click picker — the
+// same trick the Bot Mode agent editor uses. `?embed=picker` hides the docs
+// chrome and adds a "+ Add to this Agent" button per card, which posts
+//   { type: 'hermes-skill-pick', name, identifier, installCmd, source }
+// to the parent window. We validate the origin and route the install through
+// the standard hub action pipeline (background action + tailed log + Skills
+// list invalidation), scoped to the Capabilities profile selector.
+const HUB_ORIGIN = 'https://hermes-agent.nousresearch.com'
+const HUB_PICKER_URL = `${HUB_ORIGIN}/docs/skills?embed=picker`
+
+// Hub viewport height: persisted through the shared pane store (same one the
+// terminal/editor panes use), dragged from the section's TOP edge — "pull the
+// hub up" — clamped so neither the hub nor the skills list above vanishes.
+const HUB_PANE_ID = 'capabilities-hub'
+const HUB_DEFAULT_PX = 380
+const HUB_MIN_PX = 120
+const HUB_MAX_VH = 0.75
+// Collapse threshold, mirroring DetailPane: a persisted height at/below this
+// reads as "collapsed to the header" (the toggle stores 0).
+const HUB_COLLAPSED_PX = 4
+// Room the sash must always leave for the content ABOVE the picker (the
+// installed-skills list plus its strip) so dragging the hub up can never
+// crush the list to zero and shove its chrome under the hub header.
+const HUB_LIST_RESERVED_PX = 176
+
+interface SkillPickMessage {
+  identifier?: string
+  installCmd?: string
+  name?: string
+  source?: string
+  type?: string
+}
+
+interface EmbeddedHubPickerProps {
+  /** Kept mounted but fully hidden (display:none). The Capabilities view uses
+   *  this to preserve the loaded hub iframe across tab switches — a plain
+   *  unmount would reload the whole docs site on every return to Skills. */
+  hidden?: boolean
+  /** Names of skills already installed in the scoped profile — a pick that
+   *  matches is refused with a toast instead of re-running the install. */
+  installedNames: ReadonlySet<string>
+  /** Capabilities profile-scope override — installs land in THIS profile;
+   *  undefined/null targets the app-wide active profile. */
+  profile?: ProfileScope
+}
+
+/** The Skills Hub browser for the Skills tab: a resizable iframe of the live
+ *  hub where every card installs with one click. Expanded by default —
+ *  discovery IS the point — with a collapse toggle (persisted, like every
+ *  other pane) and an update-all action. Memoized: the iframe must not sit in
+ *  the parent's keystroke/re-render path. */
+export const EmbeddedHubPicker = memo(function EmbeddedHubPicker({
+  hidden = false,
+  installedNames,
+  profile
+}: EmbeddedHubPickerProps) {
+  const { t } = useI18n()
+  const h = t.skills.hub
+  // Subscribe to the ONE flag this header renders, not the whole action map —
+  // $hubActions churns on every tailed log line during an install.
+  const updating = useStoreSelector($hubActions, actions => actions[UPDATE_ALL_KEY]?.running ?? false)
+  // Collapse state rides the same persisted height override the sash writes
+  // (0 = collapsed to the header), so "Hide the hub browser" survives tab
+  // switches and restarts instead of re-expanding — and re-loading the docs
+  // site — on every visit. Same contract as DetailPane.
+  const heightOverride = useStore($paneHeightOverride(HUB_PANE_ID))
+  const height = heightOverride ?? HUB_DEFAULT_PX
+  const open = height > HUB_COLLAPSED_PX
+  const [dragging, setDragging] = useState(false)
+  const sectionRef = useRef<HTMLElement>(null)
+
+  // Top-edge sash: dragging UP grows the hub (shrinking the skills list above,
+  // which is the flex-1 sibling). Same gesture as DetailPane / the shell's
+  // bottom panes; double-click resets to the default height. The iframe gets
+  // pointer-events disabled for the duration or it swallows the pointermoves.
+  const startDrag = (event: ReactPointerEvent<HTMLDivElement>) => {
+    if (event.button !== 0) {
+      return
+    }
+
+    event.preventDefault()
+    const startY = event.clientY
+    const startHeight = height
+    // Clamp against the actual Capabilities column, not just the window: the
+    // hub may never grow past "column minus the list's reserved strip", so
+    // the installed list always keeps real height and its header/footer can't
+    // end up sharing pixels with the hub header.
+    const column = sectionRef.current?.parentElement
+    const columnMax = column ? column.clientHeight - HUB_LIST_RESERVED_PX : Number.POSITIVE_INFINITY
+    const max = Math.max(HUB_MIN_PX, Math.round(Math.min(window.innerHeight * HUB_MAX_VH, columnMax)))
+    setDragging(true)
+
+    const onMove = (move: globalThis.PointerEvent) => {
+      setPaneHeightOverride(
+        HUB_PANE_ID,
+        Math.round(Math.min(max, Math.max(HUB_MIN_PX, startHeight + (startY - move.clientY))))
+      )
+    }
+
+    const onUp = () => {
+      window.removeEventListener('pointermove', onMove)
+      setDragging(false)
+    }
+
+    window.addEventListener('pointermove', onMove)
+    window.addEventListener('pointerup', onUp, { once: true })
+  }
+
+  // Picker messages from the embedded hub page. Origin-checked; installs route
+  // through the same store pipeline the hub rows use, so the action log,
+  // optimistic flips, and Skills-list refresh all come for free.
+  useEffect(() => {
+    if (!open) {
+      return undefined
+    }
+
+    const onMessage = (event: MessageEvent) => {
+      if (event.origin !== HUB_ORIGIN) {
+        return
+      }
+
+      const data = event.data as SkillPickMessage | null
+
+      if (!data || data.type !== 'hermes-skill-pick' || !data.name) {
+        return
+      }
+
+      const target = String(data.identifier || data.name)
+      const label = String(data.name)
+
+      // Already installed in this scope → tell the user, don't reinstall.
+      if (installedNames.has(label) || installedNames.has(target)) {
+        notify({ kind: 'success', title: h.alreadyInstalled(label), message: '' })
+
+        return
+      }
+
+      notify({ kind: 'success', title: h.installStarted(label), message: h.actionLog })
+      void installHubSkill(target, profile).catch(err => notifyHubActionFailed(err, h.actionFailed, label, profile))
+    }
+
+    window.addEventListener('message', onMessage)
+
+    return () => window.removeEventListener('message', onMessage)
+  }, [h, installedNames, open, profile])
+
+  const updateAll = () => {
+    notify({ kind: 'success', title: h.updateStarted, message: h.actionLog })
+    void updateHubSkills(profile).catch(err => notifyError(err, h.actionFailed))
+  }
+
+  return (
+    <section
+      className={cn(
+        // Shrinkable (no shrink-0) + overflow-hidden: the picker is a flex
+        // child of the Capabilities column. Before, its fixed-height viewport
+        // made the section's min-content height rigid, so a short window (or a
+        // tall persisted drag height) starved the installed list to 0px and
+        // the list's strip/footer painted straight over this header. Now the
+        // section clips its own content and gives height back to the list;
+        // min-h keeps the header row itself always visible.
+        'relative flex min-h-9 flex-col overflow-hidden border-t border-(--ui-stroke-secondary)',
+        hidden && 'hidden'
+      )}
+      ref={sectionRef}
+    >
+      {/* Top-edge drag sash — pull the whole hub section up/down. */}
+      <div
+        className="group/hubsash absolute inset-x-0 top-0 z-10 h-1 -translate-y-1/2 cursor-row-resize"
+        onDoubleClick={() => setPaneHeightOverride(HUB_PANE_ID, undefined)}
+        onPointerDown={startDrag}
+      >
+        <div
+          className={cn(
+            'absolute inset-x-0 top-1/2 h-px -translate-y-1/2 transition-colors',
+            dragging ? 'bg-(--ui-stroke-secondary)' : 'group-hover/hubsash:bg-(--ui-stroke-secondary)'
+          )}
+        />
+      </div>
+      <div className="flex shrink-0 items-center justify-between px-3 py-1.5">
+        <span className="text-[0.7rem] font-medium text-(--ui-text-tertiary)">{h.pickerTitle}</span>
+        <div className="flex items-center gap-1">
+          <Button disabled={updating} onClick={updateAll} size="xs" variant="text">
+            {updating && <Loader2 className="size-3 animate-spin" />}
+            {updating ? h.updating : h.updateAll}
+          </Button>
+          <Button onClick={() => setPaneHeightOverride(HUB_PANE_ID, open ? 0 : undefined)} size="xs" variant="text">
+            {open ? h.pickerHide : h.pickerBrowse}
+          </Button>
+        </div>
+      </div>
+      {open && (
+        <div className="flex min-h-0 flex-col gap-1 px-3 pb-2">
+          {/* Resizable viewport: height comes from the top-edge drag sash
+              above (persisted; double-click resets). flex-basis instead of a
+              hard height so a short window shrinks the hub viewport rather
+              than letting it spill over the list. The iframe is rendered
+              oversized and scaled DOWN (133% × 0.75) so the hub page starts
+              zoomed out — the cross-origin page itself can't be styled, but
+              scaling the frame is ours. */}
+          <div
+            style={{
+              border: '1px solid var(--ui-stroke-secondary)',
+              borderRadius: 8,
+              flex: `0 1 ${height}px`,
+              maxWidth: '100%',
+              minHeight: 0,
+              minWidth: 320,
+              overflow: 'hidden',
+              position: 'relative',
+              width: '100%'
+            }}
+          >
+            <iframe
+              sandbox="allow-scripts allow-same-origin"
+              src={HUB_PICKER_URL}
+              style={{
+                background: 'transparent',
+                border: 'none',
+                height: '133.34%',
+                // While the sash drags, the cross-origin iframe must not eat
+                // the pointermove stream.
+                pointerEvents: dragging ? 'none' : 'auto',
+                transform: 'scale(0.75)',
+                transformOrigin: 'top left',
+                width: '133.34%'
+              }}
+              title={h.pickerTitle}
+            />
+          </div>
+          <p className="shrink-0 px-1 text-[0.65rem] leading-4 text-(--ui-text-quaternary)">{h.pickerHint}</p>
+        </div>
+      )}
+    </section>
+  )
+})
diff --git a/apps/desktop/src/app/capabilities/skills/frontmatter.test.ts b/apps/desktop/src/app/capabilities/skills/frontmatter.test.ts
new file mode 100644
index 0000000000..02b8ca634a
--- /dev/null
+++ b/apps/desktop/src/app/capabilities/skills/frontmatter.test.ts
@@ -0,0 +1,28 @@
+import { describe, expect, it } from 'vitest'
+
+import { parseFrontmatter } from './frontmatter'
+
+describe('parseFrontmatter', () => {
+  it('splits the leading YAML block from the body', () => {
+    const { body, meta } = parseFrontmatter('---\nname: web-research\nversion: 1.2.0\n---\n\n# Web Research\n\nSteps.')
+
+    expect(meta).toEqual([
+      ['name', 'web-research'],
+      ['version', '1.2.0']
+    ])
+    expect(body.trim()).toBe('# Web Research\n\nSteps.')
+  })
+
+  it('keeps a nested block with its key, de-indented one level', () => {
+    const { meta } = parseFrontmatter('---\nallowed-tools:\n  - Read\n  - Write\nname: x\n---\nbody')
+
+    expect(meta).toEqual([
+      ['allowed-tools', '- Read\n- Write'],
+      ['name', 'x']
+    ])
+  })
+
+  it('returns the whole content as body when there is no frontmatter', () => {
+    expect(parseFrontmatter('# Just a skill')).toEqual({ body: '# Just a skill', meta: [] })
+  })
+})
diff --git a/apps/desktop/src/app/capabilities/skills/frontmatter.ts b/apps/desktop/src/app/capabilities/skills/frontmatter.ts
new file mode 100644
index 0000000000..00e1b2657c
--- /dev/null
+++ b/apps/desktop/src/app/capabilities/skills/frontmatter.ts
@@ -0,0 +1,39 @@
+// Frontmatter parse for display: the YAML block between the leading `---`
+// fences, flattened to top-level `key: value` rows (nested blocks render as
+// their raw indented text). Display-only — never fed back to the backend.
+export function parseFrontmatter(content: string): { body: string; meta: [string, string][] } {
+  const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(content)
+
+  if (!match) {
+    return { body: content, meta: [] }
+  }
+
+  const meta: [string, string][] = []
+  let currentKey: null | string = null
+  let block: string[] = []
+
+  const flush = () => {
+    if (currentKey !== null) {
+      meta.push([currentKey, block.join('\n').trim()])
+    }
+
+    currentKey = null
+    block = []
+  }
+
+  for (const line of match[1].split(/\r?\n/)) {
+    const kv = /^(\w[\w-]*):\s?(.*)$/.exec(line)
+
+    if (kv) {
+      flush()
+      currentKey = kv[1]
+      block = kv[2] ? [kv[2]] : []
+    } else if (currentKey !== null) {
+      block.push(line.replace(/^ {2}/, ''))
+    }
+  }
+
+  flush()
+
+  return { body: content.slice(match[0].length), meta }
+}
diff --git a/apps/desktop/src/app/capabilities/skills/official-skill-detail.tsx b/apps/desktop/src/app/capabilities/skills/official-skill-detail.tsx
new file mode 100644
index 0000000000..533e5a99d9
--- /dev/null
+++ b/apps/desktop/src/app/capabilities/skills/official-skill-detail.tsx
@@ -0,0 +1,83 @@
+import { useQuery } from '@tanstack/react-query'
+import { useMemo } from 'react'
+
+import { Button } from '@/components/ui/button'
+import { CountSkeleton } from '@/components/ui/skeleton'
+import { previewSkillHub, type ProfileScope, profileScopeKey } from '@/hermes'
+import { useI18n } from '@/i18n'
+import { Loader2 } from '@/lib/icons'
+import type { OfficialSkillInfo } from '@/types/hermes'
+
+import { PanelPill } from '../../overlays/panel'
+import { asText, prettyName } from '../../settings/helpers'
+import { DetailHeader } from '../primitives'
+
+import { parseFrontmatter } from './frontmatter'
+
+// Detail pane for a not-yet-installed catalog skill.
+export function OfficialSkillDetail({
+  installing,
+  onInstall,
+  profile,
+  skill
+}: {
+  installing: boolean
+  onInstall: () => void
+  profile?: ProfileScope
+  skill: OfficialSkillInfo
+}) {
+  const { t } = useI18n()
+
+  const previewQuery = useQuery({
+    queryKey: ['official-skill-preview', skill.identifier, profileScopeKey(profile)],
+    queryFn: () => previewSkillHub(skill.identifier, profile),
+    staleTime: 5 * 60_000,
+    retry: false
+  })
+
+  const parsed = useMemo(
+    () => (previewQuery.data?.skill_md ? parseFrontmatter(previewQuery.data.skill_md) : null),
+    [previewQuery.data]
+  )
+
+  return (
+    <>
+      <DetailHeader
+        description={asText(skill.description) || t.skills.noDescription}
+        pills={
+          <>
+            <PanelPill>{prettyName(skill.category)}</PanelPill>
+            <PanelPill tone="muted">{t.skills.officialPill}</PanelPill>
+          </>
+        }
+        title={skill.name}
+      />
+      <div className="flex items-center gap-2">
+        <Button disabled={installing} onClick={onInstall} size="xs" variant="textStrong">
+          {installing && <Loader2 className="size-3 animate-spin" />}
+          {installing ? t.skills.hub.installing : t.skills.hub.install}
+        </Button>
+      </div>
+      {parsed && parsed.meta.length > 0 && (
+        <div className="grid gap-1 rounded-lg border border-(--ui-stroke-tertiary) bg-(--ui-bg-quinary) p-3">
+          {parsed.meta.map(([key, value]) => (
+            <div className="flex gap-2 text-[0.68rem] leading-4" key={key}>
+              <span className="w-24 shrink-0 font-medium text-(--ui-text-tertiary)">{key}</span>
+              <span className="min-w-0 whitespace-pre-wrap break-words text-(--ui-text-secondary)">{value}</span>
+            </div>
+          ))}
+        </div>
+      )}
+      {previewQuery.isLoading ? (
+        <CountSkeleton />
+      ) : parsed ? (
+        <pre
+          className="overflow-auto whitespace-pre-wrap wrap-break-word rounded-lg border border-(--ui-stroke-tertiary) bg-(--ui-bg-quinary) p-3 font-mono text-[0.68rem] leading-relaxed"
+          data-selectable-text="true"
+        >
+          {parsed.body.trim() || t.skills.noDescription}
+        </pre>
+      ) : null}
+    </>
+  )
+}
diff --git a/apps/desktop/src/app/capabilities/skills/skill-detail.tsx b/apps/desktop/src/app/capabilities/skills/skill-detail.tsx
new file mode 100644
index 0000000000..483d01e48f
--- /dev/null
+++ b/apps/desktop/src/app/capabilities/skills/skill-detail.tsx
@@ -0,0 +1,95 @@
+import { useQuery } from '@tanstack/react-query'
+import { useMemo } from 'react'
+
+import { Button } from '@/components/ui/button'
+import { CountSkeleton } from '@/components/ui/skeleton'
+import { getSkillContent, type ProfileScope, profileScopeKey } from '@/hermes'
+import { useI18n } from '@/i18n'
+import type { SkillInfo } from '@/types/hermes'
+
+import { PanelPill } from '../../overlays/panel'
+import { asText, prettyName } from '../../settings/helpers'
+import { DetailHeader } from '../primitives'
+
+import { parseFrontmatter } from './frontmatter'
+import { categoryFor } from './skills-data'
+
+export function SkillDetail({
+  onArchive,
+  onEdit,
+  profile,
+  skill
+}: {
+  onArchive: () => void
+  onEdit: () => void
+  profile?: ProfileScope
+  skill: SkillInfo
+}) {
+  const { t } = useI18n()
+  // Only learned/local skills are the user's to rewrite or archive — bundled
+  // and hub skills are managed by their sources.
+  const editable = skill.provenance === 'agent'
+
+  // The FULL skill — frontmatter metadata + complete SKILL.md body — for any
+  // provenance, scoped to the Capabilities profile selector. The row list only
+  // carries name/description; the pane shows the whole thing.
+  const contentQuery = useQuery({
+    queryKey: ['skill-content', skill.name, profileScopeKey(profile)],
+    queryFn: () => getSkillContent(skill.name, profile),
+    staleTime: 60_000
+  })
+
+  const parsed = useMemo(
+    () => (contentQuery.data ? parseFrontmatter(contentQuery.data.content) : null),
+    [contentQuery.data]
+  )
+
+  return (
+    <>
+      <DetailHeader
+        description={asText(skill.description) || t.skills.noDescription}
+        pills={
+          <>
+            <PanelPill>{prettyName(categoryFor(skill))}</PanelPill>
+            {skill.provenance && skill.provenance !== 'bundled' && (
+              <PanelPill tone={skill.provenance === 'agent' ? 'good' : 'muted'}>
+                {t.skills.provenance[skill.provenance]}
+              </PanelPill>
+            )}
+          </>
+        }
+        title={skill.name}
+      />
+      {editable && (
+        <div className="flex items-center gap-2">
+          <Button onClick={onEdit} size="xs" variant="text">
+            {t.skills.edit}
+          </Button>
+          <Button className="text-destructive hover:text-destructive" onClick={onArchive} size="xs" variant="text">
+            {t.skills.archive}
+          </Button>
+        </div>
+      )}
+      {parsed && parsed.meta.length > 0 && (
+        <div className="grid gap-1 rounded-lg border border-(--ui-stroke-tertiary) bg-(--ui-bg-quinary) p-3">
+          {parsed.meta.map(([key, value]) => (
+            <div className="flex gap-2 text-[0.68rem] leading-4" key={key}>
+              <span className="w-24 shrink-0 font-medium text-(--ui-text-tertiary)">{key}</span>
+              <span className="min-w-0 whitespace-pre-wrap break-words text-(--ui-text-secondary)">{value}</span>
+            </div>
+          ))}
+        </div>
+      )}
+      {contentQuery.isLoading ? (
+        <CountSkeleton />
+      ) : parsed ? (
+        <pre
+          className="overflow-auto whitespace-pre-wrap wrap-break-word rounded-lg border border-(--ui-stroke-tertiary) bg-(--ui-bg-quinary) p-3 font-mono text-[0.68rem] leading-relaxed"
+          data-selectable-text="true"
+        >
+          {parsed.body.trim() || t.skills.noDescription}
+        </pre>
+      ) : null}
+    </>
+  )
+}
diff --git a/apps/desktop/src/app/capabilities/skills/skills-data.ts b/apps/desktop/src/app/capabilities/skills/skills-data.ts
new file mode 100644
index 0000000000..14075c4ba4
--- /dev/null
+++ b/apps/desktop/src/app/capabilities/skills/skills-data.ts
@@ -0,0 +1,76 @@
+import { useQuery } from '@tanstack/react-query'
+
+import { getSkills, type ProfileScope, profileScopeKey } from '@/hermes'
+import { normalize } from '@/lib/text'
+import type { OfficialSkillInfo, SkillInfo } from '@/types/hermes'
+
+import { asText, includesQuery } from '../../settings/helpers'
+
+// Skills live in the RQ cache so switching tabs/pages paints the cached list
+// instantly (no reload flash) and mount only fires a deduped background
+// refetch. A profile swap globally invalidates (see store/profile), so this
+// plain key refetches against the new backend automatically.
+// `store/hub-actions` invalidates it after a hub (un)install — it imports this
+// constant rather than re-spelling the key.
+export const SKILLS_QUERY_KEY = ['skills-list'] as const
+
+/** The list key for one scope: the plain key plus the Capabilities scope key,
+ *  so every scoped profile keeps its own cached copy (prefix invalidations
+ *  still match). */
+export const skillsQueryKey = (profile: ProfileScope) => [...SKILLS_QUERY_KEY, profileScopeKey(profile)]
+
+export function useSkillsQuery(profile: ProfileScope) {
+  return useQuery({
+    queryKey: skillsQueryKey(profile),
+    queryFn: () => getSkills(profile),
+    staleTime: 0
+  })
+}
+
+export const usageOf = (skill: SkillInfo): number => (typeof skill.usage === 'number' ? skill.usage : 0)
+
+export const categoryFor = (skill: SkillInfo): string => asText(skill.category) || 'general'
+
+// Catalog rows have no usage yet — plain A–Z, with tags as searchable metadata.
+export function filteredOfficial(skills: OfficialSkillInfo[], query: string): OfficialSkillInfo[] {
+  const q = normalize(query)
+
+  return skills
+    .filter(
+      skill =>
+        !q ||
+        includesQuery(skill.name, q) ||
+        includesQuery(skill.description, q) ||
+        includesQuery(skill.category, q) ||
+        skill.tags.some(tag => includesQuery(tag, q))
+    )
+    .sort((a, b) => asText(a.name).localeCompare(asText(b.name)))
+}
+
+export function filteredSkills(skills: SkillInfo[], query: string, desc: boolean): SkillInfo[] {
+  const q = normalize(query)
+  const sign = desc ? 1 : -1
+
+  return skills
+    .filter(
+      skill =>
+        !q || includesQuery(skill.name, q) || includesQuery(skill.description, q) || includesQuery(skill.category, q)
+    )
+    .sort((a, b) => sign * (usageOf(b) - usageOf(a)) || asText(a.name).localeCompare(asText(b.name)))
+}
+
+/** The user's busiest categories, for the search field's rotating placeholder
+ *  nudges — they teach that search understands categories, not just titles. */
+export function skillSearchTerms(skills: SkillInfo[]): string[] {
+  const counts = new Map<string, number>()
+
+  for (const skill of skills) {
+    const key = categoryFor(skill)
+    counts.set(key, (counts.get(key) || 0) + 1)
+  }
+
+  return [...counts.entries()]
+    .sort(([, a], [, b]) => b - a)
+    .slice(0, 5)
+    .map(([category]) => category.toLowerCase())
+}
diff --git a/apps/desktop/src/app/capabilities/skills/skills-tab.tsx b/apps/desktop/src/app/capabilities/skills/skills-tab.tsx
new file mode 100644
index 0000000000..639dfc4617
--- /dev/null
+++ b/apps/desktop/src/app/capabilities/skills/skills-tab.tsx
@@ -0,0 +1,381 @@
+import { compactNumber } from '@hermes/shared'
+import { useStore } from '@nanostores/react'
+import { useQuery } from '@tanstack/react-query'
+import { type ReactNode, useCallback, useMemo, useState } from 'react'
+
+import { ArchiveSkillConfirmDialog } from '@/app/learning/archive-skill-confirm-dialog'
+import { CodeEditor } from '@/components/chat/code-editor'
+import { Badge } from '@/components/ui/badge'
+import { Button } from '@/components/ui/button'
+import { editLearningNode, getLearningNode, getOfficialSkills, type ProfileScope, profileScopeKey, setSkillEnabled } from '@/hermes'
+import { useI18n } from '@/i18n'
+import { Loader2 } from '@/lib/icons'
+import { Codecs, persistentAtom } from '@/lib/persisted'
+import { queryClient } from '@/lib/query-client'
+import { invalidateSlashCompletions } from '@/lib/slash-completion-cache'
+import { useStoreSelector } from '@/lib/use-session-slice'
+import { $hubActions, installHubSkill, notifyHubActionFailed, OFFICIAL_SKILLS_KEY } from '@/store/hub-actions'
+import { notify, notifyError } from '@/store/notifications'
+import type { OfficialSkillInfo, SkillInfo } from '@/types/hermes'
+
+import {
+  CapRow,
+  DetailColumn,
+  DetailPane,
+  ListColumn,
+  ListStrip,
+  ListStripMenu,
+  type ListStripMenuToggle,
+  MasterDetail
+} from '../../master-detail'
+import { prettyName } from '../../settings/helpers'
+import { CapabilityEmpty, SortButton } from '../primitives'
+
+import { OfficialSkillDetail } from './official-skill-detail'
+import { SkillDetail } from './skill-detail'
+import { categoryFor, filteredOfficial, filteredSkills, skillsQueryKey, usageOf } from './skills-data'
+
+// Sort direction for the Skills list — persisted so the tab remembers
+// most/least-used across navigations and restarts.
+const $skillsSortDesc = persistentAtom('hermes.desktop.capabilities.skillsSortDesc', true, Codecs.bool)
+
+// Row subtitle: category, with non-default origins badged.
+function skillSubtitle(skill: SkillInfo): ReactNode {
+  const category = prettyName(categoryFor(skill))
+  const provenance = skill.provenance
+
+  return (
+    <>
+      <span className="truncate">{category}</span>
+      {provenance === 'agent' && (
+        <Badge className="shrink-0 normal-case" variant="default">
+          learned
+        </Badge>
+      )}
+      {provenance === 'hub' && (
+        <Badge className="shrink-0 normal-case" variant="muted">
+          hub
+        </Badge>
+      )}
+    </>
+  )
+}
+
+interface SkillsTabProps {
+  /** The scope's skill list, straight from the shell's query. */
+  skills: SkillInfo[]
+  /** The (connection, profile) scope every read and write routes to. */
+  profile: ProfileScope
+  query: string
+  /** Page-level refresh: a saved skill edit reloads the same way the refresh
+   *  hotkey does, counts and slash completions included. */
+  onRefresh: () => void
+}
+
+/** The Skills tab: installed skills, official optional skills, and learned-skill editing. */
+export function SkillsTab({ onRefresh, profile, query, skills }: SkillsTabProps) {
+  const { t } = useI18n()
+  const skillsSortDesc = useStore($skillsSortDesc)
+  const [bulkBusy, setBulkBusy] = useState(false)
+  const [selectedSkill, setSelectedSkill] = useState<string | null>(null)
+  const [selectedOfficial, setSelectedOfficial] = useState<string | null>(null)
+
+  const { data: officialData } = useQuery({
+    queryKey: [...OFFICIAL_SKILLS_KEY, profileScopeKey(profile)],
+    queryFn: () => getOfficialSkills(profile),
+    staleTime: 60_000,
+    retry: false
+  })
+
+  // Learned/local skills are editable + archivable, mirroring the memory
+  // graph (same /api/learning/node endpoints — delete archives, restorable
+  // via `hermes curator restore`).
+  const [skillEditor, setSkillEditor] = useState<null | { content: string; name: string }>(null)
+  const [skillDraft, setSkillDraft] = useState('')
+  const [skillSaving, setSkillSaving] = useState(false)
+  const [archiveTarget, setArchiveTarget] = useState<null | string>(null)
+
+  // Optimistic write-through against the scoped Skills key: toggles/bulk/
+  // archive repaint instantly; the next background refetch reconciles.
+  const setSkills = useCallback(
+    (fn: (cur: SkillInfo[] | undefined) => SkillInfo[] | undefined) =>
+      queryClient.setQueryData<SkillInfo[]>(skillsQueryKey(profile), prev => fn(prev) ?? prev),
+    [profile]
+  )
+
+  const visibleSkills = useMemo(() => filteredSkills(skills, query, skillsSortDesc), [query, skills, skillsSortDesc])
+
+  // Installed-name set stays unfiltered so search cannot make a skill look absent.
+  const installedSkillNames = useMemo(() => new Set(skills.map(s => s.name)), [skills])
+
+  const visibleOfficial = useMemo(() => {
+    const catalog = (officialData?.skills ?? []).filter(skill => !skill.installed && !installedSkillNames.has(skill.name))
+
+    return filteredOfficial(catalog, query)
+  }, [installedSkillNames, officialData, query])
+
+  const runningInstallKey = useStoreSelector($hubActions, actions =>
+    Object.keys(actions)
+      .filter(key => actions[key]?.running)
+      .sort()
+      .join('|')
+  )
+
+  const runningInstalls = useMemo(() => new Set(runningInstallKey.split('|').filter(Boolean)), [runningInstallKey])
+
+  // Keep a valid selection: fall back to the first visible row when the
+  // current selection is filtered out (or nothing is selected yet).
+  const activeSkill = useMemo(
+    () => visibleSkills.find(s => s.name === selectedSkill) ?? visibleSkills[0] ?? null,
+    [selectedSkill, visibleSkills]
+  )
+
+  const activeOfficial = useMemo(
+    () => visibleOfficial.find(skill => skill.identifier === selectedOfficial) ?? null,
+    [selectedOfficial, visibleOfficial]
+  )
+
+  function handleInstallOfficial(skill: OfficialSkillInfo) {
+    notify({ kind: 'success', title: t.skills.hub.installStarted(skill.name), message: t.skills.hub.actionLog })
+    void installHubSkill(skill.identifier, profile).catch(err =>
+      notifyHubActionFailed(err, t.skills.hub.actionFailed, skill.name, profile)
+    )
+  }
+
+  async function handleToggleSkill(skill: SkillInfo, enabled: boolean) {
+    setSkills(current => current?.map(row => (row.name === skill.name ? { ...row, enabled } : row)) ?? current)
+
+    try {
+      await setSkillEnabled(skill.name, enabled, profile)
+      // A disabled skill loses its `/name` command, so the composer's cached
+      // `/` list has to be dropped along with the row repaint.
+      invalidateSlashCompletions()
+    } catch (err) {
+      setSkills(
+        current => current?.map(row => (row.name === skill.name ? { ...row, enabled: !enabled } : row)) ?? current
+      )
+      notifyError(err, t.skills.failedToUpdate(skill.name))
+    }
+  }
+
+  // Sequential on purpose: each toggle is a config read-modify-write on the
+  // backend; parallel calls would race the disabled-list save.
+  async function bulkApply(targets: SkillInfo[], enabled: boolean) {
+    if (bulkBusy || targets.length === 0) {
+      return
+    }
+
+    setBulkBusy(true)
+
+    let done = 0
+
+    try {
+      for (const row of targets) {
+        await setSkillEnabled(row.name, enabled, profile)
+        setSkills(cur => cur?.map(r => (r.name === row.name ? { ...r, enabled } : r)) ?? cur)
+        done += 1
+      }
+
+      notify({ kind: 'success', title: t.skills.bulkUpdated(done), message: '' })
+    } catch (err) {
+      notifyError(err, t.skills.failedToUpdate(t.skills.tabSkills))
+    } finally {
+      invalidateSlashCompletions()
+      setBulkBusy(false)
+    }
+  }
+
+  // Bulk actions ("All" master switch, "Disable unused") and the master-switch
+  // state target the WHOLE tab, never the search-filtered view — a tab-wide
+  // control that silently scoped to the current query would be a lie.
+  const allEnabled = skills.length > 0 && skills.every(s => s.enabled)
+
+  // One switch line covering enable-all/disable-all.
+  const bulkSwitch: ListStripMenuToggle = {
+    checked: allEnabled,
+    disabled: bulkBusy,
+    label: t.skills.all,
+    onToggle: checked => void bulkApply(skills.filter(row => row.enabled !== checked), checked)
+  }
+
+  // "Never used" = zero recorded activity. The pruning move for a 100+ skill
+  // install: keep the workhorses, shed the noise.
+  const disableUnused = () => bulkApply(skills.filter(skill => skill.enabled && usageOf(skill) === 0), false)
+
+  const openSkillEditor = async (name: string) => {
+    try {
+      const node = await getLearningNode(name, profile)
+
+      setSkillEditor({ content: node.content, name })
+      setSkillDraft(node.content)
+    } catch (err) {
+      notifyError(err, name)
+    }
+  }
+
+  const saveSkillEdit = async () => {
+    if (!skillEditor) {
+      return
+    }
+
+    setSkillSaving(true)
+
+    try {
+      await editLearningNode(skillEditor.name, skillDraft, profile)
+      notify({
+        kind: 'success',
+        title: t.skills.skillUpdated,
+        message: t.skills.appliesToNewSessions(skillEditor.name)
+      })
+      setSkillEditor(null)
+      onRefresh()
+    } catch (err) {
+      notifyError(err, skillEditor.name)
+    } finally {
+      setSkillSaving(false)
+    }
+  }
+
+  const skillEditorPane = skillEditor && (
+    <DetailPane
+      actions={
+        <Button disabled={skillSaving} onClick={() => void saveSkillEdit()} size="xs">
+          {skillSaving ? t.common.saving : t.common.save}
+        </Button>
+      }
+      id="skill-editor"
+      onClose={() => setSkillEditor(null)}
+      title={<span className="text-[0.68rem] font-normal text-muted-foreground/60">{skillEditor.name}/SKILL.md</span>}
+    >
+      <CodeEditor
+        filePath="SKILL.md"
+        initialValue={skillEditor.content}
+        key={skillEditor.name}
+        onCancel={() => setSkillEditor(null)}
+        onChange={setSkillDraft}
+        onSave={() => void saveSkillEdit()}
+      />
+    </DetailPane>
+  )
+
+  return (
+    <>
+      {visibleSkills.length === 0 && visibleOfficial.length === 0 ? (
+        <CapabilityEmpty noun="skills" query={query} />
+      ) : (
+        <MasterDetail pane={skillEditorPane} resizeId="capabilities-split" split="wide">
+          <ListColumn
+            header={
+              <ListStrip
+                left={<SortButton desc={skillsSortDesc} onFlip={() => $skillsSortDesc.set(!$skillsSortDesc.get())} />}
+                right={
+                  <ListStripMenu
+                    items={[
+                      {
+                        disabled: bulkBusy,
+                        label: t.skills.disableUnused,
+                        onSelect: () => void disableUnused()
+                      }
+                    ]}
+                    label={t.skills.tabSkills}
+                    toggle={bulkSwitch}
+                  />
+                }
+              />
+            }
+          >
+            {visibleSkills.map(skill => (
+              <CapRow
+                active={activeOfficial === null && activeSkill?.name === skill.name}
+                busy={bulkBusy}
+                enabled={skill.enabled}
+                key={skill.name}
+                meta={usageOf(skill) > 0 ? `×${compactNumber(usageOf(skill))}` : undefined}
+                onSelect={() => {
+                  setSelectedSkill(skill.name)
+                  setSelectedOfficial(null)
+                }}
+                onToggle={enabled => void handleToggleSkill(skill, enabled)}
+                subtitle={skillSubtitle(skill)}
+                title={skill.name}
+                toggleLabel={skill.name}
+              />
+            ))}
+            {visibleOfficial.length > 0 && (
+              <div className="flex h-7 shrink-0 items-end px-2 pb-1 text-[0.62rem] font-medium uppercase tracking-wide text-(--ui-text-quaternary)">
+                {t.skills.officialCatalog}
+              </div>
+            )}
+            {visibleOfficial.map(skill => {
+              const installing = runningInstalls.has(skill.identifier)
+
+              return (
+                <CapRow
+                  action={
+                    <Button
+                      disabled={installing}
+                      onClick={() => handleInstallOfficial(skill)}
+                      size="xs"
+                      variant="text"
+                    >
+                      {installing && <Loader2 className="size-3 animate-spin" />}
+                      {installing ? t.skills.hub.installing : t.skills.hub.install}
+                    </Button>
+                  }
+                  active={activeOfficial?.identifier === skill.identifier}
+                  enabled={false}
+                  key={skill.identifier}
+                  onSelect={() => setSelectedOfficial(skill.identifier)}
+                  subtitle={prettyName(skill.category)}
+                  title={skill.name}
+                />
+              )
+            })}
+          </ListColumn>
+          <DetailColumn footer={t.skills.changesApplyNewSessions}>
+            {activeOfficial ? (
+              <OfficialSkillDetail
+                installing={runningInstalls.has(activeOfficial.identifier)}
+                onInstall={() => handleInstallOfficial(activeOfficial)}
+                profile={profile}
+                skill={activeOfficial}
+              />
+            ) : (
+              activeSkill && (
+                <SkillDetail
+                  onArchive={() => setArchiveTarget(activeSkill.name)}
+                  onEdit={() => void openSkillEditor(activeSkill.name)}
+                  profile={profile}
+                  skill={activeSkill}
+                />
+              )
+            )}
+          </DetailColumn>
+        </MasterDetail>
+      )}
+      {archiveTarget && (
+        <ArchiveSkillConfirmDialog
+          onApply={() => {
+            const name = archiveTarget
+            const snapshot = skills
+
+            setSkills(current => current?.filter(skill => skill.name !== name) ?? current)
+            invalidateSlashCompletions()
+
+            if (skillEditor?.name === name) {
+              setSkillEditor(null)
+            }
+
+            return () => setSkills(() => snapshot)
+          }}
+          onClose={() => setArchiveTarget(null)}
+          onFailure={(err, name) => notifyError(err, name)}
+          open
+          profile={profile}
+          skillId={archiveTarget}
+          skillName={archiveTarget}
+        />
+      )}
+    </>
+  )
+}
diff --git a/apps/desktop/src/app/capabilities/toolsets/tool-calls.ts b/apps/desktop/src/app/capabilities/toolsets/tool-calls.ts
new file mode 100644
index 0000000000..8958c11704
--- /dev/null
+++ b/apps/desktop/src/app/capabilities/toolsets/tool-calls.ts
@@ -0,0 +1,77 @@
+import { useStore } from '@nanostores/react'
+import { atom } from 'nanostores'
+import { useEffect, useState } from 'react'
+
+import { getUsageAnalytics, type ProfileScope, profileScopeKey } from '@/hermes'
+
+// Per-tool call counts come from a 365-day message scan — heavy, and purely
+// cosmetic (Toolsets usage badges). Cache the result module-wide with a TTL so
+// bouncing between tabs/pages doesn't re-run the scan every time. Keyed by
+// the Capabilities scope profile: analytics are profile-scoped, so a scope or
+// app-profile switch must not show the previous profile's counts.
+const TOOL_CALLS_TTL_MS = 10 * 60 * 1000
+const toolCallsCache = new Map<string, { at: number; value: Record<string, number> }>()
+
+// Bumped once a forced pull has landed in the cache, so badges already on
+// screen pick the fresh counts up instead of sitting out the TTL.
+const $toolCallsRefreshed = atom(0)
+
+async function loadToolCalls(
+  scopeKey: string,
+  scopeProfile: ProfileScope,
+  force = false
+): Promise<Record<string, number>> {
+  const cached = toolCallsCache.get(scopeKey)
+
+  if (!force && cached && Date.now() - cached.at < TOOL_CALLS_TTL_MS) {
+    return cached.value
+  }
+
+  const analytics = await getUsageAnalytics(365, scopeProfile)
+
+  const value = Object.fromEntries((analytics.tools ?? []).map(e => [e.tool, e.count]))
+
+  toolCallsCache.set(scopeKey, { at: Date.now(), value })
+
+  return value
+}
+
+/** The page refresh's analytics leg (`useRefreshHotkey`): the one time the TTL
+ *  is bypassed — but only if the badges have been on screen at least once;
+ *  otherwise let the lazy load pick the counts up when Toolsets is first
+ *  shown. */
+export async function refreshToolCalls(profile: ProfileScope): Promise<void> {
+  if (toolCallsCache.size === 0) {
+    return
+  }
+
+  await loadToolCalls(profileScopeKey(profile), profile, true).catch(() => undefined)
+  $toolCallsRefreshed.set($toolCallsRefreshed.get() + 1)
+}
+
+/**
+ * tool name -> call count over the analytics window. `null` = still loading
+ * (badges show skeletons); `{}` = loaded empty / unavailable backend.
+ *
+ * Mounting the Toolsets tab is what asks for the scan, so Skills and MCP never
+ * pay for it and it can't starve the MCP tab's config load. A scope change
+ * remounts the tab, so a slow load from the previous scope can never land on
+ * the new one's badges.
+ */
+export function useToolCalls(profile: ProfileScope): null | Record<string, number> {
+  const refreshed = useStore($toolCallsRefreshed)
+  const [toolCalls, setToolCalls] = useState<null | Record<string, number>>(null)
+  const scopeKey = profileScopeKey(profile)
+
+  useEffect(() => {
+    let cancelled = false
+
+    loadToolCalls(scopeKey, profile)
+      .then(value => !cancelled && setToolCalls(value))
+      .catch(() => !cancelled && setToolCalls({}))
+
+    return () => void (cancelled = true)
+  }, [profile, refreshed, scopeKey])
+
+  return toolCalls
+}
diff --git a/apps/desktop/src/app/capabilities/toolsets/toolset-detail.tsx b/apps/desktop/src/app/capabilities/toolsets/toolset-detail.tsx
new file mode 100644
index 0000000000..de16e13ea4
--- /dev/null
+++ b/apps/desktop/src/app/capabilities/toolsets/toolset-detail.tsx
@@ -0,0 +1,89 @@
+import { compactNumber } from '@hermes/shared'
+import { useNavigate } from 'react-router'
+
+import { Button } from '@/components/ui/button'
+import { type ProfileScope, profileScopeKey } from '@/hermes'
+import { useI18n } from '@/i18n'
+import type { ToolsetInfo } from '@/types/hermes'
+
+import { ToolChip } from '../../master-detail'
+import { PanelPill } from '../../overlays/panel'
+import { SETTINGS_ROUTE } from '../../routes'
+import { BrowserRealProfilePanel } from '../../settings/browser-real-profile-panel'
+import { ComputerUsePanel } from '../../settings/computer-use-panel'
+import { asText, toolNames, toolsetDisplayLabel } from '../../settings/helpers'
+import { TerminalBackendPanel } from '../../settings/terminal-backend-panel'
+import { ToolsetConfigPanel } from '../../settings/toolset-config-panel'
+import { DetailHeader } from '../primitives'
+
+export function ToolsetDetail({
+  toolset,
+  toolCalls,
+  onConfiguredChange,
+  profile
+}: {
+  toolset: ToolsetInfo
+  toolCalls: Record<string, number>
+  onConfiguredChange: () => void
+  profile?: ProfileScope
+}) {
+  const { t } = useI18n()
+  const navigate = useNavigate()
+  const tools = toolNames(toolset)
+  const label = toolsetDisplayLabel(toolset)
+
+  return (
+    <>
+      {/* "Configured" as a resting state is noise — only the warn state earns a pill. */}
+      <DetailHeader
+        description={asText(toolset.description) || t.skills.noDescription}
+        pills={!toolset.configured && <PanelPill tone="warn">{t.skills.needsKeys}</PanelPill>}
+        title={label}
+      />
+      {tools.length > 0 && (
+        <div className="flex flex-wrap gap-1">
+          {tools.map(name => (
+            <ToolChip key={name}>
+              {name}
+              {(toolCalls[name] ?? 0) > 0 && (
+                <span className="ml-1 text-(--ui-text-quaternary)">×{compactNumber(toolCalls[name])}</span>
+              )}
+            </ToolChip>
+          ))}
+        </div>
+      )}
+      {toolset.name === 'vision' && (
+        // Vision has no provider matrix — model resolution runs through the
+        // auxiliary model config. Point at the actual home (Settings → Models,
+        // aux "vision" row) via an internal deep link instead of leaving the
+        // detail pane empty.
+        <div className="grid gap-1.5">
+          <p className="text-[length:var(--conversation-caption-font-size)] text-(--ui-text-tertiary)">
+            {t.skills.visionModelHint}
+          </p>
+          <div>
+            <Button
+              onClick={() => navigate(`${SETTINGS_ROUTE}?tab=config:model&aux=vision`)}
+              size="xs"
+              variant="textStrong"
+            >
+              {t.skills.visionModelLink}
+            </Button>
+          </div>
+        </div>
+      )}
+      {toolset.name === 'computer_use' && <ComputerUsePanel onConfiguredChange={onConfiguredChange} />}
+      {/* Real-profile consent toggle ABOVE the backend/provider matrix — the
+          config option users kept missing because its only GUI home was the
+          generic Settings → Config editor. */}
+      {toolset.name === 'browser' && <BrowserRealProfilePanel profile={profile} />}
+      {toolset.name === 'terminal' && <TerminalBackendPanel onConfiguredChange={onConfiguredChange} />}
+      <ToolsetConfigPanel
+        key={`${toolset.name}:${profileScopeKey(profile)}`}
+        onConfiguredChange={onConfiguredChange}
+        profile={profile}
+        toolset={toolset.name}
+      />
+    </>
+  )
+}
diff --git a/apps/desktop/src/app/capabilities/toolsets/toolsets-data.ts b/apps/desktop/src/app/capabilities/toolsets/toolsets-data.ts
new file mode 100644
index 0000000000..568e74a632
--- /dev/null
+++ b/apps/desktop/src/app/capabilities/toolsets/toolsets-data.ts
@@ -0,0 +1,75 @@
+import { useQuery } from '@tanstack/react-query'
+
+import { getToolsets, type ProfileScope, profileScopeKey } from '@/hermes'
+import { isDesktopToolsetVisible } from '@/lib/desktop-toolsets'
+import { normalize } from '@/lib/text'
+import type { ToolsetInfo } from '@/types/hermes'
+
+import { includesQuery, toolNames, toolsetDisplayLabel } from '../../settings/helpers'
+
+// Toolsets live in the RQ cache so switching tabs/pages paints the cached list
+// instantly (no reload flash) and mount only fires a deduped background
+// refetch. A profile swap globally invalidates (see store/profile), so this
+// plain key refetches against the new backend automatically.
+export const TOOLSETS_QUERY_KEY = ['toolsets-list'] as const
+
+/** The list key for one scope: the plain key plus the Capabilities scope key,
+ *  so every scoped profile keeps its own cached copy (prefix invalidations
+ *  still match). */
+export const toolsetsQueryKey = (profile: ProfileScope) => [...TOOLSETS_QUERY_KEY, profileScopeKey(profile)]
+
+export function useToolsetsQuery(profile: ProfileScope) {
+  return useQuery({
+    queryKey: toolsetsQueryKey(profile),
+    queryFn: () => getToolsets(profile),
+    staleTime: 0
+  })
+}
+
+export const toolsetCalls = (toolset: ToolsetInfo, toolCalls: Record<string, number>): number =>
+  toolNames(toolset).reduce((sum, name) => sum + (toolCalls[name] ?? 0), 0)
+
+export function filteredToolsets(
+  toolsets: ToolsetInfo[],
+  query: string,
+  toolCalls: Record<string, number>,
+  desc: boolean
+): ToolsetInfo[] {
+  const q = normalize(query)
+  const sign = desc ? 1 : -1
+
+  return toolsets
+    .filter(toolset => {
+      if (!isDesktopToolsetVisible(toolset.name)) {
+        return false
+      }
+
+      if (!q) {
+        return true
+      }
+
+      return (
+        includesQuery(toolset.name, q) ||
+        includesQuery(toolsetDisplayLabel(toolset), q) ||
+        includesQuery(toolset.description, q) ||
+        toolNames(toolset).some(name => includesQuery(name, q))
+      )
+    })
+    .sort(
+      (a, b) =>
+        sign * (toolsetCalls(b, toolCalls) - toolsetCalls(a, toolCalls)) ||
+        toolsetDisplayLabel(a).localeCompare(toolsetDisplayLabel(b))
+    )
+}
+
+export const visibleToolsetCount = (toolsets: ToolsetInfo[]) =>
+  toolsets.filter(ts => isDesktopToolsetVisible(ts.name)).length
+
+/** Tool names for the search field's rotating placeholder nudges — they teach
+ *  that search understands tool names, not just titles. */
+export function toolsetSearchTerms(toolsets: ToolsetInfo[]): string[] {
+  return toolsets
+    .filter(ts => isDesktopToolsetVisible(ts.name) && toolNames(ts).length > 0)
+    .slice(0, 5)
+    .map(ts => toolNames(ts)[0])
+}
diff --git a/apps/desktop/src/app/capabilities/toolsets/toolsets-tab.tsx b/apps/desktop/src/app/capabilities/toolsets/toolsets-tab.tsx
new file mode 100644
index 0000000000..2c9abe1ebe
--- /dev/null
+++ b/apps/desktop/src/app/capabilities/toolsets/toolsets-tab.tsx
@@ -0,0 +1,192 @@
+import { compactNumber } from '@hermes/shared'
+import { useStore } from '@nanostores/react'
+import { useCallback, useMemo, useState } from 'react'
+
+import { CountSkeleton } from '@/components/ui/skeleton'
+import { type ProfileScope, setToolsetEnabled } from '@/hermes'
+import { useI18n } from '@/i18n'
+import { isDesktopToolsetVisible } from '@/lib/desktop-toolsets'
+import { Codecs, persistentAtom } from '@/lib/persisted'
+import { queryClient } from '@/lib/query-client'
+import { invalidateSlashCompletions } from '@/lib/slash-completion-cache'
+import { notify, notifyError } from '@/store/notifications'
+import type { ToolsetInfo } from '@/types/hermes'
+
+import {
+  CapRow,
+  DetailColumn,
+  ListColumn,
+  ListStrip,
+  ListStripMenu,
+  type ListStripMenuToggle,
+  MasterDetail
+} from '../../master-detail'
+import { asText, toolNames, toolsetDisplayLabel } from '../../settings/helpers'
+import { CapabilityEmpty, SortButton } from '../primitives'
+
+import { useToolCalls } from './tool-calls'
+import { ToolsetDetail } from './toolset-detail'
+import { filteredToolsets, toolsetCalls, TOOLSETS_QUERY_KEY, toolsetsQueryKey } from './toolsets-data'
+
+// Sort direction for the Tools list — persisted so the tab remembers
+// most/least-used across navigations and restarts.
+const $toolsetsSortDesc = persistentAtom('hermes.desktop.capabilities.toolsetsSortDesc', true, Codecs.bool)
+
+interface ToolsetsTabProps {
+  /** The scope's toolset list, straight from the shell's query. */
+  toolsets: ToolsetInfo[]
+  /** The (connection, profile) scope every read and write routes to. */
+  profile: ProfileScope
+  query: string
+}
+
+/** THE Tools tab: the toolset list with its usage badges, and the inspector
+ *  that mounts each toolset's settings panels. */
+export function ToolsetsTab({ profile, query, toolsets }: ToolsetsTabProps) {
+  const { t } = useI18n()
+  const toolsetsSortDesc = useStore($toolsetsSortDesc)
+  const toolCalls = useToolCalls(profile)
+  const [bulkBusy, setBulkBusy] = useState(false)
+  const [selectedToolset, setSelectedToolset] = useState<string | null>(null)
+
+  // Optimistic write-through against the scoped Tools key: toggles repaint
+  // instantly; the next background refetch reconciles.
+  const setToolsets = useCallback(
+    (fn: (cur: ToolsetInfo[] | undefined) => ToolsetInfo[] | undefined) =>
+      queryClient.setQueryData<ToolsetInfo[]>(toolsetsQueryKey(profile), prev => fn(prev) ?? prev),
+    [profile]
+  )
+
+  const refreshToolsets = useCallback(() => {
+    void queryClient.invalidateQueries({ queryKey: TOOLSETS_QUERY_KEY })
+  }, [])
+
+  // Absent counts sort the list A–Z until the analytics scan lands.
+  const visibleToolsets = useMemo(
+    () => filteredToolsets(toolsets, query, toolCalls ?? {}, toolsetsSortDesc),
+    [query, toolCalls, toolsets, toolsetsSortDesc]
+  )
+
+  // Bulk actions and the master-switch state target the WHOLE tab, never the
+  // search-filtered view — a tab-wide control that silently scoped to the
+  // current query would be a lie.
+  const bulkToolsets = useMemo(() => toolsets.filter(ts => isDesktopToolsetVisible(ts.name)), [toolsets])
+
+  // Keep a valid selection: fall back to the first visible row when the
+  // current selection is filtered out (or nothing is selected yet).
+  const activeToolset = useMemo(
+    () => visibleToolsets.find(ts => ts.name === selectedToolset) ?? visibleToolsets[0] ?? null,
+    [selectedToolset, visibleToolsets]
+  )
+
+  // Single toggles are optimistic and silent on success (the row repaints
+  // immediately — a toast per flip would spam rapid customization). Errors
+  // revert and notify.
+  async function handleToggleToolset(toolset: ToolsetInfo, enabled: boolean) {
+    setToolsets(
+      current =>
+        current?.map(row => (row.name === toolset.name ? { ...row, enabled, available: enabled } : row)) ?? current
+    )
+
+    try {
+      await setToolsetEnabled(toolset.name, enabled, profile)
+    } catch (err) {
+      setToolsets(
+        current =>
+          current?.map(row => (row.name === toolset.name ? { ...row, enabled: !enabled, available: !enabled } : row)) ??
+          current
+      )
+      notifyError(err, t.skills.failedToUpdate(toolsetDisplayLabel(toolset)))
+    }
+  }
+
+  // Sequential on purpose: each toggle is a config read-modify-write on the
+  // backend; parallel calls would race the disabled-list save.
+  async function bulkApply(targets: ToolsetInfo[], enabled: boolean) {
+    if (bulkBusy || targets.length === 0) {
+      return
+    }
+
+    setBulkBusy(true)
+
+    let done = 0
+
+    try {
+      for (const row of targets) {
+        await setToolsetEnabled(row.name, enabled, profile)
+        setToolsets(cur => cur?.map(r => (r.name === row.name ? { ...r, enabled, available: enabled } : r)) ?? cur)
+        done += 1
+      }
+
+      notify({ kind: 'success', title: t.skills.bulkUpdated(done), message: '' })
+    } catch (err) {
+      notifyError(err, t.skills.failedToUpdate(t.skills.tabToolsets))
+    } finally {
+      invalidateSlashCompletions()
+      setBulkBusy(false)
+    }
+  }
+
+  // One switch line covering enable-all/disable-all.
+  const bulkSwitch: ListStripMenuToggle = {
+    checked: bulkToolsets.length > 0 && bulkToolsets.every(ts => ts.enabled),
+    disabled: bulkBusy,
+    label: t.skills.all,
+    onToggle: checked => void bulkApply(bulkToolsets.filter(row => row.enabled !== checked), checked)
+  }
+
+  if (visibleToolsets.length === 0) {
+    return <CapabilityEmpty noun="tools" query={query} />
+  }
+
+  return (
+    <MasterDetail resizeId="capabilities-split" split="wide">
+      <ListColumn
+        header={
+          <ListStrip
+            left={<SortButton desc={toolsetsSortDesc} onFlip={() => $toolsetsSortDesc.set(!$toolsetsSortDesc.get())} />}
+            right={<ListStripMenu label={t.skills.tabToolsets} toggle={bulkSwitch} />}
+          />
+        }
+      >
+        {visibleToolsets.map(toolset => {
+          const label = toolsetDisplayLabel(toolset)
+          const calls = toolCalls ? toolsetCalls(toolset, toolCalls) : null
+
+          return (
+            <CapRow
+              active={activeToolset?.name === toolset.name}
+              busy={bulkBusy}
+              enabled={toolset.enabled}
+              key={toolset.name}
+              meta={
+                calls === null ? (
+                  <CountSkeleton />
+                ) : calls > 0 ? (
+                  `×${compactNumber(calls)}`
+                ) : (
+                  `${toolNames(toolset).length} tools`
+                )
+              }
+              onSelect={() => setSelectedToolset(toolset.name)}
+              onToggle={checked => void handleToggleToolset(toolset, checked)}
+              subtitle={asText(toolset.description)}
+              title={label}
+              toggleLabel={t.skills.toggleToolset(label, !toolset.enabled)}
+            />
+          )
+        })}
+      </ListColumn>
+      <DetailColumn footer={t.skills.changesApplyNewSessions}>
+        {activeToolset && (
+          <ToolsetDetail
+            onConfiguredChange={refreshToolsets}
+            profile={profile}
+            toolCalls={toolCalls ?? {}}
+            toolset={activeToolset}
+          />
+        )}
+      </DetailColumn>
+    </MasterDetail>
+  )
+}
diff --git a/apps/desktop/src/app/chat/route-tile.tsx b/apps/desktop/src/app/chat/route-tile.tsx
index 4fee30c2d2..5b75a87c17 100644
--- a/apps/desktop/src/app/chat/route-tile.tsx
+++ b/apps/desktop/src/app/chat/route-tile.tsx
@@ -13,11 +13,11 @@ import { ContribBoundary, ContribRender } from '@/contrib/react/boundary'
 import { useContributions } from '@/contrib/react/use-contributions'
 import { $routeTiles, closeRouteTile, type RouteTile } from '@/store/route-tiles'
 
-import { $routesVersion, ARTIFACTS_ROUTE, contributedRoutes, MESSAGING_ROUTE, ROUTES_AREA, SKILLS_ROUTE } from '../routes'
+import { $routesVersion, ARTIFACTS_ROUTE, CAPABILITIES_ROUTE, contributedRoutes, MESSAGING_ROUTE, ROUTES_AREA } from '../routes'
 
 import { paneMirror } from './pane-mirror'
 
-const SkillsView = lazy(async () => ({ default: (await import('../skills')).SkillsView }))
+const CapabilitiesView = lazy(async () => ({ default: (await import('../capabilities')).CapabilitiesView }))
 const MessagingView = lazy(async () => ({ default: (await import('../messaging')).MessagingView }))
 const ArtifactsView = lazy(async () => ({ default: (await import('../artifacts')).ArtifactsView }))
 
@@ -25,7 +25,7 @@ const ArtifactsView = lazy(async () => ({ default: (await import('../artifacts')
 const BUILTIN_PAGES: Record<string, { render: () => ReactNode; title: string }> = {
   [ARTIFACTS_ROUTE]: { render: () => <ArtifactsView />, title: 'Artifacts' },
   [MESSAGING_ROUTE]: { render: () => <MessagingView />, title: 'Messaging' },
-  [SKILLS_ROUTE]: { render: () => <SkillsView />, title: 'Capabilities' }
+  [CAPABILITIES_ROUTE]: { render: () => <CapabilitiesView />, title: 'Capabilities' }
 }
 
 /** Humanize a route path into a tab title: `/my-atlas` → `My Atlas`. */
diff --git a/apps/desktop/src/app/chat/sidebar/chat-sidebar.integration.test.tsx b/apps/desktop/src/app/chat/sidebar/chat-sidebar.integration.test.tsx
index d83e4221df..b3d23686cc 100644
--- a/apps/desktop/src/app/chat/sidebar/chat-sidebar.integration.test.tsx
+++ b/apps/desktop/src/app/chat/sidebar/chat-sidebar.integration.test.tsx
@@ -131,7 +131,7 @@ describe('ChatSidebar navigation activity', () => {
     })
 
     for (const [pathname, currentView, label] of [
-      ['/skills', 'skills', 'Capabilities'],
+      ['/capabilities', 'capabilities', 'Capabilities'],
       ['/messaging', 'messaging', 'Messaging'],
       ['/artifacts', 'artifacts', 'Artifacts'],
       ['/cron', 'cron', 'Scheduled jobs']
diff --git a/apps/desktop/src/app/chat/sidebar/index.tsx b/apps/desktop/src/app/chat/sidebar/index.tsx
index 7ec0fc67ff..3941007c4e 100644
--- a/apps/desktop/src/app/chat/sidebar/index.tsx
+++ b/apps/desktop/src/app/chat/sidebar/index.tsx
@@ -137,11 +137,11 @@ import { $sidebarSessionRankIds } from '@/store/sidebar-sort'
 import {
   type AppView,
   ARTIFACTS_ROUTE,
+  CAPABILITIES_ROUTE,
   CRON_ROUTE,
   MESSAGING_ROUTE,
   SIDEBAR_NAV_AREA,
-  type SidebarNavContribution,
-  SKILLS_ROUTE
+  type SidebarNavContribution
 } from '../../routes'
 import type { SidebarNavItem } from '../../types'
 import { type NewSessionSplitHandler, startNewSessionDrag } from '../new-session-drag'
@@ -207,11 +207,11 @@ const SIDEBAR_NAV: SidebarNavItem[] = [
     keybindActionId: 'session.new'
   },
   {
-    id: 'skills',
+    id: 'capabilities',
     label: '',
     icon: props => <Codicon name="symbol-misc" {...props} />,
-    route: SKILLS_ROUTE,
-    keybindActionId: 'nav.skills'
+    route: CAPABILITIES_ROUTE,
+    keybindActionId: 'nav.capabilities'
   },
   {
     id: 'messaging',
@@ -1517,7 +1517,7 @@ export function ChatSidebar({
                 const isInteractive = Boolean(item.action) || Boolean(item.route)
 
                 const active =
-                  (item.id === 'skills' && currentView === 'skills') ||
+                  (item.id === 'capabilities' && currentView === 'capabilities') ||
                   (item.id === 'messaging' && currentView === 'messaging') ||
                   (item.id === 'artifacts' && currentView === 'artifacts') ||
                   (item.id === 'cron' && currentView === 'cron') ||
diff --git a/apps/desktop/src/app/chat/sidebar/project-dialog.test.tsx b/apps/desktop/src/app/chat/sidebar/project-dialog.test.tsx
index 0a1fdd9e77..322cfabc31 100644
--- a/apps/desktop/src/app/chat/sidebar/project-dialog.test.tsx
+++ b/apps/desktop/src/app/chat/sidebar/project-dialog.test.tsx
@@ -1,6 +1,6 @@
 import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react'
 import type * as Nanostores from 'nanostores'
-import { afterEach, describe, expect, it, vi } from 'vitest'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
 import { ProjectDialog } from './project-dialog'
 
@@ -35,10 +35,11 @@ vi.mock('@/i18n', () => ({
 
 // $projectDialog is a real nanostore atom in the app; recreate it here so
 // useStore behaves identically without pulling in the rest of the projects
-// store (backend calls, project list, etc.) which is irrelevant to the Tip fix.
+// store (backend calls, project list, etc.) which is irrelevant to the dialog
+// interactions under test.
 // vi.mock factories are hoisted above the rest of the file, so the atom must
 // be created inside vi.hoisted to exist by the time the factory runs.
-const { $newProjectDropPlacement, $projectDialog } = vi.hoisted(() => {
+const { $newProjectDropPlacement, $projectDialog, createProject, enterProject, pickProjectFolder } = vi.hoisted(() => {
   const { atom } = require('nanostores') as typeof Nanostores
 
   return {
@@ -46,7 +47,10 @@ const { $newProjectDropPlacement, $projectDialog } = vi.hoisted(() => {
     $newProjectDropPlacement: atom<{ anchor: string; before?: null | string; dir: string } | null>(null),
     $projectDialog: atom<{ mode: 'create' | 'rename' | 'add-folder'; name?: string; projectId?: string } | null>({
       mode: 'create'
-    })
+    }),
+    createProject: vi.fn(),
+    enterProject: vi.fn(),
+    pickProjectFolder: vi.fn()
   }
 })
 
@@ -56,12 +60,19 @@ vi.mock('@/store/projects', () => ({
   addProjectFolder: vi.fn(),
   clearNewProjectDropPlacement: vi.fn(),
   closeProjectDialog: vi.fn(),
-  createProject: vi.fn(),
+  createProject,
+  enterProject,
   generateProjectIdea: vi.fn(),
-  pickProjectFolder: vi.fn(async () => '/Users/test/my-folder'),
+  pickProjectFolder,
   renameProject: vi.fn()
 }))
 
+beforeEach(() => {
+  vi.clearAllMocks()
+  createProject.mockResolvedValue({ id: 'p_created' })
+  pickProjectFolder.mockResolvedValue('/Users/test/my-folder')
+})
+
 vi.mock('@/store/notifications', () => ({
   notifyError: vi.fn()
 }))
@@ -88,6 +99,36 @@ async function fillCreateForm() {
 }
 
 describe('ProjectDialog', () => {
+  it('creates from the folder basename and enters the created project when the name is empty', async () => {
+    render(<ProjectDialog />)
+
+    fireEvent.click(screen.getByRole('button', { name: 'Add folder' }))
+
+    await screen.findByDisplayValue('my-folder')
+    fireEvent.click(screen.getByRole('button', { name: 'Create' }))
+
+    await waitFor(() => {
+      expect(createProject).toHaveBeenCalledWith(
+        expect.objectContaining({ folders: ['/Users/test/my-folder'], name: 'my-folder' })
+      )
+      expect(enterProject).toHaveBeenCalledWith('p_created')
+    })
+  })
+
+  it('keeps an explicit project name when a folder is selected', async () => {
+    render(<ProjectDialog />)
+
+    fireEvent.change(screen.getByPlaceholderText('Project name'), { target: { value: 'My project' } })
+    fireEvent.click(screen.getByRole('button', { name: 'Add folder' }))
+
+    await screen.findByRole('button', { name: 'Remove folder' })
+    fireEvent.click(screen.getByRole('button', { name: 'Create' }))
+
+    await waitFor(() => {
+      expect(createProject).toHaveBeenCalledWith(expect.objectContaining({ name: 'My project' }))
+    })
+  })
+
   it('wraps the "shuffle idea" button in a Tip', () => {
     render(<ProjectDialog />)
 
diff --git a/apps/desktop/src/app/chat/sidebar/project-dialog.tsx b/apps/desktop/src/app/chat/sidebar/project-dialog.tsx
index b29b6bc8ed..a8330c906d 100644
--- a/apps/desktop/src/app/chat/sidebar/project-dialog.tsx
+++ b/apps/desktop/src/app/chat/sidebar/project-dialog.tsx
@@ -28,11 +28,14 @@ import {
   clearNewProjectDropPlacement,
   closeProjectDialog,
   createProject,
+  enterProject,
   generateProjectIdea,
   pickProjectFolder,
   renameProject
 } from '@/store/projects'
 
+import { baseName } from './projects/workspace-groups'
+
 // Single dialog mounted once in the sidebar; it renders create / rename /
 // add-folder flows driven by the $projectDialog atom. Folders are chosen via
 // the native directory picker (reused from the default-project-dir setting).
@@ -128,6 +131,13 @@ export function ProjectDialog() {
       }
 
       setFolders(prev => (prev.includes(dir) ? prev : [...prev, dir]))
+
+      // Picking a folder with no name typed names the project after the folder
+      // (the ⌘O "Open folder…" naming), so one pick + Create is enough. The name
+      // lands in the input, never in a hidden fallback the user cannot see.
+      if (mode === 'create') {
+        setName(prev => prev.trim() || baseName(dir) || prev)
+      }
     } catch (err) {
       notifyError(err, p.createFailed)
     }
@@ -151,10 +161,19 @@ export function ProjectDialog() {
       // The arm is consumed exactly on SUCCESS (before the close): a failed
       // create leaves the dialog open for a retry that still lands where it
       // was dropped; the open-state effect discards it on cancel/teardown.
-      await runSubmit(
-        () => createProject({ dropPlacement, folders, idea: idea.trim() || undefined, name: trimmed, use: true }),
-        clearNewProjectDropPlacement
-      )
+      await runSubmit(async () => {
+        const created = await createProject({
+          dropPlacement,
+          folders,
+          idea: idea.trim() || undefined,
+          name: trimmed,
+          use: true
+        })
+
+        if (created) {
+          enterProject(created.id)
+        }
+      }, clearNewProjectDropPlacement)
     }
   }
 
diff --git a/apps/desktop/src/app/command-palette/index.tsx b/apps/desktop/src/app/command-palette/index.tsx
index 594c6ec1e1..72b1729fc4 100644
--- a/apps/desktop/src/app/command-palette/index.tsx
+++ b/apps/desktop/src/app/command-palette/index.tsx
@@ -93,6 +93,7 @@ import { openSession, openSessionIntentFromModifiers } from '../open-session'
 import {
   AGENTS_ROUTE,
   ARTIFACTS_ROUTE,
+  CAPABILITIES_ROUTE,
   COMMAND_CENTER_ROUTE,
   CRON_ROUTE,
   MESSAGING_ROUTE,
@@ -100,7 +101,6 @@ import {
   NEW_CHAT_ROUTE,
   PROFILES_ROUTE,
   SETTINGS_ROUTE,
-  SKILLS_ROUTE,
   STARMAP_ROUTE
 } from '../routes'
 import { SECTIONS } from '../settings/constants'
@@ -812,12 +812,12 @@ function CommandPaletteBody({ onExited }: { onExited: () => void }) {
             run: go(SETTINGS_ROUTE)
           },
           {
-            action: 'nav.skills',
+            action: 'nav.capabilities',
             icon: Wrench,
             id: 'nav-skills',
             keywords: ['skills', 'tools', 'toolsets', 'mcp', 'capabilities'],
-            label: cc.nav.skills.title,
-            run: go(SKILLS_ROUTE)
+            label: cc.nav.capabilities.title,
+            run: go(CAPABILITIES_ROUTE)
           },
           {
             action: 'nav.messaging',
@@ -1077,7 +1077,7 @@ function CommandPaletteBody({ onExited }: { onExited: () => void }) {
     // Deep-link straight to a Capabilities sub-tab. The root "Go to" entry only
     // lands on the top-level Skills view; typing "mcp"/"tools"/"skills" should
     // jump to the exact tab (matches the "not just the top lvl" ask).
-    const capLabel = t.commandCenter.nav.skills.title
+    const capLabel = t.commandCenter.nav.capabilities.title
 
     result.push({
       heading: capLabel,
@@ -1087,28 +1087,28 @@ function CommandPaletteBody({ onExited }: { onExited: () => void }) {
           id: 'cap-skills',
           keywords: ['skills', 'capabilities'],
           label: `${capLabel}: ${t.skills.tabSkills}`,
-          run: go(`${SKILLS_ROUTE}?tab=skills`)
+          run: go(`${CAPABILITIES_ROUTE}?tab=skills`)
         },
         {
           icon: SlidersHorizontal,
           id: 'cap-toolsets',
           keywords: ['tools', 'toolsets', 'capabilities'],
           label: `${capLabel}: ${t.skills.tabToolsets}`,
-          run: go(`${SKILLS_ROUTE}?tab=toolsets`)
+          run: go(`${CAPABILITIES_ROUTE}?tab=toolsets`)
         },
         {
           icon: Layers3,
           id: 'cap-mcp',
           keywords: ['mcp', 'servers', 'tools', 'capabilities', 'model context protocol'],
           label: `${capLabel}: ${t.skills.tabMcp}`,
-          run: go(`${SKILLS_ROUTE}?tab=mcp`)
+          run: go(`${CAPABILITIES_ROUTE}?tab=mcp`)
         },
         {
           icon: Package,
           id: 'cap-plugins',
           keywords: ['plugins', 'extensions', 'desktop plugins', 'agent plugins', 'catalog', 'addon', 'add-on'],
           label: `${capLabel}: ${t.skills.tabPlugins}`,
-          run: go(`${SKILLS_ROUTE}?tab=plugins`)
+          run: go(`${CAPABILITIES_ROUTE}?tab=plugins`)
         }
       ]
     })
@@ -1195,7 +1195,7 @@ function CommandPaletteBody({ onExited }: { onExited: () => void }) {
           id: `sp-${entry.id}`,
           keywords: [entry.context, entry.description ?? '', ...entry.keywords],
           label: entry.label,
-          run: go(`${SKILLS_ROUTE}?tab=plugins&plugin=${encodeURIComponent(entry.plugin)}`)
+          run: go(`${CAPABILITIES_ROUTE}?tab=plugins&plugin=${encodeURIComponent(entry.plugin)}`)
         }))
       })
     }
@@ -1215,7 +1215,7 @@ function CommandPaletteBody({ onExited }: { onExited: () => void }) {
           id: `mcp-${name}`,
           keywords: ['mcp', 'server', 'tool'],
           label: name,
-          run: go(`${SKILLS_ROUTE}?tab=mcp&server=${encodeURIComponent(name)}`)
+          run: go(`${CAPABILITIES_ROUTE}?tab=mcp&server=${encodeURIComponent(name)}`)
         }))
       })
     }
diff --git a/apps/desktop/src/app/contrib/hooks/use-desktop-integrations.test.tsx b/apps/desktop/src/app/contrib/hooks/use-desktop-integrations.test.tsx
index 0633d6f50f..64d2396129 100644
--- a/apps/desktop/src/app/contrib/hooks/use-desktop-integrations.test.tsx
+++ b/apps/desktop/src/app/contrib/hooks/use-desktop-integrations.test.tsx
@@ -1,13 +1,9 @@
-import { act, renderHook, waitFor } from '@testing-library/react'
+import { renderHook } from '@testing-library/react'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
-import { setApiRequestConnection, setApiRequestProfile } from '@/hermes'
 import { createClientSessionState } from '@/lib/chat-runtime'
 import { adoptNewSessionDraft, stashSessionDraft, takeSessionDraft } from '@/store/composer'
-import { $confirmRequest, runConfirm, settleConfirm } from '@/store/confirm'
-import { $hubInstalledOverride } from '@/store/hub-actions'
 import { requestMcpInstallFromDeepLink } from '@/store/mcp-deeplink-install'
-import { $pluginInstallRequest } from '@/store/plugin-install-request'
 import { _resetLegacyDiscardForTests } from '@/store/session'
 import { dropSessionState, publishSessionState } from '@/store/session-states'
 import type * as WindowsStore from '@/store/windows'
@@ -436,15 +432,15 @@ describe('useDesktopIntegrations', () => {
   })
 
   describe('route-scoped restoration', () => {
-    it('restores a non-session route like /skills', () => {
-      window.localStorage.setItem('hermes.desktop.lastRoute.profile.default', '/skills')
+    it('restores a non-session route like /capabilities', () => {
+      window.localStorage.setItem('hermes.desktop.lastRoute.profile.default', '/capabilities')
 
       const sessions = [session({ id: 'some-session', profile: 'default' })]
 
       render({ profileReady: true, sessions })
 
       // /skills is not a session route — no ownership validation needed.
-      expect(navigate).toHaveBeenCalledWith('/skills', { replace: true })
+      expect(navigate).toHaveBeenCalledWith('/capabilities', { replace: true })
     })
 
     it('does NOT restore overlay routes (settings/command-center)', () => {
@@ -589,92 +585,6 @@ describe('useDesktopIntegrations', () => {
     })
   })
 
-  describe('catalog install deep links', () => {
-    function listen() {
-      render({ profileReady: true, resumeLastSession: false })
-
-      return vi.mocked(window.hermesDesktop.onDeepLink!).mock.calls[0]![0]
-    }
-
-    afterEach(() => {
-      settleConfirm(false)
-      $pluginInstallRequest.set(null)
-      $hubInstalledOverride.set({})
-      setApiRequestConnection(null)
-      setApiRequestProfile(null)
-    })
-
-    it('opens the existing plugin confirmation with catalog metadata intact', () => {
-      const deepLink = listen()
-      const params = { repo: 'owner/repo#plugin', catalog_name: 'catalog-plugin', sha: 'display-pin' }
-      deepLink({ kind: 'plugin', name: 'install', params })
-
-      expect($pluginInstallRequest.get()).toMatchObject({
-        repo: params.repo, catalogName: params.catalog_name, sha: params.sha, enable: true, force: false
-      })
-      expect(navigate).not.toHaveBeenCalled()
-    })
-
-    it('requires skill confirmation, preserves the request scope, and uses the hub pipeline', async () => {
-      const api = vi.fn(async (request: { path: string }) => {
-        if (request.path === '/api/skills/hub/install') {
-          return { name: 'skill-link-test' }
-        }
-
-        if (request.path.startsWith('/api/actions/skill-link-test/')) {
-          return { name: 'skill-link-test', running: false, exit_code: 0, lines: ['Installed'], pid: 123 }
-        }
-
-        return {}
-      })
-
-      desktopWindow.hermesDesktop = { ...desktopWindow.hermesDesktop, api } as unknown as Window['hermesDesktop']
-      const deepLink = listen()
-      const installs = () => api.mock.calls.filter(([r]) => r.path === '/api/skills/hub/install')
-      const identifier = 'skills-sh/owner/repo/skill'
-      const payload = { kind: 'skill', name: 'install', params: { identifier } }
-
-      for (const [connection, profile] of [['server-a', 'research'], ['server-b', 'work'], ['server-a', 'research']]) {
-        setApiRequestConnection(connection)
-        setApiRequestProfile(profile)
-        api.mockClear()
-        $hubInstalledOverride.set({})
-        act(() => deepLink(payload))
-        expect($confirmRequest.get()?.title).toBe('Install “skill”?')
-        expect($confirmRequest.get()?.details).toEqual([
-          { label: 'Source', value: identifier },
-          { label: 'Install to', value: `${connection} · ${profile}` }
-        ])
-        expect(installs()).toHaveLength(0)
-        await act(async () => settleConfirm(false))
-        expect(installs()).toHaveLength(0)
-
-        act(() => deepLink(payload))
-        await act(async () => runConfirm($confirmRequest.get()!))
-        expect($confirmRequest.get()?.phase).toBe('done')
-        settleConfirm(true)
-        await waitFor(() => expect($hubInstalledOverride.get()[identifier]).toBe(true))
-        expect(installs()).toEqual([[{
-          connectionId: connection, profile, priority: 'foreground', path: '/api/skills/hub/install', method: 'POST', body: { identifier }
-        }]])
-        expect(api).toHaveBeenCalledWith({
-          connectionId: connection, profile, priority: 'foreground', path: '/api/actions/skill-link-test/status?lines=200'
-        })
-      }
-
-      api.mockClear()
-      act(() => deepLink(payload))
-      setApiRequestConnection('server-b')
-      setApiRequestProfile('work')
-      await expect(runConfirm($confirmRequest.get()!)).rejects.toThrow('The destination changed')
-      settleConfirm(false)
-      expect(installs()).toHaveLength(0)
-      act(() => deepLink({ kind: 'skill', name: 'install', params: {} }))
-      expect($confirmRequest.get()).toBeNull()
-      expect(navigate).not.toHaveBeenCalled()
-    })
-  })
-
   describe('notification click -> focus-session id translation', () => {
     function withFocusSession(): (sessionId: string) => void {
       let handler: ((sessionId: string) => void) | undefined
diff --git a/apps/desktop/src/app/contrib/hooks/use-desktop-integrations.ts b/apps/desktop/src/app/contrib/hooks/use-desktop-integrations.ts
index a2d72ed60e..6ad036723b 100644
--- a/apps/desktop/src/app/contrib/hooks/use-desktop-integrations.ts
+++ b/apps/desktop/src/app/contrib/hooks/use-desktop-integrations.ts
@@ -30,7 +30,6 @@ import {
 } from '@/store/session'
 import { $botChatScopes, $sessionTiles, storedSessionIdForRuntimeId } from '@/store/session-states'
 import { onSessionsChanged } from '@/store/session-sync'
-import { requestSkillInstallFromDeepLink } from '@/store/skill-deeplink-install'
 import { openUpdatesWindow, startUpdatePoller, stopUpdatePoller } from '@/store/updates'
 import { isBrowserWindow, isHudWindow, isSecondaryWindow } from '@/store/windows'
 import type { SessionInfo } from '@/types/hermes'
@@ -298,7 +297,6 @@ export function useDesktopIntegrations({
   //  - mcp/install?… → pending MCP install (explicit confirm, never auto-install)
   //  - plugin/install?… (and legacy plugin-agent/plugin-desktop) → plugin install
   //    modal awaiting explicit confirmation. Never auto-installs.
-  //  - skill/install?identifier=… → confirmation, then the existing hub pipeline
   //  - blueprint/<name>?… → reviewable /blueprint command in the composer
   //  - <plugin>/<path>?… → in-app navigate (e.g. index-network/intent/1)
   //  - open/<path>?… → in-app navigate (generic)
@@ -337,24 +335,12 @@ export function useDesktopIntegrations({
           repo: action.repo,
           enable: action.enable,
           force: action.force,
-          legacyHint: action.legacyHint,
-          catalogName: action.catalogName,
-          sha: action.sha
+          legacyHint: action.legacyHint
         })
 
         return
       }
 
-      if (action.type === 'skill-install') {
-        void requestSkillInstallFromDeepLink(action.identifier)
-
-        return
-      }
-
-      if (payload.kind === 'skill') {
-        return
-      }
-
       // Not a core action — treat as a plugin-scoped or open/ navigation deep
       // link (hermes://index-network/intent/1, hermes://open/…). The resolver
       // rejects reserved kinds and unsafe paths.
diff --git a/apps/desktop/src/app/contrib/mcp-install-deeplink-dialog.tsx b/apps/desktop/src/app/contrib/mcp-install-deeplink-dialog.tsx
index a657c98687..2de39f013c 100644
--- a/apps/desktop/src/app/contrib/mcp-install-deeplink-dialog.tsx
+++ b/apps/desktop/src/app/contrib/mcp-install-deeplink-dialog.tsx
@@ -117,7 +117,7 @@ export function McpInstallDeepLinkDialog() {
       setHermesConfigCache(previous => (previous ? { ...previous, mcp_servers: nextServers } : previous))
       notify({ kind: 'success', title: m.savedTitle, message: m.savedMessage(trimmedName) })
       $mcpInstallRequest.set(null)
-      navigate(`/skills?tab=mcp&server=${encodeURIComponent(trimmedName)}`)
+      navigate(`/capabilities?tab=mcp&server=${encodeURIComponent(trimmedName)}`)
     } catch (err) {
       setError(readableError(err, m.saveFailed).message)
     } finally {
diff --git a/apps/desktop/src/app/contrib/panes.tsx b/apps/desktop/src/app/contrib/panes.tsx
index 1e972f1004..bd2b86c5f3 100644
--- a/apps/desktop/src/app/contrib/panes.tsx
+++ b/apps/desktop/src/app/contrib/panes.tsx
@@ -146,7 +146,7 @@ export function useTitlebarToolContributions(side: 'left' | 'right'): TitlebarTo
 }
 
 /**
- * Bridge a page's `GroupSetter` extension point (SkillsView, MessagingView,
+ * Bridge a page's `GroupSetter` extension point (CapabilitiesView, MessagingView,
  * ChatPreviewRail, …) into the registry: each call replaces the group's items
  * as DATA contributions in `<prefix>.<side>`, so page-owned items flow through
  * the same pipe plugins use. Setting an empty list clears the group.
diff --git a/apps/desktop/src/app/contrib/surfaces.app-routes.test.tsx b/apps/desktop/src/app/contrib/surfaces.app-routes.test.tsx
new file mode 100644
index 0000000000..dcd338cf4d
--- /dev/null
+++ b/apps/desktop/src/app/contrib/surfaces.app-routes.test.tsx
@@ -0,0 +1,55 @@
+import { cleanup, render, screen } from '@testing-library/react'
+import { atom } from 'nanostores'
+import { MemoryRouter } from 'react-router'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+import { APP_ROUTES, isOverlayView } from '../routes'
+
+import { ChatRoutesSurface } from './surfaces'
+import type { WiringActions } from './types'
+
+vi.mock('@/contrib/react/use-contributions', () => ({ useContributions: vi.fn() }))
+vi.mock('@/store/connections', () => ({ $activeConnectionId: atom('local') }))
+vi.mock('@/store/gateway', () => ({ $gateway: atom<unknown>(null) }))
+vi.mock('@/store/profile', () => ({ $activeGatewayProfile: atom('default') }))
+vi.mock('@/store/session', () => ({
+  $freshDraftReady: atom(false),
+  $gatewayState: atom('open')
+}))
+vi.mock('../chat', () => ({ ChatView: () => <div data-testid="chat-view" /> }))
+vi.mock('../capabilities', () => ({ CapabilitiesView: () => null }))
+vi.mock('../messaging', () => ({ MessagingView: () => null }))
+vi.mock('../artifacts', () => ({ ArtifactsView: () => null }))
+vi.mock('../chat/sidebar', () => ({ ChatSidebar: () => null }))
+vi.mock('../right-sidebar/terminal/chrome', () => ({ TerminalPaneChrome: () => null }))
+vi.mock('../shell/hooks/use-status-snapshot', () => ({ useStatusSnapshot: () => ({}) }))
+vi.mock('../shell/hooks/use-statusbar-items', () => ({
+  useStatusbarItems: () => ({ leftStatusbarItems: [], statusbarItems: [] })
+}))
+vi.mock('../shell/statusbar-controls', () => ({ StatusbarControls: () => null }))
+vi.mock('./latest-actions', () => ({ latestChatActions: () => ({}), latestSidebarActions: () => ({}) }))
+vi.mock('./panes', () => ({ setStatusbarItemGroup: vi.fn(), useStatusbarContributions: () => [] }))
+vi.mock('../shell/model-menu-panel', () => ({ ModelMenuPanel: () => null }))
+vi.mock('../shell/reasoning-menu-panel', () => ({ ReasoningMenuPanel: () => null }))
+
+afterEach(cleanup)
+
+// The route table (`APP_ROUTES`) and the `<Route>` list are kept by hand in two
+// files. A workspace page whose path is missing from the `<Route>` list matches
+// `:sessionId`, so the app opens a chat for a session named after the page.
+// Overlays are exempt: they are modal cards over whatever the shell shows.
+describe('ChatRoutesSurface and APP_ROUTES', () => {
+  const pages = APP_ROUTES.filter(route => route.view !== 'chat' && !isOverlayView(route.view))
+
+  it.each(pages.map(route => [route.path]))('%s has its own route and never opens as a session', path => {
+    const actions = { getGateway: () => null } as unknown as WiringActions
+
+    render(
+      <MemoryRouter initialEntries={[path]}>
+        <ChatRoutesSurface actions={actions} />
+      </MemoryRouter>
+    )
+
+    expect(screen.queryByTestId('chat-view')).toBeNull()
+  })
+})
diff --git a/apps/desktop/src/app/contrib/surfaces.tsx b/apps/desktop/src/app/contrib/surfaces.tsx
index 90b0566b9e..d214931af1 100644
--- a/apps/desktop/src/app/contrib/surfaces.tsx
+++ b/apps/desktop/src/app/contrib/surfaces.tsx
@@ -38,7 +38,7 @@ import type { SidebarActions, WiringActions } from './types'
 // (agents/settings/…) are the controller's and stay in wiring.tsx.
 const ArtifactsView = lazy(async () => ({ default: (await import('../artifacts')).ArtifactsView }))
 const MessagingView = lazy(async () => ({ default: (await import('../messaging')).MessagingView }))
-const SkillsView = lazy(async () => ({ default: (await import('../skills')).SkillsView }))
+const CapabilitiesView = lazy(async () => ({ default: (await import('../capabilities')).CapabilitiesView }))
 
 export function LegacySessionRedirect() {
   const { sessionId } = useParams()
@@ -185,7 +185,7 @@ export const ChatRoutesSurface = memo(function ChatRoutesSurface({
     <Routes>
       <Route element={chatView} index />
       <Route element={chatView} path=":sessionId" />
-      <Route element={page(<SkillsView setStatusbarItemGroup={setStatusbarItemGroup} />)} path="skills" />
+      <Route element={page(<CapabilitiesView setStatusbarItemGroup={setStatusbarItemGroup} />)} path="capabilities" />
       <Route element={page(<MessagingView setStatusbarItemGroup={setStatusbarItemGroup} />)} path="messaging" />
       <Route element={page(<ArtifactsView setStatusbarItemGroup={setStatusbarItemGroup} />)} path="artifacts" />
       <Route element={null} path="agents" />
diff --git a/apps/desktop/src/app/gateway/hooks/use-gateway-boot.ts b/apps/desktop/src/app/gateway/hooks/use-gateway-boot.ts
index e678b755dc..60846e343e 100644
--- a/apps/desktop/src/app/gateway/hooks/use-gateway-boot.ts
+++ b/apps/desktop/src/app/gateway/hooks/use-gateway-boot.ts
@@ -14,7 +14,11 @@ import type { DesktopBootProgress, HermesConnection, HermesWindowState } from '@
 import { HermesGateway } from '@/hermes'
 import { translateNow } from '@/i18n'
 import { desktopDefaultCwd } from '@/lib/desktop-fs'
-import { decideLivenessForceClose, LIVENESS_REPROBE_DELAY_MS } from '@/lib/gateway-liveness-policy'
+import {
+  decideLivenessForceClose,
+  LIVENESS_PROBE_TIMEOUT_MS,
+  LIVENESS_REPROBE_DELAY_MS
+} from '@/lib/gateway-liveness-policy'
 import { BACKEND_BOOT_WAIT_TIMEOUT_MS, RECONNECT_ATTEMPT_TIMEOUT_MS, withTimeout } from '@/lib/with-timeout'
 import {
   $desktopBoot,
@@ -119,7 +123,11 @@ const RECONNECT_ESCALATE_AFTER_MS = 300_000
 // TIMEOUT alone no longer tears the socket down mid-turn (#95327): while a
 // turn is in flight the first timeout defers behind one bounded re-probe, so
 // only a STREAK of unanswered pings rebuilds the transport.
-const GATEWAY_LIVENESS_PROBE_TIMEOUT_MS = 5_000
+
+// Renderer twin of the main process's POWER_RESUME_REVALIDATION_HOLDOFF_MS:
+// forced wake reconnects (online / power resume) are coalesced into one per
+// window instead of tearing down every secondary socket on each signal (#94769).
+const WAKE_RECONNECT_HOLDOFF_MS = 15_000
 
 // Bounded self-heal for a failed REMOTE boot (#82679): main classifies every
 // fault it can see (via getBootProgress().retryable); the renderer adds the one
@@ -566,7 +574,7 @@ export function useGatewayBoot({
       // one inconclusive probe DEFERS the teardown behind a bounded re-probe;
       // only an exhausted streak (or no in-flight work) closes.
       try {
-        await gateway.request('ping', {}, GATEWAY_LIVENESS_PROBE_TIMEOUT_MS)
+        await gateway.request('ping', {}, LIVENESS_PROBE_TIMEOUT_MS)
         livenessProbeFailures = 0
       } catch (probeErr) {
         // A version-skewed backend that predates the ping method answers
@@ -900,6 +908,8 @@ export function useGatewayBoot({
       // primary thread or a just-created session's owner hold is bound to
       // (#93892).
       foregroundScopes: foregroundSessionScopes,
+      // Defined further down the effect body; read at call time, never during boot.
+      liveScopes: () => liveWorkScopes(),
       onLocalProfileRetired: forgetProfileOnlyRuntimeOwners,
       onActiveConnectionChanged: publish,
       // Keep $activeGatewayProfile in lockstep with the registry's OWN record
@@ -1001,7 +1011,42 @@ export function useGatewayBoot({
 
     // Wake signals: power resume (macOS/Windows), network coming back, and the
     // window regaining focus/visibility. Each nudges an immediate reconnect.
-    const forceReconnectNow = () => reconnectNow({ forceOpenSocket: true })
+    //
+    // Forced reconnects (power resume / 'online') close and redial every open
+    // secondary socket. Windows fires 'online' on any interface change — VPN
+    // connects, Wi-Fi blips, virtual adapter enumeration — so an unthrottled
+    // handler reaped healthy sockets in bursts and the UI remounted on every
+    // redial: the #94769 flicker loop. Coalesce forced wakes like the main
+    // process already does for power-resume revalidation
+    // (POWER_RESUME_REVALIDATION_HOLDOFF_MS): one forced reconnect per
+    // holdoff window; a socket dropped in between is still picked up by the
+    // ordinary close/reconnect backoff and by the non-forced focus/visibility
+    // nudges below.
+    let lastForcedWakeReconnectAt = 0
+
+    const forceReconnectNow = () => {
+      // reconnectNow no-ops while boot is incomplete or a gateway switch is in
+      // flight; stamping the holdoff then would burn the window and drop the
+      // next 'online' (often the one with the network actually back), leaving
+      // recovery to the backoff loops. Stamp only when it will proceed.
+      if (cancelled || !bootCompleted || $gatewaySwitching.get()) {
+        return
+      }
+
+      // Only the destructive half is coalesced: a second wake inside the
+      // holdoff (macOS fires resume then 'online' seconds apart) still runs
+      // the cheap, idempotent nudge — primary ping probe, redial of already
+      // closed secondaries — without touching open sockets.
+      const now = Date.now()
+      const forced = now - lastForcedWakeReconnectAt >= WAKE_RECONNECT_HOLDOFF_MS
+
+      if (forced) {
+        lastForcedWakeReconnectAt = now
+      }
+
+      void reconnectNow({ forceOpenSocket: forced })
+    }
+
     const offPowerResume = desktop.onPowerResume?.(() => void forceReconnectNow())
     const offConnectionApplied = desktop.onConnectionApplied?.(() => void softSwitch())
 
@@ -1100,6 +1145,10 @@ export function useGatewayBoot({
     const keepaliveTimer = setInterval(() => {
       touchActiveGatewayBackend()
       touchSecondaryGateways()
+      // The pruner is otherwise event-driven: a socket spared by the
+      // min-lifetime grace with no store change afterwards would hold its
+      // pool slot forever.
+      recomputeKeptGateways()
     }, 60_000)
 
     // Bound concurrency cost to consumers: keep a background socket while its
@@ -1109,20 +1158,28 @@ export function useGatewayBoot({
     // and its backend is free to idle-reap. The active profile is always spared.
     // Do not key this off `entry.retained` — that flag only skips dispose-after-
     // RPC; idle prune is what reclaims hover-warmed sockets after you leave.
-    const recomputeKeptGateways = () => {
+    // Scopes with a running or needs-input session: registry-scoped
+    // (connectionId, profile) keys plus the bare profile of every live local
+    // session. Two sources can expose the same profile name (every source has
+    // a 'default'), so bare profile names can't represent a non-local
+    // source's liveness without keeping the wrong gateway alive. Feeds the
+    // pruner's keep-set and the wake probe's in-flight-work signal.
+    const liveWorkScopes = (): Set<string> => {
       const live = new Set([...$workingSessionIds.get(), ...$attentionSessionIds.get()])
-      // Registry-scoped (connectionId, profile) scopes with live work. Two
-      // sources can expose the same profile name (every source has a
-      // 'default'), so bare profile names can't represent a non-local
-      // source's liveness without keeping the wrong gateway alive.
-      const keep = new Set([...liveSessionScopes(), ...foregroundSessionScopes()])
+      const scopes = liveSessionScopes()
 
       for (const session of $sessions.get()) {
         if (live.has(session.id)) {
-          keep.add(normalizeProfileKey(session.profile))
+          scopes.add(normalizeProfileKey(session.profile))
         }
       }
 
+      return scopes
+    }
+
+    const recomputeKeptGateways = () => {
+      const keep = new Set([...liveWorkScopes(), ...foregroundSessionScopes()])
+
       for (const scope of openTileGatewayScopes()) {
         keep.add(scope)
       }
diff --git a/apps/desktop/src/app/hooks/use-keybinds.ts b/apps/desktop/src/app/hooks/use-keybinds.ts
index a3ad1efdab..8c84763cf9 100644
--- a/apps/desktop/src/app/hooks/use-keybinds.ts
+++ b/apps/desktop/src/app/hooks/use-keybinds.ts
@@ -76,14 +76,14 @@ import {
   $workspaceIsPage,
   AGENTS_ROUTE,
   ARTIFACTS_ROUTE,
+  CAPABILITIES_ROUTE,
   CRON_ROUTE,
   MESSAGING_ROUTE,
   navigateToWorkspacePage,
   NEW_CHAT_ROUTE,
   PROFILES_ROUTE,
   sessionRoute,
-  SETTINGS_ROUTE,
-  SKILLS_ROUTE
+  SETTINGS_ROUTE
 } from '../routes'
 
 export interface KeybindRuntimeDeps {
@@ -211,7 +211,7 @@ export function useKeybinds(deps: KeybindRuntimeDeps): void {
     'nav.commandCenter': deps.toggleCommandCenter,
     'nav.settings': () => navigate(SETTINGS_ROUTE),
     'nav.profiles': () => navigate(PROFILES_ROUTE),
-    'nav.skills': () => navigateToWorkspacePage(navigate, SKILLS_ROUTE),
+    'nav.capabilities': () => navigateToWorkspacePage(navigate, CAPABILITIES_ROUTE),
     'nav.messaging': () => navigateToWorkspacePage(navigate, MESSAGING_ROUTE),
     'nav.artifacts': () => navigateToWorkspacePage(navigate, ARTIFACTS_ROUTE),
     'nav.cron': () => navigate(CRON_ROUTE),
diff --git a/apps/desktop/src/app/master-detail.tsx b/apps/desktop/src/app/master-detail.tsx
index dddc87e421..95e117697b 100644
--- a/apps/desktop/src/app/master-detail.tsx
+++ b/apps/desktop/src/app/master-detail.tsx
@@ -391,12 +391,6 @@ export function ListStripMenu({
   )
 }
 
-const LIST_STRIP_LABEL_CLASS = 'text-[0.68rem] font-medium text-muted-foreground/70'
-
-export function ListStripLabel({ children }: { children: ReactNode }) {
-  return <span className={LIST_STRIP_LABEL_CLASS} role="status">{children}</span>
-}
-
 export function ListStripButton({
   active,
   children,
@@ -411,8 +405,7 @@ export function ListStripButton({
   return (
     <button
       className={cn(
-        LIST_STRIP_LABEL_CLASS,
-        'cursor-pointer transition-colors disabled:opacity-40',
+        'cursor-pointer text-[0.68rem] font-medium transition-colors disabled:opacity-40',
         active ? 'text-foreground' : 'text-muted-foreground/70 hover:text-foreground'
       )}
       disabled={disabled}
diff --git a/apps/desktop/src/app/routes.titlebar-clusters.test.ts b/apps/desktop/src/app/routes.titlebar-clusters.test.ts
index b023d14448..4e1c5c66fe 100644
--- a/apps/desktop/src/app/routes.titlebar-clusters.test.ts
+++ b/apps/desktop/src/app/routes.titlebar-clusters.test.ts
@@ -10,7 +10,7 @@ describe('hidesFixedTitlebarClusters', () => {
 
   it('keeps clusters on chat and first-party workspace pages', () => {
     expect(hidesFixedTitlebarClusters('chat')).toBe(false)
-    expect(hidesFixedTitlebarClusters('skills')).toBe(false)
+    expect(hidesFixedTitlebarClusters('capabilities')).toBe(false)
     expect(hidesFixedTitlebarClusters('messaging')).toBe(false)
     expect(hidesFixedTitlebarClusters('artifacts')).toBe(false)
   })
diff --git a/apps/desktop/src/app/routes.ts b/apps/desktop/src/app/routes.ts
index 9824935412..e9a9b4a9ea 100644
--- a/apps/desktop/src/app/routes.ts
+++ b/apps/desktop/src/app/routes.ts
@@ -12,7 +12,7 @@ export const NEW_CHAT_ROUTE = '/'
 export const SETTINGS_ROUTE = '/settings'
 export const COMMAND_CENTER_ROUTE = '/command-center'
 export const SESSION_IMPORT_ROUTE = '/session-import'
-export const SKILLS_ROUTE = '/skills'
+export const CAPABILITIES_ROUTE = '/capabilities'
 export const MESSAGING_ROUTE = '/messaging'
 export const WEBHOOKS_ROUTE = '/webhooks'
 export const ARTIFACTS_ROUTE = '/artifacts'
@@ -25,6 +25,7 @@ export type AppView =
   | 'session-import'
   | 'agents'
   | 'artifacts'
+  | 'capabilities'
   | 'chat'
   | 'command-center'
   | 'cron'
@@ -36,7 +37,6 @@ export type AppView =
   | 'messaging'
   | 'profiles'
   | 'settings'
-  | 'skills'
   | 'starmap'
   | 'webhooks'
 
@@ -44,13 +44,13 @@ export type AppRouteId =
   | 'session-import'
   | 'agents'
   | 'artifacts'
+  | 'capabilities'
   | 'command-center'
   | 'cron'
   | 'messaging'
   | 'new'
   | 'profiles'
   | 'settings'
-  | 'skills'
   | 'starmap'
   | 'webhooks'
 
@@ -65,7 +65,7 @@ export const APP_ROUTES = [
   { id: 'new', path: NEW_CHAT_ROUTE, view: 'chat' },
   { id: 'settings', path: SETTINGS_ROUTE, view: 'settings' },
   { id: 'command-center', path: COMMAND_CENTER_ROUTE, view: 'command-center' },
-  { id: 'skills', path: SKILLS_ROUTE, view: 'skills' },
+  { id: 'capabilities', path: CAPABILITIES_ROUTE, view: 'capabilities' },
   { id: 'messaging', path: MESSAGING_ROUTE, view: 'messaging' },
   { id: 'webhooks', path: WEBHOOKS_ROUTE, view: 'webhooks' },
   { id: 'artifacts', path: ARTIFACTS_ROUTE, view: 'artifacts' },
@@ -158,14 +158,14 @@ export function isOverlayView(view: AppView): boolean {
  *  Contributed full pages (`extension`) hide the app clusters only while the
  *  page actually mounts `titleBar.*` chrome — those slots are mount-scoped, so
  *  a plugin page with no titlebar contribution keeps the app controls.
- *  First-party workspace pages (skills/messaging/artifacts) keep the clusters. */
+ *  First-party workspace pages (capabilities/messaging/artifacts) keep the clusters. */
 export function hidesFixedTitlebarClusters(view: AppView): boolean {
   return isOverlayView(view) || view === 'extension'
 }
 
 /** The pathname of a router target. Every classifier below reasons about a
- *  PATH, but callers navigate to full targets (`/skills?tab=mcp`), and an
- *  unstripped query reaches the session-id parser — `/skills?tab=mcp` reads as
+ *  PATH, but callers navigate to full targets (`/capabilities?tab=mcp`), and an
+ *  unstripped query reaches the session-id parser — `/capabilities?tab=mcp` reads as
  *  the session `skills?tab=mcp`, so Capabilities classifies as a chat.
  *  `sessionRoute` percent-encodes ids, so `?`/`#` can only start a query or a
  *  hash. */
@@ -282,7 +282,7 @@ export function syncWorkspaceRoute(pathname: string): void {
  * Navigate to `to`, fronting the workspace pane when it is a page route.
  *
  * `syncWorkspaceRoute` covers route CHANGES; this covers the RE-CLICK, the one
- * case it can't see — hitting Capabilities while already on `/skills` with a
+ * case it can't see — hitting Capabilities while already on `/capabilities` with a
  * tile focused leaves the location untouched, so no effect fires and only an
  * imperative reveal brings the page back. Use it wherever a nav affordance can
  * be triggered from the page it targets.
diff --git a/apps/desktop/src/app/routes.workspace-reveal.test.ts b/apps/desktop/src/app/routes.workspace-reveal.test.ts
index 3af3212680..c7039223dc 100644
--- a/apps/desktop/src/app/routes.workspace-reveal.test.ts
+++ b/apps/desktop/src/app/routes.workspace-reveal.test.ts
@@ -19,6 +19,7 @@ import {
   AGENTS_ROUTE,
   appViewForPath,
   ARTIFACTS_ROUTE,
+  CAPABILITIES_ROUTE,
   CRON_ROUTE,
   MESSAGING_ROUTE,
   navigateToWorkspacePage,
@@ -28,7 +29,6 @@ import {
   routeSessionId,
   sessionRoute,
   SETTINGS_ROUTE,
-  SKILLS_ROUTE,
   syncWorkspaceRoute
 } from './routes'
 
@@ -68,9 +68,9 @@ afterEach(() => {
 
 describe('routePathname', () => {
   it('keeps a bare path and drops a query or hash', () => {
-    expect(routePathname(SKILLS_ROUTE)).toBe('/skills')
-    expect(routePathname('/skills?tab=mcp')).toBe('/skills')
-    expect(routePathname('/skills?tab=mcp&server=ctx7')).toBe('/skills')
+    expect(routePathname(CAPABILITIES_ROUTE)).toBe('/capabilities')
+    expect(routePathname('/capabilities?tab=mcp')).toBe('/capabilities')
+    expect(routePathname('/capabilities?tab=mcp&server=ctx7')).toBe('/capabilities')
     expect(routePathname('/settings#keys')).toBe('/settings')
   })
 
@@ -87,9 +87,9 @@ describe('classification of targets carrying a query', () => {
   // servers), and Settings redirects old /settings?tab=mcp deep links to the
   // last one. Unstripped, they parsed as SESSION ids and read as 'chat'.
   it.each([
-    [`${SKILLS_ROUTE}?tab=skills`, 'skills'],
-    [`${SKILLS_ROUTE}?tab=toolsets`, 'skills'],
-    [`${SKILLS_ROUTE}?tab=mcp&server=ctx7`, 'skills'],
+    [`${CAPABILITIES_ROUTE}?tab=skills`, 'capabilities'],
+    [`${CAPABILITIES_ROUTE}?tab=toolsets`, 'capabilities'],
+    [`${CAPABILITIES_ROUTE}?tab=mcp&server=ctx7`, 'capabilities'],
     [`${SETTINGS_ROUTE}?tab=keys`, 'settings']
   ])('%s is not a session route', (to, view) => {
     expect(routeSessionId(to)).toBeNull()
@@ -99,14 +99,14 @@ describe('classification of targets carrying a query', () => {
 
 describe('syncWorkspaceRoute', () => {
   it('publishes and fronts on a page route', () => {
-    syncWorkspaceRoute(SKILLS_ROUTE)
+    syncWorkspaceRoute(CAPABILITIES_ROUTE)
 
     expect($workspaceIsPage.get()).toBe(true)
     expect(fronted()).toBe(true)
   })
 
   it('fronts on a page route reached with a query', () => {
-    syncWorkspaceRoute(`${SKILLS_ROUTE}?tab=mcp`)
+    syncWorkspaceRoute(`${CAPABILITIES_ROUTE}?tab=mcp`)
 
     expect($workspaceIsPage.get()).toBe(true)
     expect(fronted()).toBe(true)
@@ -155,13 +155,13 @@ describe('navigateToWorkspacePage', () => {
   it('navigates and fronts, so a re-click on the page you are already on still shows it', () => {
     const navigate = vi.fn()
 
-    navigateToWorkspacePage(navigate, SKILLS_ROUTE)
+    navigateToWorkspacePage(navigate, CAPABILITIES_ROUTE)
 
-    expect(navigate).toHaveBeenCalledWith(SKILLS_ROUTE, undefined)
+    expect(navigate).toHaveBeenCalledWith(CAPABILITIES_ROUTE, undefined)
     expect(fronted()).toBe(true)
   })
 
-  it.each([`${SKILLS_ROUTE}?tab=skills`, `${SKILLS_ROUTE}?tab=toolsets`, `${SKILLS_ROUTE}?tab=mcp&server=ctx7`])(
+  it.each([`${CAPABILITIES_ROUTE}?tab=skills`, `${CAPABILITIES_ROUTE}?tab=toolsets`, `${CAPABILITIES_ROUTE}?tab=mcp&server=ctx7`])(
     'fronts for the palette target %s',
     to => {
       navigateToWorkspacePage(vi.fn(), to)
diff --git a/apps/desktop/src/app/session/hooks/use-route-resume.ts b/apps/desktop/src/app/session/hooks/use-route-resume.ts
index 631f10e007..90c6c6cab5 100644
--- a/apps/desktop/src/app/session/hooks/use-route-resume.ts
+++ b/apps/desktop/src/app/session/hooks/use-route-resume.ts
@@ -62,7 +62,7 @@ function rawHashLooksLikeSession(): boolean {
 
   return (
     !hash.startsWith('/settings') &&
-    !hash.startsWith('/skills') &&
+    !hash.startsWith('/capabilities') &&
     !hash.startsWith('/messaging') &&
     !hash.startsWith('/artifacts')
   )
diff --git a/apps/desktop/src/app/session/hooks/use-session-actions.test.tsx b/apps/desktop/src/app/session/hooks/use-session-actions.test.tsx
index 8036fedfb7..eba90a0b29 100644
--- a/apps/desktop/src/app/session/hooks/use-session-actions.test.tsx
+++ b/apps/desktop/src/app/session/hooks/use-session-actions.test.tsx
@@ -4799,10 +4799,10 @@ describe('selectSidebarItem', () => {
     await waitFor(() => expect(handle).not.toBeNull())
 
     act(() => {
-      handle!.selectSidebarItem({ icon: (() => null) as never, id: 'skills', label: 'Capabilities', route: '/skills' })
+      handle!.selectSidebarItem({ icon: (() => null) as never, id: 'skills', label: 'Capabilities', route: '/capabilities' })
     })
 
-    expect(navigate).toHaveBeenCalledWith('/skills', undefined)
+    expect(navigate).toHaveBeenCalledWith('/capabilities', undefined)
     expect(noteActiveTreeGroup).toHaveBeenCalledWith(null)
     expect(revealTreePane).toHaveBeenCalledWith('workspace')
   })
diff --git a/apps/desktop/src/app/settings/moved-tabs.test.ts b/apps/desktop/src/app/settings/moved-tabs.test.ts
index 8f2c7ee6c2..0c7c6911c7 100644
--- a/apps/desktop/src/app/settings/moved-tabs.test.ts
+++ b/apps/desktop/src/app/settings/moved-tabs.test.ts
@@ -4,11 +4,11 @@ import { movedSettingsTabRedirect } from './moved-tabs'
 
 describe('movedSettingsTabRedirect', () => {
   it('sends the retired Settings plugin/MCP tabs to Capabilities, keeping the row selector', () => {
-    expect(movedSettingsTabRedirect('?tab=plugins')).toBe('/skills?tab=plugins')
+    expect(movedSettingsTabRedirect('?tab=plugins')).toBe('/capabilities?tab=plugins')
     expect(movedSettingsTabRedirect('?tab=plugins&plugin=demo%2Fplugin')).toBe(
-      '/skills?tab=plugins&plugin=demo%2Fplugin'
+      '/capabilities?tab=plugins&plugin=demo%2Fplugin'
     )
-    expect(movedSettingsTabRedirect('?tab=mcp&server=github')).toBe('/skills?tab=mcp&server=github')
+    expect(movedSettingsTabRedirect('?tab=mcp&server=github')).toBe('/capabilities?tab=mcp&server=github')
   })
 
   it('leaves live Settings tabs alone', () => {
diff --git a/apps/desktop/src/app/settings/moved-tabs.ts b/apps/desktop/src/app/settings/moved-tabs.ts
index f9ba7b6cf2..a0a3f9d3df 100644
--- a/apps/desktop/src/app/settings/moved-tabs.ts
+++ b/apps/desktop/src/app/settings/moved-tabs.ts
@@ -1,4 +1,4 @@
-import { SKILLS_ROUTE } from '../routes'
+import { CAPABILITIES_ROUTE } from '../routes'
 
 // Settings tabs that now live in Capabilities → the row-selector param each
 // carries (`?server=` for MCP, `?plugin=` for Plugins). Old bookmarks and
@@ -19,5 +19,5 @@ export function movedSettingsTabRedirect(search: string): null | string {
   const row = params.get(rowParam)
   const suffix = row ? `&${rowParam}=${encodeURIComponent(row)}` : ''
 
-  return `${SKILLS_ROUTE}?tab=${tab}${suffix}`
+  return `${CAPABILITIES_ROUTE}?tab=${tab}${suffix}`
 }
diff --git a/apps/desktop/src/app/settings/plugin-install-modal.test.tsx b/apps/desktop/src/app/settings/plugin-install-modal.test.tsx
index 5116806a8b..e2c1a59cdc 100644
--- a/apps/desktop/src/app/settings/plugin-install-modal.test.tsx
+++ b/apps/desktop/src/app/settings/plugin-install-modal.test.tsx
@@ -27,7 +27,7 @@ import {
 import { $activeGatewayProfile } from '@/store/profile'
 import { $connection, $gatewayState } from '@/store/session'
 
-import { PluginActions, PluginsTab } from '../skills/plugins-tab'
+import { PluginsTab } from '../capabilities/plugins/plugins-tab'
 
 import { PluginInstallModal } from './plugin-install-modal'
 
@@ -36,9 +36,8 @@ const installDesktopPlugin = vi.fn()
 
 const renderFlow = () =>
   render(
-    <MemoryRouter initialEntries={['/skills?tab=plugins']}>
+    <MemoryRouter initialEntries={['/capabilities?tab=plugins']}>
       <QueryClientProvider client={queryClient}>
-        <PluginActions profile={null} />
         <PluginsTab profile={null} />
         <PluginInstallModal />
       </QueryClientProvider>
diff --git a/apps/desktop/src/app/settings/plugin-install-modal.tsx b/apps/desktop/src/app/settings/plugin-install-modal.tsx
index 0dfb390e18..ea111cdc79 100644
--- a/apps/desktop/src/app/settings/plugin-install-modal.tsx
+++ b/apps/desktop/src/app/settings/plugin-install-modal.tsx
@@ -291,7 +291,7 @@ export function PluginInstallModal() {
 
         closePluginInstallRequest()
         // Catalog picks come from Capabilities → Plugins; land back there.
-        navigate(request.catalogName ? '/skills?tab=plugins' : '/settings?tab=plugins')
+        navigate(request.catalogName ? '/capabilities?tab=plugins' : '/settings?tab=plugins')
 
         return
       }
diff --git a/apps/desktop/src/app/settings/use-settings-search.ts b/apps/desktop/src/app/settings/use-settings-search.ts
index 99db78e05b..56a07a565e 100644
--- a/apps/desktop/src/app/settings/use-settings-search.ts
+++ b/apps/desktop/src/app/settings/use-settings-search.ts
@@ -21,7 +21,7 @@ import {
   type SettingsSearchEntry
 } from './settings-search'
 
-/** An installed plugin row, deep-linkable as `/skills?tab=plugins&plugin=<id>`. */
+/** An installed plugin row, deep-linkable as `/capabilities?tab=plugins&plugin=<id>`. */
 export interface PluginSearchEntry {
   context: string
   description?: string
diff --git a/apps/desktop/src/app/shell/group-setter.ts b/apps/desktop/src/app/shell/group-setter.ts
index b0f212f15e..0e48ce5012 100644
--- a/apps/desktop/src/app/shell/group-setter.ts
+++ b/apps/desktop/src/app/shell/group-setter.ts
@@ -1,4 +1,4 @@
-// The `GroupSetter` shape pages take as an extension-point prop (SkillsView,
+// The `GroupSetter` shape pages take as an extension-point prop (CapabilitiesView,
 // MessagingView, ChatPreviewRail, …). The live implementation is the
 // registry-backed `registryGroupSetter` in app/contrib/panes.tsx.
 type Side = 'left' | 'right'
diff --git a/apps/desktop/src/app/shell/titlebar-controls.test.tsx b/apps/desktop/src/app/shell/titlebar-controls.test.tsx
index a656013946..1d3c125783 100644
--- a/apps/desktop/src/app/shell/titlebar-controls.test.tsx
+++ b/apps/desktop/src/app/shell/titlebar-controls.test.tsx
@@ -86,7 +86,7 @@ describe('TitlebarControls fixed clusters', () => {
   })
 
   it('keeps the app clusters on a first-party workspace page', () => {
-    renderControls('/skills')
+    renderControls('/capabilities')
 
     expect(windowControls()).not.toBeNull()
     expect(appControls()).not.toBeNull()
diff --git a/apps/desktop/src/app/skills/capability-tabs.tsx b/apps/desktop/src/app/skills/capability-tabs.tsx
deleted file mode 100644
index 13e2b808ef..0000000000
--- a/apps/desktop/src/app/skills/capability-tabs.tsx
+++ /dev/null
@@ -1,29 +0,0 @@
-import type { ReactNode } from 'react'
-
-import { TextTab } from '@/components/ui/text-tab'
-import { useI18n } from '@/i18n'
-
-export type CapabilityView = 'installed' | 'browse'
-
-interface CapabilityTabsProps {
-  value: CapabilityView
-  onChange: (value: CapabilityView) => void
-  actions?: ReactNode
-}
-
-/** Shared Installed / Browse navigation for Skills and Plugins. */
-export function CapabilityTabs({ value, onChange, actions }: CapabilityTabsProps) {
-  const { t } = useI18n()
-
-  return (
-    <div className="flex shrink-0 items-center gap-4 px-3 py-1" data-capability-tabs>
-      <TextTab active={value === 'installed'} aria-pressed={value === 'installed'} onClick={() => onChange('installed')}>
-        {t.catalog.installed}
-      </TextTab>
-      <TextTab active={value === 'browse'} aria-pressed={value === 'browse'} onClick={() => onChange('browse')}>
-        {t.catalog.browse}
-      </TextTab>
-      {actions && <div className="-my-0.5 -mr-2 ml-auto flex h-6 items-center gap-2">{actions}</div>}
-    </div>
-  )
-}
diff --git a/apps/desktop/src/app/skills/catalog-browser.test.tsx b/apps/desktop/src/app/skills/catalog-browser.test.tsx
deleted file mode 100644
index 674d9c6501..0000000000
--- a/apps/desktop/src/app/skills/catalog-browser.test.tsx
+++ /dev/null
@@ -1,144 +0,0 @@
-import { QueryClientProvider } from '@tanstack/react-query'
-import { cleanup, fireEvent, render, screen, waitFor, within } from '@testing-library/react'
-import { useState } from 'react'
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-
-import { queryClient } from '@/lib/query-client'
-
-import { PageSearchShell } from '../page-search-shell'
-
-import { CatalogBrowser } from './catalog-browser'
-import { type CatalogKind, parseCatalog } from './catalog-data'
-import { $catalogCardView } from './store'
-
-beforeEach(() => {
-  $catalogCardView.set(true)
-})
-
-afterEach(() => {
-  cleanup()
-  queryClient.clear()
-  $catalogCardView.set(true)
-})
-
-function setup(kind: CatalogKind) {
-  const entries = parseCatalog(kind, ['alpha', 'beta'].map(name => ({
-    name,
-    identifier: `official/${name}`,
-    installIdentifier: `official/${name}`,
-    source: 'official',
-    tier: 'official',
-    category: 'research',
-    description: `${name} research workflow`,
-    repo: `https://github.com/example/${name}`,
-    sourceUrl: `https://github.com/example/${name}`,
-    docsUrl: `https://example.com/${name}`
-  })))
-
-  queryClient.setQueryData(['public-catalog', kind], entries)
-  const onInstall = vi.fn()
-
-  function Harness() {
-    const [query, setQuery] = useState('')
-
-    return (
-      <QueryClientProvider client={queryClient}>
-        <PageSearchShell onSearchChange={setQuery} searchPlaceholder="Search catalog" searchValue={query}>
-          <CatalogBrowser
-            isInstalled={entry => entry.name === 'beta'}
-            kind={kind}
-            onInstall={onInstall}
-            onQueryChange={setQuery}
-            query={query}
-          />
-        </PageSearchShell>
-      </QueryClientProvider>
-    )
-  }
-
-  return { entries, onInstall, ...render(<Harness />) }
-}
-
-describe.each(['skills', 'plugins'] as const)('%s catalog layouts', kind => {
-  it('defaults to cards with icon-only layout controls and whole-card hover', () => {
-    const { container } = setup(kind)
-    const cards = screen.getAllByRole('article')
-    const cardView = screen.getByRole('button', { name: 'Card view', pressed: true })
-
-    expect(cards).toHaveLength(2)
-    expect(cardView.textContent).toBe('')
-    expect(cardView.querySelector('.codicon-extensions')).not.toBeNull()
-    expect(screen.getByRole('button', { name: 'List view' }).querySelector('.codicon-list-unordered')).not.toBeNull()
-    expect(cards[0].classList.contains('row-hover')).toBe(true)
-    expect(within(cards[0]).getByRole('button', { name: 'alpha' }).classList.contains('row-hover')).toBe(false)
-    expect(container.querySelector('[data-catalog-list]')).toBeNull()
-    expect(within(cards[1]).getByRole<HTMLButtonElement>('button', { name: 'Installed' }).disabled).toBe(true)
-  })
-
-  it('offers installation directly on a card without opening its details', () => {
-    const { entries, onInstall } = setup(kind)
-    const card = screen.getAllByRole('article')[0]
-
-    fireEvent.click(within(card).getByRole('button', { name: 'Install' }))
-
-    expect(onInstall).toHaveBeenCalledExactlyOnceWith(entries[0])
-    expect(screen.queryByRole('dialog')).toBeNull()
-  })
-
-  it('opens the shared detail dialog with source links and the same install target', async () => {
-    const { entries, onInstall } = setup(kind)
-    fireEvent.click(screen.getByRole('button', { name: 'alpha' }))
-    const dialog = screen.getByRole('dialog', { name: 'alpha' })
-
-    expect(within(dialog).getByRole('heading', { name: 'alpha' })).toBeTruthy()
-    expect(within(dialog).getByRole('link', { name: 'Repository' }).getAttribute('href')).toBe(entries[0].sourceUrl)
-    expect(within(dialog).getByRole('link', { name: 'Documentation' }).getAttribute('href')).toBe(entries[0].docsUrl)
-    fireEvent.click(within(dialog).getByRole('button', { name: 'Install' }))
-    expect(onInstall).toHaveBeenCalledExactlyOnceWith(entries[0])
-
-    if (kind === 'plugins') {
-      // Release the inspector before the existing plugin installation dialog opens.
-      await waitFor(() => expect(screen.queryByRole('dialog')).toBeNull())
-    } else {
-      fireEvent.click(within(dialog).getByRole('button', { name: 'Close' }))
-      await waitFor(() => expect(screen.queryByRole('dialog')).toBeNull())
-    }
-  })
-
-  it('preserves the parent search and filter when switching to list and back', async () => {
-    const { container } = setup(kind)
-    const search = screen.getByRole<HTMLInputElement>('textbox', { name: 'Search catalog' })
-    fireEvent.change(search, { target: { value: 'alpha' } })
-    await waitFor(() => expect(screen.getAllByRole('article')).toHaveLength(1))
-    fireEvent.click(screen.getByRole('combobox', { name: 'Category' }))
-    fireEvent.click(screen.getByRole('option', { name: 'Research' }))
-    fireEvent.click(screen.getByRole('button', { name: 'List view' }))
-
-    expect(container.querySelector(`[data-catalog-list="${kind}"]`)).not.toBeNull()
-    expect(screen.queryByRole('article')).toBeNull()
-    expect(screen.getByRole('heading', { name: 'alpha' })).toBeTruthy()
-    expect(screen.getByRole('combobox', { name: 'Category' }).textContent).toContain('Research')
-    expect(screen.getByRole('textbox', { name: 'Search catalog' })).toBe(search)
-    expect(search.value).toBe('alpha')
-    expect(screen.getByRole('status').textContent).toBe('1 result')
-
-    fireEvent.click(screen.getByRole('button', { name: 'Card view' }))
-    expect(screen.getAllByRole('article')).toHaveLength(1)
-    expect(screen.getByRole('textbox', { name: 'Search catalog' })).toBe(search)
-    expect(screen.getByRole('combobox', { name: 'Category' }).textContent).toContain('Research')
-    expect(screen.queryByRole('dialog')).toBeNull()
-  })
-})
-
-it('shares the saved layout choice when moving between Skills and Plugins', () => {
-  setup('skills')
-  fireEvent.click(screen.getByRole('button', { name: 'List view' }))
-  expect($catalogCardView.get()).toBe(false)
-  cleanup()
-
-  const { container } = setup('plugins')
-  expect(screen.getByRole('button', { name: 'List view', pressed: true })).toBeTruthy()
-  expect(container.querySelector('[data-catalog-list="plugins"]')).not.toBeNull()
-  fireEvent.click(screen.getByRole('button', { name: 'Card view' }))
-  expect($catalogCardView.get()).toBe(true)
-})
diff --git a/apps/desktop/src/app/skills/catalog-browser.tsx b/apps/desktop/src/app/skills/catalog-browser.tsx
deleted file mode 100644
index 1f7762bf31..0000000000
--- a/apps/desktop/src/app/skills/catalog-browser.tsx
+++ /dev/null
@@ -1,323 +0,0 @@
-import { useStore } from '@nanostores/react'
-import { memo, type ReactNode, useDeferredValue, useEffect, useMemo, useRef, useState } from 'react'
-
-import { PageLoader } from '@/components/page-loader'
-import { ActionStatus } from '@/components/ui/action-status'
-import { Badge } from '@/components/ui/badge'
-import { Button } from '@/components/ui/button'
-import { Codicon, codiconIcon } from '@/components/ui/codicon'
-import { Dialog, DialogContent, DialogTitle } from '@/components/ui/dialog'
-import { ErrorState } from '@/components/ui/error-state'
-import { RowButton } from '@/components/ui/row-button'
-import { SegmentedControl } from '@/components/ui/segmented-control'
-import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select'
-import { useI18n } from '@/i18n'
-import { ExternalLink } from '@/lib/external-link'
-import { cn } from '@/lib/utils'
-
-import { DetailColumn, ListColumn, ListStrip, ListStripLabel, MasterDetail, ToolChip } from '../master-detail'
-import { PanelEmpty } from '../overlays/panel'
-import { prettyName } from '../settings/helpers'
-
-import type { CapabilityView } from './capability-tabs'
-import { type CatalogEntry, type CatalogKind, useCatalog } from './catalog-data'
-import { $catalogCardView } from './store'
-
-interface CatalogBrowserProps {
-  kind: CatalogKind
-  query?: string
-  onQueryChange?: (value: string) => void
-  view?: CapabilityView
-  isInstalled: (entry: CatalogEntry) => boolean
-  onInstall: (entry: CatalogEntry) => void
-  isInstalling?: (entry: CatalogEntry) => boolean
-  installedEntries?: CatalogEntry[]
-  renderInstalledDetail?: (entry: CatalogEntry) => ReactNode
-}
-
-const PAGE_SIZE = 60
-const ListViewIcon = codiconIcon('list-unordered')
-const CardViewIcon = codiconIcon('extensions')
-
-export const CatalogBrowser = memo(function CatalogBrowser({
-  kind,
-  isInstalled,
-  onInstall,
-  isInstalling,
-  installedEntries,
-  renderInstalledDetail,
-  view = 'browse',
-  query = '',
-  onQueryChange
-}: CatalogBrowserProps) {
-  const { t } = useI18n()
-  const c = t.catalog
-  const cardView = useStore($catalogCardView)
-  const { data, isPending, error, refetch } = useCatalog(kind, view === 'browse')
-  const deferredQuery = useDeferredValue(query.trim().toLowerCase())
-  const [source, setSource] = useState('all')
-  const [category, setCategory] = useState('all')
-  const [selectedId, setSelectedId] = useState<string | null>(null)
-  const [detailOpen, setDetailOpen] = useState(false)
-  const selectedCardRef = useRef<HTMLButtonElement | null>(null)
-  const [limit, setLimit] = useState(PAGE_SIZE)
-
-  const entries = useMemo(() => {
-    return view === 'installed' ? (installedEntries ?? []) : (data ?? [])
-  }, [data, installedEntries, view])
-
-  const sources = useMemo(() => [...new Set(entries.map(entry => entry.source))], [entries])
-
-  const categories = useMemo(() => {
-    const values = new Map<string, string>()
-
-    for (const entry of entries) {
-      if (source === 'all' || entry.source === source) {
-        values.set(entry.category, entry.categoryLabel)
-      }
-    }
-
-    return [...values].sort((a, b) => a[1].localeCompare(b[1]))
-  }, [entries, source])
-
-  const filtered = useMemo(() => entries.filter(entry =>
-    (source === 'all' || entry.source === source) &&
-    (category === 'all' || entry.category === category) &&
-    (!deferredQuery || entry.search.includes(deferredQuery))
-  ), [entries, source, category, deferredQuery])
-
-  const selected = filtered.find(entry => entry.id === selectedId) ?? filtered[0]
-  const installedDetail = selected ? renderInstalledDetail?.(selected) : null
-
-  const resetSelection = () => {
-    setLimit(PAGE_SIZE)
-    setSelectedId(null)
-    setDetailOpen(false)
-  }
-
-  useEffect(() => {
-    setLimit(PAGE_SIZE)
-    setSelectedId(null)
-    setDetailOpen(false)
-  }, [deferredQuery])
-
-  const clearFilters = () => {
-    onQueryChange?.('')
-    setSource('all')
-    setCategory('all')
-    resetSelection()
-  }
-
-  const installButton = (entry: CatalogEntry) => {
-    const installed = isInstalled(entry)
-    const installing = isInstalling?.(entry) ?? false
-
-    return (
-      <Button disabled={installed || installing || (kind === 'skills' && !entry.installIdentifier)} onClick={() => {
-        if (kind === 'plugins') {
-          setDetailOpen(false)
-        }
-
-        onInstall(entry)
-      }} size="sm" variant={installed ? 'secondary' : 'default'}>
-        <ActionStatus
-          busy={t.skills.hub.installing}
-          done={c.installed}
-          idle={t.skills.hub.install}
-          idleIcon={<Codicon name="cloud-download" />}
-          state={installed ? 'done' : installing ? 'saving' : 'idle'}
-        />
-      </Button>
-    )
-  }
-
-  const metadata = selected ? [
-    [c.author, selected.author],
-    [c.source, prettyName(selected.source)],
-    [c.category, prettyName(selected.categoryLabel)],
-    [c.version, selected.version],
-    [c.platforms, selected.platforms.join(', ')],
-    [c.requires, selected.requiresHermes ? `Hermes ${selected.requiresHermes}` : ''],
-    [c.pinned, selected.sha ? <code title={selected.sha}>{selected.sha.slice(0, 8)}</code> : '']
-  ] as [string, ReactNode][] : []
-
-  const DetailTitle = view === 'browse' && cardView ? DialogTitle : 'h3'
-
-  const details = selected ? (
-    <>
-      <header className="space-y-3">
-        {selected.imageUrl && (
-          <img
-            alt=""
-            className="block aspect-[2/1] w-full rounded-md border border-(--ui-border) object-cover"
-            decoding="async"
-            loading="lazy"
-            onError={e => { e.currentTarget.style.display = 'none' }}
-            referrerPolicy="no-referrer"
-            src={selected.imageUrl}
-          />
-        )}
-        <div className="flex items-start gap-3">
-          <Codicon className="mt-1 shrink-0 text-(--ui-text-tertiary)" name={kind === 'plugins' ? 'extensions' : 'book'} size="1.5rem" />
-          <div className="min-w-0">
-            <DetailTitle className="break-words text-lg font-semibold tracking-tight">{selected.name}</DetailTitle>
-            <p className="mt-1 text-xs text-(--ui-text-tertiary)">{selected.author || prettyName(selected.source)}</p>
-          </div>
-        </div>
-        <div className="flex flex-wrap items-center gap-2">
-          {installButton(selected)}
-          <Badge variant="muted">{prettyName(selected.source)}</Badge>
-          {selected.stars !== null && <span className="text-xs text-(--ui-text-tertiary)">☆ {selected.stars.toLocaleString()}</span>}
-        </div>
-      </header>
-      <section className="space-y-2">
-        <h4 className="text-xs font-medium">{c.about}</h4>
-        <p className="whitespace-pre-wrap break-words text-[length:var(--conversation-caption-font-size)] leading-relaxed text-(--ui-text-secondary)">{selected.description}</p>
-        {selected.overview && selected.overview !== selected.description && <p className="whitespace-pre-wrap break-words text-[length:var(--conversation-caption-font-size)] leading-relaxed text-(--ui-text-tertiary)">{selected.overview}</p>}
-      </section>
-      <dl className="space-y-2 text-[length:var(--conversation-caption-font-size)]">
-        {metadata.filter(([, value]) => Boolean(value)).map(([label, value]) => <div className="grid grid-cols-[6rem_minmax(0,1fr)] gap-3" key={label}><dt className="text-(--ui-text-tertiary)">{label}</dt><dd className="m-0 break-words">{value}</dd></div>)}
-      </dl>
-      {[[c.tools, selected.tools], [c.hooks, selected.hooks], [c.requires, selected.requirements]].map(([label, values]) => (values as string[]).length > 0 && (
-        <section className="space-y-2" key={label as string}><h4 className="text-xs font-medium">{label as string}</h4><div className="flex flex-wrap gap-1">{(values as string[]).map(value => <ToolChip key={value}>{value}</ToolChip>)}</div></section>
-      ))}
-      <div className="flex flex-wrap gap-3 text-xs">
-        {selected.sourceUrl && <ExternalLink href={selected.sourceUrl}>{c.repository}</ExternalLink>}
-        {selected.docsUrl && <ExternalLink href={selected.docsUrl}>{c.documentation}</ExternalLink>}
-      </div>
-      <p className="text-[0.65rem] leading-relaxed text-(--ui-text-quaternary)">{c.installHint}</p>
-    </>
-  ) : null
-
-  return (
-    <div className="flex h-full min-h-0 min-w-0 flex-col" data-catalog={kind}>
-      {view === 'browse' && <div className="flex shrink-0 flex-wrap items-center gap-x-4 gap-y-2 px-3 py-2">
-        <div className="flex min-w-0 flex-wrap items-center gap-2">
-          <div className="w-36">
-            <Select onValueChange={value => { setSource(value); setCategory('all'); resetSelection() }} value={source}>
-              <SelectTrigger aria-label={c.source}><SelectValue placeholder={c.allSources} /></SelectTrigger>
-              <SelectContent>
-                <SelectItem value="all">{c.allSources}</SelectItem>
-                {sources.map(value => <SelectItem key={value} value={value}>{prettyName(value)}</SelectItem>)}
-              </SelectContent>
-            </Select>
-          </div>
-          <div className="w-40">
-            <Select onValueChange={value => { setCategory(value); resetSelection() }} value={category}>
-              <SelectTrigger aria-label={c.category}><SelectValue placeholder={c.allCategories} /></SelectTrigger>
-              <SelectContent>
-                <SelectItem value="all">{c.allCategories}</SelectItem>
-                {categories.map(([value, label]) => <SelectItem key={value} value={value || 'uncategorized'}>{prettyName(label)}</SelectItem>)}
-              </SelectContent>
-            </Select>
-          </div>
-        </div>
-        <SegmentedControl
-          className="ml-auto shrink-0"
-          iconOnly
-          onChange={layout => {
-            setDetailOpen(false)
-            $catalogCardView.set(layout === 'cards')
-          }}
-          options={[{ id: 'list', label: c.listView, icon: ListViewIcon }, { id: 'cards', label: c.cardView, icon: CardViewIcon }]}
-          value={cardView ? 'cards' : 'list'}
-        />
-      </div>}
-      <div className="min-h-0 flex-1">
-        {isPending && view === 'browse' && !entries.length ? <PageLoader label={t.skills.loading} /> : error && !entries.length ? (
-          <div className="grid h-full place-items-center p-5">
-            <ErrorState description={error.message} title={c.loadFailed}>
-              <Button onClick={() => void refetch()} size="sm" variant="secondary">{c.retry}</Button>
-            </ErrorState>
-          </div>
-        ) : !selected ? (
-          <PanelEmpty action={<Button onClick={clearFilters} size="sm" variant="secondary">{c.clearFilters}</Button>} description={c.tryAnother} icon="search" title={c.noResults} />
-        ) : view === 'browse' && cardView ? (
-          <>
-            <div className="flex h-full min-h-0 flex-col px-3 pb-3" data-catalog-cards={kind}>
-              <ListStrip left={<ListStripLabel>{c.results(filtered.length)}</ListStripLabel>} />
-              <div className="min-h-0 flex-1 overflow-y-auto overscroll-contain [scrollbar-gutter:stable]" key={`${source}:${category}:${deferredQuery}`}>
-                <div className="grid grid-cols-[repeat(auto-fill,minmax(min(100%,17rem),1fr))] gap-3 py-2">
-                  {filtered.slice(0, limit).map(entry => (
-                    <article className="row-hover flex min-w-0 flex-col overflow-hidden rounded-lg border border-(--ui-stroke-tertiary) bg-(--ui-chat-bubble-background)" data-catalog-card key={entry.id}>
-                      <RowButton
-                        aria-haspopup="dialog"
-                        aria-label={entry.name}
-                        className="flex min-w-0 flex-1 cursor-pointer flex-col gap-3 p-4 text-left focus-visible:outline-2 focus-visible:outline-primary focus-visible:-outline-offset-2"
-                        onClick={event => {
-                          selectedCardRef.current = event.currentTarget
-                          setSelectedId(entry.id)
-                          setDetailOpen(true)
-                        }}
-                      >
-                        <span className="flex w-full items-center gap-2 text-[length:var(--conversation-caption-font-size)] text-(--ui-text-tertiary)">
-                          <Codicon name={kind === 'plugins' ? 'extensions' : 'book'} size="1.25rem" />
-                          <span className="min-w-0 flex-1 truncate">{prettyName(entry.source)}</span>
-                          {entry.stars !== null && <span className="shrink-0">☆ {entry.stars.toLocaleString()}</span>}
-                        </span>
-                        <span className="line-clamp-2 break-words text-[length:var(--conversation-text-font-size)] font-semibold leading-snug">{entry.name}</span>
-                        <span className="line-clamp-3 text-[length:var(--conversation-caption-font-size)] leading-relaxed text-(--ui-text-secondary)">{entry.description}</span>
-                        <span className="mt-auto w-full truncate pt-1 text-[length:var(--conversation-caption-font-size)] text-(--ui-text-tertiary)">{entry.author || prettyName(entry.source)}</span>
-                      </RowButton>
-                      <div className="flex flex-wrap items-center justify-between gap-2 px-4 pb-4">
-                        <Badge variant="muted">{prettyName(entry.categoryLabel)}</Badge>
-                        {installButton(entry)}
-                      </div>
-                    </article>
-                  ))}
-                </div>
-                {filtered.length > limit && <Button onClick={() => setLimit(value => value + PAGE_SIZE)} size="sm" variant="text">{c.more}</Button>}
-              </div>
-            </div>
-            <Dialog onOpenChange={setDetailOpen} open={detailOpen}>
-              <DialogContent
-                aria-describedby={undefined}
-                bodyClassName="gap-5"
-                className="max-w-2xl"
-                onCloseAutoFocus={event => {
-                  event.preventDefault()
-                  selectedCardRef.current?.focus()
-                }}
-              >
-                {details}
-              </DialogContent>
-            </Dialog>
-          </>
-        ) : (
-          <div className={cn('h-full min-h-0', detailOpen ? '[&_aside]:max-sm:hidden' : '[&_main]:max-sm:hidden')} data-catalog-list={kind}>
-            <MasterDetail resizeId="capabilities-split" split="wide">
-              <ListColumn header={<ListStrip left={<ListStripLabel>{c.results(filtered.length)}</ListStripLabel>} />} key={`${source}:${category}:${deferredQuery}`}>
-                {filtered.slice(0, limit).map(entry => (
-                  <RowButton
-                    aria-pressed={entry.id === selected.id}
-                    className={cn('row-hover flex w-full min-w-0 items-start gap-3 rounded-md px-2 py-2 text-left', entry.id === selected.id && 'bg-(--ui-row-active-background)')}
-                    key={entry.id}
-                    onClick={() => { setSelectedId(entry.id); setDetailOpen(true) }}
-                  >
-                    <Codicon className="mt-0.5 shrink-0 text-(--ui-text-tertiary)" name={kind === 'plugins' ? 'extensions' : 'book'} size="1.1rem" />
-                    <span className="min-w-0 flex-1">
-                      <span className="flex items-center gap-2">
-                        <span className="truncate text-[0.78rem] font-medium">{entry.name}</span>
-                        {isInstalled(entry) && <Codicon className="shrink-0 text-(--ui-text-tertiary)" name="check" />}
-                      </span>
-                      <span className="mt-1 line-clamp-2 text-[length:var(--conversation-caption-font-size)] leading-(--conversation-caption-line-height) text-(--ui-text-tertiary)">{entry.description}</span>
-                      <span className="mt-1.5 flex items-center gap-2 text-[0.65rem] text-(--ui-text-quaternary)">
-                        <span className="truncate">{entry.author || prettyName(entry.source)}</span>
-                        {entry.stars !== null && <span className="shrink-0">☆ {entry.stars.toLocaleString()}</span>}
-                      </span>
-                    </span>
-                  </RowButton>
-                ))}
-                {filtered.length > limit && <Button onClick={() => setLimit(value => value + PAGE_SIZE)} size="sm" variant="text">{c.more}</Button>}
-              </ListColumn>
-              <DetailColumn footer={c.snapshotHint}>
-                <div className="sm:hidden"><Button onClick={() => setDetailOpen(false)} size="sm" variant="text"><Codicon name="arrow-left" />{c.back}</Button></div>
-                {installedDetail || details}
-              </DetailColumn>
-            </MasterDetail>
-          </div>
-        )}
-      </div>
-    </div>
-  )
-})
diff --git a/apps/desktop/src/app/skills/catalog-data.test.ts b/apps/desktop/src/app/skills/catalog-data.test.ts
deleted file mode 100644
index 4062999cf4..0000000000
--- a/apps/desktop/src/app/skills/catalog-data.test.ts
+++ /dev/null
@@ -1,136 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest'
-
-import { fetchCatalog, parseCatalog } from './catalog-data'
-
-afterEach(() => vi.unstubAllGlobals())
-
-describe('public catalog data', () => {
-  it('preserves every source and distinct install identifier, including same-named skills', () => {
-    const rows = ['official', 'github', 'community', 'future-source'].map(source => ({
-      name: 'research',
-      identifier: `${source}/research`,
-      source,
-      author: `${source} maintainer`,
-      description: `Research from ${source}`,
-      category: 'research',
-      categoryLabel: 'Research',
-      tags: [`${source}-tag`],
-      envVars: [`${source.toUpperCase()}_KEY`]
-    }))
-    // Same source, different identifier is also a distinct install target.
-    rows.push({ ...rows[0], identifier: 'official/alternate/research' })
-
-    const entries = parseCatalog('skills', rows)
-
-    expect(entries).toHaveLength(rows.length)
-    expect(new Set(entries.map(entry => entry.id)).size).toBe(rows.length)
-    rows.forEach(row => {
-      const entry = entries.find(candidate => candidate.identifier === row.identifier)
-      expect(entry).toMatchObject({
-        name: row.name,
-        identifier: row.identifier,
-        source: row.source,
-        author: row.author,
-        description: row.description,
-        categoryLabel: row.categoryLabel,
-        tags: row.tags,
-        requirements: row.envVars
-      })
-      expect(entry?.search).toContain(row.source)
-      expect(entry?.search).toContain(row.tags[0])
-    })
-  })
-
-  it('keeps catalog identity separate from the source-qualified skill install target', () => {
-    const [entry] = parseCatalog('skills', [{
-      name: 'Apple Design', identifier: 'apple-design', source: 'ClawHub',
-      installCmd: 'hermes skills install clawhub/apple-design'
-    }])
-
-    expect(entry.identifier).toBe('apple-design')
-    expect(entry.installIdentifier).toBe('clawhub/apple-design')
-  })
-
-  it('keeps each plugin tier, pinned install target, and published detail metadata together', () => {
-    const rows = ['official', 'community', 'future-tier'].map(tier => ({
-      name: `${tier}-plugin`,
-      tier,
-      repo: `https://github.com/example/${tier}-plugins`,
-      subdir: 'packages/weather',
-      sha: 'a'.repeat(40),
-      maintainer: `${tier} maintainer`,
-      overview: `Overview for ${tier}`,
-      version: '1.2.3',
-      requiresHermes: '>=0.17',
-      platforms: ['macos', 'linux'],
-      docsUrl: `https://example.com/${tier}/docs`,
-      capabilities: {
-        providesTools: [`${tier}_forecast`],
-        providesHooks: ['on_session_start'],
-        requiresEnv: ['WEATHER_KEY']
-      }
-    }))
-
-    const entries = parseCatalog('plugins', rows)
-
-    expect(entries).toHaveLength(rows.length)
-    rows.forEach(row => {
-      const entry = entries.find(candidate => candidate.name === row.name)
-      expect(entry).toMatchObject({
-        name: row.name,
-        source: row.tier,
-        repo: row.repo,
-        sha: row.sha,
-        subdir: row.subdir,
-        author: row.maintainer,
-        overview: row.overview,
-        version: row.version,
-        requiresHermes: row.requiresHermes,
-        platforms: row.platforms,
-        docsUrl: row.docsUrl,
-        sourceUrl: row.repo,
-        tools: row.capabilities.providesTools,
-        hooks: row.capabilities.providesHooks,
-        requirements: row.capabilities.requiresEnv
-      })
-      expect(entry?.search).toContain(row.capabilities.providesTools[0])
-    })
-  })
-
-  it.each(['skills', 'plugins'] as const)('fetches only the published %s snapshot and parses it', async kind => {
-    const rows = [{
-      name: 'weather',
-      identifier: 'official/weather',
-      source: 'official',
-      tier: 'official',
-      repo: 'https://github.com/example/weather',
-      sourceUrl: 'https://github.com/example/weather/blob/main/SKILL.md'
-    }]
-    const fetch = vi.fn().mockResolvedValue({ ok: true, json: async () => rows })
-    vi.stubGlobal('fetch', fetch)
-
-    expect(await fetchCatalog(kind)).toEqual(parseCatalog(kind, rows))
-    expect(fetch).toHaveBeenCalledExactlyOnceWith(
-      `https://nousresearch.github.io/hermes-agent/docs/api/${kind}.json`,
-      expect.objectContaining({ credentials: 'omit', signal: expect.any(AbortSignal) })
-    )
-  })
-
-  it('only renders plugin images hosted on GitHub so the browser never fans out to third-party hosts', () => {
-    const base = { name: 'x', tier: 'community', repo: 'https://github.com/o/r', sha: 'a'.repeat(40), version: '1.4.0' }
-    const [github, offhost, http] = parseCatalog('plugins', [
-      { ...base, name: 'github', image: 'https://raw.githubusercontent.com/o/r/abc/banner.png' },
-      { ...base, name: 'offhost', image: 'https://cdn.example.com/banner.png' },
-      { ...base, name: 'http', image: 'http://github.com/o/r/banner.png' }
-    ])
-
-    expect(github.imageUrl).toBe('https://raw.githubusercontent.com/o/r/abc/banner.png')
-    expect(github.version).toBe('1.4.0')
-    expect(offhost.imageUrl).toBeNull()
-    expect(http.imageUrl).toBeNull()
-  })
-
-  it('rejects a non-catalog response instead of treating an error payload as an empty catalog', () => {
-    expect(() => parseCatalog('skills', { error: 'Service unavailable' })).toThrow('Invalid catalog response')
-  })
-})
diff --git a/apps/desktop/src/app/skills/catalog-data.ts b/apps/desktop/src/app/skills/catalog-data.ts
deleted file mode 100644
index e8774431e3..0000000000
--- a/apps/desktop/src/app/skills/catalog-data.ts
+++ /dev/null
@@ -1,157 +0,0 @@
-import { skillCatalogInstallIdentifier } from '@hermes/shared'
-import { useQuery } from '@tanstack/react-query'
-
-export type CatalogKind = 'skills' | 'plugins'
-
-export interface CatalogEntry {
-  id: string
-  name: string
-  description: string
-  overview: string
-  category: string
-  categoryLabel: string
-  source: string
-  author: string
-  identifier: string
-  installIdentifier?: string | null
-  repo: string
-  sha: string
-  subdir: string
-  version: string
-  requiresHermes: string
-  tags: string[]
-  platforms: string[]
-  requirements: string[]
-  tools: string[]
-  hooks: string[]
-  sourceUrl: string | null
-  docsUrl: string | null
-  /** GitHub-hosted banner for plugin entries; the only third-party fetch the browser makes. */
-  imageUrl: string | null
-  stars: number | null
-  search: string
-}
-
-const DOCS_ORIGIN = 'https://hermes-agent.nousresearch.com'
-// The public domain redirects here without CORS headers on the redirect.
-// Use the docs' actual static host, not GitHub's API or repository endpoints.
-const CATALOG_BASE = 'https://nousresearch.github.io/hermes-agent/docs/api'
-const text = (value: unknown): string => typeof value === 'string' ? value : ''
-const strings = (value: unknown): string[] => Array.isArray(value) ? value.filter(v => typeof v === 'string') : []
-
-const IMAGE_HOSTS = new Set(['raw.githubusercontent.com', 'github.com'])
-
-/** Mirrors scripts/validate_plugin_catalog.py: https on a GitHub host, else no image. */
-export function catalogImageUrl(value: unknown): string | null {
-  try {
-    const url = new URL(text(value))
-    const host = url.hostname.toLowerCase()
-
-    return url.protocol === 'https:' && (IMAGE_HOSTS.has(host) || host.endsWith('.githubusercontent.com')) ? url.href : null
-  } catch {
-    return null
-  }
-}
-
-function webUrl(value: unknown): string | null {
-  try {
-    const url = new URL(text(value))
-
-    return url.protocol === 'https:' || url.protocol === 'http:' ? url.href : null
-  } catch {
-    return null
-  }
-}
-
-export function parseCatalog(kind: CatalogKind, data: unknown): CatalogEntry[] {
-  if (!Array.isArray(data)) {
-    throw new Error('Invalid catalog response')
-  }
-
-  const entries = new Map<string, CatalogEntry>()
-
-  for (const row of data) {
-    if (!row || typeof row !== 'object' || !text(row.name)) {
-      continue
-    }
-
-    const name = text(row.name)
-    const source = text(kind === 'plugins' ? row.tier : row.source)
-    const identifier = text(row.identifier) || name
-    const id = `${source}:${identifier}`
-    const caps = row.capabilities ?? {}
-    const category = text(row.category) || 'uncategorized'
-    const tags = strings(row.tags)
-    const tools = strings(caps.providesTools)
-    const hooks = strings(caps.providesHooks)
-    const author = text(row.maintainer ?? row.author)
-    const description = text(row.description)
-
-    entries.set(id, {
-      id,
-      name,
-      description,
-      overview: text(row.overview),
-      category,
-      categoryLabel: text(row.categoryLabel) || category,
-      source,
-      author,
-      identifier,
-      installIdentifier: kind === 'skills' ? skillCatalogInstallIdentifier({
-        name, source, identifier: text(row.identifier), installIdentifier: text(row.installIdentifier)
-      }) : null,
-      repo: text(row.repo),
-      sha: text(row.sha),
-      subdir: text(row.subdir),
-      version: text(row.version),
-      requiresHermes: text(row.requiresHermes),
-      tags,
-      tools,
-      hooks,
-      platforms: strings(row.platforms),
-      requirements: strings(kind === 'plugins' ? caps.requiresEnv : row.envVars),
-      sourceUrl: webUrl(row.repo || row.sourceUrl),
-      docsUrl: webUrl(row.docsUrl) || (text(row.docsPath)
-        ? `${DOCS_ORIGIN}/docs/user-guide/skills/${text(row.docsPath)}`
-        : null),
-      imageUrl: kind === 'plugins' ? catalogImageUrl(row.image) : null,
-      stars: typeof row.stars === 'number' && Number.isFinite(row.stars) ? row.stars : null,
-      search: [name, description, author, category, row.categoryLabel, source, ...tags, ...tools, ...hooks]
-        .filter(Boolean).join(' ').toLowerCase()
-    })
-  }
-
-  return [...entries.values()]
-}
-
-export async function fetchCatalog(kind: CatalogKind): Promise<CatalogEntry[]> {
-  // These are the same published snapshots as the docs galleries. Never fan
-  // out to repositories, README previews, avatars, or live hub searches.
-  const response = await fetch(`${CATALOG_BASE}/${kind}.json`, {
-    credentials: 'omit',
-    signal: AbortSignal.timeout(60_000)
-  })
-
-  if (!response.ok) {
-    throw new Error(`Catalog HTTP ${response.status}`)
-  }
-
-  return parseCatalog(kind, await response.json())
-}
-
-export function useCatalog(kind: CatalogKind, enabled = true) {
-  return useQuery({
-    queryKey: ['public-catalog', kind],
-    // Re-enabling a mounted query retries errors even with retryOnMount off.
-    // Keep failures parked until the user explicitly chooses Try again.
-    enabled: query => enabled && query.state.status !== 'error',
-    queryFn: () => fetchCatalog(kind),
-    staleTime: 30 * 60_000,
-    gcTime: Infinity,
-    refetchOnWindowFocus: false,
-    refetchOnReconnect: false,
-    refetchOnMount: false,
-    retryOnMount: false,
-    retry: false
-  })
-}
diff --git a/apps/desktop/src/app/skills/index.tsx b/apps/desktop/src/app/skills/index.tsx
deleted file mode 100644
index 1f4675ec1f..0000000000
--- a/apps/desktop/src/app/skills/index.tsx
+++ /dev/null
@@ -1,1190 +0,0 @@
-import { compactNumber } from '@hermes/shared'
-import { useStore } from '@nanostores/react'
-import { useQuery } from '@tanstack/react-query'
-import type * as React from 'react'
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
-import { useNavigate } from 'react-router'
-
-import { ArchiveSkillConfirmDialog } from '@/app/learning/archive-skill-confirm-dialog'
-import { CodeEditor } from '@/components/chat/code-editor'
-import { PageLoader } from '@/components/page-loader'
-import { Badge } from '@/components/ui/badge'
-import { Button } from '@/components/ui/button'
-import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select'
-import { CountSkeleton } from '@/components/ui/skeleton'
-import type { DesktopRosterAgent } from '@/global'
-import {
-  editLearningNode,
-  getLearningNode,
-  getProfiles,
-  getSkillContent,
-  getSkills,
-  getToolsets,
-  getUsageAnalytics,
-  type ProfileScope,
-  profileScopeKey,
-  setSkillEnabled,
-  setToolsetEnabled
-} from '@/hermes'
-import { useI18n } from '@/i18n'
-import { isDesktopToolsetVisible } from '@/lib/desktop-toolsets'
-import { queryClient } from '@/lib/query-client'
-import { invalidateSlashCompletions } from '@/lib/slash-completion-cache'
-import { normalize } from '@/lib/text'
-import { useStoreSelector } from '@/lib/use-session-slice'
-import { $gateway, activeGatewayConnectionId } from '@/store/gateway'
-import { notify, notifyError } from '@/store/notifications'
-import { $activeGatewayProfile, normalizeProfileKey } from '@/store/profile'
-import type { SkillInfo, ToolsetInfo } from '@/types/hermes'
-
-import { useOnProfileSwitch } from '../hooks/use-on-profile-switch'
-import { useRefreshHotkey } from '../hooks/use-refresh-hotkey'
-import { useRouteEnumParam } from '../hooks/use-route-enum-param'
-import {
-  CapRow,
-  DetailColumn,
-  DetailPane,
-  ListColumn,
-  ListStrip,
-  ListStripButton,
-  ListStripMenu,
-  type ListStripMenuToggle,
-  MasterDetail,
-  ToolChip
-} from '../master-detail'
-import { PanelEmpty, PanelPill } from '../overlays/panel'
-import { PageSearchShell } from '../page-search-shell'
-import { SETTINGS_ROUTE } from '../routes'
-import { BrowserRealProfilePanel } from '../settings/browser-real-profile-panel'
-import { ComputerUsePanel } from '../settings/computer-use-panel'
-import { asText, includesQuery, prettyName, toolNames, toolsetDisplayLabel } from '../settings/helpers'
-import { TerminalBackendPanel } from '../settings/terminal-backend-panel'
-import { ToolsetConfigPanel } from '../settings/toolset-config-panel'
-import type { SetStatusbarItemGroup } from '../shell/statusbar-controls'
-
-import { CapabilityTabs, type CapabilityView } from './capability-tabs'
-import { McpTab } from './mcp-tab'
-import { PluginActions, PluginsTab } from './plugins-tab'
-import { SkillCatalog } from './skill-catalog'
-import { $skillsSortDesc, $toolsetsSortDesc } from './store'
-import { UpdateSkillsButton } from './update-skills-button'
-
-// Skills Hub browsing lives inside the Skills tab. Legacy `?tab=hub`
-// links fall back to 'skills' via useRouteEnumParam.
-const SKILLS_MODES = ['skills', 'toolsets', 'mcp', 'plugins'] as const
-
-// Skills + toolsets live in the RQ cache so switching tabs/pages paints the
-// cached lists instantly (no reload flash) and mount only fires a deduped
-// background refetch. A profile swap globally invalidates (see store/profile),
-// so these plain keys refetch against the new backend automatically.
-// Both are extended with the Capabilities scope key at the call sites so every
-// scoped profile keeps its own cached copy (prefix invalidations still match).
-const SKILLS_QUERY_KEY = ['skills-list'] as const
-const TOOLSETS_QUERY_KEY = ['toolsets-list'] as const
-
-// Per-tool call counts come from a 365-day message scan — heavy, and purely
-// cosmetic (Toolsets usage badges). Cache the result module-wide with a TTL so
-// bouncing between tabs/pages doesn't re-run the scan every time. Keyed by
-// the Capabilities scope profile: analytics are profile-scoped, so a scope or
-// app-profile switch must not show the previous profile's counts.
-// `useRefreshHotkey` still forces a fresh pull.
-const TOOL_CALLS_TTL_MS = 10 * 60 * 1000
-const toolCallsCache = new Map<string, { at: number; value: Record<string, number> }>()
-
-async function loadToolCalls(
-  scopeKey: string,
-  scopeProfile: ProfileScope,
-  force = false
-): Promise<Record<string, number>> {
-  const cached = toolCallsCache.get(scopeKey)
-
-  if (!force && cached && Date.now() - cached.at < TOOL_CALLS_TTL_MS) {
-    return cached.value
-  }
-
-  const analytics = await getUsageAnalytics(365, scopeProfile)
-
-  const value = Object.fromEntries((analytics.tools ?? []).map(e => [e.tool, e.count]))
-
-  toolCallsCache.set(scopeKey, { at: Date.now(), value })
-
-  return value
-}
-
-const usageOf = (skill: SkillInfo): number => (typeof skill.usage === 'number' ? skill.usage : 0)
-
-const categoryFor = (skill: SkillInfo): string => asText(skill.category) || 'general'
-
-// Row subtitle: category, with non-default origins badged.
-function skillSubtitle(skill: SkillInfo): React.ReactNode {
-  const category = prettyName(categoryFor(skill))
-  const provenance = skill.provenance
-
-  return (
-    <>
-      <span className="truncate">{category}</span>
-      {provenance === 'agent' && (
-        <Badge className="shrink-0 normal-case" variant="default">
-          learned
-        </Badge>
-      )}
-      {provenance === 'hub' && (
-        <Badge className="shrink-0 normal-case" variant="muted">
-          hub
-        </Badge>
-      )}
-    </>
-  )
-}
-
-function filteredSkills(skills: SkillInfo[], query: string, desc: boolean): SkillInfo[] {
-  const q = normalize(query)
-  const sign = desc ? 1 : -1
-
-  return skills
-    .filter(
-      skill =>
-        !q || includesQuery(skill.name, q) || includesQuery(skill.description, q) || includesQuery(skill.category, q)
-    )
-    .sort((a, b) => sign * (usageOf(b) - usageOf(a)) || asText(a.name).localeCompare(asText(b.name)))
-}
-
-const toolsetCalls = (toolset: ToolsetInfo, toolCalls: Record<string, number>): number =>
-  toolNames(toolset).reduce((sum, name) => sum + (toolCalls[name] ?? 0), 0)
-
-function filteredToolsets(
-  toolsets: ToolsetInfo[],
-  query: string,
-  toolCalls: Record<string, number>,
-  desc: boolean
-): ToolsetInfo[] {
-  const q = normalize(query)
-  const sign = desc ? 1 : -1
-
-  return toolsets
-    .filter(toolset => {
-      if (!isDesktopToolsetVisible(toolset.name)) {
-        return false
-      }
-
-      if (!q) {
-        return true
-      }
-
-      return (
-        includesQuery(toolset.name, q) ||
-        includesQuery(toolsetDisplayLabel(toolset), q) ||
-        includesQuery(toolset.description, q) ||
-        toolNames(toolset).some(name => includesQuery(name, q))
-      )
-    })
-    .sort(
-      (a, b) =>
-        sign * (toolsetCalls(b, toolCalls) - toolsetCalls(a, toolCalls)) ||
-        toolsetDisplayLabel(a).localeCompare(toolsetDisplayLabel(b))
-    )
-}
-
-const visibleToolsetCount = (toolsets: ToolsetInfo[]) => toolsets.filter(ts => isDesktopToolsetVisible(ts.name)).length
-
-interface SkillsViewProps extends React.ComponentProps<'section'> {
-  setStatusbarItemGroup?: SetStatusbarItemGroup
-  /** Embedded mode (plugin dialogs — e.g. Bot Mode's Advanced section): tab
-   *  state lives in local React state instead of the route's `?tab=` param,
-   *  so an embedding dialog never fights the page router. */
-  embedded?: boolean
-  /** Pin the WHOLE view to one profile: the scope selector is hidden and
-   *  every tab reads/writes THAT profile. This is the plugin door — Bot Mode
-   *  renders the real Capabilities surface pinned to a bot. */
-  fixedProfile?: string
-  /** Pin the view to a REGISTERED gateway connection alongside `fixedProfile`:
-   *  every read/write routes to that machine's backend instead of the active
-   *  gateway. `''`/`'local'` mean the local pool. This is Bot Mode's
-   *  remote-target door — a bot living on another registered gateway gets the
-   *  live surface pointed at ITS backend. Ignored without `fixedProfile`. */
-  fixedConnection?: string
-}
-
-export function SkillsView({
-  embedded = false,
-  fixedConnection,
-  fixedProfile,
-  setStatusbarItemGroup: _setStatusbarItemGroup,
-  ...props
-}: SkillsViewProps) {
-  const { t } = useI18n()
-  // Both hooks run unconditionally (rules of hooks); embedded picks the local
-  // one so tab clicks inside a dialog don't rewrite the page URL.
-  const routeTab = useRouteEnumParam('tab', SKILLS_MODES, 'skills')
-  const localTab = useState<(typeof SKILLS_MODES)[number]>('skills')
-  const [mode, setMode] = embedded ? localTab : routeTab
-  // $gateway only feeds the MCP tab — gate the subscription so Skills/Toolsets
-  // tabs don't re-render on connect/disconnect/reconnect.
-  const gateway = useStoreSelector($gateway, g => (mode === 'mcp' ? g : null))
-
-  const [query, setQuery] = useState('')
-
-  const [capabilityView, setCapabilityView] = useState<CapabilityView>('installed')
-
-  // Capabilities scope selector: which profile's Skills/Tools/MCP config we're
-  // editing — and on WHICH gateway. A profile belongs to one gateway, so on a
-  // multi-connection desktop the selector offers every (connection, profile)
-  // pair from the union agent roster and an explicit pick routes every
-  // read/write to that machine's backend. Defaults to the app-wide active
-  // profile (unchanged behavior). A `fixedProfile` (+ optional
-  // `fixedConnection`) pins the scope outright (selector hidden).
-  const activeProfile = useStore($activeGatewayProfile)
-  const [scopeOverride, setScopeOverride] = useState<null | string | { connectionId: string; profile: string }>(null)
-
-  const scopeProfile: ProfileScope = useMemo(
-    () =>
-      fixedProfile
-        ? fixedConnection
-          ? { connectionId: fixedConnection, profile: fixedProfile }
-          : fixedProfile
-        : (scopeOverride ?? activeProfile ?? null),
-    [activeProfile, fixedConnection, fixedProfile, scopeOverride]
-  )
-
-  const scopeKey = profileScopeKey(scopeProfile)
-
-  // The registry connection an explicit override pins — null for the ambient
-  // active-profile path and for fixed-profile pins without a connection.
-  const scopeConnectionId =
-    scopeProfile && typeof scopeProfile === 'object' ? (scopeProfile.connectionId ?? '').trim() || 'local' : null
-
-  // Scoped to a DIFFERENT backend than the window's active gateway? The MCP
-  // tab's live-reload RPC rides the active gateway socket, which would reload
-  // the wrong machine — withhold it for cross-backend scopes.
-  const crossBackendScope = scopeConnectionId !== null && scopeConnectionId !== (activeGatewayConnectionId() ?? 'local')
-
-  const { data: profilesData } = useQuery({
-    queryKey: ['capabilities-profiles'],
-    queryFn: () => getProfiles(),
-    staleTime: 60_000,
-    // Pinned scope never shows the selector, so don't fetch the roster for it.
-    enabled: !fixedProfile
-  })
-
-  const profiles = profilesData?.profiles ?? []
-
-  // v2 multi-connection registry: cheap local IPC to learn whether more than
-  // one gateway is registered. Only then is the (heavier) union agent roster
-  // fetched to feed the selector — single-connection setups keep the exact
-  // legacy profiles list. Both feature-detected for older Electron mains.
-  const registryBridge = window.hermesDesktop?.connections
-  const rosterBridge = window.hermesDesktop?.getAgentRoster
-
-  const { data: registryData } = useQuery({
-    queryKey: ['capabilities-connections-registry'],
-    queryFn: () => registryBridge!.list(),
-    staleTime: 60_000,
-    enabled: !fixedProfile && Boolean(registryBridge) && Boolean(rosterBridge)
-  })
-
-  const multiConnection = (registryData?.connections.length ?? 0) > 1
-
-  const { data: rosterData } = useQuery({
-    queryKey: ['capabilities-agent-roster'],
-    queryFn: () => rosterBridge!(),
-    staleTime: 60_000,
-    enabled: !fixedProfile && multiConnection
-  })
-
-  const {
-    data: skills,
-    isError: skillsFailed,
-    error: skillsError
-  } = useQuery({
-    queryKey: [...SKILLS_QUERY_KEY, scopeKey],
-    queryFn: () => getSkills(scopeProfile),
-    staleTime: 0
-  })
-
-  const { data: toolsets, isError: toolsetsFailed } = useQuery({
-    queryKey: [...TOOLSETS_QUERY_KEY, scopeKey],
-    queryFn: () => getToolsets(scopeProfile),
-    staleTime: 0
-  })
-
-  // Optimistic write-through against the scoped Skills key: toggles/bulk/
-  // archive repaint instantly; the next background refetch reconciles.
-  const setSkills = useCallback(
-    (fn: (cur: SkillInfo[] | undefined) => SkillInfo[] | undefined) =>
-      queryClient.setQueryData<SkillInfo[]>([...SKILLS_QUERY_KEY, scopeKey], prev => fn(prev) ?? prev),
-    [scopeKey]
-  )
-
-  // tool name -> call count over the analytics window. null = still loading
-  // (badges show skeletons); {} = loaded empty / unavailable backend.
-  const [toolCalls, setToolCalls] = useState<Record<string, number> | null>(null)
-  // Bumped on profile switch so a slow analytics load from profile A can't set
-  // toolCalls after the user moved to B.
-  const toolCallsEpoch = useRef(0)
-  const skillsSortDesc = useStore($skillsSortDesc)
-  const toolsetsSortDesc = useStore($toolsetsSortDesc)
-  const [bulkBusy, setBulkBusy] = useState(false)
-  const [selectedSkill, setSelectedSkill] = useState<string | null>(null)
-  const [selectedToolset, setSelectedToolset] = useState<string | null>(null)
-
-  const refreshCapabilities = useCallback(async () => {
-    await Promise.all([
-      queryClient.invalidateQueries({ queryKey: SKILLS_QUERY_KEY }),
-      queryClient.invalidateQueries({ queryKey: TOOLSETS_QUERY_KEY })
-    ])
-
-    invalidateSlashCompletions()
-
-    // An explicit refresh is the one time we bypass the analytics TTL — but
-    // only if the badges are already on screen; otherwise let the lazy load
-    // pick it up when Toolsets is first shown. Guard the async set against a
-    // profile/scope switch landing before it resolves.
-    if (toolCallsCache.size > 0) {
-      const epoch = toolCallsEpoch.current
-
-      loadToolCalls(scopeKey, scopeProfile, true)
-        .then(value => toolCallsEpoch.current === epoch && setToolCalls(value))
-        .catch(() => toolCallsEpoch.current === epoch && setToolCalls({}))
-    }
-  }, [scopeKey, scopeProfile])
-
-  const refreshToolsets = useCallback(() => {
-    void queryClient.invalidateQueries({ queryKey: TOOLSETS_QUERY_KEY })
-  }, [])
-
-  useRefreshHotkey(refreshCapabilities)
-
-  // Per-tool call counts feed ONLY the Toolsets tab's usage badges/sort, and
-  // the query behind them is a 365-day message scan — heavy. Fetch it lazily
-  // the first time Toolsets is shown, never on Skills or MCP, so it can't
-  // starve the MCP tab's config load. Absent → toolsets sort A–Z until it lands.
-  useEffect(() => {
-    if (mode !== 'toolsets' || toolCalls !== null) {
-      return
-    }
-
-    let cancelled = false
-    // Guard the setter by epoch too: when toolCalls is already null at switch
-    // time, setToolCalls(null) is a no-op so this effect never re-runs to flip
-    // `cancelled` — the epoch check catches that gap.
-    const epoch = toolCallsEpoch.current
-    const live = () => !cancelled && toolCallsEpoch.current === epoch
-
-    loadToolCalls(scopeKey, scopeProfile)
-      .then(value => live() && setToolCalls(value))
-      .catch(() => live() && setToolCalls({}))
-
-    return () => void (cancelled = true)
-  }, [mode, scopeKey, scopeProfile, toolCalls])
-
-  // On an app-wide profile switch the analytics cache is scope-keyed, but our
-  // local toolCalls state isn't — leaving it non-null would keep the lazy
-  // effect from ever re-running, so badges/sort would show the previous
-  // profile's counts. Reset to null so the next Toolsets view reloads for the
-  // active profile. The switch also drops any scope override — the user just
-  // changed what "here" means, and a stale override pointing at the previous
-  // selection would be surprising.
-  useOnProfileSwitch(() => {
-    toolCallsEpoch.current += 1
-    setToolCalls(null)
-    setScopeOverride(null)
-  })
-
-  const visibleSkills = useMemo(
-    () => (skills ? filteredSkills(skills, query, skillsSortDesc) : []),
-    [query, skills, skillsSortDesc]
-  )
-
-  // Installed-name set for the catalog's already-installed guard — the
-  // UNFILTERED list on purpose (search must not make a skill look absent).
-  const installedSkillNames = useMemo(() => new Set((skills ?? []).map(s => s.name)), [skills])
-
-  const visibleToolsets = useMemo(
-    () => (toolsets ? filteredToolsets(toolsets, query, toolCalls ?? {}, toolsetsSortDesc) : []),
-    [query, toolCalls, toolsets, toolsetsSortDesc]
-  )
-
-  // Bulk actions ("All" master switch, "Disable unused") and the master-switch
-  // state target the WHOLE tab, never the search-filtered view — a tab-wide
-  // control that silently scoped to the current query would be a lie.
-  const bulkSkills = skills ?? []
-  const bulkToolsets = useMemo(() => (toolsets ?? []).filter(ts => isDesktopToolsetVisible(ts.name)), [toolsets])
-
-  // Rotating placeholder nudges from the user's own data — teach that search
-  // understands categories and tool names, not just titles.
-  const searchHints = useMemo(() => {
-    if (mode === 'skills' && skills?.length) {
-      const counts = new Map<string, number>()
-
-      for (const skill of skills) {
-        const key = categoryFor(skill)
-        counts.set(key, (counts.get(key) || 0) + 1)
-      }
-
-      return [...counts.entries()]
-        .sort(([, a], [, b]) => b - a)
-        .slice(0, 5)
-        .map(([category]) => t.common.tryHint(category.toLowerCase()))
-    }
-
-    if (mode === 'toolsets' && toolsets?.length) {
-      return toolsets
-        .filter(ts => isDesktopToolsetVisible(ts.name) && toolNames(ts).length > 0)
-        .slice(0, 5)
-        .map(ts => t.common.tryHint(toolNames(ts)[0]))
-    }
-
-    return undefined
-  }, [mode, skills, toolsets, t])
-
-  // Keep a valid selection: fall back to the first visible row when the
-  // current selection is filtered out (or nothing is selected yet).
-  const activeSkill = useMemo(
-    () => visibleSkills.find(s => s.name === selectedSkill) ?? visibleSkills[0] ?? null,
-    [selectedSkill, visibleSkills]
-  )
-
-  const activeToolset = useMemo(
-    () => visibleToolsets.find(ts => ts.name === selectedToolset) ?? visibleToolsets[0] ?? null,
-    [selectedToolset, visibleToolsets]
-  )
-
-  // Single toggles are optimistic and silent on success (the row repaints
-  // immediately — a toast per flip would spam rapid customization). Errors
-  // revert and notify.
-  async function handleToggleSkill(skill: SkillInfo, enabled: boolean) {
-    setSkills(current => current?.map(row => (row.name === skill.name ? { ...row, enabled } : row)) ?? current)
-
-    try {
-      await setSkillEnabled(skill.name, enabled, scopeProfile)
-      // A disabled skill loses its `/name` command, so the composer's cached
-      // `/` list has to be dropped along with the row repaint.
-      invalidateSlashCompletions()
-    } catch (err) {
-      setSkills(
-        current => current?.map(row => (row.name === skill.name ? { ...row, enabled: !enabled } : row)) ?? current
-      )
-      notifyError(err, t.skills.failedToUpdate(skill.name))
-    }
-  }
-
-  async function handleToggleToolset(toolset: ToolsetInfo, enabled: boolean) {
-    const scopedToolsetKey = [...TOOLSETS_QUERY_KEY, scopeKey]
-
-    const writeScoped = (fn: (cur: ToolsetInfo[] | undefined) => ToolsetInfo[] | undefined) =>
-      queryClient.setQueryData<ToolsetInfo[]>(scopedToolsetKey, prev => fn(prev) ?? prev)
-
-    writeScoped(
-      current =>
-        current?.map(row => (row.name === toolset.name ? { ...row, enabled, available: enabled } : row)) ?? current
-    )
-
-    try {
-      await setToolsetEnabled(toolset.name, enabled, scopeProfile)
-    } catch (err) {
-      writeScoped(
-        current =>
-          current?.map(row => (row.name === toolset.name ? { ...row, enabled: !enabled, available: !enabled } : row)) ??
-          current
-      )
-      notifyError(err, t.skills.failedToUpdate(toolsetDisplayLabel(toolset)))
-    }
-  }
-
-  // Sequential on purpose: each toggle is a config read-modify-write on the
-  // backend; parallel calls would race the disabled-list save.
-  async function bulkApply(skillTargets: SkillInfo[], toolsetTargets: ToolsetInfo[], enabled: boolean) {
-    if (bulkBusy || skillTargets.length + toolsetTargets.length === 0) {
-      return
-    }
-
-    setBulkBusy(true)
-
-    let done = 0
-
-    try {
-      for (const row of skillTargets) {
-        await setSkillEnabled(row.name, enabled, scopeProfile)
-        setSkills(cur => cur?.map(r => (r.name === row.name ? { ...r, enabled } : r)) ?? cur)
-        done += 1
-      }
-
-      for (const row of toolsetTargets) {
-        await setToolsetEnabled(row.name, enabled, scopeProfile)
-        queryClient.setQueryData<ToolsetInfo[]>(
-          [...TOOLSETS_QUERY_KEY, scopeKey],
-          cur => cur?.map(r => (r.name === row.name ? { ...r, enabled, available: enabled } : r)) ?? cur
-        )
-        done += 1
-      }
-
-      notify({ kind: 'success', title: t.skills.bulkUpdated(done), message: '' })
-    } catch (err) {
-      notifyError(err, t.skills.failedToUpdate(mode === 'skills' ? t.skills.tabSkills : t.skills.tabToolsets))
-    } finally {
-      invalidateSlashCompletions()
-      setBulkBusy(false)
-    }
-  }
-
-  const bulkToggle = (enabled: boolean) =>
-    mode === 'skills'
-      ? bulkApply(
-          bulkSkills.filter(row => row.enabled !== enabled),
-          [],
-          enabled
-        )
-      : bulkApply(
-          [],
-          bulkToolsets.filter(row => row.enabled !== enabled),
-          enabled
-        )
-
-  // "Never used" = zero recorded activity. The pruning move for a 100+ skill
-  // install: keep the workhorses, shed the noise.
-  const disableUnused = () =>
-    bulkApply(
-      bulkSkills.filter(skill => skill.enabled && usageOf(skill) === 0),
-      [],
-      false
-    )
-
-  // One switch line covering enable-all/disable-all.
-  const bulkSwitch = (allEnabled: boolean): ListStripMenuToggle => ({
-    checked: allEnabled,
-    disabled: bulkBusy,
-    label: t.skills.all,
-    onToggle: checked => void bulkToggle(checked)
-  })
-
-  const allSkillsEnabled = bulkSkills.length > 0 && bulkSkills.every(s => s.enabled)
-  const allToolsetsEnabled = bulkToolsets.length > 0 && bulkToolsets.every(ts => ts.enabled)
-
-  const sortButton = (desc: boolean, flip: () => void) => (
-    <ListStripButton onClick={flip}>{desc ? t.skills.sortMostUsedDesc : t.skills.sortLeastUsedAsc}</ListStripButton>
-  )
-
-  // Full-bleed empty state, matching the MCP tab (spans both columns, not a
-  // cramped note in the left rail). Query-aware, and says "tools" not the
-  // internal "toolsets".
-  const capabilityEmpty = (noun: string) => {
-    const q = query.trim()
-
-    return (
-      <div className="flex h-full min-h-0 flex-1">
-        <PanelEmpty
-          description={q ? t.skills.emptyNothingMatches(q) : t.skills.emptyNoneAvailable(noun)}
-          icon="search"
-          title={t.skills.emptyNoneFound(noun)}
-        />
-      </div>
-    )
-  }
-
-  // Learned/local skills are editable + archivable, mirroring the memory
-  // graph (same /api/learning/node endpoints — delete archives, restorable
-  // via `hermes curator restore`).
-  const [skillEditor, setSkillEditor] = useState<null | { content: string; name: string }>(null)
-  const [skillDraft, setSkillDraft] = useState('')
-  const [skillSaving, setSkillSaving] = useState(false)
-  const [archiveTarget, setArchiveTarget] = useState<null | string>(null)
-  // Bumped on profile switch so an in-flight openSkillEditor fetch from profile
-  // A can't reopen the editor with A's content after switching to B.
-  const skillEditorEpoch = useRef(0)
-
-  // A profile switch swaps the backend under the open editor/archive dialog —
-  // their targets belong to profile A, so a save/archive would hit B. Drop them
-  // so nothing edits or archives against the newly active profile.
-  useOnProfileSwitch(() => {
-    skillEditorEpoch.current += 1
-    setSkillEditor(null)
-    setSkillDraft('')
-    setArchiveTarget(null)
-  })
-
-  const openSkillEditor = async (name: string) => {
-    const epoch = skillEditorEpoch.current
-
-    try {
-      const node = await getLearningNode(name, scopeProfile)
-
-      if (skillEditorEpoch.current !== epoch) {
-        return
-      }
-
-      setSkillEditor({ content: node.content, name })
-      setSkillDraft(node.content)
-    } catch (err) {
-      notifyError(err, name)
-    }
-  }
-
-  const saveSkillEdit = async () => {
-    if (!skillEditor) {
-      return
-    }
-
-    setSkillSaving(true)
-
-    try {
-      await editLearningNode(skillEditor.name, skillDraft, scopeProfile)
-      notify({
-        kind: 'success',
-        title: t.skills.skillUpdated,
-        message: t.skills.appliesToNewSessions(skillEditor.name)
-      })
-      setSkillEditor(null)
-      void refreshCapabilities()
-    } catch (err) {
-      notifyError(err, skillEditor.name)
-    } finally {
-      setSkillSaving(false)
-    }
-  }
-
-  const skillEditorPane = skillEditor && (
-    <DetailPane
-      actions={
-        <Button disabled={skillSaving} onClick={() => void saveSkillEdit()} size="xs">
-          {skillSaving ? t.common.saving : t.common.save}
-        </Button>
-      }
-      id="skill-editor"
-      onClose={() => setSkillEditor(null)}
-      title={<span className="text-[0.68rem] font-normal text-muted-foreground/60">{skillEditor.name}/SKILL.md</span>}
-    >
-      <CodeEditor
-        filePath="SKILL.md"
-        initialValue={skillEditor.content}
-        key={skillEditor.name}
-        onCancel={() => setSkillEditor(null)}
-        onChange={setSkillDraft}
-        onSave={() => void saveSkillEdit()}
-      />
-    </DetailPane>
-  )
-
-  // Selecting a different scope is the same staleness hazard as an app-wide
-  // profile switch: in-flight analytics belong to the previous scope's cache
-  // key, and an open skill editor / archive dialog targets the PREVIOUS
-  // scope's skill (a save/archive would hit the new one). Reset both here —
-  // this handler is the only way the scope changes besides an app profile
-  // switch, which useOnProfileSwitch already covers.
-  //
-  // Selector option values are `connectionId::profile` on multi-connection
-  // desktops (the roster path) and bare profile names otherwise, so one
-  // handler decodes both.
-  const changeScope = (value: string) => {
-    const sep = value.indexOf('::')
-
-    // Roster picks (`connectionId::profile`) stay objects — a `local::` pick
-    // must PIN the local pool even while a remote gateway is active. Legacy
-    // bare-name picks stay strings so cache keys and routing are unchanged.
-    const next: ProfileScope = sep >= 0 ? { connectionId: value.slice(0, sep), profile: value.slice(sep + 2) } : value
-
-    if (profileScopeKey(next) === scopeKey) {
-      return
-    }
-
-    setScopeOverride(next as string | { connectionId: string; profile: string })
-    toolCallsEpoch.current += 1
-    setToolCalls(null)
-    skillEditorEpoch.current += 1
-    setSkillEditor(null)
-    setSkillDraft('')
-    setArchiveTarget(null)
-  }
-
-  // Scope-selector rows. Multi-connection desktops list every reachable
-  // (connection, profile) agent from the union roster — the selected profile
-  // is configured ON ITS OWN GATEWAY. Otherwise the legacy per-profile list.
-  const scopeOptions: { key: string; label: string; value: string }[] = useMemo(() => {
-    if (multiConnection && rosterData?.agents?.length) {
-      const activeId = activeGatewayConnectionId() ?? 'local'
-
-      return rosterData.agents.map((agent: DesktopRosterAgent) => ({
-        key: `${agent.connectionId}::${agent.profile}`,
-        label:
-          agent.connectionId === activeId
-            ? `${agent.profile} — ${agent.connectionLabel} (current)`
-            : `${agent.profile} — ${agent.connectionLabel}`,
-        value: `${agent.connectionId}::${agent.profile}`
-      }))
-    }
-
-    return (profilesData?.profiles ?? []).map(p => ({
-      key: p.name,
-      label: p.is_default ? 'Hermes (default)' : p.name,
-      value: p.name
-    }))
-  }, [multiConnection, profilesData, rosterData])
-
-  // The selector's current value must match one option's value exactly. On the
-  // roster path an ambient (non-override) scope is the active gateway's
-  // profile, which lives at `activeConnectionId::profile`.
-  const scopeSelectValue = useMemo(() => {
-    if (scopeProfile && typeof scopeProfile === 'object') {
-      return `${(scopeProfile.connectionId ?? '').trim() || 'local'}::${scopeProfile.profile ?? ''}`
-    }
-
-    if (multiConnection && rosterData?.agents?.length) {
-      return `${activeGatewayConnectionId() ?? 'local'}::${normalizeProfileKey(scopeProfile)}`
-    }
-
-    return scopeProfile ?? ''
-  }, [multiConnection, rosterData, scopeProfile])
-
-  // Scope selector, shown above EVERY Capabilities tab (Skills, Tools, MCP,
-  // Browse Hub). Lets the user configure ANY profile's capabilities — on any
-  // registered gateway — without switching the whole app. Only meaningful
-  // with >1 option; hidden otherwise to avoid clutter.
-  // Keep the selector in the same slot across tabs. Plugins labels its scope
-  // as Agent because desktop halves belong to the app, not this profile.
-  const scopeLabel = scopeOptions.find(option => option.value === scopeSelectValue)?.label
-
-  const profileScopeSelector =
-    scopeOptions.length > 1 ? (
-      <div
-        className="flex min-w-0 items-center gap-2 border-b border-(--ui-stroke-secondary) px-3 py-2"
-      >
-        <span className="text-[0.7rem] font-medium text-(--ui-text-tertiary)">{mode === 'plugins' ? t.skills.plugins.halfAgent : t.skills.configuringProfile}</span>
-        <Select onValueChange={changeScope} value={scopeSelectValue}>
-          <SelectTrigger className="h-7 w-56 text-xs">
-            <SelectValue />
-          </SelectTrigger>
-          <SelectContent>
-            {scopeOptions.map(option => (
-              <SelectItem key={option.key} value={option.value}>
-                {option.label}
-              </SelectItem>
-            ))}
-          </SelectContent>
-        </Select>
-      </div>
-    ) : null
-
-  return (
-    <PageSearchShell
-      {...props}
-      activeTab={mode}
-      onSearchChange={setQuery}
-      onTabChange={id => setMode(id as (typeof SKILLS_MODES)[number])}
-      // MCP manages a handful of entries with the editor right there —
-      // searching it is noise.
-      searchHidden={mode === 'mcp'}
-      searchHints={searchHints}
-      searchPlaceholder={mode === 'plugins' ? t.catalog.searchPlugins : mode === 'skills' ? t.catalog.searchSkills : t.skills.searchToolsets}
-      searchValue={query}
-      tabs={[
-        { id: 'skills', label: t.skills.tabSkills, meta: skills?.length ?? null },
-        { id: 'toolsets', label: t.skills.tabToolsets, meta: toolsets ? visibleToolsetCount(toolsets) : null },
-        { id: 'mcp', label: t.skills.tabMcp },
-        { id: 'plugins', label: t.skills.tabPlugins }
-      ]}
-    >
-      {/* One shared column: the scope selector sits above whichever tab is
-          active, so Skills / Tools / MCP all read and write the SAME selected
-          profile. */}
-      <div className="flex h-full flex-col">
-        {profileScopeSelector}
-        {(mode === 'skills' || mode === 'plugins') && (
-          <CapabilityTabs
-            actions={mode === 'skills' ? <UpdateSkillsButton profile={scopeProfile} /> : <PluginActions profile={scopeProfile} />}
-            onChange={setCapabilityView}
-            value={capabilityView}
-          />
-        )}
-        <div className="flex min-h-0 flex-1 flex-col">
-          <div className="min-h-0 flex-1 overflow-hidden">
-            {mode === 'plugins' ? (
-              // Agent plugins for the scoped profile (selector in the section
-              // header), app-level desktop plugins, and the native catalog
-              // underneath. Keyed on scope so a profile/connection switch
-              // reloads the agent list.
-              <PluginsTab
-                key={`plugins-${scopeKey}`}
-                onQueryChange={setQuery}
-                profile={scopeProfile}
-                query={query}
-                scopeLabel={scopeLabel}
-                view={capabilityView}
-              />
-            ) : mode === 'mcp' ? (
-              // The gateway instance backs ONLY the live `reload.mcp` RPC, and
-              // it is the ACTIVE gateway's socket — for a scope pinned to a
-              // different backend that RPC would hot-reload the wrong
-              // machine's MCP servers, so it is withheld (config edits still
-              // apply on that backend's next session).
-              <McpTab gateway={crossBackendScope ? null : gateway} key={`mcp-${scopeKey}`} profile={scopeProfile} />
-            ) : mode === 'skills' && capabilityView === 'browse' ? (
-              <SkillCatalog installedNames={installedSkillNames} key={scopeKey} onQueryChange={setQuery} profile={scopeProfile} query={query} />
-            ) : (skillsFailed || toolsetsFailed) && (!skills || !toolsets) ? (
-              <PanelEmpty
-                action={
-                  <Button onClick={() => void refreshCapabilities()} size="sm">
-                    {t.skills.refresh}
-                  </Button>
-                }
-                description={skillsError instanceof Error ? skillsError.message : undefined}
-                icon="error"
-                title={t.skills.skillsLoadFailed}
-              />
-            ) : !skills || !toolsets ? (
-              <PageLoader label={t.skills.loading} />
-            ) : mode === 'skills' ? (
-              visibleSkills.length === 0 ? (
-                capabilityEmpty('skills')
-              ) : (
-                <MasterDetail pane={skillEditorPane} resizeId="capabilities-split" split="wide">
-                  <ListColumn
-                    header={
-                      <ListStrip
-                        left={sortButton(skillsSortDesc, () => $skillsSortDesc.set(!$skillsSortDesc.get()))}
-                        right={
-                          <ListStripMenu
-                            items={[
-                              {
-                                disabled: bulkBusy,
-                                label: t.skills.disableUnused,
-                                onSelect: () => void disableUnused()
-                              }
-                            ]}
-                            label={t.skills.tabSkills}
-                            toggle={bulkSwitch(allSkillsEnabled)}
-                          />
-                        }
-                      />
-                    }
-                  >
-                    {visibleSkills.map(skill => (
-                      <CapRow
-                        active={activeSkill?.name === skill.name}
-                        busy={bulkBusy}
-                        enabled={skill.enabled}
-                        key={skill.name}
-                        meta={usageOf(skill) > 0 ? `×${compactNumber(usageOf(skill))}` : undefined}
-                        onSelect={() => setSelectedSkill(skill.name)}
-                        onToggle={enabled => void handleToggleSkill(skill, enabled)}
-                        subtitle={skillSubtitle(skill)}
-                        title={skill.name}
-                        toggleLabel={skill.name}
-                      />
-                    ))}
-                  </ListColumn>
-                  <DetailColumn footer={t.skills.changesApplyNewSessions}>
-                    {activeSkill && (
-                      <SkillDetail
-                        onArchive={() => setArchiveTarget(activeSkill.name)}
-                        onEdit={() => void openSkillEditor(activeSkill.name)}
-                        profile={scopeProfile}
-                        skill={activeSkill}
-                      />
-                    )}
-                  </DetailColumn>
-                </MasterDetail>
-              )
-            ) : visibleToolsets.length === 0 ? (
-              capabilityEmpty('tools')
-            ) : (
-              <MasterDetail resizeId="capabilities-split" split="wide">
-                <ListColumn
-                  header={
-                    <ListStrip
-                      left={sortButton(toolsetsSortDesc, () => $toolsetsSortDesc.set(!$toolsetsSortDesc.get()))}
-                      right={<ListStripMenu label={t.skills.tabToolsets} toggle={bulkSwitch(allToolsetsEnabled)} />}
-                    />
-                  }
-                >
-                  {visibleToolsets.map(toolset => {
-                    const label = toolsetDisplayLabel(toolset)
-                    const calls = toolCalls ? toolsetCalls(toolset, toolCalls) : null
-
-                    return (
-                      <CapRow
-                        active={activeToolset?.name === toolset.name}
-                        busy={bulkBusy}
-                        enabled={toolset.enabled}
-                        key={toolset.name}
-                        meta={
-                          calls === null ? (
-                            <CountSkeleton />
-                          ) : calls > 0 ? (
-                            `×${compactNumber(calls)}`
-                          ) : (
-                            `${toolNames(toolset).length} tools`
-                          )
-                        }
-                        onSelect={() => setSelectedToolset(toolset.name)}
-                        onToggle={checked => void handleToggleToolset(toolset, checked)}
-                        subtitle={asText(toolset.description)}
-                        title={label}
-                        toggleLabel={t.skills.toggleToolset(label, !toolset.enabled)}
-                      />
-                    )
-                  })}
-                </ListColumn>
-                <DetailColumn footer={t.skills.changesApplyNewSessions}>
-                  {activeToolset && (
-                    <ToolsetDetail
-                      onConfiguredChange={refreshToolsets}
-                      profile={scopeProfile}
-                      toolCalls={toolCalls ?? {}}
-                      toolset={activeToolset}
-                    />
-                  )}
-                </DetailColumn>
-              </MasterDetail>
-            )}
-          </div>
-        </div>
-      </div>
-      {archiveTarget && (
-        <ArchiveSkillConfirmDialog
-          onApply={() => {
-            const name = archiveTarget
-            const snapshot = skills
-
-            setSkills(current => current?.filter(skill => skill.name !== name) ?? current)
-            invalidateSlashCompletions()
-
-            if (skillEditor?.name === name) {
-              setSkillEditor(null)
-            }
-
-            return () => setSkills(() => snapshot)
-          }}
-          onClose={() => setArchiveTarget(null)}
-          onFailure={(err, name) => notifyError(err, name)}
-          open
-          profile={scopeProfile}
-          skillId={archiveTarget}
-          skillName={archiveTarget}
-        />
-      )}
-    </PageSearchShell>
-  )
-}
-
-// Feature-detection flag for plugins (Bot Mode): TRUE means this build's
-// SkillsView routes `fixedConnection` to the pinned connection's backend.
-// Older builds export SkillsView WITHOUT the prop — passing it there would
-// silently read/write the ACTIVE gateway under the remote bot's profile name,
-// which is exactly the wrong-machine bug the prop exists to prevent. A static
-// property is probe-able without rendering.
-SkillsView.supportsFixedConnection = true as const
-
-// Shared inspector header — mirrors Messaging's PlatformDetail so Skills and
-// Tools share one title/description block and tab switches don't jump.
-function DetailHeader({
-  description,
-  pills,
-  title
-}: {
-  description: React.ReactNode
-  pills?: React.ReactNode
-  title: string
-}) {
-  return (
-    <header>
-      <div className="flex min-h-6 flex-wrap items-center gap-2">
-        <h3 className="min-w-0 truncate text-[0.9375rem] font-semibold tracking-tight">{title}</h3>
-        {pills}
-      </div>
-      <p className="mt-1 text-[length:var(--conversation-caption-font-size)] leading-(--conversation-caption-line-height) text-(--ui-text-tertiary)">
-        {description}
-      </p>
-    </header>
-  )
-}
-
-// Frontmatter parse for display: the YAML block between the leading `---`
-// fences, flattened to top-level `key: value` rows (nested blocks render as
-// their raw indented text). Display-only — never fed back to the backend.
-function parseFrontmatter(content: string): { body: string; meta: [string, string][] } {
-  const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(content)
-
-  if (!match) {
-    return { body: content, meta: [] }
-  }
-
-  const meta: [string, string][] = []
-  let currentKey: null | string = null
-  let block: string[] = []
-
-  const flush = () => {
-    if (currentKey !== null) {
-      meta.push([currentKey, block.join('\n').trim()])
-    }
-
-    currentKey = null
-    block = []
-  }
-
-  for (const line of match[1].split(/\r?\n/)) {
-    const kv = /^(\w[\w-]*):\s?(.*)$/.exec(line)
-
-    if (kv) {
-      flush()
-      currentKey = kv[1]
-      block = kv[2] ? [kv[2]] : []
-    } else if (currentKey !== null) {
-      block.push(line.replace(/^ {2}/, ''))
-    }
-  }
-
-  flush()
-
-  return { body: content.slice(match[0].length), meta }
-}
-
-function SkillDetail({
-  onArchive,
-  onEdit,
-  profile,
-  skill
-}: {
-  onArchive: () => void
-  onEdit: () => void
-  profile?: ProfileScope
-  skill: SkillInfo
-}) {
-  const { t } = useI18n()
-  // Only learned/local skills are the user's to rewrite or archive — bundled
-  // and hub skills are managed by their sources.
-  const editable = skill.provenance === 'agent'
-
-  // The FULL skill — frontmatter metadata + complete SKILL.md body — for any
-  // provenance, scoped to the Capabilities profile selector. The row list only
-  // carries name/description; the pane shows the whole thing.
-  const contentQuery = useQuery({
-    queryKey: ['skill-content', skill.name, profileScopeKey(profile)],
-    queryFn: () => getSkillContent(skill.name, profile),
-    staleTime: 60_000
-  })
-
-  const parsed = useMemo(
-    () => (contentQuery.data ? parseFrontmatter(contentQuery.data.content) : null),
-    [contentQuery.data]
-  )
-
-  return (
-    <>
-      <DetailHeader
-        description={asText(skill.description) || t.skills.noDescription}
-        pills={
-          <>
-            <PanelPill>{prettyName(categoryFor(skill))}</PanelPill>
-            {skill.provenance && skill.provenance !== 'bundled' && (
-              <PanelPill tone={skill.provenance === 'agent' ? 'good' : 'muted'}>
-                {t.skills.provenance[skill.provenance]}
-              </PanelPill>
-            )}
-          </>
-        }
-        title={skill.name}
-      />
-      {editable && (
-        <div className="flex items-center gap-2">
-          <Button onClick={onEdit} size="xs" variant="text">
-            {t.skills.edit}
-          </Button>
-          <Button className="text-destructive hover:text-destructive" onClick={onArchive} size="xs" variant="text">
-            {t.skills.archive}
-          </Button>
-        </div>
-      )}
-      {parsed && parsed.meta.length > 0 && (
-        <div className="grid gap-1 rounded-lg border border-(--ui-stroke-tertiary) bg-(--ui-bg-quinary) p-3">
-          {parsed.meta.map(([key, value]) => (
-            <div className="flex gap-2 text-[0.68rem] leading-4" key={key}>
-              <span className="w-24 shrink-0 font-medium text-(--ui-text-tertiary)">{key}</span>
-              <span className="min-w-0 whitespace-pre-wrap break-words text-(--ui-text-secondary)">{value}</span>
-            </div>
-          ))}
-        </div>
-      )}
-      {contentQuery.isLoading ? (
-        <CountSkeleton />
-      ) : parsed ? (
-        <pre
-          className="overflow-auto whitespace-pre-wrap wrap-break-word rounded-lg border border-(--ui-stroke-tertiary) bg-(--ui-bg-quinary) p-3 font-mono text-[0.68rem] leading-relaxed"
-          data-selectable-text="true"
-        >
-          {parsed.body.trim() || t.skills.noDescription}
-        </pre>
-      ) : null}
-    </>
-  )
-}
-
-function ToolsetDetail({
-  toolset,
-  toolCalls,
-  onConfiguredChange,
-  profile
-}: {
-  toolset: ToolsetInfo
-  toolCalls: Record<string, number>
-  onConfiguredChange: () => void
-  profile?: ProfileScope
-}) {
-  const { t } = useI18n()
-  const navigate = useNavigate()
-  const tools = toolNames(toolset)
-  const label = toolsetDisplayLabel(toolset)
-
-  return (
-    <>
-      {/* "Configured" as a resting state is noise — only the warn state earns a pill. */}
-      <DetailHeader
-        description={asText(toolset.description) || t.skills.noDescription}
-        pills={!toolset.configured && <PanelPill tone="warn">{t.skills.needsKeys}</PanelPill>}
-        title={label}
-      />
-      {tools.length > 0 && (
-        <div className="flex flex-wrap gap-1">
-          {tools.map(name => (
-            <ToolChip key={name}>
-              {name}
-              {(toolCalls[name] ?? 0) > 0 && (
-                <span className="ml-1 text-(--ui-text-quaternary)">×{compactNumber(toolCalls[name])}</span>
-              )}
-            </ToolChip>
-          ))}
-        </div>
-      )}
-      {toolset.name === 'vision' && (
-        // Vision has no provider matrix — model resolution runs through the
-        // auxiliary model config. Point at the actual home (Settings → Models,
-        // aux "vision" row) via an internal deep link instead of leaving the
-        // detail pane empty.
-        <div className="grid gap-1.5">
-          <p className="text-[length:var(--conversation-caption-font-size)] text-(--ui-text-tertiary)">
-            {t.skills.visionModelHint}
-          </p>
-          <div>
-            <Button
-              onClick={() => navigate(`${SETTINGS_ROUTE}?tab=config:model&aux=vision`)}
-              size="xs"
-              variant="textStrong"
-            >
-              {t.skills.visionModelLink}
-            </Button>
-          </div>
-        </div>
-      )}
-      {toolset.name === 'computer_use' && <ComputerUsePanel onConfiguredChange={onConfiguredChange} />}
-      {/* Real-profile consent toggle ABOVE the backend/provider matrix — the
-          config option users kept missing because its only GUI home was the
-          generic Settings → Config editor. */}
-      {toolset.name === 'browser' && <BrowserRealProfilePanel profile={profile} />}
-      {toolset.name === 'terminal' && <TerminalBackendPanel onConfiguredChange={onConfiguredChange} />}
-      <ToolsetConfigPanel
-        key={`${toolset.name}:${profileScopeKey(profile)}`}
-        onConfiguredChange={onConfiguredChange}
-        profile={profile}
-        toolset={toolset.name}
-      />
-    </>
-  )
-}
diff --git a/apps/desktop/src/app/skills/plugins-tab.test.tsx b/apps/desktop/src/app/skills/plugins-tab.test.tsx
deleted file mode 100644
index 15057d52cc..0000000000
--- a/apps/desktop/src/app/skills/plugins-tab.test.tsx
+++ /dev/null
@@ -1,516 +0,0 @@
-import { QueryClientProvider } from '@tanstack/react-query'
-import { act, cleanup, fireEvent, render, screen, waitFor, within } from '@testing-library/react'
-import { type ComponentProps, useState } from 'react'
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-
-import { $pluginRecords } from '@/contrib/plugins-store'
-import { queryClient } from '@/lib/query-client'
-import { $agentPlugins, $agentPluginsStatus } from '@/store/agent-plugins'
-import { $pluginInstallRequest, closePluginInstallRequest } from '@/store/plugin-install-request'
-import { $connection } from '@/store/session'
-
-import { PageSearchShell } from '../page-search-shell'
-
-import { CapabilityTabs } from './capability-tabs'
-import { parseCatalog } from './catalog-data'
-import { PluginActions, PluginsTab } from './plugins-tab'
-import { $catalogCardView } from './store'
-
-const requestGateway = vi.fn(async () => ({ plugins: $agentPlugins.get() }))
-
-const connectionFixture = {
-  baseUrl: 'http://localhost',
-  isFullscreen: false,
-  logs: [],
-  nativeOverlayWidth: 0,
-  token: '',
-  windowButtonPosition: null,
-  wsUrl: ''
-}
-
-// SkillsView owns navigation and search; exercise that controlled contract
-// with the same primitives instead of giving PluginsTab private controls.
-function PluginsHarness({
-  view: initialView = 'installed',
-  query: initialQuery = '',
-  ...props
-}: ComponentProps<typeof PluginsTab>) {
-  const [view, setView] = useState(initialView)
-  const [query, setQuery] = useState(initialQuery)
-
-  return (
-    <PageSearchShell onSearchChange={setQuery} searchPlaceholder="Search plugins" searchValue={query}>
-      <CapabilityTabs actions={<PluginActions profile={props.profile} />} onChange={setView} value={view} />
-      <PluginsTab {...props} onQueryChange={setQuery} query={query} view={view} />
-    </PageSearchShell>
-  )
-}
-
-function renderPlugins(props: ComponentProps<typeof PluginsTab>) {
-  return render(
-    <QueryClientProvider client={queryClient}>
-      <PluginsHarness {...props} />
-    </QueryClientProvider>
-  )
-}
-
-const weatherEntry = {
-  name: 'weather-plugin',
-  repo: 'https://github.com/example/weather-plugin',
-  sha: 'a'.repeat(40),
-  subdir: '',
-  tier: 'community',
-  category: 'weather',
-  description: 'Local weather forecasts'
-}
-
-function seedCatalog(entries = [weatherEntry]) {
-  queryClient.setQueryData(['public-catalog', 'plugins'], parseCatalog('plugins', entries))
-}
-
-async function selectCatalogEntry(name: string) {
-  fireEvent.click(screen.getByRole('button', { name: 'Browse' }))
-  fireEvent.click(await screen.findByRole('button', { name: text => text.startsWith(name) }))
-  expect(screen.getByRole('heading', { name })).toBeTruthy()
-}
-
-afterEach(() => {
-  cleanup()
-  $connection.set(null)
-  queryClient.clear()
-  vi.unstubAllGlobals()
-})
-
-vi.mock('@/app/gateway/hooks/use-gateway-request', () => ({
-  useGatewayRequest: () => ({ requestGateway })
-}))
-
-describe('PluginsTab', () => {
-  beforeEach(() => {
-    $pluginRecords.set({})
-    $agentPlugins.set([])
-    $agentPluginsStatus.set('ready')
-    $catalogCardView.set(false)
-    closePluginInstallRequest()
-    requestGateway.mockReset()
-    requestGateway.mockImplementation(async () => ({ plugins: $agentPlugins.get() }))
-  })
-
-  it('lists the scoped profile agent plugins with toggles', () => {
-    $agentPlugins.set([
-      {
-        description: 'A test plugin',
-        key: 'demo-plugin',
-        name: 'demo-plugin',
-        source: 'git',
-        status: 'enabled',
-        version: '1.0.0'
-      }
-    ])
-
-    renderPlugins({ profile: 'workbot' })
-
-    expect(screen.getByRole('button', { name: /^demo-plugin/, pressed: true })).toBeTruthy()
-    const detail = within(screen.getByRole('row', { name: /^demo-plugin/ }))
-    expect(detail.getByRole('switch', { name: 'Agent: demo-plugin' }).getAttribute('aria-checked')).toBe('true')
-  })
-
-  it('hides bundled plugins (managed from their own surfaces)', () => {
-    $agentPlugins.set([
-      {
-        description: '',
-        key: 'image_gen/fal',
-        name: 'fal',
-        source: 'bundled',
-        status: 'enabled',
-        version: ''
-      }
-    ])
-
-    renderPlugins({ profile: null })
-
-    expect(screen.queryByText('fal')).toBeNull()
-    expect(screen.queryByRole('row')).toBeNull()
-    expect(screen.getByText('No matches')).toBeTruthy()
-  })
-
-  // A desktop half can only be copied out of a backend that runs on THIS
-  // machine; against a remote one the reconcile is a structural no-op, so the
-  // row must say so instead of pending forever (#114079).
-  it('marks a remote-backend desktop half unavailable instead of forever copying', () => {
-    $connection.set({ ...connectionFixture, mode: 'remote' })
-    $agentPlugins.set([
-      {
-        description: '',
-        has_desktop_half: true,
-        key: 'nous-prices',
-        name: 'nous-prices',
-        source: 'catalog',
-        status: 'enabled',
-        version: '1'
-      }
-    ])
-
-    renderPlugins({ profile: null })
-
-    const detail = within(screen.getByRole('row', { name: /^nous-prices/ }))
-    expect(detail.getByText('unavailable (remote backend)')).toBeTruthy()
-    expect(detail.queryByText('copying…')).toBeNull()
-  })
-
-  it('keeps the pending desktop-half state on a local backend', () => {
-    $agentPlugins.set([
-      {
-        description: '',
-        has_desktop_half: true,
-        key: 'nous-prices',
-        name: 'nous-prices',
-        source: 'catalog',
-        status: 'enabled',
-        version: '1'
-      }
-    ])
-
-    renderPlugins({ profile: null })
-
-    const detail = within(screen.getByRole('row', { name: /^nous-prices/ }))
-    expect(detail.getByText('copying…')).toBeTruthy()
-    expect(detail.queryByText('unavailable (remote backend)')).toBeNull()
-  })
-
-  it('renders a unified package as ONE row with a Desktop switch and an Agent switch', () => {
-    $pluginRecords.set({
-      media: { id: 'media', name: 'Media Studio', kind: 'disk', status: 'loaded', packageName: 'hermes-media-studio' }
-    })
-    $agentPlugins.set([
-      {
-        description: '',
-        key: 'hermes-media-studio',
-        name: 'hermes-media-studio',
-        source: 'git',
-        status: 'disabled',
-        version: '1'
-      }
-    ])
-
-    renderPlugins({ profile: 'workbot', scopeLabel: 'workbot' })
-
-    expect(screen.getAllByRole('button', { name: /^Media Studio/ })).toHaveLength(1)
-    expect(screen.getAllByRole('row')).toHaveLength(1)
-    const detail = within(screen.getByRole('row', { name: /^Media Studio/ }))
-    expect(detail.getByText('Agent + Desktop')).toBeTruthy()
-    expect(detail.getByRole('switch', { name: 'Desktop: Media Studio' }).getAttribute('aria-checked')).toBe('true')
-    expect(detail.getByRole('switch', { name: 'Agent: Media Studio' }).getAttribute('aria-checked')).toBe('false')
-    expect(detail.getByRole('cell', { name: 'Agent in workbot' })).toBeTruthy()
-  })
-
-  it('offers "Install here" for a desktop half whose agent half is not in the selected profile', async () => {
-    $pluginRecords.set({
-      media: {
-        id: 'media',
-        name: 'Media Studio',
-        kind: 'disk',
-        status: 'loaded',
-        packageName: 'hermes-media-studio',
-        packageOrigin: { repo: 'https://github.com/NousResearch/hermes-media-studio.git', sha: 'abc' }
-      }
-    })
-
-    renderPlugins({ profile: 'workbot', scopeLabel: 'workbot' })
-
-    expect(screen.queryByRole('switch', { name: /^Agent:/ })).toBeNull()
-    screen.getByRole('button', { name: 'Install here' }).click()
-    // Pre-filled from the package marker: repo + pinned sha, agent half only.
-    await waitFor(() => {
-      expect($pluginInstallRequest.get()).toMatchObject({
-        legacyHint: 'agent',
-        profile: 'workbot',
-        repo: 'https://github.com/NousResearch/hermes-media-studio.git',
-        sha: 'abc'
-      })
-    })
-  })
-
-  it('disables "Install here" when the package has no known origin (hand-copied folder)', () => {
-    $pluginRecords.set({
-      media: { id: 'media', name: 'Media Studio', kind: 'disk', status: 'loaded', packageName: 'hermes-media-studio' }
-    })
-
-    renderPlugins({ profile: 'workbot', scopeLabel: 'workbot' })
-
-    expect((screen.getByRole('button', { name: 'Install here' }) as HTMLButtonElement).disabled).toBe(true)
-  })
-
-  it('loads the plugin list scoped to the selected profile', () => {
-    renderPlugins({ profile: 'workbot' })
-
-    expect(requestGateway).toHaveBeenCalledWith(
-      'plugins.manage',
-      expect.objectContaining({ action: 'list', profile: 'workbot' })
-    )
-  })
-
-  it('opens the dual-target install modal for the selected catalog entry in the scoped profile', async () => {
-    seedCatalog([
-      { ...weatherEntry, name: 'other-plugin', repo: 'https://github.com/example/other-plugin' },
-      weatherEntry
-    ])
-    renderPlugins({ profile: 'workbot' })
-
-    await selectCatalogEntry(weatherEntry.name)
-    expect($pluginInstallRequest.get()).toBeNull()
-    fireEvent.click(screen.getByRole('button', { name: 'Install' }))
-
-    expect($pluginInstallRequest.get()).toMatchObject({
-      catalogName: weatherEntry.name,
-      repo: weatherEntry.repo,
-      profile: 'workbot',
-      sha: weatherEntry.sha
-    })
-  })
-
-  it('toggles by canonical key through plugins.manage', async () => {
-    $agentPlugins.set([
-      {
-        description: '',
-        key: 'image_gen/legacy',
-        name: 'Legacy plugin',
-        source: 'user',
-        status: 'disabled',
-        version: '0.20.0'
-      }
-    ])
-    requestGateway.mockResolvedValueOnce({
-      ok: true,
-      plugin: { key: 'image_gen/legacy', name: 'Legacy plugin', status: 'enabled' }
-    } as never)
-
-    renderPlugins({ profile: null })
-
-    screen.getByRole('switch', { name: 'Agent: Legacy plugin' }).click()
-
-    await waitFor(() =>
-      expect(requestGateway).toHaveBeenCalledWith(
-        'plugins.manage',
-        expect.objectContaining({ action: 'toggle', key: 'image_gen/legacy', enable: true })
-      )
-    )
-  })
-
-  it('renders keyless rows read-only (no name-addressed toggle RPC)', () => {
-    // Name-addressed toggles flip every same-named plugin across category
-    // dirs — pre-contract-v6 rows must never reach the RPC.
-    $agentPlugins.set([
-      {
-        description: 'Returned by a pre-key backend',
-        name: 'Legacy plugin',
-        source: 'user',
-        status: 'disabled',
-        version: '0.20.0'
-      }
-    ])
-
-    renderPlugins({ profile: null })
-
-    const toggle = screen.getByRole('switch', { name: 'Agent: Legacy plugin' })
-
-    expect(toggle.hasAttribute('disabled') || toggle.getAttribute('aria-disabled') === 'true').toBe(true)
-
-    toggle.click()
-
-    expect(requestGateway).not.toHaveBeenCalledWith('plugins.manage', expect.objectContaining({ action: 'toggle' }))
-  })
-
-  it('appends the selected subdir for multi-plugin repos without changing its catalog pin', async () => {
-    const entry = {
-      ...weatherEntry,
-      name: 'nested-plugin',
-      repo: 'https://github.com/example/plugins-monorepo',
-      subdir: 'packages/nested-plugin'
-    }
-    seedCatalog([entry])
-    renderPlugins({ profile: null })
-
-    await selectCatalogEntry(entry.name)
-    fireEvent.click(screen.getByRole('button', { name: 'Install' }))
-
-    expect($pluginInstallRequest.get()).toMatchObject({
-      catalogName: entry.name,
-      repo: `${entry.repo}#${entry.subdir}`,
-      profile: null,
-      sha: entry.sha
-    })
-  })
-})
-
-describe('PluginsTab catalog UX', () => {
-  beforeEach(() => {
-    $agentPlugins.set([])
-    $agentPluginsStatus.set('ready')
-    $catalogCardView.set(false)
-    closePluginInstallRequest()
-    requestGateway.mockReset()
-    requestGateway.mockImplementation(async () => ({ plugins: $agentPlugins.get() }))
-    $pluginRecords.set({})
-  })
-
-  it('fetches only on Browse, with no extra requests for selection, search, or tab bounce', async () => {
-    const fetchCatalog = vi.fn().mockResolvedValue({
-      ok: true,
-      json: async () => [weatherEntry, { ...weatherEntry, name: 'garden-plugin', category: 'garden', description: 'Garden planning' }]
-    })
-    vi.stubGlobal('fetch', fetchCatalog)
-    await act(async () => { renderPlugins({ profile: null }) })
-
-    expect(fetchCatalog).not.toHaveBeenCalled()
-    expect(screen.queryByRole('heading', { name: weatherEntry.name })).toBeNull()
-    await selectCatalogEntry('garden-plugin')
-    const search = screen.getByRole<HTMLInputElement>('textbox', { name: 'Search plugins' })
-    fireEvent.change(search, { target: { value: 'weather' } })
-    expect(await screen.findByRole('heading', { name: weatherEntry.name })).toBeTruthy()
-    expect(screen.queryByRole('button', { name: /^garden-plugin/ })).toBeNull()
-    fireEvent.click(screen.getByRole('button', { name: 'Installed', pressed: false }))
-    expect(screen.queryByRole('heading', { name: weatherEntry.name })).toBeNull()
-    // The parent retains the shared search across navigation. Clearing from
-    // the empty state must propagate through onQueryChange, not local state.
-    expect(search.value).toBe('weather')
-    fireEvent.click(screen.getByRole('button', { name: 'Clear filters' }))
-    expect(search.value).toBe('')
-    await selectCatalogEntry('garden-plugin')
-
-    expect(fetchCatalog).toHaveBeenCalledTimes(1)
-    expect(fetchCatalog.mock.calls[0][0]).toMatch(/\/docs\/api\/plugins\.json$/)
-    expect(fetchCatalog.mock.calls[0][1]).toMatchObject({ credentials: 'omit' })
-    expect($pluginInstallRequest.get()).toBeNull()
-  })
-
-  it('offers an explicit retry after a catalog failure rather than refetching on tab bounce', async () => {
-    const fetchCatalog = vi.fn()
-      .mockResolvedValueOnce({ ok: false, status: 503 })
-      .mockResolvedValue({ ok: true, json: async () => [weatherEntry] })
-    vi.stubGlobal('fetch', fetchCatalog)
-    await act(async () => { renderPlugins({ profile: null }) })
-    fireEvent.click(screen.getByRole('button', { name: 'Browse' }))
-
-    expect(await screen.findByText('Catalog HTTP 503')).toBeTruthy()
-    expect(fetchCatalog).toHaveBeenCalledTimes(1)
-    await act(async () => {
-      fireEvent.click(screen.getByRole('button', { name: /^Installed/ }))
-    })
-    await act(async () => {
-      fireEvent.click(screen.getByRole('button', { name: 'Browse' }))
-    })
-    expect(fetchCatalog).toHaveBeenCalledTimes(1)
-    expect(screen.getByText('Catalog HTTP 503')).toBeTruthy()
-    fireEvent.click(screen.getByRole('button', { name: 'Try again' }))
-
-    expect(await screen.findByRole('heading', { name: weatherEntry.name })).toBeTruthy()
-    expect(fetchCatalog).toHaveBeenCalledTimes(2)
-  })
-
-  it('shows an Update chip when the catalog pin moved past the installed SHA', () => {
-    $agentPlugins.set([
-      {
-        catalog_name: 'demo-weather',
-        catalog_sha: 'b'.repeat(40),
-        catalog_tier: 'community',
-        description: '',
-        installed_sha: 'a'.repeat(40),
-        key: 'demo-weather',
-        name: 'demo-weather',
-        source: 'git',
-        status: 'enabled',
-        update_available: true,
-        version: '1.0.0'
-      }
-    ])
-
-    renderPlugins({ profile: null })
-
-    expect(screen.getByRole('button', { name: `Update to ${'b'.repeat(8)}` })).toBeTruthy()
-  })
-
-  it('re-pins through plugins.manage update when the chip is clicked', async () => {
-    $agentPlugins.set([
-      {
-        catalog_name: 'demo-weather',
-        catalog_sha: 'b'.repeat(40),
-        catalog_tier: 'community',
-        description: '',
-        installed_sha: 'a'.repeat(40),
-        key: 'demo-weather',
-        name: 'demo-weather',
-        source: 'git',
-        status: 'enabled',
-        update_available: true,
-        version: '1.0.0'
-      }
-    ])
-    requestGateway.mockResolvedValue({ ok: true, unchanged: false, plugins: [] } as never)
-
-    renderPlugins({ profile: 'workbot' })
-
-    screen.getByRole('button', { name: `Update to ${'b'.repeat(8)}` }).click()
-
-    await waitFor(() =>
-      expect(requestGateway).toHaveBeenCalledWith(
-        'plugins.manage',
-        expect.objectContaining({ action: 'update', name: 'demo-weather', profile: 'workbot' })
-      )
-    )
-  })
-
-  it('disables installation of a catalog entry that is already installed and current', async () => {
-    $agentPlugins.set([
-      {
-        catalog_name: 'demo-weather',
-        description: '',
-        installed_sha: 'a'.repeat(40),
-        key: 'demo-weather',
-        name: 'demo-weather',
-        source: 'git',
-        status: 'enabled',
-        update_available: false,
-        version: '1.0.0'
-      }
-    ])
-
-    seedCatalog([{ ...weatherEntry, name: 'demo-weather' }])
-    await act(async () => { renderPlugins({ profile: null }) })
-    await selectCatalogEntry('demo-weather')
-
-    const installed = within(screen.getByRole('main')).getByRole<HTMLButtonElement>('button', { name: 'Installed' })
-    expect(installed.disabled).toBe(true)
-    fireEvent.click(installed)
-    expect($pluginInstallRequest.get()).toBeNull()
-  })
-
-  it('offers catalog installation for an installed entry when an update is available', async () => {
-    $agentPlugins.set([
-      {
-        catalog_name: 'demo-weather',
-        description: '',
-        installed_sha: 'a'.repeat(40),
-        key: 'demo-weather',
-        name: 'demo-weather',
-        source: 'git',
-        status: 'enabled',
-        update_available: true,
-        version: '1.0.0'
-      }
-    ])
-
-    const entry = { ...weatherEntry, name: 'demo-weather', sha: 'b'.repeat(40) }
-    seedCatalog([entry])
-    await act(async () => { renderPlugins({ profile: null }) })
-    await selectCatalogEntry(entry.name)
-    fireEvent.click(screen.getByRole('button', { name: 'Install' }))
-
-    expect($pluginInstallRequest.get()).toMatchObject({
-      catalogName: entry.name,
-      repo: entry.repo,
-      profile: null,
-      sha: entry.sha
-    })
-  })
-})
diff --git a/apps/desktop/src/app/skills/plugins-tab.tsx b/apps/desktop/src/app/skills/plugins-tab.tsx
deleted file mode 100644
index 4427b15d6e..0000000000
--- a/apps/desktop/src/app/skills/plugins-tab.tsx
+++ /dev/null
@@ -1,441 +0,0 @@
-import { useStore } from '@nanostores/react'
-import { memo, type ReactNode, useEffect, useMemo } from 'react'
-
-import { useGatewayRequest } from '@/app/gateway/hooks/use-gateway-request'
-import { Button } from '@/components/ui/button'
-import { Codicon } from '@/components/ui/codicon'
-import { Switch } from '@/components/ui/switch'
-import { Tip } from '@/components/ui/tooltip'
-import { $pluginRecords, type PluginRecord, setPluginEnabled } from '@/contrib/plugins-store'
-import { discoverRuntimePlugins } from '@/contrib/runtime-loader'
-import type { ProfileScope } from '@/hermes'
-import { useI18n } from '@/i18n'
-import { triggerHaptic } from '@/lib/haptics'
-import { FolderOpen, Loader2, Monitor, Package, RefreshCw } from '@/lib/icons'
-import { cn } from '@/lib/utils'
-import {
-  $agentPluginBusy,
-  $agentPlugins,
-  type AgentPluginRow,
-  type GatewayRequest,
-  isDesktopRelevantPlugin,
-  loadAgentPlugins,
-  toggleAgentPlugin,
-  updateAgentPlugin
-} from '@/store/agent-plugins'
-import { notify, notifyError } from '@/store/notifications'
-import { openPluginInstallRequest } from '@/store/plugin-install-request'
-import { $connection } from '@/store/session'
-
-import { Pill } from '../settings/primitives'
-import { useDeepLinkHighlight } from '../settings/use-deep-link-highlight'
-
-import type { CapabilityView } from './capability-tabs'
-import { CatalogBrowser } from './catalog-browser'
-import { type CatalogEntry, parseCatalog } from './catalog-data'
-import { mergePluginPackages, type PackageKind, type PluginPackage } from './plugin-packages'
-
-/** Deep-link anchor for a package row (`/skills?tab=plugins&plugin=<key>`).
- *  Accepts the agent key, the agent name, or the desktop record id. */
-export const pluginElementId = (target: string) => `plugin-${target}`
-
-/** Derive the bare profile name a `plugins.manage` call should target. */
-function profileParam(scope: ProfileScope): null | string {
-  if (!scope) {
-    return null
-  }
-
-  return typeof scope === 'string' ? scope : (scope.profile ?? null)
-}
-
-function reveal(file: string) {
-  void window.hermesDesktop?.revealPath?.(file)?.catch(() => undefined)
-}
-
-async function revealPluginsDir() {
-  try {
-    // Electron owns the app-level plugin root — deriving it from the backend's
-    // hermes_home breaks against a remote backend (#66899).
-    const dir = await window.hermesDesktop?.desktopPluginsRoot?.()
-
-    if (!dir) {
-      notifyError('Desktop plugins are unavailable', 'Could not resolve the plugins folder')
-
-      return
-    }
-
-    const result = await window.hermesDesktop?.openDir?.(dir)
-
-    if (result && !result.ok) {
-      notifyError(result.error ?? 'unknown error', 'Could not open the plugins folder')
-    }
-  } catch (err) {
-    notifyError(err, 'Could not resolve the plugins folder')
-  }
-}
-
-/** Copy any changed unified desktop halves into the app root FIRST, then
- *  rescan the root — a concurrent scan would read the pre-copy state. */
-async function rescanAll(requestGateway: GatewayRequest, scope: null | string) {
-  await window.hermesDesktop?.reconcileDesktopPlugins?.().catch(() => undefined)
-  await discoverRuntimePlugins()
-  await loadAgentPlugins(requestGateway, scope)
-}
-
-/** Open the dual-target install modal pre-filled to install ONLY the agent
- *  half of a unified package into the scoped profile (the desktop half is
- *  already here). Provenance comes from the package marker Electron stamped
- *  when it copied the half out (catalog sidecar or git remote). */
-function installAgentHalfHere(record: PluginRecord, profile: null | string) {
-  const origin = record.packageOrigin
-
-  if (!origin?.repo) {
-    return
-  }
-
-  openPluginInstallRequest({
-    catalogName: origin.catalogName,
-    legacyHint: 'agent',
-    profile,
-    repo: origin.repo,
-    sha: origin.sha
-  })
-}
-
-function KindBadge({ kind }: { kind: PackageKind }) {
-  const { t } = useI18n()
-  const p = t.skills.plugins
-
-  return (
-    <span className="inline-flex items-center gap-1 rounded border border-(--ui-stroke-tertiary) px-1.5 py-px text-[0.65rem] text-(--ui-text-tertiary)">
-      {kind !== 'desktop' && <Package aria-hidden className="size-3" />}
-      {kind !== 'agent' && <Monitor aria-hidden className="size-3" />}
-      {kind === 'both' ? p.kindBoth : kind === 'agent' ? p.kindAgent : p.kindDesktop}
-    </span>
-  )
-}
-
-/** Provenance pill: where the package came from. */
-function ProvenancePill({ pkg }: { pkg: PluginPackage }) {
-  const { t } = useI18n()
-  const p = t.skills.plugins
-
-  if (pkg.agent?.catalog_name) {
-    return (
-      <Tip label={p.catalogProvenance(pkg.agent.installed_sha?.slice(0, 8) ?? '')}>
-        <span>
-          <Pill>{pkg.agent.catalog_tier === 'official' ? p.tierOfficial : p.tierCommunity}</Pill>
-        </span>
-      </Tip>
-    )
-  }
-
-  if (pkg.agent?.pinned_sha) {
-    return (
-      <Tip label={p.pinnedProvenance(pkg.agent.pinned_sha.slice(0, 8))}>
-        <span>
-          <Pill>
-            <span className="font-mono">{p.pinnedBadge(pkg.agent.pinned_sha.slice(0, 8))}</span>
-          </Pill>
-        </span>
-      </Tip>
-    )
-  }
-
-  if (pkg.agent) {
-    return <Pill>{pkg.agent.source}</Pill>
-  }
-
-  if (pkg.desktop) {
-    return <Pill>{t.settings.plugins.kinds[pkg.desktop.kind]}</Pill>
-  }
-
-  return null
-}
-
-/** Controls for one installed plugin half in the detail pane. */
-function HalfCell({ label, children }: { label: string; children: ReactNode }) {
-  return (
-    <div aria-label={label} className="flex w-full items-center gap-3" role="cell">
-      <span className="min-w-0 flex-1 text-xs text-(--ui-text-tertiary)">{label}</span>
-      {children}
-    </div>
-  )
-}
-
-function Dash() {
-  return (
-    <span aria-hidden className="w-9 text-center text-(--ui-text-quaternary)">
-      —
-    </span>
-  )
-}
-
-function PackageRow({
-  pkg,
-  scope,
-  scopeLabel,
-  busy,
-  onAgentToggle,
-  onAgentUpdate
-}: {
-  pkg: PluginPackage
-  scope: null | string
-  scopeLabel: string
-  busy: boolean
-  onAgentToggle: (row: AgentPluginRow, enable: boolean) => void
-  onAgentUpdate: (row: AgentPluginRow) => void
-}) {
-  const { t } = useI18n()
-  const p = t.skills.plugins
-  const d = t.settings.plugins
-  const desktop = pkg.desktop
-  const agent = pkg.agent
-  const desktopOn = desktop ? desktop.status !== 'disabled' : false
-  const agentOn = agent?.status === 'enabled'
-  const agentToggleable = Boolean(agent?.key)
-  // Electron's desktop-half reconcile only walks THIS machine's homes, so a
-  // package installed on a remote backend can never materialize here (#114079).
-  const remoteBackend = useStore($connection)?.mode === 'remote'
-
-  return (
-    <div
-      className="flex flex-col gap-5"
-      data-testid={`plugin-row-${pkg.key}`}
-      id={pluginElementId(agent?.key ?? agent?.name ?? desktop?.id ?? pkg.key)}
-      role="row"
-    >
-      <div className="flex w-full min-w-0 flex-1 items-start gap-2" role="cell">
-        <div className="min-w-0 flex-1">
-          <div className="flex flex-wrap items-center gap-2 text-[length:var(--conversation-text-font-size)] font-medium text-foreground">
-            <span>{pkg.name}</span>
-            {agent?.version && <span className="text-(--ui-text-quaternary)">v{agent.version}</span>}
-            <KindBadge kind={pkg.kind} />
-            <ProvenancePill pkg={pkg} />
-            {agent?.portable && <Pill>{p.portableBadge}</Pill>}
-            {desktop?.status === 'error' && <Pill tone="primary">{d.failed}</Pill>}
-          </div>
-          {(desktop?.status === 'error' ? desktop.error : pkg.description) && (
-            <div
-              className={cn(
-                'mt-0.5 text-[length:var(--conversation-caption-font-size)] break-words',
-                desktop?.status === 'error' ? 'text-(--ui-danger,#f87171)' : 'text-(--ui-text-tertiary)'
-              )}
-            >
-              {desktop?.status === 'error' ? desktop.error : pkg.description}
-            </div>
-          )}
-        </div>
-        {/* Fixed slot so the switch column stays straight whether or not
-            this row has a folder to reveal (bundled plugins have none). */}
-        <span className="flex size-7 shrink-0 items-center justify-center">
-          {desktop?.file && (
-            <Tip label={d.reveal}>
-              <Button onClick={() => reveal(desktop.file!)} size="icon" variant="ghost">
-                <Codicon name="folder-opened" size="0.85rem" />
-              </Button>
-            </Tip>
-          )}
-        </span>
-      </div>
-
-      {/* The two halves. Desktop is app-level and reads the same whichever
-          profile is selected; Agent follows the selector. A half the package
-          lacks shows a dash; a half it has but which is missing on this side
-          shows the install affordance. */}
-      <HalfCell label={p.halfDesktop}>
-        {desktop ? (
-          <Switch
-            aria-label={`${p.halfDesktop}: ${pkg.name}`}
-            checked={desktopOn}
-            onCheckedChange={on => {
-              triggerHaptic('selection')
-              void setPluginEnabled(desktop.id, on)
-            }}
-          />
-        ) : pkg.desktopMissing ? (
-          <Tip label={remoteBackend ? p.desktopHalfRemoteTip : p.desktopHalfPendingTip}>
-            <span className="text-[0.65rem] text-(--ui-text-tertiary)">
-              {remoteBackend ? p.desktopHalfRemote : p.desktopHalfPending}
-            </span>
-          </Tip>
-        ) : (
-          <Dash />
-        )}
-      </HalfCell>
-
-      <HalfCell label={p.halfAgentIn(scopeLabel)}>
-        {agent ? (
-          <>
-            {agent.update_available && (
-              <Button
-                className="h-5 px-1.5 text-[0.65rem]"
-                disabled={busy}
-                onClick={() => onAgentUpdate(agent)}
-                size="xs"
-                variant="outline"
-              >
-                {p.updateToPin(agent.catalog_version ?? agent.catalog_sha?.slice(0, 8) ?? '')}
-              </Button>
-            )}
-            {busy && <Loader2 className="size-3.5 animate-spin text-(--ui-text-tertiary)" />}
-            {agentToggleable ? (
-              <Switch
-                aria-label={`${p.halfAgent}: ${pkg.name}`}
-                checked={agentOn}
-                disabled={busy}
-                onCheckedChange={on => onAgentToggle(agent, on)}
-              />
-            ) : (
-              <Tip label={p.legacyBackend}>
-                <span>
-                  <Switch aria-label={`${p.halfAgent}: ${pkg.name}`} checked={agentOn} disabled />
-                </span>
-              </Tip>
-            )}
-          </>
-        ) : pkg.agentMissingInProfile && desktop ? (
-          <Tip label={desktop.packageOrigin?.repo ? p.installAgentHereTip(scopeLabel) : p.installAgentHereNoOrigin}>
-            <span>
-              <Button
-                className="h-5 px-1.5 text-[0.65rem]"
-                disabled={!desktop.packageOrigin?.repo}
-                onClick={() => installAgentHalfHere(desktop, scope)}
-                size="xs"
-                variant="outline"
-              >
-                {p.installAgentHere}
-              </Button>
-            </span>
-          </Tip>
-        ) : (
-          <Dash />
-        )}
-      </HalfCell>
-    </div>
-  )
-}
-
-export function PluginActions({ profile }: { profile: ProfileScope }) {
-  const { t } = useI18n()
-  const d = t.settings.plugins
-  const { requestGateway } = useGatewayRequest()
-  const scope = profileParam(profile)
-
-  return <>
-    <Button className="underline" onClick={() => openPluginInstallRequest({ profile: scope, repo: '' })} size="xs" variant="text">
-      {d.installModal.installFromGit}
-    </Button>
-    <Tip label={d.openFolder}>
-      <Button aria-label={d.openFolder} onClick={() => void revealPluginsDir()} size="icon-xs" variant="ghost"><FolderOpen /></Button>
-    </Tip>
-    <Tip label={d.rescan}>
-      <Button aria-label={d.rescan} onClick={() => void rescanAll(requestGateway, scope)} size="icon-xs" variant="ghost"><RefreshCw /></Button>
-    </Tip>
-  </>
-}
-
-/** THE plugins surface: one row per package. Each row shows its Desktop half
- *  (this app — the same for every profile, gateway, or machine) and its Agent
- *  half (the selected profile's backend). Browse uses the shared native
- *  catalog; Install from Git remains available for unlisted packages. */
-export const PluginsTab = memo(function PluginsTab({
-  profile,
-  scopeLabel,
-  view = 'installed',
-  query = '',
-  onQueryChange
-}: {
-  query?: string
-  onQueryChange?: (value: string) => void
-  view?: CapabilityView
-  profile: ProfileScope
-  /** Display name of the selected profile for the Agent column label. */
-  scopeLabel?: string
-}) {
-  const { t } = useI18n()
-  const p = t.skills.plugins
-  const { requestGateway } = useGatewayRequest()
-
-  const desktopRecords = useStore($pluginRecords)
-  const agentRows = useStore($agentPlugins)
-  const busyKey = useStore($agentPluginBusy)
-
-  const scope = profileParam(profile)
-  const label = scopeLabel ?? scope ?? t.skills.plugins.defaultProfile
-
-  useEffect(() => {
-    void loadAgentPlugins(requestGateway, scope)
-  }, [requestGateway, scope])
-
-  const packages = useMemo(
-    () => mergePluginPackages(Object.values(desktopRecords), agentRows.filter(isDesktopRelevantPlugin)),
-    [agentRows, desktopRecords]
-  )
-
-  useDeepLinkHighlight({ param: 'plugin', ready: () => true, elementId: pluginElementId })
-
-  const agentBusy = (row: AgentPluginRow) => busyKey === (row.key ?? row.name) || busyKey === row.name
-  const installedEntries = useMemo(() => parseCatalog('plugins', packages.map(pkg => ({
-    name: pkg.name,
-    identifier: pkg.agent?.catalog_name ?? pkg.desktop?.packageOrigin?.catalogName ?? pkg.key,
-    description: pkg.description,
-    category: pkg.kind === 'desktop' ? 'desktop' : 'general',
-    tier: pkg.agent?.catalog_tier ?? pkg.agent?.source ?? pkg.desktop?.kind ?? '',
-    repo: pkg.desktop?.packageOrigin?.repo ?? '',
-    sha: pkg.agent?.installed_sha ?? pkg.desktop?.packageOrigin?.sha ?? '',
-    version: pkg.agent?.version ?? ''
-  }))).map((entry, index) => ({ ...entry, id: `installed:${packages[index].key}` })), [packages])
-  const packageById = useMemo(() => new Map(packages.map(pkg => [`installed:${pkg.key}`, pkg])), [packages])
-  const isInstalled = (entry: CatalogEntry) => packageById.has(entry.id) || agentRows.some(row =>
-    (row.catalog_name === entry.name || row.name === entry.name) && !row.update_available
-  )
-  const install = (entry: CatalogEntry) => openPluginInstallRequest({
-    catalogName: entry.name,
-    profile: scope,
-    repo: entry.subdir ? `${entry.repo}#${entry.subdir}` : entry.repo,
-    sha: entry.sha
-  })
-
-  return (
-    <div className="flex h-full min-h-0 flex-col">
-      <CatalogBrowser
-        installedEntries={installedEntries}
-        isInstalled={isInstalled}
-        kind="plugins"
-        onInstall={install}
-        onQueryChange={onQueryChange}
-        query={query}
-        renderInstalledDetail={entry => {
-          const pkg = packageById.get(entry.id)
-
-          if (!pkg) {
-            return null
-          }
-
-          return <PackageRow
-            busy={pkg.agent ? agentBusy(pkg.agent) : false}
-            key={pkg.key}
-            onAgentToggle={(row, enable) => {
-              if (row.key) {
-                void toggleAgentPlugin(requestGateway, row.key, enable, p.toggleFailed(row.name), scope)
-              }
-            }}
-            onAgentUpdate={row => {
-              void updateAgentPlugin(requestGateway, row.name, p.updateFailed(row.name), scope).then(applied => {
-                if (applied) {
-                  notify({ kind: 'success', message: p.updated(row.name) })
-                  void rescanAll(requestGateway, scope)
-                }
-              })
-            }}
-            pkg={pkg}
-            scope={scope}
-            scopeLabel={label}
-          />
-        }}
-        view={view}
-      />
-    </div>
-  )
-})
diff --git a/apps/desktop/src/app/skills/skill-catalog.tsx b/apps/desktop/src/app/skills/skill-catalog.tsx
deleted file mode 100644
index 61bc62636f..0000000000
--- a/apps/desktop/src/app/skills/skill-catalog.tsx
+++ /dev/null
@@ -1,46 +0,0 @@
-import { useCallback, useState } from 'react'
-
-import type { ProfileScope } from '@/hermes'
-import { useI18n } from '@/i18n'
-import { installHubSkill, notifyHubActionFailed } from '@/store/hub-actions'
-import { notify } from '@/store/notifications'
-
-import { CatalogBrowser } from './catalog-browser'
-import type { CatalogEntry } from './catalog-data'
-
-interface SkillCatalogProps {
-  installedNames: ReadonlySet<string>
-  profile?: ProfileScope
-  query?: string
-  onQueryChange?: (value: string) => void
-}
-
-export function SkillCatalog({ installedNames, profile, query = '', onQueryChange }: SkillCatalogProps) {
-  const { t } = useI18n()
-  const h = t.skills.hub
-  const [installing, setInstalling] = useState<ReadonlySet<string>>(new Set())
-  const isInstalled = useCallback((entry: CatalogEntry) => installedNames.has(entry.name) || installedNames.has(entry.identifier), [installedNames])
-
-  const install = (entry: CatalogEntry) => {
-    if (!entry.installIdentifier || isInstalled(entry) || installing.has(entry.id)) {
-      return
-    }
-
-    setInstalling(current => new Set(current).add(entry.id))
-    notify({ kind: 'success', title: h.installStarted(entry.name), message: h.actionLog })
-    void installHubSkill(entry.installIdentifier, profile)
-      .catch(err => notifyHubActionFailed(err, h.actionFailed, entry.name, profile))
-      .finally(() => setInstalling(current => new Set([...current].filter(id => id !== entry.id))))
-  }
-
-  return (
-    <CatalogBrowser
-      isInstalled={isInstalled}
-      isInstalling={entry => installing.has(entry.id)}
-      kind="skills"
-      onInstall={install}
-      onQueryChange={onQueryChange}
-      query={query}
-    />
-  )
-}
diff --git a/apps/desktop/src/app/skills/store.ts b/apps/desktop/src/app/skills/store.ts
deleted file mode 100644
index 7be2e7baa3..0000000000
--- a/apps/desktop/src/app/skills/store.ts
+++ /dev/null
@@ -1,9 +0,0 @@
-import { Codecs, persistentAtom } from '@/lib/persisted'
-
-// Per-view sort direction for the Capabilities lists — persisted so each tab
-// remembers most/least-used across navigations and restarts.
-export const $skillsSortDesc = persistentAtom('hermes.desktop.capabilities.skillsSortDesc', true, Codecs.bool)
-export const $toolsetsSortDesc = persistentAtom('hermes.desktop.capabilities.toolsetsSortDesc', true, Codecs.bool)
-
-// One browsing layout across Skills and Plugins; Installed keeps its own list.
-export const $catalogCardView = persistentAtom('hermes.desktop.capabilities.catalogCardView', true, Codecs.bool)
diff --git a/apps/desktop/src/app/skills/update-skills-button.tsx b/apps/desktop/src/app/skills/update-skills-button.tsx
deleted file mode 100644
index 56fa026c02..0000000000
--- a/apps/desktop/src/app/skills/update-skills-button.tsx
+++ /dev/null
@@ -1,21 +0,0 @@
-import { Button } from '@/components/ui/button'
-import type { ProfileScope } from '@/hermes'
-import { useI18n } from '@/i18n'
-import { useStoreSelector } from '@/lib/use-session-slice'
-import { $hubActions, UPDATE_ALL_KEY, updateHubSkills } from '@/store/hub-actions'
-import { notify, notifyError } from '@/store/notifications'
-
-export function UpdateSkillsButton({ profile }: { profile?: ProfileScope }) {
-  const { t } = useI18n()
-  const h = t.skills.hub
-  const updating = useStoreSelector($hubActions, actions => actions[UPDATE_ALL_KEY]?.running ?? false)
-
-  return (
-    <Button disabled={updating} onClick={() => {
-      notify({ kind: 'success', title: h.updateStarted, message: h.actionLog })
-      void updateHubSkills(profile).catch(err => notifyError(err, h.actionFailed))
-    }} size="xs" variant="text">
-      {updating ? h.updating : h.updateAll}
-    </Button>
-  )
-}
diff --git a/apps/desktop/src/app/types.ts b/apps/desktop/src/app/types.ts
index 1236178bfc..1c4efe0aca 100644
--- a/apps/desktop/src/app/types.ts
+++ b/apps/desktop/src/app/types.ts
@@ -122,7 +122,14 @@ export interface HandoffFailResponse {
   state?: string
 }
 
-export type SidebarNavId = 'artifacts' | 'command-center' | 'cron' | 'messaging' | 'new-session' | 'settings' | 'skills'
+export type SidebarNavId =
+  | 'artifacts'
+  | 'capabilities'
+  | 'command-center'
+  | 'cron'
+  | 'messaging'
+  | 'new-session'
+  | 'settings'
 
 export interface SidebarNavItem {
   /** Built-in view id, or a contributed row's namespaced contribution id. */
diff --git a/apps/desktop/src/components/confirm-host.test.tsx b/apps/desktop/src/components/confirm-host.test.tsx
index 7ae5ff312f..0aeff59273 100644
--- a/apps/desktop/src/components/confirm-host.test.tsx
+++ b/apps/desktop/src/components/confirm-host.test.tsx
@@ -64,42 +64,6 @@ describe('confirm()', () => {
     expect(read()).toBe(false)
   })
 
-  it('keeps async actions open through progress, inline failure, retry and completion', async () => {
-    render(<ConfirmHost />)
-    let fail!: (error: Error) => void
-    let finish!: () => void
-    let attempts = 0
-    let answer: boolean | undefined
-
-    const pending = confirm({
-      title: 'Install “pdf”?',
-      confirmLabel: 'Install',
-      busyLabel: 'Installing…',
-      doneLabel: 'Installed',
-      details: [{ label: 'Source', value: 'official/productivity/pdf' }],
-      onConfirm: () => new Promise<void>((resolve, reject) => {
-        attempts += 1
-        finish = resolve
-        fail = reject
-      })
-    }).then(value => { answer = value })
-
-    expect(await screen.findByText('official/productivity/pdf')).toBeTruthy()
-    fireEvent.click(screen.getByRole('button', { name: 'Install' }))
-    expect(await screen.findByRole('button', { name: 'Installing…' })).toBeTruthy()
-    expect(answer).toBeUndefined()
-    expect(await confirm({ title: 'Must not interrupt' })).toBe(false)
-    await act(async () => fail(new Error('Network unavailable')))
-    expect(await screen.findByText('Network unavailable')).toBeTruthy()
-    fireEvent.click(screen.getByRole('button', { name: 'Install' }))
-    await act(async () => finish())
-    expect(await screen.findByRole('button', { name: 'Installed' })).toBeTruthy()
-    await waitFor(() => expect(screen.queryByRole('dialog')).toBeNull())
-    await pending
-    expect(answer).toBe(true)
-    expect(attempts).toBe(2)
-  })
-
   it('supersedes an open request, answering the one it replaces no', async () => {
     render(<ConfirmHost />)
 
diff --git a/apps/desktop/src/components/confirm-host.tsx b/apps/desktop/src/components/confirm-host.tsx
index 02446f70d0..2b6f8752b9 100644
--- a/apps/desktop/src/components/confirm-host.tsx
+++ b/apps/desktop/src/components/confirm-host.tsx
@@ -2,7 +2,7 @@ import { useStore } from '@nanostores/react'
 import { useEffect, useState } from 'react'
 
 import { ConfirmDialog } from '@/components/ui/confirm-dialog'
-import { $confirmRequest, type PendingConfirm, runConfirm, settleConfirm } from '@/store/confirm'
+import { $confirmRequest, type PendingConfirm, settleConfirm } from '@/store/confirm'
 
 // The one mount point for `confirm()` from @/store/confirm. Mounted once at the
 // shell, the way NotificationStack backs notify().
@@ -24,29 +24,17 @@ export function ConfirmHost() {
 
   return (
     <ConfirmDialog
-      busyLabel={shown.busyLabel}
       cancelLabel={shown.cancelLabel}
       confirmLabel={shown.confirmLabel}
       description={shown.description}
       destructive={shown.destructive}
-      dismissOnConfirm={!shown.onConfirm}
-      doneLabel={shown.doneLabel}
-      key={shown.id}
-      onClose={() => settleConfirm(shown.phase === 'done', shown)}
-      onConfirm={() => runConfirm(shown)}
+      // The caller does the work once it has its answer, so there is nothing
+      // here to keep the dialog open for.
+      dismissOnConfirm
+      onClose={() => settleConfirm(false)}
+      onConfirm={() => settleConfirm(true)}
       open={request !== null}
       title={shown.title}
-    >
-      {shown.details && (
-        <dl className="space-y-3 text-xs">
-          {shown.details.map(({ label, value }) => (
-            <div className="grid grid-cols-[5rem_minmax(0,1fr)] gap-3" key={label}>
-              <dt className="text-muted-foreground">{label}</dt>
-              <dd className="m-0 whitespace-pre-wrap break-words text-foreground">{value}</dd>
-            </div>
-          ))}
-        </dl>
-      )}
-    </ConfirmDialog>
+    />
   )
 }
diff --git a/apps/desktop/src/components/pane-shell/tree/focused-session-tab.test.ts b/apps/desktop/src/components/pane-shell/tree/focused-session-tab.test.ts
index 4dddfeaaf7..c75b893f66 100644
--- a/apps/desktop/src/components/pane-shell/tree/focused-session-tab.test.ts
+++ b/apps/desktop/src/components/pane-shell/tree/focused-session-tab.test.ts
@@ -89,7 +89,7 @@ describe('focused chat zone drives the tab verbs', () => {
     const model = await import('@/components/pane-shell/tree/model')
     const { registry } = await import('@/contrib/registry')
 
-    for (const id of ['workspace', 'preview-tile:url:x', 'route-tile:/skills']) {
+    for (const id of ['workspace', 'preview-tile:url:x', 'route-tile:/capabilities']) {
       registry.register({
         area: 'panes',
         data: id === 'workspace' ? { placement: 'main', uncloseable: true } : { placement: 'main' },
@@ -105,15 +105,15 @@ describe('focused chat zone drives the tab verbs', () => {
     tree.declareDefaultTree(
       model.split('row', [
         model.group(['workspace'], { active: 'workspace', id: 'grp-main' }),
-        model.group(['preview-tile:url:x', 'route-tile:/skills'], { active: 'preview-tile:url:x', id: 'grp-view' })
+        model.group(['preview-tile:url:x', 'route-tile:/capabilities'], { active: 'preview-tile:url:x', id: 'grp-view' })
       ])
     )
     tree.noteActiveTreeGroup('grp-view')
 
     // ⌃Tab cycles within the preview zone, not main's.
-    expect(tree.cycleTreeTabInFocusedZone(1)).toBe('route-tile:/skills')
+    expect(tree.cycleTreeTabInFocusedZone(1)).toBe('route-tile:/capabilities')
     expect(tree.$layoutTree.get() && model.findGroup(tree.$layoutTree.get()!, 'grp-view')?.active).toBe(
-      'route-tile:/skills'
+      'route-tile:/capabilities'
     )
 
     // ⌘W closes the zone's active tab through its registered closer.
diff --git a/apps/desktop/src/components/ui/confirm-dialog.tsx b/apps/desktop/src/components/ui/confirm-dialog.tsx
index 37f5a90461..fc166efd43 100644
--- a/apps/desktop/src/components/ui/confirm-dialog.tsx
+++ b/apps/desktop/src/components/ui/confirm-dialog.tsx
@@ -21,7 +21,6 @@ interface ConfirmDialogProps {
   onConfirm: () => Promise<void> | void
   title: ReactNode
   description?: ReactNode
-  children?: ReactNode
   confirmLabel?: string
   busyLabel?: string
   doneLabel?: string
@@ -49,7 +48,6 @@ export function ConfirmDialog({
   onConfirm,
   title,
   description,
-  children,
   confirmLabel,
   busyLabel,
   doneLabel,
@@ -155,7 +153,6 @@ export function ConfirmDialog({
           {description ? <DialogDescription className="whitespace-pre-line">{description}</DialogDescription> : null}
         </DialogHeader>
 
-        {children}
         {error && (
           <div className="flex items-start gap-2 rounded-md border border-destructive/30 bg-destructive/10 px-3 py-2 text-xs text-destructive">
             <AlertTriangle className="mt-0.5 size-3.5 shrink-0" />
diff --git a/apps/desktop/src/components/ui/segmented-control.test.tsx b/apps/desktop/src/components/ui/segmented-control.test.tsx
deleted file mode 100644
index 110acbe9fa..0000000000
--- a/apps/desktop/src/components/ui/segmented-control.test.tsx
+++ /dev/null
@@ -1,51 +0,0 @@
-import { cleanup, fireEvent, render, screen } from '@testing-library/react'
-import { afterEach, describe, expect, it, vi } from 'vitest'
-
-import { codiconIcon } from './codicon'
-import { SegmentedControl } from './segmented-control'
-
-const options = [
-  { id: 'list', label: 'List view', icon: codiconIcon('list-unordered') },
-  { id: 'cards', label: 'Card view', icon: codiconIcon('extensions') }
-]
-
-afterEach(cleanup)
-
-describe('SegmentedControl', () => {
-  it('preserves visible labels by default', () => {
-    render(<SegmentedControl onChange={vi.fn()} options={options} value="cards" />)
-
-    expect(screen.getByRole('button', { name: 'Card view', pressed: true }).textContent).toBe('Card view')
-    expect(screen.getByRole('button', { name: 'List view', pressed: false }).textContent).toBe('List view')
-  })
-
-  it('keeps accessible labels and selection behavior for icon-only controls', () => {
-    const onChange = vi.fn()
-    render(<SegmentedControl iconOnly onChange={onChange} options={options} value="cards" />)
-    const list = screen.getByRole('button', { name: 'List view', pressed: false })
-    const cards = screen.getByRole('button', { name: 'Card view', pressed: true })
-
-    expect(list.textContent).toBe('')
-    expect(cards.textContent).toBe('')
-    expect(list.querySelector('.codicon-list-unordered')).not.toBeNull()
-    expect(cards.querySelector('.codicon-extensions')).not.toBeNull()
-    fireEvent.click(list)
-    expect(onChange).toHaveBeenCalledExactlyOnceWith('list')
-  })
-
-  it('retains a visible label when an icon-only option has no icon', () => {
-    render(<SegmentedControl iconOnly onChange={vi.fn()} options={[{ id: 'list', label: 'List view' }]} value="list" />)
-
-    expect(screen.getByRole('button', { name: 'List view' }).textContent).toBe('List view')
-  })
-
-  it('does not change a disabled icon-only control', () => {
-    const onChange = vi.fn()
-    render(<SegmentedControl disabled iconOnly onChange={onChange} options={options} value="cards" />)
-    const list = screen.getByRole<HTMLButtonElement>('button', { name: 'List view' })
-
-    expect(list.disabled).toBe(true)
-    fireEvent.click(list)
-    expect(onChange).not.toHaveBeenCalled()
-  })
-})
diff --git a/apps/desktop/src/components/ui/segmented-control.tsx b/apps/desktop/src/components/ui/segmented-control.tsx
index 4e5a9e625a..45c854ecf2 100644
--- a/apps/desktop/src/components/ui/segmented-control.tsx
+++ b/apps/desktop/src/components/ui/segmented-control.tsx
@@ -1,4 +1,3 @@
-import { Tip } from '@/components/ui/tooltip'
 import type { IconComponent } from '@/lib/icons'
 import { cn } from '@/lib/utils'
 
@@ -13,8 +12,6 @@ interface SegmentedControlProps<T extends string> {
   value: T
   onChange: (id: T) => void
   className?: string
-  /** Icon buttons retain localized labels for tooltips and screen readers. */
-  iconOnly?: boolean
   /** Dims the whole track and blocks selection (e.g. gated behind a prerequisite). */
   disabled?: boolean
 }
@@ -27,7 +24,6 @@ interface SegmentedControlProps<T extends string> {
 export function SegmentedControl<T extends string>({
   className,
   disabled = false,
-  iconOnly = false,
   onChange,
   options,
   value
@@ -43,14 +39,12 @@ export function SegmentedControl<T extends string>({
       {options.map(({ id, label, icon: Icon }) => {
         const active = value === id
 
-        const button = (
+        return (
           <button
-            aria-label={iconOnly ? label : undefined}
             aria-pressed={active}
             className={cn(
               'flex items-center justify-center gap-1 rounded-[3px] px-2.5 py-0.5 text-[0.6875rem] font-medium transition-colors disabled:cursor-default',
-              active ? 'bg-background text-foreground shadow-sm' : 'text-muted-foreground hover:text-foreground',
-              iconOnly && Icon && 'size-6 p-0 text-sm'
+              active ? 'bg-background text-foreground shadow-sm' : 'text-muted-foreground hover:text-foreground'
             )}
             disabled={disabled}
             key={id}
@@ -58,11 +52,9 @@ export function SegmentedControl<T extends string>({
             type="button"
           >
             {Icon && <Icon className="size-3" />}
-            {(!iconOnly || !Icon) && label}
+            {label}
           </button>
         )
-
-        return iconOnly && Icon ? <Tip key={id} label={label}>{button}</Tip> : button
       })}
     </div>
   )
diff --git a/apps/desktop/src/i18n/ar.ts b/apps/desktop/src/i18n/ar.ts
index ea6ff57a25..faa9ec7e4e 100644
--- a/apps/desktop/src/i18n/ar.ts
+++ b/apps/desktop/src/i18n/ar.ts
@@ -8,46 +8,6 @@ export const ar = defineLocale({
     close: 'إغلاق'
   },
 
-  catalog: {
-    listView: 'عرض القائمة',
-    cardView: 'عرض البطاقات',
-    installTitle: (name: string) => `تثبيت «${name}»؟`,
-    installDescription: 'ستتوفر هذه المهارة في الجلسات الجديدة. ثبّت من المصادر التي تثق بها فقط.',
-    installTo: 'التثبيت في',
-    thisComputer: 'هذا الكمبيوتر',
-    installing: 'جارٍ التثبيت…',
-    installComplete: (name: string) => `تم تثبيت «${name}»`,
-    destinationChanged: 'تغيرت وجهة التثبيت. أغلق هذا الحوار وافتح رابط التثبيت مجددًا.',
-    browse: 'تصفح',
-    installed: 'المثبتة',
-    searchSkills: 'البحث في المهارات',
-    searchPlugins: 'البحث في الإضافات',
-    allSources: 'كل المصادر',
-    allCategories: 'كل الفئات',
-    about: 'نبذة',
-    author: 'المؤلف',
-    source: 'المصدر',
-    category: 'الفئة',
-    version: 'الإصدار',
-    platforms: 'المنصات',
-    requires: 'المتطلبات',
-    tools: 'الأدوات',
-    hooks: 'الخطافات',
-    repository: 'المستودع',
-    documentation: 'التوثيق',
-    noResults: 'لا توجد نتائج مطابقة',
-    tryAnother: 'جرّب بحثًا آخر أو امسح عوامل التصفية.',
-    clearFilters: 'مسح عوامل التصفية',
-    loadFailed: 'تعذر تحميل الكتالوج',
-    retry: 'حاول مرة أخرى',
-    more: 'عرض المزيد',
-    pinned: 'التزام تمت مراجعته',
-    snapshotHint: 'من كتالوج Hermes. لا يتصل التصفح بمستودعات المصدر مطلقًا.',
-    installHint: 'راجع المصدر قبل التثبيت. تسري التغييرات على الجلسات الجديدة.',
-    results: (count: number) => `النتائج: ${count.toLocaleString('ar')}`,
-    back: 'العودة إلى النتائج'
-  },
-
   sessionImport: {
     title: 'المتابعة من تطبيق آخر',
     subtitle: 'انقل محادثة إلى Hermes وتابع من حيث توقفت.',
@@ -331,7 +291,7 @@ export const ar = defineLocale({
       'nav.commandCenter': 'فتح مركز الأوامر',
       'nav.settings': 'فتح الإعدادات',
       'nav.profiles': 'فتح الملفات الشخصية',
-      'nav.skills': 'فتح المهارات',
+      'nav.capabilities': 'فتح المهارات',
       'nav.messaging': 'فتح المراسلة',
       'nav.artifacts': 'فتح العناصر',
       'nav.cron': 'فتح المهام المجدولة',
@@ -1333,7 +1293,7 @@ export const ar = defineLocale({
         title: 'الإعدادات',
         detail: 'تكوين Hermes desktop'
       },
-      skills: {
+      capabilities: {
         title: 'المهارات والأدوات',
         detail: 'تفعيل المهارات ومجموعات الأدوات والمزوّدين'
       },
@@ -1926,7 +1886,7 @@ export const ar = defineLocale({
     },
     nav: {
       'new-session': 'جلسة جديدة',
-      skills: 'المهارات',
+      capabilities: 'المهارات',
       messaging: 'المراسلة',
       artifacts: 'العناصر',
       cron: 'المهام المجدولة'
diff --git a/apps/desktop/src/i18n/en.ts b/apps/desktop/src/i18n/en.ts
index e00258d837..3158a56f6e 100644
--- a/apps/desktop/src/i18n/en.ts
+++ b/apps/desktop/src/i18n/en.ts
@@ -9,45 +9,6 @@ export const en: Translations = {
     copyUrl: 'Copy link',
     close: 'Close'
   },
-  catalog: {
-    listView: 'List view',
-    cardView: 'Card view',
-    installTitle: (name: string) => `Install “${name}”?`,
-    installDescription: 'This skill will be available in new sessions. Only install sources you trust.',
-    installTo: 'Install to',
-    thisComputer: 'This computer',
-    installing: 'Installing…',
-    installComplete: (name: string) => `“${name}” installed`,
-    destinationChanged: 'The destination changed. Close this dialog and open the install link again.',
-    browse: 'Browse',
-    installed: 'Installed',
-    searchSkills: 'Search skills',
-    searchPlugins: 'Search plugins',
-    allSources: 'All sources',
-    allCategories: 'All categories',
-    about: 'About',
-    author: 'Author',
-    source: 'Source',
-    category: 'Category',
-    version: 'Version',
-    platforms: 'Platforms',
-    requires: 'Requires',
-    tools: 'Tools',
-    hooks: 'Hooks',
-    repository: 'Repository',
-    documentation: 'Documentation',
-    noResults: 'No matches',
-    tryAnother: 'Try another search or clear your filters.',
-    clearFilters: 'Clear filters',
-    loadFailed: 'Could not load the catalog',
-    retry: 'Try again',
-    more: 'Show more',
-    pinned: 'Reviewed commit',
-    snapshotHint: 'From the Hermes catalog. Browsing never contacts source repositories.',
-    installHint: 'Review the source before installing. Changes apply to new sessions.',
-    results: (count: number) => `${count.toLocaleString()} result${count === 1 ? '' : 's'}`,
-    back: 'Back to results'
-  },
   connectors: {
     title: 'Connect your apps',
     connect: 'Connect',
@@ -432,7 +393,7 @@ export const en: Translations = {
       'nav.commandCenter': 'Open command center',
       'nav.settings': 'Open settings',
       'nav.profiles': 'Open profiles',
-      'nav.skills': 'Open skills',
+      'nav.capabilities': 'Open skills',
       'nav.messaging': 'Open messaging',
       'nav.artifacts': 'Open artifacts',
       'nav.cron': 'Open scheduled jobs',
@@ -2037,7 +1998,7 @@ export const en: Translations = {
     nav: {
       newChat: { title: 'New session', detail: 'Start a fresh session' },
       settings: { title: 'Settings', detail: 'Configure Hermes desktop' },
-      skills: { title: 'Capabilities', detail: 'Skills, tools, MCP servers, and plugins' },
+      capabilities: { title: 'Capabilities', detail: 'Skills, tools, MCP servers, and plugins' },
       messaging: { title: 'Messaging', detail: 'Set up Telegram, Slack, Discord, and more' },
       artifacts: { title: 'Artifacts', detail: 'Browse generated outputs' }
     },
@@ -2757,7 +2718,7 @@ export const en: Translations = {
     profileRail: 'Profile rail',
     nav: {
       'new-session': 'New session',
-      skills: 'Capabilities',
+      capabilities: 'Capabilities',
       messaging: 'Messaging',
       artifacts: 'Artifacts',
       cron: 'Scheduled jobs'
diff --git a/apps/desktop/src/i18n/ja.ts b/apps/desktop/src/i18n/ja.ts
index d79db66fa0..2467a1f83d 100644
--- a/apps/desktop/src/i18n/ja.ts
+++ b/apps/desktop/src/i18n/ja.ts
@@ -9,45 +9,6 @@ export const ja = defineLocale({
     copyUrl: 'リンクをコピー',
     close: '閉じる'
   },
-  catalog: {
-    listView: 'リスト表示',
-    cardView: 'カード表示',
-    installTitle: (name: string) => `「${name}」をインストールしますか？`,
-    installDescription: 'このスキルは新しいセッションで利用できます。信頼できる提供元からのみインストールしてください。',
-    installTo: 'インストール先',
-    thisComputer: 'このコンピューター',
-    installing: 'インストール中…',
-    installComplete: (name: string) => `「${name}」をインストールしました`,
-    destinationChanged: 'インストール先が変更されました。このダイアログを閉じ、インストールリンクを開き直してください。',
-    browse: '閲覧',
-    installed: 'インストール済み',
-    searchSkills: 'スキルを検索',
-    searchPlugins: 'プラグインを検索',
-    allSources: 'すべての提供元',
-    allCategories: 'すべてのカテゴリ',
-    about: '概要',
-    author: '作者',
-    source: '提供元',
-    category: 'カテゴリ',
-    version: 'バージョン',
-    platforms: '対応プラットフォーム',
-    requires: '必要なもの',
-    tools: 'ツール',
-    hooks: 'フック',
-    repository: 'リポジトリ',
-    documentation: 'ドキュメント',
-    noResults: '一致する項目がありません',
-    tryAnother: '別の検索を試すか、フィルターをクリアしてください。',
-    clearFilters: 'フィルターをクリア',
-    loadFailed: 'カタログを読み込めませんでした',
-    retry: '再試行',
-    more: 'さらに表示',
-    pinned: 'レビュー済みコミット',
-    snapshotHint: 'Hermesカタログの情報です。閲覧時に提供元のリポジトリへ接続することはありません。',
-    installHint: 'インストール前にソースを確認してください。変更は新しいセッションに適用されます。',
-    results: (count: number) => `${count.toLocaleString('ja')}件の結果`,
-    back: '結果に戻る'
-  },
   sessionImport: {
     title: '別のアプリから続ける',
     subtitle: '会話をHermesに取り込み、続きを始めましょう。',
@@ -1676,7 +1637,7 @@ export const ja = defineLocale({
     nav: {
       newChat: { title: '新しいセッション', detail: '新しいセッションを開始' },
       settings: { title: '設定', detail: 'Hermes デスクトップを設定' },
-      skills: { title: 'スキルとツール', detail: 'スキル、ツールセット、プロバイダーを有効化' },
+      capabilities: { title: 'スキルとツール', detail: 'スキル、ツールセット、プロバイダーを有効化' },
       messaging: { title: 'メッセージング', detail: 'Telegram、Slack、Discord などを設定' },
       artifacts: { title: 'アーティファクト', detail: '生成された出力を閲覧' }
     },
@@ -2256,7 +2217,7 @@ export const ja = defineLocale({
     },
     nav: {
       'new-session': '新しいセッション',
-      skills: 'スキルとツール',
+      capabilities: 'スキルとツール',
       messaging: 'メッセージング',
       artifacts: 'アーティファクト',
       cron: 'スケジュール済みジョブ'
diff --git a/apps/desktop/src/i18n/ru.ts b/apps/desktop/src/i18n/ru.ts
index e7263f59a5..81a8de29b7 100644
--- a/apps/desktop/src/i18n/ru.ts
+++ b/apps/desktop/src/i18n/ru.ts
@@ -24,46 +24,6 @@ const RU_NOUN = (count: number | string, one: string, few: string, many: string)
 }
 
 export const ru = defineLocale({
-  catalog: {
-    listView: 'Список',
-    cardView: 'Карточки',
-    installTitle: (name: string) => `Установить «${name}»?`,
-    installDescription: 'Навык будет доступен в новых сессиях. Устанавливайте только из источников, которым доверяете.',
-    installTo: 'Установить в',
-    thisComputer: 'Этот компьютер',
-    installing: 'Установка…',
-    installComplete: (name: string) => `«${name}» установлен`,
-    destinationChanged: 'Место установки изменилось. Закройте диалог и снова откройте ссылку установки.',
-    browse: 'Обзор',
-    installed: 'Установленные',
-    searchSkills: 'Поиск навыков',
-    searchPlugins: 'Поиск плагинов',
-    allSources: 'Все источники',
-    allCategories: 'Все категории',
-    about: 'Описание',
-    author: 'Автор',
-    source: 'Источник',
-    category: 'Категория',
-    version: 'Версия',
-    platforms: 'Платформы',
-    requires: 'Требования',
-    tools: 'Инструменты',
-    hooks: 'Хуки',
-    repository: 'Репозиторий',
-    documentation: 'Документация',
-    noResults: 'Совпадений нет',
-    tryAnother: 'Попробуйте другой запрос или сбросьте фильтры.',
-    clearFilters: 'Сбросить фильтры',
-    loadFailed: 'Не удалось загрузить каталог',
-    retry: 'Попробовать снова',
-    more: 'Показать ещё',
-    pinned: 'Проверенный коммит',
-    snapshotHint: 'Из каталога Hermes. При просмотре нет обращений к исходным репозиториям.',
-    installHint: 'Проверьте исходный код перед установкой. Изменения применяются к новым сессиям.',
-    results: (count: number) =>
-      `${count.toLocaleString('ru')} ${RU_PLURAL(count, 'результат', 'результата', 'результатов')}`,
-    back: 'Назад к результатам'
-  },
   sessionImport: {
     title: 'Продолжить из другого приложения',
     subtitle: 'Перенесите разговор в Hermes и продолжите с того места, где остановились.',
@@ -345,7 +305,7 @@ export const ru = defineLocale({
       'nav.commandCenter': 'Открыть центр команд',
       'nav.settings': 'Открыть настройки',
       'nav.profiles': 'Открыть профили',
-      'nav.skills': 'Открыть навыки',
+      'nav.capabilities': 'Открыть навыки',
       'nav.messaging': 'Открыть мессенджеры',
       'nav.artifacts': 'Открыть артефакты',
       'nav.cron': 'Открыть запланированные задачи',
@@ -1838,7 +1798,7 @@ export const ru = defineLocale({
     nav: {
       newChat: { title: 'Новый сеанс', detail: 'Начать новый сеанс' },
       settings: { title: 'Настройки', detail: 'Настройка Hermes desktop' },
-      skills: { title: 'Возможности', detail: 'Навыки, инструменты и MCP-серверы' },
+      capabilities: { title: 'Возможности', detail: 'Навыки, инструменты и MCP-серверы' },
       messaging: { title: 'Сообщения', detail: 'Настройка Telegram, Slack, Discord и других' },
       artifacts: { title: 'Артефакты', detail: 'Просмотр сгенерированных результатов' }
     },
@@ -2509,7 +2469,7 @@ export const ru = defineLocale({
     },
     nav: {
       'new-session': 'Новый сеанс',
-      skills: 'Возможности',
+      capabilities: 'Возможности',
       messaging: 'Сообщения',
       artifacts: 'Артефакты',
       cron: 'Запланированные задачи'
diff --git a/apps/desktop/src/i18n/types.ts b/apps/desktop/src/i18n/types.ts
index fabcf2a5e7..8e77a8857c 100644
--- a/apps/desktop/src/i18n/types.ts
+++ b/apps/desktop/src/i18n/types.ts
@@ -65,45 +65,6 @@ export interface Translations {
     copyUrl: string
     close: string
   };
-  catalog: {
-    listView: string
-    cardView: string
-    installTitle: (name: string) => string
-    installDescription: string
-    installTo: string
-    thisComputer: string
-    installing: string
-    installComplete: (name: string) => string
-    destinationChanged: string
-    browse: string
-    installed: string
-    searchSkills: string
-    searchPlugins: string
-    allSources: string
-    allCategories: string
-    about: string
-    author: string
-    source: string
-    category: string
-    version: string
-    platforms: string
-    requires: string
-    tools: string
-    hooks: string
-    repository: string
-    documentation: string
-    noResults: string
-    tryAnother: string
-    clearFilters: string
-    loadFailed: string
-    retry: string
-    more: string
-    pinned: string
-    snapshotHint: string
-    installHint: string
-    results: (count: number) => string
-    back: string
-  };
   connectors: {
     title: string
     connect: string
@@ -1812,7 +1773,7 @@ export interface Translations {
     archivedChats: string
     sections: Record<'maintenance' | 'sessions' | 'system' | 'usage', string>
     sectionDescriptions: Record<'maintenance' | 'sessions' | 'system' | 'usage', string>
-    nav: Record<'newChat' | 'settings' | 'skills' | 'messaging' | 'artifacts', { title: string; detail: string }>
+    nav: Record<'newChat' | 'settings' | 'capabilities' | 'messaging' | 'artifacts', { title: string; detail: string }>
     sectionEntries: Record<'sessions' | 'system' | 'usage', { title: string; detail: string }>
     providerNavigate: string
     providerSessions: string
diff --git a/apps/desktop/src/i18n/zh-hant.ts b/apps/desktop/src/i18n/zh-hant.ts
index 2ef86a0837..ba84449911 100644
--- a/apps/desktop/src/i18n/zh-hant.ts
+++ b/apps/desktop/src/i18n/zh-hant.ts
@@ -9,45 +9,6 @@ export const zhHant = defineLocale({
     copyUrl: '複製連結',
     close: '關閉'
   },
-  catalog: {
-    listView: '清單檢視',
-    cardView: '卡片檢視',
-    installTitle: (name: string) => `安裝「${name}」？`,
-    installDescription: '此技能將於新的工作階段中可用。請僅安裝可信來源的內容。',
-    installTo: '安裝至',
-    thisComputer: '這部電腦',
-    installing: '正在安裝…',
-    installComplete: (name: string) => `已安裝「${name}」`,
-    destinationChanged: '安裝目標已變更。請關閉此對話框並重新開啟安裝連結。',
-    browse: '瀏覽',
-    installed: '已安裝',
-    searchSkills: '搜尋技能',
-    searchPlugins: '搜尋外掛',
-    allSources: '所有來源',
-    allCategories: '所有分類',
-    about: '簡介',
-    author: '作者',
-    source: '來源',
-    category: '分類',
-    version: '版本',
-    platforms: '支援的平台',
-    requires: '相依項目',
-    tools: '工具',
-    hooks: '掛鉤',
-    repository: '程式碼儲存庫',
-    documentation: '文件',
-    noResults: '沒有符合的項目',
-    tryAnother: '請嘗試其他搜尋或清除篩選條件。',
-    clearFilters: '清除篩選條件',
-    loadFailed: '無法載入目錄',
-    retry: '再試一次',
-    more: '顯示更多',
-    pinned: '已審核的提交',
-    snapshotHint: '內容來自 Hermes 目錄。瀏覽時不會連線至來源程式碼儲存庫。',
-    installHint: '安裝前請檢查原始碼。變更將於新的工作階段生效。',
-    results: (count: number) => `${count.toLocaleString('zh-Hant')} 個結果`,
-    back: '返回結果'
-  },
   sessionImport: {
     title: '從其他應用程式繼續',
     subtitle: '將對話匯入 Hermes，接著上次的進度繼續。',
@@ -1688,7 +1649,7 @@ export const zhHant = defineLocale({
     nav: {
       newChat: { title: '新工作階段', detail: '開始新的工作階段' },
       settings: { title: '設定', detail: '設定 Hermes 桌面端' },
-      skills: { title: '技能與工具', detail: '啟用技能、工具集和提供方' },
+      capabilities: { title: '技能與工具', detail: '啟用技能、工具集和提供方' },
       messaging: { title: '訊息平台', detail: '設定 Telegram、Slack、Discord 等' },
       artifacts: { title: '成品', detail: '瀏覽產生的輸出' }
     },
@@ -2243,7 +2204,7 @@ export const zhHant = defineLocale({
     },
     nav: {
       'new-session': '新工作階段',
-      skills: '技能與工具',
+      capabilities: '技能與工具',
       messaging: '訊息平台',
       artifacts: '成品',
       cron: '排程工作'
diff --git a/apps/desktop/src/i18n/zh.ts b/apps/desktop/src/i18n/zh.ts
index 31adf4ce57..d909ff3a94 100644
--- a/apps/desktop/src/i18n/zh.ts
+++ b/apps/desktop/src/i18n/zh.ts
@@ -9,45 +9,6 @@ export const zh = defineLocale({
     copyUrl: '复制链接',
     close: '关闭'
   },
-  catalog: {
-    listView: '列表视图',
-    cardView: '卡片视图',
-    installTitle: (name: string) => `安装“${name}”？`,
-    installDescription: '此技能将在新会话中可用。请仅安装可信来源的内容。',
-    installTo: '安装到',
-    thisComputer: '此电脑',
-    installing: '正在安装…',
-    installComplete: (name: string) => `已安装“${name}”`,
-    destinationChanged: '安装目标已更改。请关闭此对话框并重新打开安装链接。',
-    browse: '浏览',
-    installed: '已安装',
-    searchSkills: '搜索技能',
-    searchPlugins: '搜索插件',
-    allSources: '所有来源',
-    allCategories: '所有分类',
-    about: '简介',
-    author: '作者',
-    source: '来源',
-    category: '分类',
-    version: '版本',
-    platforms: '支持的平台',
-    requires: '依赖项',
-    tools: '工具',
-    hooks: '钩子',
-    repository: '代码仓库',
-    documentation: '文档',
-    noResults: '没有匹配项',
-    tryAnother: '请尝试其他搜索或清除筛选条件。',
-    clearFilters: '清除筛选条件',
-    loadFailed: '无法加载目录',
-    retry: '重试',
-    more: '显示更多',
-    pinned: '已审核的提交',
-    snapshotHint: '内容来自 Hermes 目录。浏览时不会连接来源代码仓库。',
-    installHint: '安装前请检查源代码。更改将在新会话中生效。',
-    results: (count: number) => `${count.toLocaleString('zh')} 个结果`,
-    back: '返回结果'
-  },
   connectors: {
     title: '连接你的应用',
     connect: '连接',
@@ -393,7 +354,7 @@ export const zh = defineLocale({
       'nav.commandCenter': '打开命令中心',
       'nav.settings': '打开设置',
       'nav.profiles': '打开配置',
-      'nav.skills': '打开技能',
+      'nav.capabilities': '打开技能',
       'nav.messaging': '打开消息',
       'nav.artifacts': '打开制品',
       'nav.cron': '打开定时任务',
@@ -2190,7 +2151,7 @@ export const zh = defineLocale({
     nav: {
       newChat: { title: '新建会话', detail: '开始一个新会话' },
       settings: { title: '设置', detail: '配置 Hermes 桌面端' },
-      skills: { title: '技能与工具', detail: '启用技能、工具集与提供方' },
+      capabilities: { title: '技能与工具', detail: '启用技能、工具集与提供方' },
       messaging: { title: '消息平台', detail: '配置 Telegram、Slack、Discord 等' },
       artifacts: { title: '产物', detail: '浏览生成的输出' }
     },
@@ -2895,7 +2856,7 @@ export const zh = defineLocale({
     },
     nav: {
       'new-session': '新建会话',
-      skills: '技能与工具',
+      capabilities: '技能与工具',
       messaging: '消息平台',
       artifacts: '产物',
       cron: '定时任务'
diff --git a/apps/desktop/src/lib/catalog-install.test.ts b/apps/desktop/src/lib/catalog-install.test.ts
deleted file mode 100644
index 62b3b76f00..0000000000
--- a/apps/desktop/src/lib/catalog-install.test.ts
+++ /dev/null
@@ -1,37 +0,0 @@
-import { pluginCatalogInstallUrl, skillCatalogInstallIdentifier, skillCatalogInstallUrl } from '@hermes/shared'
-import { describe, expect, it } from 'vitest'
-
-import { resolveDeepLinkAction } from './deeplink-routes'
-
-function route(href: string) {
-  const url = new URL(href)
-
-  return resolveDeepLinkAction({ kind: url.hostname, name: url.pathname.slice(1), params: Object.fromEntries(url.searchParams) })
-}
-
-describe('public catalog install links', () => {
-  it.each([
-    [{ name: 'Apple Design', source: 'ClawHub', identifier: 'apple-design' }, 'clawhub/apple-design'],
-    [{ name: 'Apple Design', source: 'ClawHub', identifier: 'clawhub/apple-design' }, 'clawhub/apple-design'],
-    [{ name: 'pdf', source: 'Anthropic', identifier: 'anthropics/skills/skills/pdf' }, 'anthropics/skills/skills/pdf'],
-    [{ name: 'pdf', source: 'optional' }, 'official/pdf'],
-    [{ name: 'pdf', source: 'built-in', installIdentifier: 'NousResearch/hermes-agent/skills/productivity/pdf' }, 'NousResearch/hermes-agent/skills/productivity/pdf'],
-    [{ name: 'A name', source: 'future-source', identifier: 'provider/path?mode=one&two#readme' }, 'provider/path?mode=one&two#readme']
-  ])('preserves the source-specific target for %o', (entry, identifier) => {
-    expect(skillCatalogInstallIdentifier(entry)).toBe(identifier)
-    expect(route(skillCatalogInstallUrl(entry)!)).toEqual({ type: 'skill-install', identifier })
-  })
-
-  it('omits bundled install links when an older snapshot has no exact target', () => {
-    expect(skillCatalogInstallUrl({ name: 'pdf', source: 'built-in' })).toBeNull()
-  })
-
-  it('forwards catalog identity, display pin and encoded subdirectory to the plugin confirmation', () => {
-    const plugin = { name: 'weather', repo: 'https://github.com/owner/plugins', subdir: 'packages/weather', sha: 'a'.repeat(40) }
-
-    expect(route(pluginCatalogInstallUrl(plugin))).toEqual({
-      type: 'plugin-install', repo: `${plugin.repo}#${plugin.subdir}`, catalogName: plugin.name,
-      sha: plugin.sha, enable: true, force: false, legacyHint: null
-    })
-  })
-})
diff --git a/apps/desktop/src/lib/deeplink-routes.test.ts b/apps/desktop/src/lib/deeplink-routes.test.ts
index d5350303f6..76683577af 100644
--- a/apps/desktop/src/lib/deeplink-routes.test.ts
+++ b/apps/desktop/src/lib/deeplink-routes.test.ts
@@ -19,30 +19,6 @@ describe('resolveDeepLinkAction', () => {
     })
   })
 
-  it('preserves catalog provenance without treating the display pin as an install target', () => {
-    const params = {
-      repo: 'https://github.com/owner/repo#plugins/example',
-      catalog_name: 'example',
-      sha: '0123456789abcdef0123456789abcdef01234567',
-      enable: '1'
-    }
-    const url = new URL(`hermes://plugin/install?${new URLSearchParams(params)}`)
-
-    expect(resolveDeepLinkAction({
-      kind: url.hostname,
-      name: url.pathname.slice(1),
-      params: Object.fromEntries(url.searchParams)
-    })).toEqual({
-      type: 'plugin-install',
-      repo: params.repo,
-      catalogName: params.catalog_name,
-      sha: params.sha,
-      enable: true,
-      force: false,
-      legacyHint: null
-    })
-  })
-
   it('routes legacy plugin-agent alias', () => {
     expect(
       resolveDeepLinkAction({
@@ -53,30 +29,6 @@ describe('resolveDeepLinkAction', () => {
     ).toMatchObject({ type: 'plugin-install', legacyHint: 'agent' })
   })
 
-  it('only routes skill installs with an explicit, unchanged identifier', () => {
-    const identifier = 'skills-sh/owner/repo/a skill?mode=one&two#readme'
-    const url = new URL(`hermes://skill/install?${new URLSearchParams({ identifier })}`)
-
-    expect(resolveDeepLinkAction({
-      kind: url.hostname,
-      name: url.pathname.slice(1),
-      params: Object.fromEntries(url.searchParams)
-    })).toEqual({ type: 'skill-install', identifier })
-
-    const invalidParams: Record<string, string>[] = [
-      {},
-      { identifier: '' },
-      { identifier: '   ' },
-      { identifier: ' official/skill ' }
-    ]
-
-    for (const params of invalidParams) {
-      expect(resolveDeepLinkAction({ kind: 'skill', name: 'install', params })).toEqual({ type: 'ignore' })
-    }
-    expect(resolveDeepLinkAction({ kind: 'skill', name: 'remove', params: { identifier } })).toEqual({ type: 'ignore' })
-    expect(resolveDeepLinkAction({ kind: 'plugin', name: 'install', params: {} })).toEqual({ type: 'ignore' })
-  })
-
   it('routes blueprint composer inserts', () => {
     expect(
       resolveDeepLinkAction({
diff --git a/apps/desktop/src/lib/deeplink-routes.ts b/apps/desktop/src/lib/deeplink-routes.ts
index f291ab4014..c943e23449 100644
--- a/apps/desktop/src/lib/deeplink-routes.ts
+++ b/apps/desktop/src/lib/deeplink-routes.ts
@@ -7,16 +7,7 @@ export interface DeepLinkPayload {
 }
 
 export type DeepLinkAction =
-  | {
-      type: 'plugin-install'
-      repo: string
-      enable: boolean
-      force: boolean
-      legacyHint: PluginInstallLegacyHint
-      catalogName?: string
-      sha?: string
-    }
-  | { type: 'skill-install'; identifier: string }
+  | { type: 'plugin-install'; repo: string; enable: boolean; force: boolean; legacyHint: PluginInstallLegacyHint }
   | { type: 'composer-blueprint'; name: string; params: Record<string, string> }
   | { type: 'ignore' }
 
@@ -39,17 +30,7 @@ export function resolveDeepLinkAction(payload: DeepLinkPayload | null | undefine
     return { type: 'composer-blueprint', name: payload.name, params: payload.params || {} }
   }
 
-  if (payload.kind === 'skill') {
-    const identifier = payload.params?.identifier
-
-    return payload.name === 'install' && identifier && identifier === identifier.trim()
-      ? { type: 'skill-install', identifier }
-      : { type: 'ignore' }
-  }
-
-  const repo = (
-    payload.params?.repo || payload.params?.identifier || (payload.kind !== 'plugin' ? payload.name : '') || ''
-  ).trim()
+  const repo = (payload.params?.repo || payload.params?.identifier || payload.name || '').trim()
 
   if (payload.kind === 'plugin' && payload.name === 'install' && repo) {
     return {
@@ -57,9 +38,7 @@ export function resolveDeepLinkAction(payload: DeepLinkPayload | null | undefine
       repo,
       enable: truthyParam(payload.params?.enable, true),
       force: truthyParam(payload.params?.force, false),
-      legacyHint: null,
-      catalogName: payload.params?.catalog_name || undefined,
-      sha: payload.params?.sha || undefined
+      legacyHint: null
     }
   }
 
diff --git a/apps/desktop/src/lib/gateway-liveness-policy.ts b/apps/desktop/src/lib/gateway-liveness-policy.ts
index 7e525f765b..3f219a433b 100644
--- a/apps/desktop/src/lib/gateway-liveness-policy.ts
+++ b/apps/desktop/src/lib/gateway-liveness-policy.ts
@@ -34,6 +34,9 @@
  * (mirroring gateway-liveness usage in use-gateway-boot).
  */
 
+/** Ping budget for a liveness probe (primary and secondary sockets share it). */
+export const LIVENESS_PROBE_TIMEOUT_MS = 5_000
+
 /** Consecutive unanswered probes tolerated while work is in flight. */
 export const LIVENESS_PROBE_FAILURE_STREAK = 2
 
diff --git a/apps/desktop/src/lib/hermes-open-target.test.ts b/apps/desktop/src/lib/hermes-open-target.test.ts
index 59f8d3f4fe..35f1c7439d 100644
--- a/apps/desktop/src/lib/hermes-open-target.test.ts
+++ b/apps/desktop/src/lib/hermes-open-target.test.ts
@@ -59,6 +59,5 @@ describe('pathFromHermesDeepLink', () => {
   it('ignores reserved kinds', () => {
     expect(pathFromHermesDeepLink('blueprint', 'morning-brief')).toBeNull()
     expect(pathFromHermesDeepLink('plugin', 'install')).toBeNull()
-    expect(pathFromHermesDeepLink('skill', 'install')).toBeNull()
   })
 })
diff --git a/apps/desktop/src/lib/hermes-open-target.ts b/apps/desktop/src/lib/hermes-open-target.ts
index 6c0f36bef0..a865486d1b 100644
--- a/apps/desktop/src/lib/hermes-open-target.ts
+++ b/apps/desktop/src/lib/hermes-open-target.ts
@@ -26,8 +26,7 @@ const RESERVED_DEEP_LINK_KINDS = new Set([
   'plugin',
   'plugin-agent',
   'plugin-desktop',
-  'settings',
-  'skill'
+  'settings'
 ])
 
 function appendSearch(path: string, params: URLSearchParams | Record<string, string> | undefined): string {
diff --git a/apps/desktop/src/lib/keybinds/actions.ts b/apps/desktop/src/lib/keybinds/actions.ts
index a20379a316..553c134ba3 100644
--- a/apps/desktop/src/lib/keybinds/actions.ts
+++ b/apps/desktop/src/lib/keybinds/actions.ts
@@ -109,7 +109,7 @@ export const KEYBIND_ACTIONS: readonly KeybindActionMeta[] = [
   { id: 'nav.commandCenter', category: 'navigation', defaults: ['mod+.'] },
   { id: 'nav.settings', category: 'navigation', defaults: ['mod+,'] },
   { id: 'nav.profiles', category: 'navigation', defaults: [] },
-  { id: 'nav.skills', category: 'navigation', defaults: [] },
+  { id: 'nav.capabilities', category: 'navigation', defaults: [] },
   { id: 'nav.messaging', category: 'navigation', defaults: [] },
   { id: 'nav.artifacts', category: 'navigation', defaults: [] },
   { id: 'nav.cron', category: 'navigation', defaults: [] },
diff --git a/apps/desktop/src/lib/keybinds/combo.test.ts b/apps/desktop/src/lib/keybinds/combo.test.ts
index 0d8fffd395..82a2044536 100644
--- a/apps/desktop/src/lib/keybinds/combo.test.ts
+++ b/apps/desktop/src/lib/keybinds/combo.test.ts
@@ -150,7 +150,7 @@ describe('actionAllowedInInput', () => {
     expect(actionAllowedInInput('session.prev', 'ctrl+shift+tab')).toBe(true)
     expect(actionAllowedInInput('nav.commandPalette', 'mod+k')).toBe(true)
     expect(actionAllowedInInput('view.findInPage', 'mod+f')).toBe(true)
-    expect(actionAllowedInInput('nav.skills', 'mod+k')).toBe(true)
+    expect(actionAllowedInInput('nav.capabilities', 'mod+k')).toBe(true)
     expect(actionAllowedInInput('view.showTerminal', 'ctrl+`')).toBe(true)
     expect(actionAllowedInInput('profile.next', 'mod+shift+]')).toBe(true)
 
diff --git a/apps/desktop/src/lib/query-client.ts b/apps/desktop/src/lib/query-client.ts
index 1828041563..cfea4f1054 100644
--- a/apps/desktop/src/lib/query-client.ts
+++ b/apps/desktop/src/lib/query-client.ts
@@ -28,7 +28,6 @@ export const writeCache =
 // previous profile's data (a bug).
 const PROFILE_INDEPENDENT_QUERY_ROOTS = new Set<string>([
   'billing',
-  'public-catalog',
   'marketplace-themes',
   'marketplace-themes-settings',
   'onboarding-model-options',
diff --git a/apps/desktop/src/lib/tips/catalog.ts b/apps/desktop/src/lib/tips/catalog.ts
index 157968c85e..deedc1612e 100644
--- a/apps/desktop/src/lib/tips/catalog.ts
+++ b/apps/desktop/src/lib/tips/catalog.ts
@@ -45,7 +45,7 @@ export type TipId =
 // to stand alone, because that is how they arrive.
 export const TIP_CATALOG: readonly TipDef[] = [
   { id: 'new-session', keybind: 'session.new', side: 'right', targets: ['[data-tour="sidebar-nav-new-session"]'] },
-  { id: 'skills', keybind: 'nav.skills', side: 'right', targets: ['[data-tour="sidebar-nav-skills"]'] },
+  { id: 'skills', keybind: 'nav.capabilities', side: 'right', targets: ['[data-tour="sidebar-nav-capabilities"]'] },
   { id: 'messaging', keybind: 'nav.messaging', side: 'right', targets: ['[data-tour="sidebar-nav-messaging"]'] },
   { id: 'artifacts', keybind: 'nav.artifacts', side: 'right', targets: ['[data-tour="sidebar-nav-artifacts"]'] },
   { id: 'cron', keybind: 'nav.cron', side: 'right', targets: ['[data-tour="sidebar-nav-cron"]'] },
diff --git a/apps/desktop/src/plugins/hermes-bots/create-agent-lazy-profile.test.tsx b/apps/desktop/src/plugins/hermes-bots/create-agent-lazy-profile.test.tsx
index 25a6d746a2..613f1a369f 100644
--- a/apps/desktop/src/plugins/hermes-bots/create-agent-lazy-profile.test.tsx
+++ b/apps/desktop/src/plugins/hermes-bots/create-agent-lazy-profile.test.tsx
@@ -22,7 +22,7 @@ import type * as DataModule from './data'
 import { translateBots } from './i18n-test-helper'
 import type { RosterRow } from './types'
 
-interface SkillsViewProps {
+interface CapabilitiesViewProps {
   fixedConnection?: string
   fixedProfile?: string
 }
@@ -32,19 +32,19 @@ const mocks = vi.hoisted(() => ({
   createCanonicalChat: vi.fn(async () => 'session-1'),
   deleteBot: vi.fn(async () => undefined),
   /** Flipped off to model a desktop build that predates the live surface. */
-  hasSkillsView: { value: true },
+  hasCapabilitiesView: { value: true },
   notify: vi.fn(),
   notifyError: vi.fn(),
   request: vi.fn(),
   requestProfile: vi.fn(async () => ({})),
   saveBotMeta: vi.fn(),
-  skillsView: [] as SkillsViewProps[]
+  skillsView: [] as CapabilitiesViewProps[]
 }))
 
 vi.mock('@hermes/plugin-sdk', async importOriginal => {
   const original = await importOriginal<typeof HermesSdk>()
 
-  const SkillsViewStub = (props: SkillsViewProps) => {
+  const CapabilitiesViewStub = (props: CapabilitiesViewProps) => {
     mocks.skillsView.push(props)
 
     return null
@@ -52,7 +52,7 @@ vi.mock('@hermes/plugin-sdk', async importOriginal => {
 
   // Builds that route `fixedConnection` get the live Capabilities tab for
   // remote targets too, pinned to the target machine's backend.
-  SkillsViewStub.supportsFixedConnection = true
+  CapabilitiesViewStub.supportsFixedConnection = true
 
   const mocked: Record<string, unknown> = {
     ...original,
@@ -68,10 +68,10 @@ vi.mock('@hermes/plugin-sdk', async importOriginal => {
     usePluginI18n: () => translateBots
   }
 
-  Object.defineProperty(mocked, 'SkillsView', {
+  Object.defineProperty(mocked, 'CapabilitiesView', {
     configurable: true,
     enumerable: true,
-    get: () => (mocks.hasSkillsView.value ? SkillsViewStub : undefined)
+    get: () => (mocks.hasCapabilitiesView.value ? CapabilitiesViewStub : undefined)
   })
 
   return mocked
@@ -101,8 +101,8 @@ function withQueryClient(children: ReactNode) {
   )
 }
 
-async function renderDialog(hasSkillsView: boolean) {
-  mocks.hasSkillsView.value = hasSkillsView
+async function renderDialog(hasCapabilitiesView: boolean) {
+  mocks.hasCapabilitiesView.value = hasCapabilitiesView
   vi.resetModules()
 
   const { CreateAgentDialog } = await import('./create-dialog')
diff --git a/apps/desktop/src/plugins/hermes-bots/create-dialog.tsx b/apps/desktop/src/plugins/hermes-bots/create-dialog.tsx
index 6c739154bb..0dad5b8d96 100644
--- a/apps/desktop/src/plugins/hermes-bots/create-dialog.tsx
+++ b/apps/desktop/src/plugins/hermes-bots/create-dialog.tsx
@@ -66,7 +66,7 @@ import type {
   ProfileConfigurePayload,
   ProfileDescribeResponse
 } from './profile-config'
-import { CheckList, SkillsView, skillsViewRoutesConnections } from './profile-config'
+import { CapabilitiesView, capabilitiesViewRoutesConnections, CheckList } from './profile-config'
 import { deleteBot } from './profile-ops'
 import { botRosterMeta } from './routing'
 import { HubSkillsSection } from './skills-hub'
@@ -195,7 +195,7 @@ export function CreateAgentDialog({ open, onClose, roster }: CreateAgentDialogPr
       : host.request(method, params)
 
   // Set once ensureAgentCreated() materializes the profile for the live
-  // Capabilities tab (SkillsView needs a real backend to point at). State —
+  // Capabilities tab (CapabilitiesView needs a real backend to point at). State —
   // not just createdRef — because the render must flip when it lands.
   const [createdForCaps, setCreatedForCaps] = useState<null | string>(null)
   const [caps, setCaps] = useState<CapabilityCatalog | null>(null)
@@ -721,7 +721,7 @@ export function CreateAgentDialog({ open, onClose, roster }: CreateAgentDialogPr
                   }
                 }}
                 options={
-                  SkillsView && (!remoteTarget || skillsViewRoutesConnections)
+                  CapabilitiesView && (!remoteTarget || capabilitiesViewRoutesConnections)
                     ? [
                         { id: 'general', label: 'General' },
                         { id: 'capabilities', label: 'Capabilities' }
@@ -814,9 +814,9 @@ export function CreateAgentDialog({ open, onClose, roster }: CreateAgentDialogPr
                   <div className="flex justify-center py-4">
                     <GlyphSpinner className="text-(--ui-text-tertiary)" spinner="breathe" />
                   </div>
-                ) : SkillsView ? (
+                ) : CapabilitiesView ? (
                   <ResizableFrame height={440} minHeight={280}>
-                    <SkillsView
+                    <CapabilitiesView
                       embedded
                       fixedProfile={createdForCaps}
                       {...(remoteTarget
diff --git a/apps/desktop/src/plugins/hermes-bots/group-test-utils.ts b/apps/desktop/src/plugins/hermes-bots/group-test-utils.ts
index 4594f43137..f537265e3a 100644
--- a/apps/desktop/src/plugins/hermes-bots/group-test-utils.ts
+++ b/apps/desktop/src/plugins/hermes-bots/group-test-utils.ts
@@ -442,7 +442,7 @@ export async function pluginSdkMock(host: Record<string, unknown>) {
     computed: nanostores.computed,
     createBudgetedLoop: undefined,
     host,
-    SkillsView: undefined,
+    CapabilitiesView: undefined,
     MessageTextContent: undefined,
     Streamdown: undefined,
     queryClient: { invalidateQueries: () => undefined },
diff --git a/apps/desktop/src/plugins/hermes-bots/legacy-sdk-compat.test.ts b/apps/desktop/src/plugins/hermes-bots/legacy-sdk-compat.test.ts
index acbf19c8ce..673364158a 100644
--- a/apps/desktop/src/plugins/hermes-bots/legacy-sdk-compat.test.ts
+++ b/apps/desktop/src/plugins/hermes-bots/legacy-sdk-compat.test.ts
@@ -1,7 +1,7 @@
 /**
  * Bot Mode has to keep linking against an OLDER desktop SDK.
  *
- * `McpTab`, `ToolsetConfigPanel` and `SkillsView` are capability exports: the
+ * `McpTab`, `ToolsetConfigPanel` and `CapabilitiesView` are capability exports: the
  * shell that hosts the plugin may predate any of them. Every use site is
  * therefore guarded, and the plugin module graph must evaluate — and still
  * hand back a registrable plugin — when all three are missing. A bare
@@ -12,7 +12,7 @@
 import { describe, expect, it, vi } from 'vitest'
 
 /** Names an older SDK is allowed not to export. */
-const OPTIONAL_CAPABILITY_EXPORTS = new Set(['McpTab', 'SkillsView', 'ToolsetConfigPanel'])
+const OPTIONAL_CAPABILITY_EXPORTS = new Set(['McpTab', 'CapabilitiesView', 'ToolsetConfigPanel'])
 
 vi.mock('@hermes/plugin-sdk', async () => {
   const { atom } = await import('nanostores')
@@ -65,13 +65,13 @@ describe('an SDK without the optional capability exports', () => {
     expect(typeof plugin.register).toBe('function')
   })
 
-  it('leaves the SkillsView connection-routing capability off', async () => {
-    // `skillsViewRoutesConnections` gates whether a source-scoped bot may open
-    // the Capabilities tab at all — with no SkillsView it must read false, not
+  it('leaves the CapabilitiesView connection-routing capability off', async () => {
+    // `capabilitiesViewRoutesConnections` gates whether a source-scoped bot may open
+    // the Capabilities tab at all — with no CapabilitiesView it must read false, not
     // throw on the missing export.
-    const { SkillsView, skillsViewRoutesConnections } = await import('./profile-config')
+    const { CapabilitiesView, capabilitiesViewRoutesConnections } = await import('./profile-config')
 
-    expect(SkillsView).toBeUndefined()
-    expect(skillsViewRoutesConnections).toBe(false)
+    expect(CapabilitiesView).toBeUndefined()
+    expect(capabilitiesViewRoutesConnections).toBe(false)
   })
 })
diff --git a/apps/desktop/src/plugins/hermes-bots/profile-config-capabilities.test.tsx b/apps/desktop/src/plugins/hermes-bots/profile-config-capabilities.test.tsx
index d46a01dbf5..226d1a59cb 100644
--- a/apps/desktop/src/plugins/hermes-bots/profile-config-capabilities.test.tsx
+++ b/apps/desktop/src/plugins/hermes-bots/profile-config-capabilities.test.tsx
@@ -1,13 +1,13 @@
 /**
  * The bot editor's Advanced section renders the REAL core Capabilities
- * surfaces — SkillsView (installed skills + hub installs + detail),
+ * surfaces — CapabilitiesView (installed skills + hub installs + detail),
  * ToolsetConfigPanel (per-toolset env/keys/model/post-setup) and McpTab
  * (per-server enable + OAuth + API keys) — pinned to the bot's own profile,
  * instead of bare checkbox stand-ins.
  *
  * All three are optional SDK namespace exports (hermes-agent#87317), so every
  * use site is feature-detected and older desktop builds keep the staged
- * checklist UI. The sharp edge is a REMOTE bot on a build whose SkillsView
+ * checklist UI. The sharp edge is a REMOTE bot on a build whose CapabilitiesView
  * predates `supportsFixedConnection`: rendering the live surface there would
  * read and write the ACTIVE gateway's skills under the remote bot's name —
  * the wrong machine — so those builds must fail closed to "staged only".
@@ -33,7 +33,7 @@ interface StubProps {
 
 /** The optional SDK exports, swapped per test to model each desktop build. */
 const sdk = vi.hoisted(() => {
-  const seen: Record<string, StubProps[]> = { McpTab: [], SkillsView: [], ToolsetConfigPanel: [] }
+  const seen: Record<string, StubProps[]> = { McpTab: [], CapabilitiesView: [], ToolsetConfigPanel: [] }
 
   const spy = (name: string) => {
     const Stub = (props: StubProps) => {
@@ -77,7 +77,7 @@ vi.mock('@hermes/plugin-sdk', async importOriginal => {
     usePluginI18n: () => translateBots
   }
 
-  for (const name of ['McpTab', 'SkillsView', 'ToolsetConfigPanel']) {
+  for (const name of ['McpTab', 'CapabilitiesView', 'ToolsetConfigPanel']) {
     Object.defineProperty(mocked, name, { configurable: true, enumerable: true, get: () => sdk.exports[name] })
   }
 
@@ -178,10 +178,10 @@ afterEach(() => {
   cleanup()
 })
 
-describe('a build whose SkillsView cannot route connections', () => {
+describe('a build whose CapabilitiesView cannot route connections', () => {
   const oldBuild = () => ({
     McpTab: sdk.spy('McpTab'),
-    SkillsView: sdk.spy('SkillsView'),
+    CapabilitiesView: sdk.spy('CapabilitiesView'),
     ToolsetConfigPanel: sdk.spy('ToolsetConfigPanel')
   })
 
@@ -191,7 +191,7 @@ describe('a build whose SkillsView cannot route connections', () => {
     // The model catalog settles first so the picker is past its spinner.
     expect(await screen.findByText('Provider')).toBeTruthy()
     expect(screen.getByText(/Remote capabilities require a newer desktop/)).toBeTruthy()
-    expect(sdk.seen.SkillsView).toHaveLength(0)
+    expect(sdk.seen.CapabilitiesView).toHaveLength(0)
     expect(sdk.seen.McpTab).toHaveLength(0)
     expect(sdk.seen.ToolsetConfigPanel).toHaveLength(0)
     expect(screen.queryByText('Skills Hub')).toBeNull()
@@ -228,38 +228,38 @@ describe('a build whose SkillsView cannot route connections', () => {
   })
 })
 
-describe('a connection-aware SkillsView', () => {
+describe('a connection-aware CapabilitiesView', () => {
   it('receives the connection and the BACKEND profile separately', async () => {
-    const Routed = sdk.spy('SkillsView')
+    const Routed = sdk.spy('CapabilitiesView')
 
     ;(Routed as unknown as { supportsFixedConnection: boolean }).supportsFixedConnection = true
 
-    await renderEditor({ SkillsView: Routed }, remoteBot)
+    await renderEditor({ CapabilitiesView: Routed }, remoteBot)
 
     // The alias's logical name is `default`; the backend row it activates into
     // is `backend-default`. Pinning the logical name would edit the wrong one.
-    expect(sdk.seen.SkillsView[0]).toMatchObject({
+    expect(sdk.seen.CapabilitiesView[0]).toMatchObject({
       fixedConnection: 'remote-a',
       fixedProfile: 'backend-default'
     })
   })
 
   it('#93492: degrades an orphaned row to its own name instead of throwing', async () => {
-    const Routed = sdk.spy('SkillsView')
+    const Routed = sdk.spy('CapabilitiesView')
 
     ;(Routed as unknown as { supportsFixedConnection: boolean }).supportsFixedConnection = true
 
     // A row whose owning connection was removed resolves to no route at all.
     // The editor renders on the render path, so a throw here would take the
     // whole pane down through the dialog's error boundary.
-    await renderEditor({ SkillsView: Routed }, { ...remoteBot, connectionId: '', route: undefined })
+    await renderEditor({ CapabilitiesView: Routed }, { ...remoteBot, connectionId: '', route: undefined })
 
-    expect(sdk.seen.SkillsView[0]).toEqual({ embedded: true, fixedProfile: 'default' })
+    expect(sdk.seen.CapabilitiesView[0]).toEqual({ embedded: true, fixedProfile: 'default' })
   })
 })
 
 describe('a build with no Capabilities exports at all', () => {
-  const bareBuild = { McpTab: undefined, SkillsView: undefined, ToolsetConfigPanel: undefined }
+  const bareBuild = { McpTab: undefined, CapabilitiesView: undefined, ToolsetConfigPanel: undefined }
 
   it('keeps the checkbox MCP list with its inline setup button', async () => {
     await renderEditor(bareBuild, localBot)
diff --git a/apps/desktop/src/plugins/hermes-bots/profile-config.test.ts b/apps/desktop/src/plugins/hermes-bots/profile-config.test.ts
index 2ddc99494e..34e7f0fdf7 100644
--- a/apps/desktop/src/plugins/hermes-bots/profile-config.test.ts
+++ b/apps/desktop/src/plugins/hermes-bots/profile-config.test.ts
@@ -64,7 +64,7 @@ vi.mock('@hermes/plugin-sdk', async () => {
     SelectItem: () => null,
     SelectTrigger: () => null,
     SelectValue: () => null,
-    SkillsView: undefined,
+    CapabilitiesView: undefined,
     surfaceModelSwitchConfirm: confirmMock,
     Textarea: () => null,
     ToolsetConfigPanel: undefined,
diff --git a/apps/desktop/src/plugins/hermes-bots/profile-config.tsx b/apps/desktop/src/plugins/hermes-bots/profile-config.tsx
index 18ab72da5e..a431bcfe9c 100644
--- a/apps/desktop/src/plugins/hermes-bots/profile-config.tsx
+++ b/apps/desktop/src/plugins/hermes-bots/profile-config.tsx
@@ -34,13 +34,13 @@ import type { RosterRow } from './types'
 // The Partial is the point: both are guarded at every use site because an older
 // build (or a stripped harness namespace) simply doesn't export them.
 const { McpTab, ToolsetConfigPanel }: Partial<Pick<typeof sdk, 'McpTab' | 'ToolsetConfigPanel'>> = sdk
-export const SkillsView = typeof sdk === 'undefined' ? undefined : sdk.SkillsView
-// TRUE only on builds whose SkillsView routes `fixedConnection` to the pinned
-// registry connection's backend. Older builds export SkillsView WITHOUT the
+export const CapabilitiesView = typeof sdk === 'undefined' ? undefined : sdk.CapabilitiesView
+// TRUE only on builds whose CapabilitiesView routes `fixedConnection` to the pinned
+// registry connection's backend. Older builds export CapabilitiesView WITHOUT the
 // prop — rendering it for a remote-target draft there would read/write the
 // ACTIVE gateway's skills under the remote bot's name (the wrong machine),
 // so those builds keep the staged checklists for remote targets.
-export const skillsViewRoutesConnections = Boolean(SkillsView && SkillsView.supportsFixedConnection)
+export const capabilitiesViewRoutesConnections = Boolean(CapabilitiesView && CapabilitiesView.supportsFixedConnection)
 
 // ── advanced profile config (skills / toolsets / model / SOUL) ──────────────
 //
@@ -255,7 +255,7 @@ export function AdvancedProfileConfig({ bot, state, setState }: AdvancedProfileC
   // Render THAT instead of the checkbox stand-ins; writes go straight to the
   // bot's backend, so the dirty-section staging below only carries
   // model + SOUL on these builds. Older builds keep the full checklist UI.
-  if (SkillsView && (!botRoute || skillsViewRoutesConnections)) {
+  if (CapabilitiesView && (!botRoute || capabilitiesViewRoutesConnections)) {
     return (
       <div className="grid gap-4">
         <ModelPicker
@@ -275,7 +275,7 @@ export function AdvancedProfileConfig({ bot, state, setState }: AdvancedProfileC
         {labeled(
           'Capabilities (applies immediately — skills, tools, MCP)',
           <ResizableFrame height={460} minHeight={300}>
-            <SkillsView
+            <CapabilitiesView
               embedded
               fixedProfile={backendProfile}
               {...(botRoute
@@ -304,7 +304,7 @@ export function AdvancedProfileConfig({ bot, state, setState }: AdvancedProfileC
     )
   }
 
-  if (bot?.sourceScoped && botRoute?.mode === 'remote' && !skillsViewRoutesConnections) {
+  if (bot?.sourceScoped && botRoute?.mode === 'remote' && !capabilitiesViewRoutesConnections) {
     return (
       <div className="grid gap-4">
         <ModelPicker
diff --git a/apps/desktop/src/sdk/index.ts b/apps/desktop/src/sdk/index.ts
index 229a219ea8..1d401ac276 100644
--- a/apps/desktop/src/sdk/index.ts
+++ b/apps/desktop/src/sdk/index.ts
@@ -1538,6 +1538,24 @@ export const host = {
 
 // -- react bridge -------------------------------------------------------------
 
+/** THE whole Capabilities surface (Skills / Tools / MCP tabs, installed
+ *  lists, full-skill detail pane, embedded hub picker with one-click
+ *  installs). For plugin dialogs pass `embedded` (tab state stays local —
+ *  never touches the page router) and `fixedProfile` to pin every tab to one
+ *  bot's backend; the internal profile selector hides itself. Add
+ *  `fixedConnection` (registry connection id) to pin a bot living on another
+ *  registered gateway — probe `CapabilitiesView.supportsFixedConnection` first;
+ *  builds without it would route the pin to the ACTIVE gateway. Bot Mode's
+ *  Advanced section is the reference consumer. */
+export { CapabilitiesView } from '@/app/capabilities'
+
+// -- ui: the design language --------------------------------------------------
+
+/** THE full MCP tab core Settings renders — per-server enable + OAuth sign-in
+ *  + API-key setup + live probes, not a checkbox list. Route-decoupled so it
+ *  renders anywhere (a plugin dialog); pass a live `gateway` (see
+ *  `host.getGateway()`) and an optional `profile` to scope it to one bot. */
+export { McpTab } from '@/app/capabilities/mcp/mcp-tab'
 // Every contribution surface, plugin-reachable: register keybinds, palette
 // commands, routes, themes, panes, composer extensions, and bar items with
 // the same area ids + payload types core uses.
@@ -1548,9 +1566,6 @@ export {
   type ComposerAttachmentProvider,
   type ComposerMiddleware
 } from '@/app/chat/composer/contrib'
-
-// -- ui: the design language --------------------------------------------------
-
 /** THE session status dot — the one primitive the sidebar row, the pane tabs
  *  and the session switcher render, so a session's status can never disagree
  *  between surfaces. Pass the STORED session id and it resolves the rest
@@ -1628,21 +1643,6 @@ export {
 } from '@/app/shell/model-catalog-menu'
 export type { StatusbarItem } from '@/app/shell/statusbar-controls'
 export type { TitlebarTool } from '@/app/shell/titlebar-controls'
-/** THE whole Capabilities surface (Skills / Tools / MCP tabs, installed
- *  lists, full-skill detail pane, embedded hub picker with one-click
- *  installs). For plugin dialogs pass `embedded` (tab state stays local —
- *  never touches the page router) and `fixedProfile` to pin every tab to one
- *  bot's backend; the internal profile selector hides itself. Add
- *  `fixedConnection` (registry connection id) to pin a bot living on another
- *  registered gateway — probe `SkillsView.supportsFixedConnection` first;
- *  builds without it would route the pin to the ACTIVE gateway. Bot Mode's
- *  Advanced section is the reference consumer. */
-export { SkillsView } from '@/app/skills'
-/** THE full MCP tab core Settings renders — per-server enable + OAuth sign-in
- *  + API-key setup + live probes, not a checkbox list. Route-decoupled so it
- *  renders anywhere (a plugin dialog); pass a live `gateway` (see
- *  `host.getGateway()`) and an optional `profile` to scope it to one bot. */
-export { McpTab } from '@/app/skills/mcp-tab'
 /** Canonical raw message renderer: applies Desktop message transforms (including
  * `MEDIA:` delivery directives) and the same rich Markdown/media components as
  * core chat. Prefer this over raw Streamdown for transcript-style messages. */
diff --git a/apps/desktop/src/store/confirm.ts b/apps/desktop/src/store/confirm.ts
index d1918bdaf5..6fd6fa46d0 100644
--- a/apps/desktop/src/store/confirm.ts
+++ b/apps/desktop/src/store/confirm.ts
@@ -4,68 +4,34 @@ export interface ConfirmRequest {
   title: string
   description?: string
   confirmLabel?: string
-  busyLabel?: string
-  doneLabel?: string
-  details?: { label: string; value: string }[]
-  onConfirm?: () => Promise<void>
   cancelLabel?: string
   destructive?: boolean
 }
 
 export interface PendingConfirm extends ConfirmRequest {
-  id: number
   resolve: (confirmed: boolean) => void
-  phase?: 'running' | 'done'
 }
 
 export const $confirmRequest = atom<null | PendingConfirm>(null)
-let nextRequestId = 0
 
 // Imperative front door to ConfirmDialog, for handlers that want the answer
-// inline the way window.confirm gave it — `if (!ok) return`. Pass onConfirm
-// to use the shared dialog's progress, completion and inline error states.
+// inline the way window.confirm gave it — `if (!ok) return`. A surface that
+// wants the busy → done beat or an inline error should mount <ConfirmDialog>
+// itself and hand it the async onConfirm.
 export function confirm(request: ConfirmRequest): Promise<boolean> {
-  // An action already in progress must not lose its owner or completion UI.
-  if ($confirmRequest.get()?.phase) {
-    return Promise.resolve(false)
-  }
-
-  // One modal at a time: a second ask supersedes an unanswered question.
+  // One modal at a time: a second ask supersedes the first, which answers no.
   settleConfirm(false)
 
   return new Promise<boolean>(resolve => {
-    $confirmRequest.set({ ...request, id: ++nextRequestId, resolve })
+    $confirmRequest.set({ ...request, resolve })
   })
 }
 
-/** Run the captured request, not a replacement that arrived during I/O. */
-export async function runConfirm(pending: PendingConfirm): Promise<void> {
-  if ($confirmRequest.get() !== pending || pending.phase) {
-    return
-  }
-
-  if (!pending.onConfirm) {
-    settleConfirm(true, pending)
-
-    return
-  }
-
-  pending.phase = 'running'
-
-  try {
-    await pending.onConfirm()
-    pending.phase = 'done'
-  } catch (error) {
-    delete pending.phase
-    throw error
-  }
-}
-
 /** Answer the open request, if there still is one. Idempotent. */
-export function settleConfirm(confirmed: boolean, expected?: PendingConfirm): void {
+export function settleConfirm(confirmed: boolean): void {
   const pending = $confirmRequest.get()
 
-  if (!pending || pending.phase === 'running' || (expected && pending !== expected)) {
+  if (!pending) {
     return
   }
 
diff --git a/apps/desktop/src/store/gateway-activation-prune-lease.test.ts b/apps/desktop/src/store/gateway-activation-prune-lease.test.ts
index 184f75f5ed..c38f2fa41e 100644
--- a/apps/desktop/src/store/gateway-activation-prune-lease.test.ts
+++ b/apps/desktop/src/store/gateway-activation-prune-lease.test.ts
@@ -53,7 +53,8 @@ const {
   ensureGatewayForAgent,
   ensureGatewayForProfile,
   pruneSecondaryGateways,
-  setPrimaryGateway
+  setPrimaryGateway,
+  SECONDARY_MIN_LIFETIME_MS
 } = await import('./gateway')
 
 function installDesktop(): void {
@@ -152,7 +153,11 @@ describe('activation lease vs. the live-work pruner (#89622)', () => {
     // lease released, the idle entry must be disposed exactly as before.
     await ensureGatewayForProfile('default')
 
+    // Age the socket past the min-lifetime grace so this prune asserts the
+    // lease release, not the freshly-opened spare (#94769).
+    vi.useFakeTimers({ now: Date.now() + SECONDARY_MIN_LIFETIME_MS + 1_000 })
     pruneSecondaryGateways(new Set())
+    vi.useRealTimers()
 
     expect(secondaryGateways[0].close).toHaveBeenCalled()
   })
@@ -176,10 +181,35 @@ describe('activation lease vs. the live-work pruner (#89622)', () => {
 
     // Past the lease window: reclaimed. (Lease is wall-clock bounded so a
     // leaked lease cannot pin a dead entry forever.)
-    vi.setSystemTime(Date.now() + 31_000)
+    vi.setSystemTime(Date.now() + SECONDARY_MIN_LIFETIME_MS + 1_000)
     pruneSecondaryGateways(new Set())
     expect(secondaryGateways[0].close).toHaveBeenCalled()
 
     releaseConnect()
   })
+
+  it('a freshly opened idle secondary rides one prune tick before reaping (#94769)', async () => {
+    vi.useFakeTimers()
+
+    // A socket that just opened is a prune ↔ on-demand-dial race in the making:
+    // its consumer may not have registered in the keep-set yet, and closing it
+    // detaches the runtime → backend orphan-reap → `session.reclaimed` →
+    // re-resume on a fresh socket the next recompute closes again. The
+    // min-lifetime grace bounds that race without pinning the entry forever.
+    await ensureGatewayForProfile('bot')
+    expect(secondaryGateways[0].connectionState).toBe('open')
+
+    // Move away so 'bot' is neither active nor in the keep-set.
+    await ensureGatewayForProfile('default')
+    expect(secondaryGateways).toHaveLength(1)
+
+    // Immediately after open: spared by the grace window.
+    pruneSecondaryGateways(new Set())
+    expect(secondaryGateways[0].close).not.toHaveBeenCalled()
+
+    // Past the grace window: reclaimed as idle, as before.
+    vi.setSystemTime(Date.now() + SECONDARY_MIN_LIFETIME_MS + 1_000)
+    pruneSecondaryGateways(new Set())
+    expect(secondaryGateways[0].close).toHaveBeenCalled()
+  })
 })
diff --git a/apps/desktop/src/store/gateway-connection-lifecycle.test.ts b/apps/desktop/src/store/gateway-connection-lifecycle.test.ts
index 6b2c7fa382..155341c930 100644
--- a/apps/desktop/src/store/gateway-connection-lifecycle.test.ts
+++ b/apps/desktop/src/store/gateway-connection-lifecycle.test.ts
@@ -1,5 +1,8 @@
+import { JsonRpcGatewayError } from '@hermes/shared'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
+import { LIVENESS_REPROBE_DELAY_MS } from '@/lib/gateway-liveness-policy'
+
 // Connection lifecycle for registry-scoped secondary gateways:
 //
 //  1. Removing a connection must dispose its secondaries — remote/cloud
@@ -13,7 +16,11 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 //     the entry instead of retrying forever.
 
 const gatewayMocks = vi.hoisted(() => {
-  const instances: { close: ReturnType<typeof vi.fn>; connectionState: string }[] = []
+  const instances: {
+    close: ReturnType<typeof vi.fn>
+    request: ReturnType<typeof vi.fn>
+    connectionState: string
+  }[] = []
 
   return {
     connect: vi.fn(async (_wsUrl: string): Promise<void> => undefined),
@@ -38,6 +45,7 @@ vi.mock('@/hermes', () => ({
       await gatewayMocks.connect(wsUrl)
       this.connectionState = 'open'
     }
+    request = vi.fn(async (_method: string, _params: Record<string, unknown>) => ({}))
     onEvent = vi.fn((handler: (event: unknown) => void) => {
       gatewayMocks.eventHandlers.push(handler)
 
@@ -71,10 +79,12 @@ const {
   parkSecondariesForRetiredBackend,
   pruneSecondaryGateways,
   reconnectSecondaryGateways,
+  requestGatewayForAgent,
   retainGatewayForAgent,
   retainGatewayForSessionTurn,
   retireLocalProfileGateways,
-  setPrimaryGateway
+  setPrimaryGateway,
+  SECONDARY_MIN_LIFETIME_MS
 } = await import('./gateway')
 
 function installDesktop(stub: Record<string, unknown>): void {
@@ -318,7 +328,12 @@ describe('secondary reconnect runtime scope', () => {
 
     await openGatewayForAgent('homelab', 'writer')
     const firstSocket = gatewayMocks.instances[0]
+
+    // Age the socket past the min-lifetime grace so this prune exercises the
+    // stale-binding invalidation path, not the freshly-opened spare (#94769).
+    vi.useFakeTimers({ now: Date.now() + SECONDARY_MIN_LIFETIME_MS + 1_000 })
     pruneSecondaryGateways(new Set())
+    vi.useRealTimers()
     expect(firstSocket.close).toHaveBeenCalledOnce()
 
     let finishReconnect!: () => void
@@ -436,6 +451,99 @@ describe('reconnectSecondaryGateways', () => {
     expect(getConnectionFor).toHaveBeenCalledTimes(2)
     expect(gatewayMocks.instances[0].connectionState).toBe('open')
   })
+
+  it('spares a foreground-pinned secondary from the forced wake redial (#94769)', async () => {
+    // A forced wake (power resume / network online) closing a socket a mounted
+    // surface is bound to detaches its runtime → backend orphan-reap →
+    // `session.reclaimed` → re-resume on a fresh socket the same signal may
+    // close again: the reconnect/remount flicker loop. The registry's
+    // foregroundScopes hook is the same pin the live-work pruner honors.
+    configureGatewayRegistry({
+      onEvent: vi.fn(),
+      foregroundScopes: () => new Set(['conn:homelab::default'])
+    } as never)
+
+    const getConnectionFor = vi.fn(async ({ connectionId, profile }: { connectionId: string; profile: string }) =>
+      descriptorFor(connectionId, profile)
+    )
+
+    installDesktop({ getConnectionFor })
+
+    await ensureGatewayForAgent('homelab', 'default')
+    expect(gatewayMocks.instances[0].connectionState).toBe('open')
+
+    reconnectSecondaryGateways({ forceOpenSockets: true })
+    await Promise.resolve()
+
+    expect(gatewayMocks.instances[0].close).not.toHaveBeenCalled()
+    expect(gatewayMocks.instances[0].connectionState).toBe('open')
+    expect(getConnectionFor).toHaveBeenCalledTimes(1)
+  })
+
+  it('closes a live-in-use secondary on a forced wake only when its liveness probe fails', async () => {
+    // A half-open socket never fires a close event, so skipping it would strand
+    // an in-flight request until its per-call timeout (30 min for
+    // prompt.submit). The wake path probes instead: a dead transport is
+    // closed; a healthy one — including a version-skewed backend answering
+    // -32601 — keeps its socket (#94769 review).
+    // The foreground turn is in flight on this scope. prompt.submit has long
+    // since returned (turn completion arrives as stream events), so the entry
+    // shows no counted request — the registry's live-scope hook is what tells
+    // the probe there is work to protect.
+    configureGatewayRegistry({
+      onEvent: vi.fn(),
+      foregroundScopes: () => new Set(['conn:homelab::default']),
+      liveScopes: () => new Set(['conn:homelab::default'])
+    } as never)
+
+    const getConnectionFor = vi.fn(async ({ connectionId, profile }: { connectionId: string; profile: string }) =>
+      descriptorFor(connectionId, profile)
+    )
+
+    installDesktop({ getConnectionFor })
+
+    await ensureGatewayForAgent('homelab', 'default')
+    const socket = gatewayMocks.instances[0]
+    expect(socket.connectionState).toBe('open')
+
+    // Healthy version-skewed backend: -32601 (method not found) is a live
+    // answer, not a dead socket — the same carve-out the primary's probe
+    // makes. The socket stays open.
+    socket.request = vi.fn(async () => {
+      throw new JsonRpcGatewayError('Method not found', { code: -32601 })
+    })
+
+    reconnectSecondaryGateways({ forceOpenSockets: true })
+    await Promise.resolve()
+    await Promise.resolve()
+
+    expect(socket.close).not.toHaveBeenCalled()
+    expect(socket.connectionState).toBe('open')
+
+    // Mid-turn, the backend — alive, but starved past the probe budget by a
+    // long tool call — cannot answer the ping. ONE unanswered probe must NOT
+    // close it: force-closing feeds the backend's ws_orphan_reap and
+    // interrupts the valid turn (#94769 review). The first failure defers
+    // behind a bounded re-probe.
+    vi.useFakeTimers()
+    socket.request = vi.fn(async () => {
+      throw new Error('probe timeout')
+    })
+
+    reconnectSecondaryGateways({ forceOpenSockets: true })
+    await vi.advanceTimersByTimeAsync(0)
+
+    expect(socket.close).not.toHaveBeenCalled()
+    expect(socket.connectionState).toBe('open')
+
+    // The bounded re-probe also goes unanswered: the failure streak is
+    // exhausted and the socket is torn down so its reconnect backoff can
+    // heal it — a persistently unresponsive backend is never trusted forever.
+    await vi.advanceTimersByTimeAsync(LIVENESS_REPROBE_DELAY_MS)
+
+    expect(socket.close).toHaveBeenCalledOnce()
+    expect(socket.connectionState).toBe('closed')
+  })
 })
 
 describe('reconnect fail-stop on a removed connection', () => {
@@ -866,12 +974,12 @@ describe('cooperative pool retirement (supersedes #104871)', () => {
   })
 })
 
-
 describe('rejected secondary authentication', () => {
   it('parks only the rejected source across automatic nudges and recovers on explicit selection', async () => {
     vi.useFakeTimers()
     const getConnectionFor = vi.fn(async ({ connectionId, profile }: { connectionId: string; profile: string }) => ({
-      ...descriptorFor(connectionId, profile), authMode: 'oauth'
+      ...descriptorFor(connectionId, profile),
+      authMode: 'oauth'
     }))
     const getGatewayWsUrlFor = vi.fn(async () => ({ ok: true, wsUrl: 'wss://cloud.invalid/api/ws?ticket=fresh' }))
     installDesktop({ getConnectionFor, getGatewayWsUrlFor })
@@ -900,7 +1008,8 @@ describe('rejected secondary authentication', () => {
     vi.useFakeTimers()
 
     const getConnectionFor = vi.fn(async ({ connectionId, profile }: { connectionId: string; profile: string }) => ({
-      ...descriptorFor(connectionId, profile), authMode: 'oauth'
+      ...descriptorFor(connectionId, profile),
+      authMode: 'oauth'
     }))
 
     const getGatewayWsUrlFor = vi.fn(async () => ({ ok: true, wsUrl: 'wss://cloud.invalid/api/ws?ticket=fresh' }))
@@ -922,11 +1031,11 @@ describe('rejected secondary authentication', () => {
   })
 })
 
-
 it('keeps background auth rejection after socket disposal until recovery or connection removal', async () => {
   const { requestGatewayForAgent } = await import('./gateway')
   const getConnectionFor = vi.fn(async ({ connectionId, profile }: { connectionId: string; profile: string }) => ({
-    ...descriptorFor(connectionId, profile), authMode: 'oauth'
+    ...descriptorFor(connectionId, profile),
+    authMode: 'oauth'
   }))
   const getGatewayWsUrlFor = vi.fn(async () => ({ ok: false, needsOauthLogin: true, error: 'Sign in again' }))
   installDesktop({ getConnectionFor, getGatewayWsUrlFor })
@@ -946,14 +1055,16 @@ it('keeps background auth rejection after socket disposal until recovery or conn
   expect(getGatewayWsUrlFor).toHaveBeenCalledTimes(3)
 })
 
-
 it('does not let a removed connection repopulate the auth rejection', async () => {
   const { requestGatewayForAgent } = await import('./gateway')
   const getConnectionFor = vi.fn(async ({ connectionId, profile }: { connectionId: string; profile: string }) => ({
-    ...descriptorFor(connectionId, profile), authMode: 'oauth'
+    ...descriptorFor(connectionId, profile),
+    authMode: 'oauth'
   }))
   let rejectTicket!: (error: Error) => void
-  const ticket = new Promise<never>((_resolve, reject) => { rejectTicket = reject })
+  const ticket = new Promise<never>((_resolve, reject) => {
+    rejectTicket = reject
+  })
   const getGatewayWsUrlFor = vi.fn(() => ticket)
   installDesktop({ getConnectionFor, getGatewayWsUrlFor })
   const pending = requestGatewayForAgent('cloud', 'default', 'session.list')
diff --git a/apps/desktop/src/store/gateway-connection-scope.test.ts b/apps/desktop/src/store/gateway-connection-scope.test.ts
index 5fb959a00b..c043675e1b 100644
--- a/apps/desktop/src/store/gateway-connection-scope.test.ts
+++ b/apps/desktop/src/store/gateway-connection-scope.test.ts
@@ -49,7 +49,8 @@ const {
   openGatewayForAgent,
   pruneSecondaryGateways,
   setPrimaryGateway,
-  setPrimaryGatewayConnectionId
+  setPrimaryGatewayConnectionId,
+  SECONDARY_MIN_LIFETIME_MS
 } = await import('./gateway')
 
 const { setApiRequestConnection } = await import('@/hermes')
@@ -129,6 +130,15 @@ describe('primary gateway registry scope', () => {
 })
 
 describe('pruneSecondaryGateways with registry-scoped entries', () => {
+  // The min-lifetime grace (#94769) spares a freshly opened idle socket for
+  // one prune tick, so reclamation assertions age the socket past the grace
+  // window first; spare assertions are unaffected by aging.
+  const pruneAged = (keep?: Set<string>) => {
+    vi.useFakeTimers({ now: Date.now() + SECONDARY_MIN_LIFETIME_MS + 1_000 })
+    pruneSecondaryGateways(keep ?? new Set())
+    vi.useRealTimers()
+  }
+
   it('keeps the previous source socket open when Sessions switches backends', async () => {
     await ensureGatewayForAgent('work', 'default')
     await ensureGatewayForAgent('homelab', 'default')
@@ -144,7 +154,7 @@ describe('pruneSecondaryGateways with registry-scoped entries', () => {
     // LOCAL source has live work; that must not pin homelab's socket.
     await openGatewayForAgent('homelab', 'default')
 
-    pruneSecondaryGateways(new Set(['default']))
+    pruneAged(new Set(['default']))
 
     expect(gatewayMocks.closed).toEqual(['wss://homelab.invalid/api/ws?profile=default'])
   })
@@ -172,11 +182,11 @@ describe('pruneSecondaryGateways with registry-scoped entries', () => {
   it('still keeps a local (profile-keyed) secondary via its bare profile name', async () => {
     await openGatewayForAgent(null, 'research')
 
-    pruneSecondaryGateways(new Set(['research']))
+    pruneAged(new Set(['research']))
 
     expect(gatewayMocks.closed).toEqual([])
 
-    pruneSecondaryGateways(new Set())
+    pruneAged()
 
     expect(gatewayMocks.closed).toHaveLength(1)
   })
@@ -189,7 +199,7 @@ describe('pruneSecondaryGateways with registry-scoped entries', () => {
     await openGatewayForAgent(null, 'default')
     await openGatewayForAgent('homelab', 'default')
 
-    pruneSecondaryGateways(new Set(['conn:homelab::default']))
+    pruneAged(new Set(['conn:homelab::default']))
 
     expect(gatewayMocks.closed).toEqual(['wss://local.invalid/api/ws?token=t'])
   })
diff --git a/apps/desktop/src/store/gateway-foreground-retention.test.ts b/apps/desktop/src/store/gateway-foreground-retention.test.ts
index baf801bdf2..b51eb01ef8 100644
--- a/apps/desktop/src/store/gateway-foreground-retention.test.ts
+++ b/apps/desktop/src/store/gateway-foreground-retention.test.ts
@@ -41,7 +41,8 @@ const {
   openGatewayForAgent,
   pruneSecondaryGateways,
   requestGatewayForAgent,
-  setPrimaryGateway
+  setPrimaryGateway,
+  SECONDARY_MIN_LIFETIME_MS
 } = await import('./gateway')
 
 const { $sessionTiles, foregroundSessionScopes, liveSessionScopes } = await import('./session-states')
@@ -97,6 +98,15 @@ afterEach(() => {
 })
 
 describe('foreground tile retention vs. the live-work pruner (#93892)', () => {
+  // The min-lifetime grace (#94769) spares a freshly opened idle socket for
+  // one prune tick, so reclamation assertions age the socket past the grace
+  // window first; spare assertions are unaffected by aging.
+  const pruneAged = () => {
+    vi.useFakeTimers({ now: Date.now() + SECONDARY_MIN_LIFETIME_MS + 1_000 })
+    pruneSecondaryGateways(idleKeepSet())
+    vi.useRealTimers()
+  }
+
   it('keeps an idle Bot Chat tile’s owner socket across prune recomputes', async () => {
     // The BOTS workspace dials the bot's own backend without activating it
     // (keepAllProfilesScope) and opens the canonical chat as a tile on that
@@ -107,8 +117,8 @@ describe('foreground tile retention vs. the live-work pruner (#93892)', () => {
     // Idle: no working / needs-input session anywhere. Before the fix this
     // recompute closed the socket → backend reaped the runtime → reclaim →
     // unbind → resume → … forever.
-    pruneSecondaryGateways(idleKeepSet())
-    pruneSecondaryGateways(idleKeepSet())
+    pruneAged()
+    pruneAged()
 
     expect(gatewayMocks.closed).toEqual([])
   })
@@ -117,7 +127,7 @@ describe('foreground tile retention vs. the live-work pruner (#93892)', () => {
     await openGatewayForAgent('local', 'bot')
     $sessionTiles.set([{ ...BOT_TILE, runtimeId: undefined }])
 
-    pruneSecondaryGateways(idleKeepSet())
+    pruneAged()
 
     expect(gatewayMocks.closed).toEqual([])
   })
@@ -125,11 +135,11 @@ describe('foreground tile retention vs. the live-work pruner (#93892)', () => {
   it('releases the socket once the tile is closed — the pin never latches', async () => {
     await openGatewayForAgent('local', 'bot')
     $sessionTiles.set([BOT_TILE])
-    pruneSecondaryGateways(idleKeepSet())
+    pruneAged()
     expect(gatewayMocks.closed).toEqual([])
 
     $sessionTiles.set([])
-    pruneSecondaryGateways(idleKeepSet())
+    pruneAged()
 
     expect(gatewayMocks.closed).toEqual(['wss://local.invalid/api/ws?profile=bot'])
   })
@@ -161,7 +171,7 @@ describe('foreground tile retention vs. the live-work pruner (#93892)', () => {
     // the same `retained` flag; with no tile bound to it, it is idle garbage.
     await openGatewayForAgent('local', 'bot')
 
-    pruneSecondaryGateways(idleKeepSet())
+    pruneAged()
 
     expect(gatewayMocks.closed).toEqual(['wss://local.invalid/api/ws?profile=bot'])
   })
@@ -170,7 +180,7 @@ describe('foreground tile retention vs. the live-work pruner (#93892)', () => {
     await openGatewayForAgent('homelab', 'bot')
     $sessionTiles.set([BOT_TILE])
 
-    pruneSecondaryGateways(idleKeepSet())
+    pruneAged()
 
     expect(gatewayMocks.closed).toEqual(['wss://homelab.invalid/api/ws?profile=bot'])
   })
diff --git a/apps/desktop/src/store/gateway.ts b/apps/desktop/src/store/gateway.ts
index 81c49a688c..d318c3df3a 100644
--- a/apps/desktop/src/store/gateway.ts
+++ b/apps/desktop/src/store/gateway.ts
@@ -12,6 +12,12 @@ import { atom } from 'nanostores'
 import type { HermesConnection } from '@/global'
 import { HermesGateway, setApiRequestConnection } from '@/hermes'
 import { translateNow } from '@/i18n'
+import {
+  decideLivenessForceClose,
+  LIVENESS_PROBE_TIMEOUT_MS,
+  LIVENESS_REPROBE_DELAY_MS
+} from '@/lib/gateway-liveness-policy'
+import { isMissingRpcMethod } from '@/lib/gateway-rpc'
 import { isTimeoutError, RECONNECT_ATTEMPT_TIMEOUT_MS, withTimeout } from '@/lib/with-timeout'
 import { notifyError, RECOVERY_ACTIONS } from '@/store/notifications'
 import { markNativeNotifyBaseline } from '@/store/notify-baseline'
@@ -92,6 +98,14 @@ interface RegistryConfig {
    * follows the tile set, so closing the tile releases the socket.
    */
   foregroundScopes?: () => ReadonlySet<string>
+  /**
+   * Scopes with a running or needs-input session runtime, in the same key
+   * language as `foregroundScopes` (composite registry keys, bare profiles
+   * for local/legacy entries). The wake-path liveness probe counts these as
+   * in-flight work: prompt.submit returns before the turn ends, so
+   * `activeRequests` is 0 during most of a turn.
+   */
+  liveScopes?: () => ReadonlySet<string>
 }
 
 // ── Secondary (pool) backends ──────────────────────────────────────────────
@@ -103,8 +117,14 @@ interface Secondary {
   connectionId: null | string
   connection: HermesConnection | null
   gateway: HermesGateway
-  /** True after this entry completed at least one socket connection. */
-  openedOnce: boolean
+  /**
+   * Date.now() of the most recent socket 'open'. The live-work pruner's
+   * min-lifetime grace reads this: an idle prune can race an on-demand dial
+   * (prune → redial → prune) and close freshly opened sockets before their
+   * consumer registers in the keep-set, re-triggering the orphan-reap /
+   * remount loop (#94769). 0 = never opened.
+   */
+  lastOpenedAt: number
   activeRequests: number
   connectPromise: Promise<void> | null
   offEvent: () => void
@@ -112,6 +132,15 @@ interface Secondary {
   offState: () => void
   reconnectTimer: ReturnType<typeof setTimeout> | null
   reconnectAttempt: number
+  /**
+   * Consecutive unanswered wake-probe pings on this entry's current socket;
+   * drives the same streak tolerance the primary's probe applies
+   * (decideLivenessForceClose). Reset on every answered probe and on every
+   * fresh socket open.
+   */
+  livenessProbeFailures: number
+  /** Pending deferred liveness re-probe after an in-flight-work deferral. */
+  livenessReprobeTimer: ReturnType<typeof setTimeout> | null
   /** Consecutive automatic dials that stalled (slot wait / dial timeout)
    *  rather than failing fast; see SECONDARY_STALLED_DIAL_BUDGET. */
   stalledDials: number
@@ -653,7 +682,7 @@ async function openSecondary(entry: Secondary, spawnPriority: SpawnPriority = 'b
     // open. Awaiting it is intentional: correctness at the generation boundary
     // outranks the single local-module microtask this adds to a reconnect.
     const openedScopes = openedSecondaryScopes()
-    const reopening = entry.openedOnce || entry.connection !== null || openedScopes.has(entry.scope)
+    const reopening = entry.lastOpenedAt > 0 || entry.connection !== null || openedScopes.has(entry.scope)
     let reconcileBusyAfterOpen: null | (() => void) = null
 
     if (reopening) {
@@ -725,7 +754,10 @@ async function openSecondary(entry: Secondary, spawnPriority: SpawnPriority = 'b
       throw error
     }
 
-    entry.openedOnce = true
+    entry.lastOpenedAt = Date.now()
+    // A fresh socket owes nothing to a previous socket's missed pings.
+    entry.livenessProbeFailures = 0
+    clearSecondaryLivenessReprobe(entry)
     openedScopes.add(entry.scope)
 
     try {
@@ -907,7 +939,7 @@ function createSecondary(profile: string, connectionId: null | string = null): S
     connectionId,
     connection: null,
     gateway,
-    openedOnce: false,
+    lastOpenedAt: 0,
     activeRequests: 0,
     connectPromise: null,
     offEvent: () => {},
@@ -915,6 +947,8 @@ function createSecondary(profile: string, connectionId: null | string = null): S
     offState: () => {},
     reconnectTimer: null,
     reconnectAttempt: 0,
+    livenessProbeFailures: 0,
+    livenessReprobeTimer: null,
     stalledDials: 0,
     reconnecting: false,
     pendingConnectionRedial: false,
@@ -1891,6 +1925,97 @@ export async function ensureActiveGatewayOpen({ explicit = false }: { explicit?:
 // activation before reporting the gateway as unavailable.
 const ACTIVE_GATEWAY_OPEN_WAIT_MS = 8_000
 
+// Grace period before the live-work pruner may dispose a freshly opened
+// secondary socket; see the min-lifetime guard in pruneSecondaryGateways
+// (#94769 prune ↔ redial race). Exported for the tests that age a socket past it.
+export const SECONDARY_MIN_LIFETIME_MS = 30_000
+
+// A deferred liveness re-probe for one entry: cleared when the probe is
+// answered, the socket is redialed (fresh streak), or the entry is disposed.
+function clearSecondaryLivenessReprobe(entry: Secondary): void {
+  if (entry.livenessReprobeTimer !== null) {
+    clearTimeout(entry.livenessReprobeTimer)
+    entry.livenessReprobeTimer = null
+  }
+}
+
+// Probe a live-in-use secondary instead of blind-closing it on a forced wake,
+// and close it only when the probe proves it not alive. A half-open TCP
+// connection (sleep/wake, silent network drop) reports connectionState
+// 'open' forever and fires no close event, so without this close an in-flight
+// request rides a dead transport until its per-call timeout — prompt.submit's
+// is 30 minutes. Closing arms the entry's ordinary reconnect backoff via its
+// onState('closed') handler; a healthy-but-busy backend answers the ping and
+// keeps its socket (#94769 review).
+function probeSecondaryLiveness(entry: Secondary): void {
+  void entry.gateway.request('ping', {}, LIVENESS_PROBE_TIMEOUT_MS).then(
+    () => {
+      entry.livenessProbeFailures = 0
+      clearSecondaryLivenessReprobe(entry)
+    },
+    (error: unknown) => {
+      // -32601 (method not found) = a version-skewed but HEALTHY backend that
+      // predates the ping method — the same compatibility carve-out the
+      // primary's probe makes in use-gateway-boot.
+      if (isMissingRpcMethod(error)) {
+        entry.livenessProbeFailures = 0
+        clearSecondaryLivenessReprobe(entry)
+
+        return
+      }
+
+      // The entry may have been pruned or redialed while the probe was
+      // pending; only the very same socket may be torn down.
+      if (g.secondaries.get(entry.scope) !== entry || !isOpen(entry.gateway)) {
+        return
+      }
+
+      // ONE missed ping is not proof of death: a live backend mid tool call
+      // can starve its event loop past the probe budget, and force-closing it
+      // feeds the backend's ws_orphan_reap, interrupting the valid turn
+      // (#94769 review). Apply the SAME streak policy as the primary's probe
+      // (decideLivenessForceClose): defer the first failure while work is
+      // in flight behind a bounded re-probe, close only when the streak is
+      // exhausted — or immediately when nothing is in flight to protect.
+      entry.livenessProbeFailures += 1
+
+      // Counted RPCs alone under-report in-flight work: prompt.submit returns
+      // before the turn ends, so a foreground turn mid tool call shows
+      // activeRequests 0. The registry's live-scope hook supplies the turn.
+      const liveScopes = g.config?.liveScopes?.()
+      const turnInFlight =
+        liveScopes && (liveScopes.has(entry.scope) || (!entry.connectionId && liveScopes.has(entry.profile))) ? 1 : 0
+
+      const decision = decideLivenessForceClose({
+        workingSessionCount: entry.activeRequests + turnInFlight,
+        consecutiveFailures: entry.livenessProbeFailures
+      })
+
+      if (!decision.close) {
+        if (entry.livenessReprobeTimer === null) {
+          entry.livenessReprobeTimer = setTimeout(() => {
+            entry.livenessReprobeTimer = null
+
+            // The entry may have been pruned or redialed while the re-probe
+            // waited; only the same open socket may be probed again.
+            if (g.secondaries.get(entry.scope) !== entry || !isOpen(entry.gateway)) {
+              return
+            }
+
+            probeSecondaryLiveness(entry)
+          }, LIVENESS_REPROBE_DELAY_MS)
+        }
+
+        return
+      }
+
+      entry.livenessProbeFailures = 0
+      clearSecondaryLivenessReprobe(entry)
+      entry.gateway.close()
+    }
+  )
+}
+
 // Recovery signal: nudge every live secondary back open. Power-resume/network
 // signals can force sockets that still report open to retire before redialing.
 export function reconnectSecondaryGateways({ forceOpenSockets = false }: { forceOpenSockets?: boolean } = {}): void {
@@ -1912,6 +2037,21 @@ export function reconnectSecondaryGateways({ forceOpenSockets = false }: { force
         continue
       }
 
+      // A forced wake (power resume / network online) used to close EVERY open
+      // secondary socket before redialing. Closing one that is mid-use detaches
+      // its runtime → the backend orphan-reaps it → `session.reclaimed` → the
+      // surface re-resumes on a fresh socket the same signal may close again:
+      // the #94769 flicker loop. But a live socket also cannot simply be
+      // SKIPPED: a half-open socket never fires a close event, so an in-flight
+      // request would hang until its per-call timeout. Probe liveness instead —
+      // a healthy-but-busy backend answers and keeps its socket; a dead
+      // transport is closed and healed by the ordinary reconnect backoff.
+      if (entry.activeRequests > 0 || relayRetained(entry) || foregroundPinned(entry)) {
+        probeSecondaryLiveness(entry)
+
+        continue
+      }
+
       entry.gateway.close()
     }
 
@@ -2005,6 +2145,7 @@ export function parkSecondariesForRetiredBackend(poolKey: string): string[] {
 function disposeSecondary(entry: Secondary): void {
   entry.wantOpen = false
   clearTimer(entry)
+  clearSecondaryLivenessReprobe(entry)
   entry.offEvent()
   entry.offRequest()
   entry.offState()
@@ -2077,6 +2218,17 @@ export function pruneSecondaryGateways(keep: Set<string>): void {
       continue
     }
 
+    // Min-lifetime grace: an idle prune can race an on-demand dial (prune →
+    // redial → prune) and dispose a socket that opened moments ago, before
+    // its consumer registered in the keep-set — closing it detaches the
+    // runtime, the backend orphan-reaps it, and the reclaimed surface
+    // re-resumes on a fresh socket the next recompute closes again: the
+    // #94769 flicker loop. A young socket rides one prune tick; the keepalive
+    // tick recomputes the keep-set so an idle one is still reaped within a minute.
+    if (now - entry.lastOpenedAt < SECONDARY_MIN_LIFETIME_MS) {
+      continue
+    }
+
     // The route is no longer live work. Release turn leases first so their
     // counted request holds cannot outlive a disposed route or leave a stale
     // release closure attached to a later same-key socket.
diff --git a/apps/desktop/src/store/hub-actions.ts b/apps/desktop/src/store/hub-actions.ts
index d1cf3f320d..e89830500e 100644
--- a/apps/desktop/src/store/hub-actions.ts
+++ b/apps/desktop/src/store/hub-actions.ts
@@ -1,5 +1,8 @@
 import { atom, map } from 'nanostores'
 
+// The Capabilities Skills-list query key, imported rather than re-spelled so a
+// hub (un)install updates the Skills tab, not just the hub.
+import { SKILLS_QUERY_KEY } from '@/app/capabilities/skills/skills-data'
 import {
   getActionStatus,
   installSkillFromHub,
@@ -20,9 +23,6 @@ const POLL_MS = 1200
 // Shared with hub.tsx's sources useQuery so a finished action refreshes the
 // installed map.
 export const HUB_SOURCES_KEY = ['skill-hub-sources'] as const
-// The Capabilities Skills-list query key (see app/skills/index.tsx) — kept in
-// sync here so a hub (un)install updates the Skills tab, not just the hub.
-const SKILLS_LIST_KEY = ['skills-list'] as const
 // The built-in optional-skills catalog rows in the Skills tab: an install
 // flips one of them to an installed (toggle) row, so the catalog's
 // installed-flags must refetch alongside the skills list.
@@ -125,7 +125,7 @@ async function runHubAction(
     // Refresh the hub's installed map AND the Capabilities Skills list — a hub
     // (un)install adds/removes a skill, so its count/rows must update too.
     void queryClient.invalidateQueries({ queryKey: HUB_SOURCES_KEY })
-    void queryClient.invalidateQueries({ queryKey: SKILLS_LIST_KEY })
+    void queryClient.invalidateQueries({ queryKey: SKILLS_QUERY_KEY })
     void queryClient.invalidateQueries({ queryKey: OFFICIAL_SKILLS_KEY })
     // …and the composer's `/` list, which caches the command catalog for an
     // hour and would otherwise keep offering the skill we just removed.
diff --git a/apps/desktop/src/store/mcp-health.ts b/apps/desktop/src/store/mcp-health.ts
index d2d37ffec2..d3ca78ffda 100644
--- a/apps/desktop/src/store/mcp-health.ts
+++ b/apps/desktop/src/store/mcp-health.ts
@@ -102,7 +102,7 @@ let offProfile: (() => void) | null = null
 // scrolls to and focuses the server so its ServerConfig pane (with the
 // Authenticate button) is one click away.
 function openMcpServerPage(name: string): void {
-  window.location.hash = `#/skills?tab=mcp&server=${encodeURIComponent(name)}`
+  window.location.hash = `#/capabilities?tab=mcp&server=${encodeURIComponent(name)}`
 }
 
 // "Disable" from the toast: `enabled: false` in config.yaml (the server stays
diff --git a/apps/desktop/src/store/route-tiles.ts b/apps/desktop/src/store/route-tiles.ts
index 0713952c80..d2e2b6cec0 100644
--- a/apps/desktop/src/store/route-tiles.ts
+++ b/apps/desktop/src/store/route-tiles.ts
@@ -10,7 +10,7 @@ import type { SplitDir } from './session-states'
  * the page analog of session tiles. Persisted by path so they re-open on boot.
  */
 export interface RouteTile {
-  /** The route path this tile renders, e.g. `/skills`. */
+  /** The route path this tile renders, e.g. `/capabilities`. */
   path: string
   /** Edge to dock against main on adoption (default right). */
   dir?: SplitDir
diff --git a/apps/desktop/src/store/session-request-router.test.ts b/apps/desktop/src/store/session-request-router.test.ts
index 8c3261b402..579b1744a4 100644
--- a/apps/desktop/src/store/session-request-router.test.ts
+++ b/apps/desktop/src/store/session-request-router.test.ts
@@ -76,7 +76,8 @@ const {
   ensureGatewayForProfile,
   pruneSecondaryGateways,
   retireLocalProfileGateways,
-  setPrimaryGateway
+  setPrimaryGateway,
+  SECONDARY_MIN_LIFETIME_MS
 } = await import('./gateway')
 
 const { requestForSessionProfile, sessionRpcNeedsProfileRoute } = await import('./session-request-router')
@@ -507,7 +508,11 @@ describe('requestForSessionProfile', () => {
     })
     expect(secondaryGateways[0].close).not.toHaveBeenCalled()
 
+    // Age the socket past the min-lifetime grace (#94769) so this prune
+    // asserts the turn-lease release, not the freshly-opened spare.
+    vi.useFakeTimers({ now: Date.now() + SECONDARY_MIN_LIFETIME_MS + 1_000 })
     pruneSecondaryGateways(new Set())
+    vi.useRealTimers()
     expect(secondaryGateways[0].close).toHaveBeenCalledOnce()
 
     await requestForSessionProfile(route, ambient as never, 'session.resume', { session_id: 'rt-pruned' })
diff --git a/apps/desktop/src/store/session.test.ts b/apps/desktop/src/store/session.test.ts
index cf49cbc6bb..ee875f084b 100644
--- a/apps/desktop/src/store/session.test.ts
+++ b/apps/desktop/src/store/session.test.ts
@@ -1335,7 +1335,7 @@ describe('remembered route (per profile)', () => {
   })
 
   it('discards legacy unsuffixed keys on first read (zero-migration, refuse-to-guess)', () => {
-    localStorage.setItem('hermes.desktop.lastRoute', '/skills')
+    localStorage.setItem('hermes.desktop.lastRoute', '/capabilities')
 
     // Reading from any profile discards the legacy key.
     expect(getRememberedRoute('default')).toBeNull()
diff --git a/apps/desktop/src/store/settings-scope.ts b/apps/desktop/src/store/settings-scope.ts
index fe9f8f99a7..a4c878f1ad 100644
--- a/apps/desktop/src/store/settings-scope.ts
+++ b/apps/desktop/src/store/settings-scope.ts
@@ -59,7 +59,7 @@ export function setSettingsScope(name: string): void {
 // An app-wide profile switch re-homes every settings surface to the new
 // backend; a surviving override would silently keep edits pointed at the
 // previous target. Same drop-the-override contract as the Capabilities
-// selector (app/skills useOnProfileSwitch).
+// selector (app/capabilities useOnProfileSwitch).
 let lastActiveProfile = normalizeProfileKey($activeGatewayProfile.get())
 
 $activeGatewayProfile.subscribe(value => {
diff --git a/apps/desktop/src/store/skill-deeplink-install.test.ts b/apps/desktop/src/store/skill-deeplink-install.test.ts
deleted file mode 100644
index 0b39697232..0000000000
--- a/apps/desktop/src/store/skill-deeplink-install.test.ts
+++ /dev/null
@@ -1,100 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-
-import { setApiRequestConnection, setApiRequestProfile } from '@/hermes'
-
-import { $confirmRequest, runConfirm, settleConfirm } from './confirm'
-import { $connectionsRegistry } from './connection-registry-state'
-import type * as HubActions from './hub-actions'
-import { installHubSkill } from './hub-actions'
-import { notify } from './notifications'
-import { requestSkillInstallFromDeepLink } from './skill-deeplink-install'
-
-vi.mock('./hub-actions', async importOriginal => ({
-  ...(await importOriginal<typeof HubActions>()),
-  installHubSkill: vi.fn()
-}))
-vi.mock('./notifications', () => ({ notify: vi.fn(), notifyError: vi.fn() }))
-
-beforeEach(() => {
-  setApiRequestConnection('local')
-  setApiRequestProfile('research')
-  vi.mocked(installHubSkill).mockResolvedValue(undefined)
-})
-
-afterEach(() => {
-  settleConfirm(false)
-  $connectionsRegistry.set(null)
-  setApiRequestConnection(null)
-  setApiRequestProfile(null)
-  vi.clearAllMocks()
-})
-
-describe('skill link installation', () => {
-  it('shows the exact source and readable destination, and cancellation installs nothing', async () => {
-    const pending = requestSkillInstallFromDeepLink('clawhub/apple-design')
-    expect($confirmRequest.get()).toMatchObject({
-      title: 'Install “apple-design”?',
-      details: [
-        { label: 'Source', value: 'clawhub/apple-design' },
-        { label: 'Install to', value: 'This computer · research' }
-      ]
-    })
-    settleConfirm(false)
-    await pending
-    expect(installHubSkill).not.toHaveBeenCalled()
-    expect(notify).not.toHaveBeenCalled()
-  })
-
-  it('uses the registered remote name without changing the install destination', async () => {
-    setApiRequestConnection('server-a')
-    $connectionsRegistry.set({
-      version: 2, primary: 'server-a', secureTokenStorage: false,
-      connections: [{ id: 'server-a', kind: 'remote', label: 'Homelab', tokenSet: false, tokenPreview: null }]
-    })
-    const pending = requestSkillInstallFromDeepLink('official/research/example')
-    const request = $confirmRequest.get()!
-    expect(request.details?.[1].value).toBe('Homelab · research')
-    await runConfirm(request)
-    expect(installHubSkill).toHaveBeenCalledExactlyOnceWith('official/research/example', {
-      connectionId: 'server-a', profile: 'research'
-    })
-    expect(notify).toHaveBeenCalledWith(expect.objectContaining({ title: '“example” installed' }))
-    settleConfirm(true)
-    await pending
-  })
-
-  it('keeps a failed action retryable without sending a success notification', async () => {
-    vi.mocked(installHubSkill).mockRejectedValueOnce(new Error('Download failed'))
-    const pending = requestSkillInstallFromDeepLink('clawhub/apple-design')
-    const request = $confirmRequest.get()!
-    await expect(runConfirm(request)).rejects.toThrow('Download failed')
-    expect($confirmRequest.get()).toBe(request)
-    expect(request.phase).toBeUndefined()
-    expect(notify).not.toHaveBeenCalled()
-    await runConfirm(request)
-    expect(request.phase).toBe('done')
-    expect(notify).toHaveBeenCalledExactlyOnceWith(expect.objectContaining({ title: '“apple-design” installed' }))
-    settleConfirm(true)
-    await pending
-  })
-
-  it('refuses a changed destination before installation or retry', async () => {
-    const pending = requestSkillInstallFromDeepLink('clawhub/apple-design')
-    setApiRequestConnection('server-b')
-    await expect(runConfirm($confirmRequest.get()!)).rejects.toThrow('The destination changed')
-    expect(installHubSkill).not.toHaveBeenCalled()
-    settleConfirm(false)
-    await pending
-  })
-
-  it('does not report completion when a profile switch abandons polling', async () => {
-    vi.mocked(installHubSkill).mockImplementationOnce(async () => { setApiRequestProfile('other') })
-    const pending = requestSkillInstallFromDeepLink('clawhub/apple-design')
-    const request = $confirmRequest.get()!
-    await expect(runConfirm(request)).rejects.toThrow('The destination changed')
-    expect(request.phase).toBeUndefined()
-    expect(notify).not.toHaveBeenCalled()
-    settleConfirm(false)
-    await pending
-  })
-})
diff --git a/apps/desktop/src/store/skill-deeplink-install.ts b/apps/desktop/src/store/skill-deeplink-install.ts
deleted file mode 100644
index 10ddedb17e..0000000000
--- a/apps/desktop/src/store/skill-deeplink-install.ts
+++ /dev/null
@@ -1,62 +0,0 @@
-import { getApiRequestConnection, getApiRequestProfile, type ProfileScope } from '@/hermes'
-import { translateNow } from '@/i18n'
-
-import { confirm } from './confirm'
-import { $connectionsRegistry } from './connection-registry-state'
-import { HubInstallBlockedError, installHubSkill, notifyHubActionFailed } from './hub-actions'
-import { notify } from './notifications'
-
-/** The URL supplies only an identifier, never a destination profile or scan override. */
-export async function requestSkillInstallFromDeepLink(identifier: string): Promise<void> {
-  const connectionId = getApiRequestConnection()
-  const profile = getApiRequestProfile()
-  const scope: ProfileScope = { connectionId, profile }
-  const name = identifier.split('/').filter(Boolean).at(-1) || identifier
-
-  const connectionLabel = !connectionId || connectionId === 'local'
-    ? translateNow('catalog.thisComputer')
-    : $connectionsRegistry.get()?.connections.find(connection => connection.id === connectionId)?.label || connectionId
-
-  const destination = `${connectionLabel} · ${profile || 'default'}`
-
-  const assertDestination = () => {
-    if (connectionId !== getApiRequestConnection() || profile !== getApiRequestProfile()) {
-      throw new Error(translateNow('catalog.destinationChanged'))
-    }
-  }
-
-  await confirm({
-    title: translateNow('catalog.installTitle', name),
-    description: translateNow('catalog.installDescription'),
-    details: [
-      { label: translateNow('catalog.source'), value: identifier },
-      { label: translateNow('catalog.installTo'), value: destination }
-    ],
-    confirmLabel: translateNow('skills.hub.install'),
-    busyLabel: translateNow('catalog.installing'),
-    doneLabel: translateNow('catalog.installed'),
-    onConfirm: async () => {
-      // Recheck on retries too: a link must never follow a changed destination.
-      assertDestination()
-
-      try {
-        await installHubSkill(identifier, scope)
-      } catch (error) {
-        if (error instanceof HubInstallBlockedError) {
-          notifyHubActionFailed(error, translateNow('skills.hub.actionFailed'), name, scope)
-        }
-
-        throw error
-      }
-
-      // The hub abandons polling when the active profile changes. That is not
-      // proof of success, so do not show an Installed state in that case.
-      assertDestination()
-      notify({
-        kind: 'success',
-        title: translateNow('catalog.installComplete', name),
-        message: translateNow('skills.changesApplyNewSessions')
-      })
-    }
-  })
-}
diff --git a/apps/desktop/src/store/terminal-backend-warning.test.ts b/apps/desktop/src/store/terminal-backend-warning.test.ts
index fc69b5a625..721ad79fa8 100644
--- a/apps/desktop/src/store/terminal-backend-warning.test.ts
+++ b/apps/desktop/src/store/terminal-backend-warning.test.ts
@@ -45,7 +45,7 @@ test('a selected non-local backend that is not ready warns once with Use Local /
   expect(`${toast?.title} ${toast?.message} ${toast?.action?.label}`).not.toMatch(/backend/i)
 
   toast?.action?.onClick()
-  expect($routeRequest.get()?.path).toBe('/skills?tab=toolsets')
+  expect($routeRequest.get()?.path).toBe('/capabilities?tab=toolsets')
 
   toast?.secondaryAction?.onClick()
   expect(selectTerminalBackend).toHaveBeenCalledWith('local')
diff --git a/apps/desktop/src/store/terminal-backend-warning.ts b/apps/desktop/src/store/terminal-backend-warning.ts
index 9c6238e5b7..781e145e2a 100644
--- a/apps/desktop/src/store/terminal-backend-warning.ts
+++ b/apps/desktop/src/store/terminal-backend-warning.ts
@@ -13,7 +13,7 @@ import type { TerminalBackendInfo } from '@/types/hermes'
  * is an older/remote backend, not a broken terminal.
  */
 
-const TERMINAL_TOOLSET_ROUTE = '/skills?tab=toolsets'
+const TERMINAL_TOOLSET_ROUTE = '/capabilities?tab=toolsets'
 const TOAST_ID = 'terminal-backend-unavailable'
 
 /** The active backend row when it is selected but not ready, else null. */
diff --git a/apps/shared/src/catalog-install.ts b/apps/shared/src/catalog-install.ts
deleted file mode 100644
index 3f24e03c09..0000000000
--- a/apps/shared/src/catalog-install.ts
+++ /dev/null
@@ -1,40 +0,0 @@
-/** Install targets shared by the public docs galleries and native catalog. */
-export interface SkillCatalogTarget {
-  name: string
-  source: string
-  identifier?: string
-  installIdentifier?: string
-}
-
-export function skillCatalogInstallIdentifier(skill: SkillCatalogTarget): string | null {
-  if (skill.installIdentifier) {
-    return skill.installIdentifier
-  }
-
-  const identifier = skill.identifier
-
-  // Older snapshots omit identifiers for local skills. Optional skills have a
-  // source-qualified name lookup; bundled skills are not in that source.
-  if (!identifier) {
-    return skill.source === 'built-in' ? null : skill.source === 'optional' ? `official/${skill.name}` : skill.name
-  }
-
-  return skill.source.toLowerCase() === 'clawhub' && !identifier.startsWith('clawhub/')
-    ? `clawhub/${identifier}`
-    : identifier
-}
-
-export function skillCatalogInstallUrl(skill: SkillCatalogTarget): string | null {
-  const identifier = skillCatalogInstallIdentifier(skill)
-
-  return identifier ? `hermes://skill/install?${new URLSearchParams({ identifier })}` : null
-}
-
-export function pluginCatalogInstallUrl(plugin: { name: string; repo: string; subdir?: string; sha: string }): string {
-  return `hermes://plugin/install?${new URLSearchParams({
-    repo: plugin.subdir ? `${plugin.repo}#${plugin.subdir}` : plugin.repo,
-    catalog_name: plugin.name,
-    sha: plugin.sha,
-    enable: '1'
-  })}`
-}
diff --git a/apps/shared/src/index.ts b/apps/shared/src/index.ts
index 9d612f83ec..c9c018149f 100644
--- a/apps/shared/src/index.ts
+++ b/apps/shared/src/index.ts
@@ -27,7 +27,6 @@ export type {
   UsageBarData,
   UsageModelData
 } from './billing-types'
-export { pluginCatalogInstallUrl, skillCatalogInstallIdentifier, skillCatalogInstallUrl } from './catalog-install'
 export {
   driveChargeSettlement,
   SETTLEMENT_MAX_RETRY_AFTER_MS,
diff --git a/apps/shared/src/json-rpc-gateway-connect.test.ts b/apps/shared/src/json-rpc-gateway-connect.test.ts
new file mode 100644
index 0000000000..bff00a1846
--- /dev/null
+++ b/apps/shared/src/json-rpc-gateway-connect.test.ts
@@ -0,0 +1,69 @@
+import { describe, expect, it } from 'vitest'
+
+import { JsonRpcGatewayClient } from './json-rpc-gateway'
+
+/** EventTarget-based WebSocket stand-in that never opens, so each failure leg can be driven by hand. */
+class StuckSocket extends EventTarget {
+  readyState = 0
+
+  send(): void {}
+
+  close(): void {
+    this.readyState = 3
+  }
+}
+
+const connectErrorMessage = 'Could not connect to Hermes gateway'
+
+const rejection = (pending: Promise<void>): Promise<Error> =>
+  pending.then(
+    () => new Error('connect resolved'),
+    (error: Error) => error
+  )
+
+const dial = (connectTimeoutMs = 1000) => {
+  let socket!: StuckSocket
+
+  const client = new JsonRpcGatewayClient({
+    socketFactory: () => (socket = new StuckSocket()) as unknown as WebSocket,
+    heartbeatIntervalMs: 0,
+    heartbeatDeadlineMs: 0,
+    connectTimeoutMs,
+    connectErrorMessage
+  })
+
+  const pending = client.connect('ws://gateway.test/api/ws')
+  pending.catch(() => {})
+
+  return { client, pending, socket }
+}
+
+// Regression for #41566: the overlay showed the same sentence for an auth rejection, a TLS failure and a
+// silent host, so users verified the gateway with curl and still could not tell what the app hit.
+describe('JsonRpcGatewayClient.connect failure classes', () => {
+  it('a handshake close carries its code and reason, distinct from a timeout', async () => {
+    const closed = dial()
+    closed.socket.dispatchEvent(new CloseEvent('close', { code: 4403, reason: 'token_mismatch' }))
+    const closeError = await rejection(closed.pending)
+
+    const timedOut = dial(20)
+    const timeoutError = await rejection(timedOut.pending)
+
+    expect(closeError.message).toContain(connectErrorMessage)
+    expect(closeError.message).toContain('4403')
+    expect(closeError.message).toContain('token_mismatch')
+    expect(timeoutError.message).toContain(connectErrorMessage)
+    expect(timeoutError.message).toContain('20 ms')
+    expect(timeoutError.message).not.toBe(closeError.message)
+    expect(timedOut.client.connectionState).toBe('error')
+  })
+
+  it('every failure keeps the base message as its prefix — the overlay headline and includes() matchers bind to it', async () => {
+    const { pending, socket } = dial()
+    socket.dispatchEvent(new Event('error'))
+    const error = await rejection(pending)
+
+    expect(error.message.startsWith(connectErrorMessage)).toBe(true)
+    expect(error.message).not.toBe(connectErrorMessage)
+  })
+})
diff --git a/apps/shared/src/json-rpc-gateway.ts b/apps/shared/src/json-rpc-gateway.ts
index 365e6d0feb..fe8f5759b1 100644
--- a/apps/shared/src/json-rpc-gateway.ts
+++ b/apps/shared/src/json-rpc-gateway.ts
@@ -252,6 +252,9 @@ export class JsonRpcGatewayClient {
         void this.fetchReplay()
       }
 
+      // Every rejection below names its failure class. The boot overlay renders this message verbatim, and
+      // a bare connectErrorMessage collapses "server refused the token", "TLS/DNS/refused before open" and
+      // "nothing answered" into one sentence nobody can act on (#41566).
       const onError = () => {
         if (settled || this.socket !== socket) {
           return
@@ -260,7 +263,8 @@ export class JsonRpcGatewayClient {
         settled = true
         cleanup()
         this.setState('error')
-        reject(new Error(this.options.connectErrorMessage))
+        // A browser/renderer 'error' event carries no detail; the class is the message.
+        reject(this.connectFailure('WebSocket error before open'))
       }
 
       // A server that closes during the handshake (auth gate, 4401/4403)
@@ -270,7 +274,7 @@ export class JsonRpcGatewayClient {
       // and moved the generation to 'closed'; the branch below only runs
       // when `onSocketClose` intercepted that transition and left the
       // half-open socket bound.
-      const onClose = () => {
+      const onClose = (event: CloseEvent) => {
         if (settled) {
           return
         }
@@ -283,7 +287,11 @@ export class JsonRpcGatewayClient {
           this.setState('error')
         }
 
-        reject(new Error(this.options.connectErrorMessage))
+        reject(
+          this.connectFailure(
+            `WebSocket closed during handshake: code ${event.code}${event.reason ? ` ${event.reason}` : ''}`
+          )
+        )
       }
 
       socket.addEventListener('open', onOpen, { once: true })
@@ -312,12 +320,16 @@ export class JsonRpcGatewayClient {
             this.setState('error')
           }
 
-          reject(new Error(this.options.connectErrorMessage))
+          reject(this.connectFailure(`no WebSocket open within ${this.options.connectTimeoutMs} ms`))
         }, this.options.connectTimeoutMs)
       }
     })
   }
 
+  private connectFailure(detail: string): Error {
+    return new Error(`${this.options.connectErrorMessage} (${detail})`)
+  }
+
   close(): void {
     this.invalidate()
   }
diff --git a/cli.py b/cli.py
index 768e2de587..efe51210e3 100644
--- a/cli.py
+++ b/cli.py
@@ -1041,6 +1041,7 @@ from hermes_cli.worktree_ops import (
     _repo_is_shallow,
     _setup_worktree,
     _worktree_has_unpushed_commits,
+    release_lsp_clients,
 )
 
 # ============================================================================= Git Worktree Isolation
@@ -1070,7 +1071,9 @@ def _cleanup_worktree(info: Dict[str, str] = None) -> None:
         _active_worktree = None
         return
 
-    # Unlock first so `remove` isn't blocked by the lock placed at creation. Fail-soft.
+    # Release the tree's language servers while the path still exists, then unlock so `remove`
+    # isn't blocked by the lock placed at creation. Fail-soft.
+    release_lsp_clients(wt_path)
     _git_quiet(["worktree", "unlock", wt_path], repo_root, log="git worktree unlock failed (non-fatal)")
     _git_quiet(["worktree", "remove", wt_path, "--force"], repo_root, timeout=15, log="Failed to remove worktree")
     _git_quiet(["branch", "-D", branch], repo_root, log=f"Failed to delete branch {branch}")
diff --git a/contributors/emails/155116265+psam-717@users.noreply.github.com b/contributors/emails/155116265+psam-717@users.noreply.github.com
new file mode 100644
index 0000000000..843939862a
--- /dev/null
+++ b/contributors/emails/155116265+psam-717@users.noreply.github.com
@@ -0,0 +1,2 @@
+psam-717
+# PR #112834 salvage
diff --git a/contributors/emails/anton.vykhovanets@icloud.com b/contributors/emails/anton.vykhovanets@icloud.com
new file mode 100644
index 0000000000..e71b6468aa
--- /dev/null
+++ b/contributors/emails/anton.vykhovanets@icloud.com
@@ -0,0 +1,2 @@
+vykhovanets
+# PR #68621 salvage
diff --git a/contributors/emails/brandan@wrengineers.com b/contributors/emails/brandan@wrengineers.com
new file mode 100644
index 0000000000..2c405020f2
--- /dev/null
+++ b/contributors/emails/brandan@wrengineers.com
@@ -0,0 +1,2 @@
+dankkush
+# PR #111472 salvage
diff --git a/contributors/emails/gameoverhf12@gmail.com b/contributors/emails/gameoverhf12@gmail.com
new file mode 100644
index 0000000000..0068f9b25a
--- /dev/null
+++ b/contributors/emails/gameoverhf12@gmail.com
@@ -0,0 +1,2 @@
+BrierAinz
+# PR #73088 salvage
diff --git a/contributors/emails/sasan1200@gmail.com b/contributors/emails/sasan1200@gmail.com
new file mode 100644
index 0000000000..ec3b9e6543
--- /dev/null
+++ b/contributors/emails/sasan1200@gmail.com
@@ -0,0 +1,2 @@
+sasan1200
+# PR #72932 salvage
diff --git a/evals/desktop_mcp_oauth/renderer_lifecycle.mjs b/evals/desktop_mcp_oauth/renderer_lifecycle.mjs
index 02144f506e..23baf63914 100644
--- a/evals/desktop_mcp_oauth/renderer_lifecycle.mjs
+++ b/evals/desktop_mcp_oauth/renderer_lifecycle.mjs
@@ -59,7 +59,7 @@ wss.on('connection', ws =>
 )
 const entry = `import React from 'react'; import {createRoot} from 'react-dom/client';
 import {QueryClient, QueryClientProvider} from '@tanstack/react-query';
-import {McpTab} from '${repo}/apps/desktop/src/app/skills/mcp-tab.tsx';
+import {McpTab} from '${repo}/apps/desktop/src/app/capabilities/mcp/mcp-tab.tsx';
 import {setApiRequestProfile,setApiRequestConnection} from '${repo}/apps/desktop/src/api/client.ts';
 setApiRequestProfile('profile-b');setApiRequestConnection('fixture-remote');
 const queryClient=new QueryClient({defaultOptions:{queries:{retry:false}}});function Probe(){const [profile,setProfile]=React.useState('profile-b');const [shown,setShown]=React.useState(true);window.cancelFlow=()=>setProfile('profile-c');window.unmountFlow=()=>setShown(false);return <QueryClientProvider client={queryClient}>{shown && <McpTab gateway={null} profile={{connectionId:'fixture-remote',profile}} />}</QueryClientProvider>};createRoot(document.getElementById('root')).render(<Probe/>);`
diff --git a/evals/gateway_status_render/iteration_ceiling_ab.py b/evals/gateway_status_render/iteration_ceiling_ab.py
index bb10a68783..d75136bcf1 100644
--- a/evals/gateway_status_render/iteration_ceiling_ab.py
+++ b/evals/gateway_status_render/iteration_ceiling_ab.py
@@ -75,7 +75,7 @@ async def _heartbeat(agent) -> str:
     mixin = GatewayTurnMixin()
     adapter = MagicMock()
     adapter.send = AsyncMock(return_value=SimpleNamespace(success=True, message_id="hb1"))
-    mixin._adapter_for_source = MagicMock(return_value=adapter)
+    mixin._delivery_adapter_for = MagicMock(return_value=adapter)
     mixin._should_emit_long_running_notification = MagicMock(side_effect=[True, False])
     disp = MagicMock()
     disp._display_surface_mode.return_value = "on"
diff --git a/evals/heartbeat_idle_wire.py b/evals/heartbeat_idle_wire.py
index b83404321d..8369dd5ad9 100644
--- a/evals/heartbeat_idle_wire.py
+++ b/evals/heartbeat_idle_wire.py
@@ -46,7 +46,7 @@ async def main(base_poller):
     runner._run_in_executor_with_context = asyncio.to_thread
     adapter = WireAdapter(PlatformConfig(enabled=True, typing_indicator=False), Platform.TELEGRAM)
     adapter.wire = []
-    runner._adapter_for_source = lambda source: adapter
+    runner._delivery_adapter_for = lambda source: adapter
     source = SessionSource(platform=Platform.TELEGRAM, chat_id="42", user_id="42", chat_type="dm")
     key = build_session_key(source)
     watch = {key: (source, "wire-session")}
diff --git a/gateway/AGENTS.md b/gateway/AGENTS.md
index d41911e2d2..0bb5baa37a 100644
--- a/gateway/AGENTS.md
+++ b/gateway/AGENTS.md
@@ -133,15 +133,37 @@ gateway under the backend, and do NOT "fix" update locks by widening the tree-ki
 
 ## Profile scope (adapters, turns, and everything between turns)
 
-- **One identity per inbound event.** `gateway/session_identity.py::resolve_identity` answers
-  "which bot received it / who may admit it / where does it run" ONCE per event and pins a frozen
-  `RoutingIdentity` on the source (wire-invisible, like `_transport_adapter_ref`);
-  `_transport_owner`, `_authorization_home_for_source`, `_resolve_profile_home_for_source`,
-  `_session_key_profile` and `_resolve_profile_for_key` read it when present and fall back to
-  their old chain only for sources nothing resolved (restored rows, hand-built sources). Never
-  derive a second answer next to the identity; extend the object. `transport_profile` ≠
-  `runtime_profile` is normal (shared bot → routed satellite). A source copy goes through
-  `session_identity.replace_source` so the identity travels with it.
+- **One identity per inbound event, canonicalized FIRST.** `gateway/session_identity.py::resolve_identity`
+  answers "which bot received it / who may admit it / where does it run" ONCE per event and pins a
+  frozen `RoutingIdentity` on the source (wire-invisible, like `_transport_adapter_ref`). Every
+  ingress path calls the canonicalize seam before it derives a key: the adapter side
+  (`platforms/base.py::_canonicalize` — `handle_message`, `_enqueue_text_event`, Telegram photo /
+  album routing, `_handle_message_while_active`, every `_source_session_key`) and the runner side
+  (`run_adapters.py::_canonicalize` — the per-profile / default message, busy and platform-event
+  handlers, the adapter auth-check callback, `run_inbound.py::_hm_admit_event`). No key derivation
+  before it; an unresolved identity under multiplexing (route to an unserved profile) is dropped
+  with one WARNING at the first seam it reaches, never keyed into `agent:main`. `_transport_owner`,
+  `_authorization_home_for_source`, `_resolve_profile_home_for_source`, `_session_key_profile` and
+  `_resolve_profile_for_key` read the identity when present and fall back to their old chain only
+  for sources nothing resolved (restored rows, hand-built sources). Never derive a second answer
+  next to the identity; extend the object. `transport_profile` ≠ `runtime_profile` is normal
+  (shared bot → routed satellite). A source copy goes through `session_identity.replace_source`
+  so the identity travels with it (`_apply_topic_recovery` does).
+- **Intake vs delivery adapter.** `authz_mixin.py::_intake_adapter_for(source)` is the bot that
+  RECEIVED the event (live transport ref → relay socket → identity's `transport_profile`); it gates
+  intake policy (ignored channels, relay fronting, re-dispatch of a still-live event) and fails
+  closed to `None` for a source with no live provenance. `_delivery_adapter_for(source)` is the bot
+  that ANSWERS — the receiving bot whenever known, else the unique owner of `(platform,
+  runtime_profile)` via `_adapters_for_profile`. Never read `self.adapters[platform]` for a source;
+  never add a third resolver. The matrix (`tests/gateway/test_multiplex_transport_matrix.py`):
+
+  | Topology | runtime | intake | delivery |
+  |---|---|---|---|
+  | per-credential bot, no route | owner | owner adapter | owner adapter |
+  | shared credential → satellite (`profile_routes`) | routed | receiving adapter | receiving adapter (`_is_shared_bot_satellite` after restart) |
+  | shared bot → profile that owns its own bot | routed | receiving adapter | receiving adapter (conversation continuity; #70625's "routed bot" reading was not adopted) |
+  | secondary-owned bot → `default` (`bot_profile`) | default (`agent:main`) | receiving adapter | receiving adapter |
+  | restored / hand-built, no live provenance | stored `source.profile` | **`None`** | unique owner of `(platform, runtime)`; a disconnected secondary → `None`, never the default bot |
 - **Token locks.** An adapter that connects with a unique credential (bot token, API key) calls
   `acquire_scoped_lock()` from `gateway.status` in `connect()`/`start()` and `release_scoped_lock()`
   in `disconnect()`/`stop()`, so two profiles cannot share one credential. Canonical:
diff --git a/gateway/authz_mixin.py b/gateway/authz_mixin.py
index dc9a98af87..06996f673f 100644
--- a/gateway/authz_mixin.py
+++ b/gateway/authz_mixin.py
@@ -253,18 +253,53 @@ class GatewayAuthorizationMixin:
         except Exception:
             return False
 
-    def _adapter_for_source(self, source: Optional[SessionSource]):
-        """Resolve the live adapter for an inbound ``SessionSource``."""
+    def _intake_adapter_for(self, source: Optional[SessionSource]):
+        """The adapter that RECEIVED *source*'s event — the only one whose intake policy (ignored
+        channels, relay fronting, re-dispatch of a still-live event) may act on it.
+
+        Live provenance only: the registered transport that built the source, the process-level
+        RelayAdapter for relay-delivered events, or the receiving bot named by a pinned
+        ``RoutingIdentity`` (``transport_profile``) when its adapter reconnected. A source with none
+        of these (restored row, hand-built) fails closed under multiplexing — nothing can say which
+        bot admitted it, and guessing the runtime profile's bot is exactly the shared-bot /
+        route-override confusion the identity exists to end. A standalone gateway owns one adapter
+        per platform, so that adapter is the receiver by construction.
+        """
         if source is None:
             return None
         owner = self._transport_owner(source)
         if owner is not None:
             return owner[0]
-        # Relay ingress keeps the underlying platform on the source, but delivery must use the one
-        # process-level RelayAdapter owning the connector socket; a profile-aware lookup would
-        # silently disable streaming/typing/tool progress.
+        # Relay ingress keeps the underlying platform on the source, but the one process-level
+        # RelayAdapter owns the connector socket; a profile-aware lookup would silently disable
+        # streaming/typing/tool progress.
         if getattr(source, "delivered_via_upstream_relay", False) is True:
             return self._primary_adapters().get(Platform.RELAY)
+        platform = getattr(source, "platform", None)
+        from gateway.session_identity import identity_of
+        identity = identity_of(source)
+        if identity is not None and identity.multiplexed:
+            return self._adapters_for_profile(identity.transport_profile).get(platform) if platform else None
+        if not getattr(getattr(self, "config", None), "multiplex_profiles", False):
+            return self._primary_adapters().get(platform) if platform else None
+        return None
+
+    def _delivery_adapter_for(self, source: Optional[SessionSource]):
+        """The adapter that ANSWERS *source*: sends, edits, typing, progress, pickers, pending slots.
+
+        The receiving bot whenever it is known (:meth:`_intake_adapter_for` — a routed event replies
+        through the bot that received it, whether the runtime is a shared-bot satellite or a profile
+        with a bot of its own). With no live provenance the unique owner of ``(platform,
+        runtime_profile)`` delivers — ``_adapters_for_profile`` holds one adapter per platform per
+        profile, a shared-bot satellite drains through the primary, and a disconnected secondary
+        fails closed to ``{}`` rather than borrowing the default bot. Restored sessions, cron,
+        kanban and completion notices all rely on this row. Matrix: gateway/AGENTS.md § Profile scope.
+        """
+        if source is None:
+            return None
+        adapter = self._intake_adapter_for(source)
+        if adapter is not None:
+            return adapter
         # ``getattr``: test fixtures build bare SimpleNamespace sources without ``profile``.
         return self._authorization_adapter(getattr(source, "platform", None), getattr(source, "profile", None))
 
@@ -310,7 +345,9 @@ class GatewayAuthorizationMixin:
             return Path(stamped)
         if not getattr(getattr(self, "config", None), "multiplex_profiles", False):
             return None
-        adapter = self._adapter_for_source(source)
+        # A restored/hand-built source is admitted by the bot that will answer it (auto-resume,
+        # plugin injection) — the same unique-owner row delivery uses.
+        adapter = self._delivery_adapter_for(source)
         if adapter is None:
             return None
         _registered, profile = self._owning_profile(adapter, getattr(source, "platform", None))
@@ -390,7 +427,7 @@ class GatewayAuthorizationMixin:
         return per_profile[profile] if profile and profile in per_profile else getattr(self, "pairing_store", None)
 
     def _adapter_extra_for_source(self, source) -> dict:
-        return _adapter_config_extra(self._adapter_for_source(source))
+        return _adapter_config_extra(self._delivery_adapter_for(source))
 
     def _own_policy_authorizes(self, source, user_id, is_group, adapter_profile) -> Optional[bool]:
         """Own-policy adapter verdict when no env allowlist exists; None = no verdict.
@@ -417,7 +454,7 @@ class GatewayAuthorizationMixin:
     def _adapter_extra_allowlist_authorizes(self, source, user_id, is_group) -> bool:
         """Adapters (e.g. Telegram) that gate via config.extra.allow_from / group_allow_from
         without setting enforces_own_access_policy."""
-        adapter = self._adapter_for_source(source)
+        adapter = self._delivery_adapter_for(source)
         if adapter is None:
             return False
         extra = _adapter_config_extra(adapter)
@@ -452,7 +489,7 @@ class GatewayAuthorizationMixin:
         """
         adapter = resolved_ids = None
         with contextlib.suppress(Exception):
-            adapter = self._adapter_for_source(source)
+            adapter = self._delivery_adapter_for(source)
         resolver = getattr(adapter, "resolved_allowlist_user_ids", None)
         if callable(resolver):
             with contextlib.suppress(Exception):
diff --git a/gateway/platforms/base.py b/gateway/platforms/base.py
index 20586b4353..83a5afca45 100644
--- a/gateway/platforms/base.py
+++ b/gateway/platforms/base.py
@@ -2247,7 +2247,8 @@ class BasePlatformAdapter(ABC):
             logger.debug("topic recovery hook failed", exc_info=True)
             return
         try:
-            event.source = dataclasses.replace(source, thread_id=str(recovered))
+            from gateway.session_identity import replace_source
+            event.source = replace_source(source, thread_id=str(recovered))  # keeps the pinned identity
         except Exception:
             logger.debug("topic recovery rewrite failed", exc_info=True)
 
@@ -2304,6 +2305,50 @@ class BasePlatformAdapter(ABC):
         :meth:`_session_key_profile` so adapter-level keys leave ``agent:main:``."""
         self._owner_profile = None if (name := (profile_name or "").strip() or None) == "default" else name
 
+    def _owner_transport_profile(self) -> Optional[str]:
+        """Transport profile for :func:`resolve_identity`: the owner name, or ``None`` = derive it
+        from the registry (the primary's identity then spells ``"default"`` out itself)."""
+        owner = getattr(self, "_owner_profile", None)
+        return owner if isinstance(owner, str) and owner.strip() else None
+
+    def _canonicalize(self, source: Optional["SessionSource"]):
+        """Pin the source's :class:`RoutingIdentity` before anything derives a key from it. Every
+        ingress path (fresh event, batch merge, busy path, control command, callback) calls this
+        FIRST. Returns the identity, or ``None`` when it cannot be resolved (a rejected route under
+        multiplexing marks ``source.profile_route_rejected``; ``_drop_unresolved`` reads it) or when
+        no runner seam exists (hand-built adapters, restored sources: the legacy readers stay)."""
+        if source is None:
+            return None
+        from gateway.session_identity import canonical_identity, identity_of
+        identity = identity_of(source)
+        if identity is not None:
+            return identity
+        runner = getattr(self, "gateway_runner", None)
+        if runner is None or not callable(getattr(runner, "_transport_owner", None)):
+            return None
+        try:
+            return canonical_identity(
+                source, runner=runner, adapter=self, transport_profile=self._owner_transport_profile())
+        except Exception:
+            # Duck-typed runners (SimpleNamespace / MagicMock rigs) have no registry to resolve
+            # against; the key then falls back to the pre-identity readers instead of failing ingress.
+            logger.debug("[%s] identity resolution failed; using legacy key readers", self.name, exc_info=True)
+            return None
+
+    def _drop_unresolved(self, event: "MessageEvent") -> bool:
+        """True when *event* must be dropped: its identity could not be resolved because the route
+        targets an unserved profile. Same disposition as the runner's ingress gate — one WARNING,
+        never a fall-through to ``agent:main``."""
+        source = getattr(event, "source", None)
+        if self._canonicalize(source) is not None:
+            return False
+        if getattr(source, "profile_route_rejected", False) is not True:
+            return False
+        logger.warning(
+            "[%s] Dropping inbound event for %s: explicit profile route targets an unserved profile",
+            self.name, getattr(source, "chat_id", "?"))
+        return True
+
     def _session_key_profile(self, source: Optional[Any] = None) -> Optional[str]:
         """Profile namespace for an adapter-derived session key. Ingress runs BEFORE the runner
         stamps ``source.profile``, so without this every bot in a multiplexed gateway shares one
@@ -2344,6 +2389,7 @@ class BasePlatformAdapter(ABC):
         return self._source_session_key(event.source)
 
     def _source_session_key(self, source: "SessionSource") -> str:
+        self._canonicalize(source)  # identity FIRST; no key derivation before it
         extra = self.config.extra
         return build_session_key(
             source, group_sessions_per_user=extra.get("group_sessions_per_user", True),
@@ -2356,6 +2402,8 @@ class BasePlatformAdapter(ABC):
 
     def _enqueue_text_event(self, event: "MessageEvent") -> None:
         """Buffer a text event (merging into a pending one) and restart the flush timer."""
+        if self._drop_unresolved(event):
+            return
         key = self._text_batch_key(event)
         existing = self._pending_text_batches.get(key)
         if existing is None:
@@ -3396,7 +3444,7 @@ class BasePlatformAdapter(ABC):
         """The runner's CURRENT adapter for a new final-response send: a reconnect can swap the
         registry adapter mid-task; an unsent final response belongs on the replacement transport,
         while message IDs, edits and deletes stay owned by the old one (nothing is migrated)."""
-        resolve = getattr(self.gateway_runner, "_adapter_for_source", None)
+        resolve = getattr(self.gateway_runner, "_delivery_adapter_for", None)
         if not callable(resolve):
             return self
         try:
@@ -3816,6 +3864,9 @@ class BasePlatformAdapter(ABC):
 
         if event.allow_gateway_control:
             coerce_plaintext_gateway_command(event)
+        # Identity FIRST: every key below (routing check, guard lookup, batch lane) derives from it.
+        if self._drop_unresolved(event):
+            return
         expected_session_key = str((event.metadata or {}).get("gateway_session_key") or "").strip()
         # Explicitly routed events already name their destination; recovering a
         # different topic would redirect them and yield before the session claim.
@@ -3846,6 +3897,7 @@ class BasePlatformAdapter(ABC):
         # races with the running task (split-brain, see PR #4926).
         # Certain commands must bypass the active-session guard and be dispatched directly to the gateway
         # runner. Without this, they are queued as pending messages and either: See #4926.
+        self._canonicalize(event.source)  # identity FIRST (direct callers may skip handle_message)
         cmd = event.get_command()
         from hermes_cli.commands import (is_interrupt_then_dispatch, should_bypass_active_session)
         if should_bypass_active_session(cmd):
diff --git a/gateway/run_adapters.py b/gateway/run_adapters.py
index 8c1ad3834f..1c9b07afdc 100644
--- a/gateway/run_adapters.py
+++ b/gateway/run_adapters.py
@@ -1348,40 +1348,49 @@ class GatewayAdapterLifecycleMixin:
         """``scope_factory(profile_home)`` or a nullcontext when the profile home is unknown."""
         return scope_factory(profile_home) if profile_home is not None else contextlib.nullcontext()
 
-    def _stamp_event_profile(self, event, profile_name: str) -> None:
-        """Best-effort: pin the secondary's identity on an inbound event (stamps ``source.profile``
-        when none yet). A source that cannot resolve keeps today's fallback readers."""
-        source = getattr(event, "source", None)
+    def _canonicalize(self, source, *, transport_profile: Optional[str] = None,
+                      primary_home: Optional[Path] = None):
+        """Runner-side identity seam: the pinned :class:`RoutingIdentity` of *source*, resolving it
+        once when absent. ``transport_profile`` names a secondary's own bot (its handlers know it by
+        construction); ``None`` = the primary/shared bot. ``None`` result = rejected route under
+        multiplexing (the caller drops; the ingress gate warns once) or a source that cannot resolve
+        (bare test rigs) — the legacy readers then stay in force."""
         if source is None:
-            return
-        with suppress(Exception):
-            from gateway.session_identity import resolve_identity
-            resolve_identity(source, runner=self, transport_profile=profile_name)
-        with suppress(Exception):
-            if not source.profile:
-                source.profile = profile_name
+            return None
+        from gateway.session_identity import canonical_identity
+        try:
+            identity = canonical_identity(
+                source, runner=self, transport_profile=transport_profile, primary_home=primary_home)
+        except Exception:
+            logger.debug("identity resolution failed; legacy readers stay in force", exc_info=True)
+            return None
+        if transport_profile and not getattr(source, "profile", None):
+            with suppress(Exception):
+                source.profile = transport_profile  # a secondary's own event is at least its own
+        return identity
 
     def _make_profile_message_handler(self, profile_name: str):
-        """Message handler that stamps source.profile, then delegates under the profile scope
-        (auth runs BEFORE the agent-turn scope, so the profile's ``.env`` must be visible here)."""
+        """Message handler that canonicalizes the event's identity FIRST, then delegates under the
+        profile scope (auth runs BEFORE the agent-turn scope, so the profile's ``.env`` must be
+        visible here)."""
         from gateway.run import _async_profile_runtime_scope
         profile_home = self._profile_home_or_none(profile_name)
 
         async def _handler(event):
-            self._stamp_event_profile(event, profile_name)
+            self._canonicalize(getattr(event, "source", None), transport_profile=profile_name)
             async with self._scope_or_null(_async_profile_runtime_scope, profile_home):
                 return await self._handle_message(event)
 
         return _handler
 
     def _make_profile_busy_session_handler(self, profile_name: str):
-        """Stamp an owning adapter's profile, then resolve busy policy under the profile scope
+        """Busy-path twin: canonicalize FIRST, then resolve busy policy under the profile scope
         (auth runs against the profile's own allowlist, same as the cold-path message handler)."""
         from gateway.run import _async_profile_runtime_scope
         profile_home = self._profile_home_or_none(profile_name)
 
         async def _handler(event, _session_key):
-            self._stamp_event_profile(event, profile_name)
+            self._canonicalize(event.source, transport_profile=profile_name)
             async with self._scope_or_null(_async_profile_runtime_scope, profile_home):
                 return await self._handle_active_session_busy_message(event, self._session_key_for_source(event.source))
 
@@ -1421,27 +1430,13 @@ class GatewayAdapterLifecycleMixin:
         return _handler
 
     def _admit_primary_source(self, source, default_home: Path) -> Optional[Path]:
-        """Resolve the primary-adapter source's identity (transport home for authorization, routed
-        profile for the runtime) and return the runtime home to scope the turn under; ``None`` when
-        the route targets an unserved profile. Route ≠ admitting bot."""
-        from gateway.session_identity import IdentityUnresolved, resolve_identity
-        try:
-            return resolve_identity(source, runner=self, primary_home=default_home).runtime_home
-        except IdentityUnresolved:
-            return None
-
-    def _stamp_routed_profile(self, source, adapter_profile: Optional[str] = None) -> bool:
-        """Stamp ``source.profile`` from ``profile_routes``; False when the route is rejected.
-
-        ``adapter_profile`` owns the receiving bot: routes are scoped to it and it is the
-        fallback when none matches, so re-stamping a source never crosses a bot boundary.
-        """
-        from gateway.profile_routing import ProfileRouteRejected
-        try:
-            source.profile = self._profile_name_for_source(source, adapter_profile=adapter_profile) or adapter_profile
-        except ProfileRouteRejected:
-            return False
-        return True
+        """Canonicalize a primary-adapter source (transport home for authorization, routed profile
+        for the runtime) and return the runtime home to scope the turn under; ``None`` when the
+        route targets an unserved profile. Route ≠ admitting bot."""
+        identity = self._canonicalize(source, primary_home=default_home)
+        if identity is not None:
+            return identity.runtime_home
+        return None if getattr(source, "profile_route_rejected", False) is True else default_home
 
     def _primary_message_handler(self):
         """Return the correctly scoped handler for a primary adapter."""
@@ -1483,8 +1478,7 @@ class GatewayAdapterLifecycleMixin:
         profile_home = self._profile_home_or_none(profile_name)
 
         async def _handler(event, source):
-            if getattr(source, "profile", None) is None:
-                source.profile = profile_name
+            self._canonicalize(source, transport_profile=profile_name)
             with self._scope_or_null(_profile_runtime_scope, profile_home):
                 return await self._handle_gateway_platform_event(event, source)
 
@@ -1496,8 +1490,10 @@ class GatewayAdapterLifecycleMixin:
         default_home = Path(get_hermes_home())
 
         async def _handler(event, source):
-            source._authorization_profile_home = default_home
-            with _profile_runtime_scope(self._resolve_profile_home_for_source(source)):
+            profile_home = self._admit_primary_source(source, default_home)
+            if profile_home is None:
+                return None  # rejected route: same disposition as the message ingress gate
+            with _profile_runtime_scope(profile_home):
                 return await self._handle_gateway_platform_event(event, source)
 
         return _handler
@@ -1609,8 +1605,9 @@ class GatewayAdapterLifecycleMixin:
                 source._transport_adapter_ref = _weakref.ref(adapter)
             if transport_home is None:
                 return self._is_user_authorized(source)
-            source._authorization_profile_home = transport_home
-            if not self._stamp_routed_profile(source):
+            # Canonicalize FIRST (callback sources never went through ``build_source``): the routed
+            # profile's pairing store is consulted, allowlists read under the transport home.
+            if self._canonicalize(source, primary_home=transport_home) is None:
                 return False  # fail-closed, like the ``_handle_message`` ingress gate
             return self._is_user_authorized_for_source(source)
         return check
diff --git a/gateway/run_agent_cache.py b/gateway/run_agent_cache.py
index 19a7e0b086..2d864fe54e 100644
--- a/gateway/run_agent_cache.py
+++ b/gateway/run_agent_cache.py
@@ -505,7 +505,7 @@ class GatewayAgentCacheMixin:
                 )
             except Exception:
                 logger.debug("agent_loop_stopped hook dispatch failed", exc_info=True)
-        adapter = self._adapter_for_source(source)
+        adapter = self._delivery_adapter_for(source)
         interrupt_session_activity = getattr(type(adapter), "interrupt_session_activity", None)
         if adapter and callable(interrupt_session_activity):
             metadata = self._thread_metadata_for_source(source)
diff --git a/gateway/run_busy.py b/gateway/run_busy.py
index e332c59422..6d4cd58422 100644
--- a/gateway/run_busy.py
+++ b/gateway/run_busy.py
@@ -357,7 +357,7 @@ class GatewayBusySessionMixin:
 
     def _queue_or_replace_pending_event(self, session_key: str, event: MessageEvent) -> None:
         from gateway.platforms.base import merge_pending_message_event
-        adapter = self._adapter_for_source(event.source)
+        adapter = self._delivery_adapter_for(event.source)
         if not adapter:
             return
         # FIFO so each follow-up gets its own turn in arrival order (the single pending slot used to
@@ -418,7 +418,7 @@ class GatewayBusySessionMixin:
         if not self._pending_event_audio_paths(event):
             return text
         enriched_text, successful_transcripts = await self._transcribe_and_echo_pending_voice(
-            event, self._adapter_for_source(event.source), event.source, text, log_context="Busy-steer"
+            event, self._delivery_adapter_for(event.source), event.source, text, log_context="Busy-steer"
         )
         return (enriched_text or text).strip() if successful_transcripts else text
 
@@ -486,7 +486,7 @@ class GatewayBusySessionMixin:
 
     async def _send_busy_drain_notice(self, event: MessageEvent, session_key: str, effective_mode: str) -> None:
         """Busy path while the gateway is restarting/stopping: queue (if allowed) and tell the user."""
-        adapter = self._adapter_for_source(event.source)
+        adapter = self._delivery_adapter_for(event.source)
         if not adapter:
             return
         if self._queue_during_drain_enabled(effective_mode):
@@ -543,7 +543,7 @@ class GatewayBusySessionMixin:
                         "Approval response via plain text: session=%s verb=%s args=%r",
                         session_key, _verb, _normalized_args,
                     )
-                    _adapter = self._adapter_for_source(event.source)
+                    _adapter = self._delivery_adapter_for(event.source)
                     if _adapter and _reply:
                         _text, _eph_ttl = _adapter._unwrap_ephemeral(_reply)
                         if _text:
@@ -745,7 +745,7 @@ class GatewayBusySessionMixin:
         # Gateway wakes have no external user identity. Admit them before auth/drain/approval
         # handling, without merging their text into an already queued human message.
         if event.internal and event.allow_gateway_control:
-            adapter = self._adapter_for_source(event.source)
+            adapter = self._delivery_adapter_for(event.source)
             if adapter and session_key in getattr(adapter, "_pending_messages", {}):
                 self._queue_or_replace_pending_event(session_key, event)
                 return True
@@ -774,7 +774,7 @@ class GatewayBusySessionMixin:
             return True
         if await self._route_plaintext_approval_while_busy(event, session_key):
             return True
-        adapter = self._adapter_for_source(event.source)
+        adapter = self._delivery_adapter_for(event.source)
         if not adapter:
             return False  # let default path handle it
         # Internal synthetic events (delegation / background completions) must never interrupt or
@@ -873,7 +873,7 @@ class GatewayBusySessionMixin:
     async def _send_command_ack(self, source, text: str, label: str) -> None:
         """Best-effort acknowledgment for a slash command that falls through to agent processing."""
         try:
-            adapter = self._adapter_for_source(source)
+            adapter = self._delivery_adapter_for(source)
             if adapter:
                 await adapter.send(
                     str(source.chat_id), text, metadata=self._thread_metadata_for_source(source)
@@ -984,7 +984,7 @@ class GatewayBusySessionMixin:
         has_media = bool(getattr(event, "media_urls", None))
         if not queued_text and not has_media:
             return "Usage: /queue <prompt>"
-        adapter = self._adapter_for_source(source)
+        adapter = self._delivery_adapter_for(source)
         if adapter:
             self._enqueue_fifo(quick_key, MessageEvent(
                 text=queued_text, message_type=event.message_type if has_media else MessageType.TEXT,
@@ -1014,7 +1014,7 @@ class GatewayBusySessionMixin:
 
         def _queue_fallback(reply: str) -> str:
             # Turn-boundary fallback: queue the steer text as its own follow-up turn.
-            adapter = self._adapter_for_source(source)
+            adapter = self._delivery_adapter_for(source)
             if adapter:
                 self._enqueue_fifo(quick_key, MessageEvent(
                     text=steer_text, message_type=MessageType.TEXT, source=event.source,
@@ -1332,7 +1332,7 @@ class GatewayBusySessionMixin:
         # Register FIRST so a fast button click cannot race the send_slash_confirm return.
         _slash_confirm_mod.register(session_key, confirm_id, command, handler)
 
-        adapter = self._adapter_for_source(source)
+        adapter = self._delivery_adapter_for(source)
         metadata = self._thread_metadata_for_source(source, self._reply_anchor_for_event(event))
 
         if adapter is not None:
diff --git a/gateway/run_goals.py b/gateway/run_goals.py
index b983db21de..9f6adf037e 100644
--- a/gateway/run_goals.py
+++ b/gateway/run_goals.py
@@ -139,7 +139,7 @@ class GatewayGoalsMixin:
                 return
             session_id = current
             watch[quick_key] = (source, session_id)
-        adapter = self._adapter_for_source(source)
+        adapter = self._delivery_adapter_for(source)
         if adapter is None or not adapter._message_handler:
             return
         if (
@@ -205,7 +205,7 @@ class GatewayGoalsMixin:
             logger.debug("Failed to start heartbeat poller", exc_info=True)
 
     def _goal_notice_adapter(self, source: Any):
-        adapter = self._adapter_for_source(source)
+        adapter = self._delivery_adapter_for(source)
         if not adapter:
             logger.debug("goal continuation: no adapter for %s", getattr(source, "platform", None))
         return adapter
@@ -308,7 +308,7 @@ class GatewayGoalsMixin:
             return
         # Enqueue via the adapter's FIFO so a user message already in flight preempts naturally.
         try:
-            adapter = self._adapter_for_source(source)
+            adapter = self._delivery_adapter_for(source)
             _quick_key = self._session_key_for_source(source)
             if adapter and _quick_key:
                 self._enqueue_fifo(_quick_key, self._synthetic_prompt_event(source, prompt), adapter)
diff --git a/gateway/run_inbound.py b/gateway/run_inbound.py
index 0cee837298..17db75bd8d 100644
--- a/gateway/run_inbound.py
+++ b/gateway/run_inbound.py
@@ -111,7 +111,7 @@ class GatewayInboundMixin:
         if pairing_store._is_rate_limited(platform_name, source.user_id):
             return
         code = pairing_store.generate_code(platform_name, source.user_id, source.user_name or "")
-        adapter = self._adapter_for_source(source)
+        adapter = self._delivery_adapter_for(source)
         if code:
             reply = pairing_code_reply(platform_name, code, pairing_profile_arg(pairing_store))
         else:
@@ -132,7 +132,7 @@ class GatewayInboundMixin:
         if pairing_store is None or pairing_store.has_recent_decline(platform_name, source.user_id):
             return
         pairing_store.record_decline(platform_name, source.user_id)
-        adapter = self._adapter_for_source(source)
+        adapter = self._delivery_adapter_for(source)
         if not adapter:
             return
         config = getattr(self, "config", None)
@@ -176,21 +176,12 @@ class GatewayInboundMixin:
         except Exception:
             logger.debug("reset_session_vars failed at handler entry", exc_info=True)
 
-        # Most adapters resolve profile routes in build_source(); internal/voice paths construct
-        # SessionSource directly, so resolve those here as the shared fail-closed ingress gate.
-        # Strict boolean marker: require the literal True so duck-typed test/internal sources with
-        # dynamic attributes are not mistaken for a rejection.
-        if (
-            getattr(_config, "multiplex_profiles", False)
-            and not getattr(source, "profile", None)
-            and getattr(source, "profile_route_rejected", False) is not True
-        ):
-            from gateway.profile_routing import ProfileRouteRejected
-
-            try:
-                source.profile = self._profile_name_for_source(source)
-            except ProfileRouteRejected:
-                source.profile_route_rejected = True
+        # Identity FIRST. Most adapters canonicalize at their own ingress; internal/voice paths
+        # construct SessionSource directly, so this is the shared fail-closed gate. Strict boolean
+        # marker: require the literal True so duck-typed test/internal sources with dynamic
+        # attributes are not mistaken for a rejection.
+        if getattr(_config, "multiplex_profiles", False):
+            self._canonicalize(source)
         if getattr(source, "profile_route_rejected", False) is True:
             logger.warning(
                 "Dropping inbound message because its explicit profile route "
@@ -207,7 +198,7 @@ class GatewayInboundMixin:
             # The routed adapter's extra carries a secondary profile's own list; ``_config`` is the default's.
             _slack_adapter = None
             with suppress(Exception):
-                _slack_adapter = self._adapter_for_source(source)
+                _slack_adapter = self._intake_adapter_for(source)
         if (
             # See #51899.
             not is_internal
@@ -406,7 +397,7 @@ class GatewayInboundMixin:
             )
             # The clarify callback pauses the platform typing/status indicator while waiting so
             # Slack users can type; the active agent resumes now, so re-enable its indicator.
-            _clarify_adapter = self._adapter_for_source(source)
+            _clarify_adapter = self._delivery_adapter_for(source)
             if _clarify_adapter:
                 try:
                     _clarify_adapter.resume_typing_for_chat(source.chat_id)
@@ -435,7 +426,7 @@ class GatewayInboundMixin:
                 # prose is routed, so its buttons stop advertising a dead answer path. The pop inside
                 # retire_clarify_card runs before its first await, so the agent thread's own expiry
                 # notice (scheduled once the wait unblocks) finds nothing and stays a no-op.
-                _clarify_adapter = self._adapter_for_source(source)
+                _clarify_adapter = self._delivery_adapter_for(source)
                 # Class lookup: a MagicMock adapter must not fabricate the method.
                 if callable(getattr(type(_clarify_adapter), "retire_clarify_card", None)):
                     try:
@@ -576,7 +567,7 @@ class GatewayInboundMixin:
     ) -> None:
         """Merge *event* into the source adapter's pending slot (no-op without an adapter)."""
         from gateway.platforms.base import merge_pending_message_event
-        adapter = self._adapter_for_source(source)
+        adapter = self._delivery_adapter_for(source)
         if adapter:
             merge_pending_message_event(adapter._pending_messages, _quick_key, event, merge_text=merge_text)
 
@@ -631,7 +622,7 @@ class GatewayInboundMixin:
         if effective_busy_input_mode != "queue":
             self._hm_merge_pending_for_source(source, _quick_key, event, merge_text=True)
         else:
-            adapter = self._adapter_for_source(source)
+            adapter = self._delivery_adapter_for(source)
             if adapter:
                 self._enqueue_fifo(_quick_key, event, adapter)
         return True
@@ -676,7 +667,7 @@ class GatewayInboundMixin:
         _interrupt_text = event.text
         if self._pending_event_audio_paths(event):
             _interrupt_text, _ = await self._transcribe_and_echo_pending_voice(
-                event, self._adapter_for_source(source), source, event.text or "",
+                event, self._delivery_adapter_for(source), source, event.text or "",
                 log_context="Voice-priority-interrupt",
             )
         elif not _interrupt_text and getattr(event, "media_urls", None):
@@ -1252,7 +1243,7 @@ class GatewayInboundMixin:
             # turn for this session NOW: re-stage the orphans in FIFO order and enqueue the incoming event
             # behind them, so arrival order (#28503) holds: oldest orphan runs as this turn, the rest drain
             # in order, the new message last.
-            _orphan_adapter = self._adapter_for_source(source)
+            _orphan_adapter = self._delivery_adapter_for(source)
             if _orphan_adapter is None or getattr(event, "internal", False) or event.get_command():
                 return event, source, is_internal
             _rescued = self._rescue_orphaned_overflow(_quick_key, _orphan_adapter)
@@ -1504,7 +1495,7 @@ class GatewayInboundMixin:
         # quality in real time. On transcription failure do NOT send a hardcoded notice: that
         # bypassed the LLM and produced two replies; enrichment leaves one neutral marker instead.
         if _successful_transcripts and self._should_echo_stt_transcripts():
-            _echo_adapter = self._adapter_for_source(source)
+            _echo_adapter = self._delivery_adapter_for(source)
             if _echo_adapter:
                 _echo_meta = self._thread_metadata_for_source(source, self._reply_anchor_for_event(event))
                 await self._echo_stt_transcripts(_echo_adapter, source, _successful_transcripts, metadata=_echo_meta)
@@ -1674,7 +1665,7 @@ class GatewayInboundMixin:
                 message_text, cwd=_msg_cwd, context_length=_msg_ctx_len, allowed_root=_msg_cwd
             )
             if _ctx_result.blocked:
-                _adapter = self._adapter_for_source(source)
+                _adapter = self._delivery_adapter_for(source)
                 if _adapter:
                     await _adapter.send(
                         source.chat_id,
@@ -1882,7 +1873,7 @@ class GatewayInboundMixin:
             )
             return False
 
-        adapter = self._adapter_for_source(source)
+        adapter = self._delivery_adapter_for(source)
         if adapter is None:
             return False
 
diff --git a/gateway/run_notifications.py b/gateway/run_notifications.py
index 7056366efd..37f25a670f 100644
--- a/gateway/run_notifications.py
+++ b/gateway/run_notifications.py
@@ -117,7 +117,7 @@ class GatewayNotificationsMixin:
     async def _deliver_platform_notice(self, source, content: str) -> None:
         """Deliver a setup/operational notice using platform-specific privacy rules."""
         from gateway.run import _is_slack_ignored_channel
-        adapter = self._adapter_for_source(source)
+        adapter = self._delivery_adapter_for(source)
         if not adapter:
             return
         config = getattr(self, "config", None)
diff --git a/gateway/run_shutdown.py b/gateway/run_shutdown.py
index 75b803d0e5..e0d2f91f44 100644
--- a/gateway/run_shutdown.py
+++ b/gateway/run_shutdown.py
@@ -1005,7 +1005,7 @@ class GatewayShutdownMixin:
                 # The session's OWN profile's bot (transport ref → profile map), never a bare
                 # self.adapters hit: under multiplex that is the default bot, so a secondary session's
                 # "Gateway shutting down" would land in the user's chat with the wrong bot.
-                adapter = self._adapter_for_source(source) if source is not None else None
+                adapter = self._delivery_adapter_for(source) if source is not None else None
                 if adapter is None:
                     adapter = self._authorization_adapter(platform, profile)
                 if not adapter:
diff --git a/gateway/run_startup.py b/gateway/run_startup.py
index a1b2772122..f2e1176fa2 100644
--- a/gateway/run_startup.py
+++ b/gateway/run_startup.py
@@ -85,7 +85,7 @@ class GatewayStartupMixin:
         while queue:
             event = queue.pop(0)
             source = getattr(event, "source", None)
-            adapter = self._adapter_for_source(source)
+            adapter = self._intake_adapter_for(source)
             if adapter is None:
                 logger.debug(
                     "Dropping startup-restore queued message: adapter unavailable for %s",
@@ -567,7 +567,7 @@ class GatewayStartupMixin:
             if self._is_session_running(entry.session_key):
                 continue
             source = entry.origin
-            adapter = self._adapter_for_source(source)
+            adapter = self._delivery_adapter_for(source)
             if adapter is None:
                 logger.debug(
                     "Skipping auto-resume for %s: adapter not ready for %s", entry.session_key,
diff --git a/gateway/run_topics.py b/gateway/run_topics.py
index cc467c1b43..fac741312f 100644
--- a/gateway/run_topics.py
+++ b/gateway/run_topics.py
@@ -231,7 +231,7 @@ class GatewayTopicThreadsMixin:
 
     async def _get_telegram_topic_capabilities(self, source: SessionSource) -> dict:
         """Read Telegram private-topic capability flags via Bot API getMe."""
-        bot = getattr(self._adapter_for_source(source), "_bot", None)
+        bot = getattr(self._delivery_adapter_for(source), "_bot", None)
         if bot is None or not hasattr(bot, "get_me"):
             return {"checked": False}
         try:
@@ -252,7 +252,7 @@ class GatewayTopicThreadsMixin:
 
     async def _ensure_telegram_system_topic(self, source: SessionSource) -> None:
         """Create/pin the managed System topic after /topic activation when possible."""
-        adapter = self._adapter_for_source(source)
+        adapter = self._delivery_adapter_for(source)
         create_topic = getattr(adapter, "_create_dm_topic", None) if adapter is not None and source.chat_id else None
         if not callable(create_topic):
             return
@@ -281,7 +281,7 @@ class GatewayTopicThreadsMixin:
 
     async def _send_telegram_topic_setup_image(self, source: SessionSource) -> None:
         """Send the bundled BotFather Threads Settings screenshot when available."""
-        adapter = self._adapter_for_source(source)
+        adapter = self._delivery_adapter_for(source)
         image_path = Path(__file__).resolve().parent / "assets" / "telegram-botfather-threads-settings.jpg"
         if adapter is None or not source.chat_id or not hasattr(adapter, "send_image_file") or not image_path.exists():
             return
@@ -347,7 +347,7 @@ class GatewayTopicThreadsMixin:
             # Deterministic per-thread identity; the empty initial-name marker signals the caller
             # to rely on the connector-side no-clobber guard.
             return (str(prospective), "")
-        info_fn = getattr(self._adapter_for_source(source), "auto_thread_info_for_chat", None)
+        info_fn = getattr(self._delivery_adapter_for(source), "auto_thread_info_for_chat", None)
         if not callable(info_fn):
             return None
         with suppress(Exception):
@@ -363,7 +363,7 @@ class GatewayTopicThreadsMixin:
         known = self._relay_auto_thread_info(source)
         if known is not None:
             return known
-        wait_fn = getattr(self._adapter_for_source(source), "wait_for_auto_thread_info", None)
+        wait_fn = getattr(self._delivery_adapter_for(source), "wait_for_auto_thread_info", None)
         if not callable(wait_fn) or not source.chat_id:
             return None
         # 0 means the operator disabled the turn limit; the backstop still needs one.
@@ -388,7 +388,7 @@ class GatewayTopicThreadsMixin:
             relay_info = await self._await_relay_auto_thread_info(source)
             if relay_info is None:
                 return
-        adapter = self._adapter_for_source(source) if getattr(self, "adapters", None) else None
+        adapter = self._delivery_adapter_for(source) if getattr(self, "adapters", None) else None
         rename_thread = getattr(adapter, "rename_thread", None)
         if rename_thread is None:
             return
@@ -501,7 +501,7 @@ class GatewayTopicThreadsMixin:
         # auto-renaming would silently mutate operator config. Check the class, not the instance —
         # getattr() on a MagicMock auto-creates attributes, so every test double would match. Only
         # dict-shaped returns count; a bare MagicMock or other sentinel shouldn't.
-        adapter = self._adapter_for_source(source)
+        adapter = self._delivery_adapter_for(source)
         get_info = getattr(type(adapter), "_get_dm_topic_info", None) if adapter is not None else None
         if callable(get_info):
             try:
diff --git a/gateway/run_turn.py b/gateway/run_turn.py
index eb7b9b37f7..58f74da9f8 100644
--- a/gateway/run_turn.py
+++ b/gateway/run_turn.py
@@ -45,6 +45,33 @@ if TYPE_CHECKING:  # string annotations only; never imported at runtime (cycle)
 # Log-record parity with the origin module.
 logger = logging.getLogger("gateway.run")
 
+_tool_call_logger_lock = threading.Lock()
+
+
+def _tool_call_logger() -> logging.Logger:
+    """Process-wide ``hermes.tool_calls`` Logger + one RotatingFileHandler on logs/tool_calls.log.
+    Named Loggers live in ``logging.Logger.manager.loggerDict`` forever, so the former per-turn name
+    (``hermes.tool_calls.<id(log_queue)>``) leaked one Logger per logged turn (#62950); a single
+    shared handler also keeps concurrent turns from double-writing lines."""
+    tool_logger = logging.getLogger("hermes.tool_calls")
+    with _tool_call_logger_lock:
+        if not tool_logger.handlers:
+            from logging.handlers import RotatingFileHandler
+            from agent.redact import RedactingFormatter
+            from gateway.run import _hermes_home
+
+            log_dir = _hermes_home / "logs"
+            log_dir.mkdir(parents=True, exist_ok=True)
+            handler = RotatingFileHandler(
+                log_dir / "tool_calls.log", maxBytes=5 * 1024 * 1024, backupCount=3, encoding="utf-8",
+            )
+            handler.setFormatter(RedactingFormatter("%(message)s"))
+            tool_logger.setLevel(logging.INFO)
+            tool_logger.propagate = False
+            tool_logger.addHandler(handler)
+    return tool_logger
+
+
 
 _CONTEXT_OVERFLOW_ERROR_PHRASES = (
     "context length", "context size", "context window",
@@ -480,7 +507,7 @@ class GatewayTurnMixin:
 
         try:
             should_notify = reset_reason == "suspended"
-            adapter = self._adapter_for_source(source) if should_notify else None
+            adapter = self._delivery_adapter_for(source) if should_notify else None
             if adapter:
                 notice = (
                     "◐ Session reset after being stopped. "
@@ -826,7 +853,7 @@ class GatewayTurnMixin:
     async def _hmwa_hygiene_notify(self, source, meta, message, what):
         """Best-effort user notice on the hygiene thread; failure is logged, never raised."""
         try:
-            _adapter = self._adapter_for_source(source)
+            _adapter = self._delivery_adapter_for(source)
             if _adapter and source.chat_id:
                 await _adapter.emit_warning(source.chat_id, message, metadata=meta,
                                             logical_platform=source.platform)
@@ -1429,7 +1456,7 @@ class GatewayTurnMixin:
         """Stop the typing indicator (never raises). Slack AI status is scoped to a thread/
         workspace, so preserve the routing metadata used by the response delivery path."""
         with suppress(Exception):
-            _typing_adapter = self._adapter_for_source(source)
+            _typing_adapter = self._delivery_adapter_for(source)
             _kind = type(_typing_adapter)
             if _typing_adapter and callable(getattr(_kind, "_stop_typing_with_metadata", None)):
                 await _typing_adapter._stop_typing_with_metadata(source.chat_id, self._event_thread_metadata(event, source))
@@ -1855,7 +1882,7 @@ class GatewayTurnMixin:
             logger.info("Suppressing intentional silence marker for session %s", session_entry.session_id)
             response = ""
 
-        adapter = self._adapter_for_source(source)
+        adapter = self._delivery_adapter_for(source)
         # Auto voice reply (TTS audio before the text) unless streaming TTS already delivered audio.
         _streaming_tts_done = adapter is not None and bool(
             getattr(adapter, "_streaming_tts_turn_completed", lambda *_a, **_k: False)(session_key, run_generation)
@@ -1956,7 +1983,7 @@ class GatewayTurnMixin:
             "Discarding stale agent result for %s — generation %d is no longer current",
             _quick_key or "?", run_generation,
         )
-        self._pop_post_delivery_callback(self._adapter_for_source(source), _quick_key, run_generation)
+        self._pop_post_delivery_callback(self._delivery_adapter_for(source), _quick_key, run_generation)
 
     @dataclasses.dataclass
     class _PreparedTurn:
@@ -2050,7 +2077,7 @@ class GatewayTurnMixin:
 
         # Bind this run generation to the adapter so deferred post-delivery callbacks are released
         # by the run that registered them.
-        self._bind_adapter_run_generation(self._adapter_for_source(source), session_key, run_generation)
+        self._bind_adapter_run_generation(self._delivery_adapter_for(source), session_key, run_generation)
         # Delivery IDs are only unique in their transport namespace. Keyless turns
         # need their own identity, even when another process writes to this session.
         import uuid
@@ -2283,7 +2310,7 @@ class GatewayTurnMixin:
         toolsets dropped, not trusted)."""
         from hermes_cli.tools_config import _get_platform_tools
         try:
-            adapter = self._adapter_for_source(source)
+            adapter = self._delivery_adapter_for(source)
             override = adapter.toolsets_for_source(source) if adapter is not None else None
         except Exception:
             override = None
@@ -2313,7 +2340,7 @@ class GatewayTurnMixin:
         from run_agent import AIAgent
         media_urls = media_urls or []
         media_types = media_types or []
-        adapter = self._adapter_for_source(source)
+        adapter = self._delivery_adapter_for(source)
         if not adapter:
             logger.warning("No adapter for platform %s in background task %s", source.platform, task_id)
             return
@@ -2633,7 +2660,7 @@ class GatewayTurnMixin:
             return None
         try:
             from gateway.stream_consumer import GatewayStreamConsumer
-            _adapter = self._adapter_for_source(source)
+            _adapter = self._delivery_adapter_for(source)
             if not _adapter:
                 return None
             _consumer_cfg, _pause_typing_before_finalize = self._build_stream_consumer_config(
@@ -2717,7 +2744,7 @@ class GatewayTurnMixin:
         )
         stream_task = asyncio.create_task(_stream_consumer.run()) if _stream_consumer else None
 
-        _adapter = self._adapter_for_source(source)
+        _adapter = self._delivery_adapter_for(source)
         if _adapter and not scheduled_heartbeat:
             with suppress(Exception):
                 await _adapter.send_typing(source.chat_id, metadata=_thread_metadata)
@@ -2847,7 +2874,7 @@ class GatewayTurnMixin:
         user_config = _load_gateway_config()
         platform_key = _platform_config_key(source.platform)
         enabled_toolsets, disabled_toolsets = self._resolve_turn_toolsets(user_config, source, platform_key)
-        adapter = self._adapter_for_source(source)
+        adapter = self._delivery_adapter_for(source)
         # Tool preview length (0 = no limit) and friendly tool labels (default on), per-platform.
         for _setter, _setting, _default, _cast in (
             ("set_tool_preview_max_len", "tool_preview_length", 0, lambda v: int(v) if v else 0),
@@ -2980,7 +3007,7 @@ class GatewayTurnMixin:
         _cleanup_progress = bool(
             disp.resolve_display_setting(disp.user_config, disp.platform_key, "cleanup_progress")
         )
-        _cleanup_adapter = self._adapter_for_source(source) if _cleanup_progress else None
+        _cleanup_adapter = self._delivery_adapter_for(source) if _cleanup_progress else None
         if _cleanup_adapter is not None and getattr(type(_cleanup_adapter), "delete_message", None) in (
             None, BasePlatformAdapter.delete_message,
         ):
@@ -3039,7 +3066,7 @@ class GatewayTurnMixin:
         from gateway.run import _non_conversational_metadata, _resolve_progress_thread_id
         is_buzz = str(getattr(source.platform, "value", source.platform) or "").lower() == "buzz"
         _progress_reply_in_thread = True
-        _adapter = self._adapter_for_source(source) if source.platform == Platform.SLACK or is_buzz else None
+        _adapter = self._delivery_adapter_for(source) if source.platform == Platform.SLACK or is_buzz else None
         if _adapter is not None:
             try:
                 if is_buzz:
@@ -3098,22 +3125,9 @@ class GatewayTurnMixin:
         """Drain log_queue and append tool-call lines to tool_calls.log (tool_progress=log).
 
         RotatingFileHandler (5MB × 3) bounds the log; RedactingFormatter keeps secrets off disk."""
-        from gateway.run import _hermes_home
         if log_queue is None:
             return
-        from logging.handlers import RotatingFileHandler
-        from agent.redact import RedactingFormatter
-
-        log_dir = _hermes_home / "logs"
-        log_dir.mkdir(parents=True, exist_ok=True)
-        file_handler = RotatingFileHandler(
-            log_dir / "tool_calls.log", maxBytes=5 * 1024 * 1024, backupCount=3, encoding="utf-8",
-        )
-        file_handler.setFormatter(RedactingFormatter("%(message)s"))
-        tool_logger = logging.getLogger(f"hermes.tool_calls.{id(log_queue)}")
-        tool_logger.setLevel(logging.INFO)
-        tool_logger.propagate = False
-        tool_logger.addHandler(file_handler)
+        tool_logger = _tool_call_logger()
         try:
             while True:
                 try:
@@ -3130,10 +3144,9 @@ class GatewayTurnMixin:
             with suppress(Exception):
                 while True:
                     tool_logger.info("%s", log_queue.get_nowait())
-            tool_logger.removeHandler(file_handler)
             with suppress(Exception):
-                file_handler.flush()
-                file_handler.close()
+                for handler in tool_logger.handlers:
+                    handler.flush()
 
     def _run_agent_start_streaming_tts(
         self, source: SessionSource, message_type: Optional[str],
@@ -3147,7 +3160,7 @@ class GatewayTurnMixin:
         # This avoids a cross-scope NameError: the outer interrupt / finalisation paths reference the
         # consumer via ``streaming_tts_consumer_holder[0]``. Gates: voice input, auto-TTS enabled for this
         # chat, adapter supports streaming, and a usable streaming TTS provider configured. See #60671.
-        _stts_adapter = self._adapter_for_source(source)
+        _stts_adapter = self._delivery_adapter_for(source)
         _is_voice_input = (
             message_type is not None
             and str(getattr(message_type, "value", message_type)).lower() == "voice"
@@ -3255,7 +3268,7 @@ class GatewayTurnMixin:
             await asyncio.sleep(0.2)
             try:
                 # Re-resolve the adapter each iteration so reconnects don't leave a stale reference.
-                _adapter = self._adapter_for_source(source)
+                _adapter = self._delivery_adapter_for(source)
                 if not _adapter:
                     continue
                 if hasattr(_adapter, 'has_pending_interrupt') and _adapter.has_pending_interrupt(session_key):
@@ -3279,7 +3292,7 @@ class GatewayTurnMixin:
         source, session_key = turn_ctx.source, turn_ctx.session_key
         if _interrupt_detected.is_set() or not session_key:
             return
-        _backup_adapter = self._adapter_for_source(source)
+        _backup_adapter = self._delivery_adapter_for(source)
         _backup_agent = turn_ctx.agent_holder[0]
         if (_backup_adapter and _backup_agent
                 and hasattr(_backup_adapter, 'has_pending_interrupt')
@@ -3403,7 +3416,7 @@ class GatewayTurnMixin:
     async def _run_agent_inactivity_warning(self, worker, source, _status_thread_metadata) -> None:
         """Staged one-shot warning before the inactivity timeout escalates."""
         from gateway.run import _interim_metadata
-        _warn_adapter = self._adapter_for_source(source)
+        _warn_adapter = self._delivery_adapter_for(source)
         if not _warn_adapter:
             return
         try:
@@ -3696,7 +3709,7 @@ class GatewayTurnMixin:
                 "Interrupt recursion depth %d reached for session %s — "
                 "queueing message instead of recursing.", _interrupt_depth, session_key,
             )
-            adapter = self._adapter_for_source(source)
+            adapter = self._delivery_adapter_for(source)
             if adapter and pending_event:
                 merge_pending_message_event(adapter._pending_messages, session_key, pending_event)
             elif adapter and hasattr(adapter, 'queue_message'):
@@ -3750,7 +3763,7 @@ class GatewayTurnMixin:
 
         # Clear the prior turn's streaming-TTS completion marker so the recursive turn isn't suppressed.
         # See #60671.
-        _clear_adapter = self._adapter_for_source(source)
+        _clear_adapter = self._delivery_adapter_for(source)
         _completed_turns = getattr(_clear_adapter, "_streaming_tts_completed_turns", None)
         _prior_key = getattr(_clear_adapter, "_streaming_tts_turn_key", None)
         if _completed_turns is not None and callable(_prior_key) and session_key and run_generation is not None:
@@ -3779,7 +3792,7 @@ class GatewayTurnMixin:
         # Resolve the adapter from the follow-up's OWN source — a multiplexed gateway can route it to a
         # different profile's adapter, and only that instance holds the per-message reaction state.
         from gateway.run_turn_followup_ack import _followup_cancel_outcome, _run_followup_processing_hook
-        _hook_adapter = self._adapter_for_source(next_source) if pending_event is not None else None
+        _hook_adapter = self._intake_adapter_for(next_source) if pending_event is not None else None
         await _run_followup_processing_hook(_hook_adapter, pending_event, "on_processing_start")
         # The re-baseline sits inside the try: a /stop landing on its DB await must still close the marker
         # (the helper's own ``except Exception`` does not catch cancellation).
@@ -4028,7 +4041,7 @@ class GatewayTurnMixin:
         turn_ctx._step_callback_sync = turn_runner._step_callback_sync
         turn_ctx._event_callback_sync = turn_runner._event_callback_sync
         turn_ctx._status_callback_sync = turn_runner._status_callback_sync
-        turn_ctx._status_adapter = self._adapter_for_source(source)
+        turn_ctx._status_adapter = self._delivery_adapter_for(source)
         turn_ctx._status_chat_id = source.chat_id
         turn_ctx._status_thread_metadata = _status_thread_metadata
         return _status_thread_metadata
@@ -4050,7 +4063,7 @@ class GatewayTurnMixin:
             return
         source, session_key, agent_holder = turn_ctx.source, turn_ctx.session_key, turn_ctx.agent_holder
         _status_thread_metadata = turn_ctx._status_thread_metadata
-        _notify_adapter = self._adapter_for_source(source)
+        _notify_adapter = self._delivery_adapter_for(source)
         if not _notify_adapter:
             return
         _heartbeat_msg_id: Optional[str] = None
@@ -4192,7 +4205,7 @@ class GatewayTurnMixin:
 
             # Interrupted OR queued message (/queue)?
             result = turn_ctx.result_holder[0]
-            adapter = self._adapter_for_source(source)
+            adapter = self._delivery_adapter_for(source)
             await self._run_agent_finalize_streaming_tts(turn_ctx, adapter)
             pending_event, pending = await self._run_agent_drain_pending(result, adapter, source, session_key)
             if pending_event or pending:
diff --git a/gateway/run_turn_runner.py b/gateway/run_turn_runner.py
index 795db09467..1b09f5af18 100644
--- a/gateway/run_turn_runner.py
+++ b/gateway/run_turn_runner.py
@@ -264,7 +264,7 @@ class TurnRunner:
         from agent.display import get_tool_emoji
         emoji = get_tool_emoji(tool_name, default="⚙️")
         try:
-            adapter = self._runner._adapter_for_source(ctx.source)
+            adapter = self._runner._delivery_adapter_for(ctx.source)
         except Exception:
             adapter = None
         code_full, code_short = self._progress_terminal_blocks(adapter, tool_name, args, emoji)
@@ -704,7 +704,7 @@ class TurnRunner:
 
     async def send_progress_messages(self):
         ctx = self._ctx
-        adapter = self._runner._adapter_for_source(ctx.source) if ctx.progress_queue else None
+        adapter = self._runner._delivery_adapter_for(ctx.source) if ctx.progress_queue else None
         if not adapter:
             return
         if ctx._native_slack_task_cards and hasattr(adapter, "send_native_task_card_progress"):
@@ -928,7 +928,7 @@ class TurnRunner:
         if want_stream_deltas or want_interim_messages:
             try:
                 from gateway.stream_consumer import GatewayStreamConsumer
-                adapter = self._runner._adapter_for_source(ctx.source)
+                adapter = self._runner._delivery_adapter_for(ctx.source)
                 if adapter:
                     consumer_cfg, pause_typing_before_finalize = self._runner._build_stream_consumer_config(
                         ctx.source, scfg, adapter, on_missing_cursor="raise",
@@ -1597,7 +1597,7 @@ class TurnRunner:
     def _resume_note_interactive(self) -> bool:
         """Interactive platforms report the restore and ask what next; event platforms (webhook,
         API server) continue the work — nobody is present to answer."""
-        return bool(getattr(self._runner._adapter_for_source(self._ctx.source), "interactive_resume", True))
+        return bool(getattr(self._runner._delivery_adapter_for(self._ctx.source), "interactive_resume", True))
 
     def _prepare_turn_message(self, agent_history):
         """Prepend recovery/notice guidance to ``ctx.message``.
diff --git a/gateway/run_voice.py b/gateway/run_voice.py
index 22ac693ca9..7441d49ebe 100644
--- a/gateway/run_voice.py
+++ b/gateway/run_voice.py
@@ -136,7 +136,7 @@ class GatewayVoiceMixin:
         return raw.guild.id if getattr(raw, "guild", None) else None  # regular message
 
     async def _handle_voice_channel_join(self, event: MessageEvent) -> str:
-        adapter = self._adapter_for_source(event.source)
+        adapter = self._delivery_adapter_for(event.source)
         if not hasattr(adapter, "join_voice_channel"):
             return "Voice channels are not supported on this platform."
         guild_id = self._get_guild_id(event)
@@ -177,7 +177,7 @@ class GatewayVoiceMixin:
                 f"I'll speak my replies and listen to you. Use /voice leave to disconnect.")
 
     async def _handle_voice_channel_leave(self, event: MessageEvent) -> str:
-        adapter = self._adapter_for_source(event.source)
+        adapter = self._delivery_adapter_for(event.source)
         guild_id = self._get_guild_id(event)
         if not (guild_id and hasattr(adapter, "leave_voice_channel")
                 and hasattr(adapter, "is_in_voice_channel")
@@ -248,8 +248,11 @@ class GatewayVoiceMixin:
         if not text_ch_id:
             return
         source = self._voice_input_source(adapter, guild_id, user_id, text_ch_id)
-        # Cached source still carries the previous speaker's routed profile.
-        if not self._stamp_routed_profile(source, getattr(adapter, "_owner_profile", None)):
+        # The cached source still carries the previous speaker's identity (per-sender routes,
+        # #106019): drop the pin so the seam re-resolves for THIS speaker.
+        from gateway.session_identity import clear_identity
+        clear_identity(source)
+        if self._canonicalize(source, transport_profile=getattr(adapter, "_owner_profile", None)) is None:
             logger.warning("Dropping voice input: its profile route targets an unserved profile")
             return
         # Validate the session owner against the current allowlist before auto-resuming. A session created
@@ -295,7 +298,7 @@ class GatewayVoiceMixin:
         chat_id = event.source.chat_id
         voice_mode = self._voice_mode.get(self._voice_key_for_source(event.source))
         is_voice_input = event.message_type == MessageType.VOICE
-        adapter = self._adapter_for_source(event.source)
+        adapter = self._delivery_adapter_for(event.source)
         adapter_auto_tts = False
         with suppress(Exception):  # adapters without the probe read as False
             adapter_auto_tts = bool(adapter._should_auto_tts_for_chat(chat_id))
@@ -359,7 +362,7 @@ class GatewayVoiceMixin:
 
     async def _deliver_voice_reply(self, event: MessageEvent, audio_paths: List[str]) -> None:
         """Play the files in the connected voice channel, else send them as voice messages."""
-        adapter = self._adapter_for_source(event.source)
+        adapter = self._delivery_adapter_for(event.source)
         guild_id = self._get_guild_id(event)
         play = getattr(adapter, "play_in_voice_channel", None)
         is_in_vc = getattr(adapter, "is_in_voice_channel", None)
diff --git a/gateway/run_watchers.py b/gateway/run_watchers.py
index bb19769840..86f8950b6e 100644
--- a/gateway/run_watchers.py
+++ b/gateway/run_watchers.py
@@ -109,7 +109,7 @@ class GatewaySessionWatchersMixin:
             if not session_key or session_key in candidates or not overflow:
                 continue
             source = getattr(overflow[0], "source", None)
-            if source is not None and (adapter := self._adapter_for_source(source)) is not None:
+            if source is not None and (adapter := self._delivery_adapter_for(source)) is not None:
                 candidates[session_key] = (adapter, overflow[0])
         return candidates
 
diff --git a/gateway/session_identity.py b/gateway/session_identity.py
index d746cb6e4f..c1408fb95f 100644
--- a/gateway/session_identity.py
+++ b/gateway/session_identity.py
@@ -15,6 +15,8 @@ receiving bot's own profile — so nothing here changes the wire format or any h
 from __future__ import annotations
 
 import dataclasses
+import logging
+from contextlib import suppress
 import weakref
 from dataclasses import dataclass, field
 from pathlib import Path
@@ -23,6 +25,8 @@ from typing import TYPE_CHECKING, Any, Optional
 if TYPE_CHECKING:
     from gateway.session import SessionSource
 
+logger = logging.getLogger(__name__)
+
 _IDENTITY_ATTR = "_identity"
 # Wire-invisible provenance copied alongside the identity when a source is duplicated.
 _PROVENANCE_ATTRS = ("_transport_adapter_ref", "_authorization_profile_home", _IDENTITY_ATTR)
@@ -82,6 +86,19 @@ def identity_of(source: Any) -> Optional[RoutingIdentity]:
     return identity if isinstance(identity, RoutingIdentity) else None
 
 
+def clear_identity(source: Any) -> None:
+    """Drop the pinned identity AND the routed runtime profile so the next :func:`canonical_identity`
+    re-routes from scratch — for sources a caller reuses across events whose routing may differ (a
+    guild's cached voice source is shared by every speaker, and ``profile_routes[].user_id`` routes
+    per speaker). ``source.profile`` is the previous event's routing *result*; left in place it
+    short-circuits the route and the new speaker runs as the old one."""
+    for attr in (_IDENTITY_ATTR, "profile_route_rejected", "_authorization_profile_home"):
+        with suppress(AttributeError):
+            delattr(source, attr)
+    with suppress(AttributeError):
+        source.profile = None
+
+
 def replace_source(source: "SessionSource", **changes: Any) -> "SessionSource":
     """:func:`dataclasses.replace` that keeps the wire-invisible provenance (transport ref,
     authorization home, identity). A plain ``replace`` silently produces a source the runner
@@ -99,6 +116,26 @@ def _name(value: Any) -> Optional[str]:
     return text or None
 
 
+def canonical_identity(
+    source: "SessionSource", *, runner: Any, adapter: Any = None,
+    transport_profile: Optional[str] = None, primary_home: Optional[Path] = None,
+) -> Optional[RoutingIdentity]:
+    """The identity already pinned on *source*, else :func:`resolve_identity` — the one call every
+    ingress path makes FIRST, before any key is derived. ``None`` = unresolved under multiplexing
+    (``source.profile_route_rejected`` is set): the caller drops the event and says so once; it
+    must never fall through to ``agent:main``."""
+    identity = identity_of(source)
+    if identity is not None:
+        return identity
+    try:
+        return resolve_identity(
+            source, runner=runner, adapter=adapter, transport_profile=transport_profile,
+            primary_home=primary_home)
+    except IdentityUnresolved as exc:
+        logger.debug("identity unresolved: %s", exc)
+        return None
+
+
 def resolve_identity(
     source: "SessionSource", *, runner: Any, adapter: Any = None,
     transport_profile: Optional[str] = None, primary_home: Optional[Path] = None,
diff --git a/gateway/shutdown_forensics.py b/gateway/shutdown_forensics.py
index 34b18cd090..058e7a2c92 100644
--- a/gateway/shutdown_forensics.py
+++ b/gateway/shutdown_forensics.py
@@ -10,6 +10,7 @@ from __future__ import annotations
 
 import json
 import os
+import shutil
 import signal
 import subprocess
 import sys
@@ -120,9 +121,11 @@ def _async_diagnostic_script(signal_name: str, self_pid: int) -> str:
         f"echo '=== shutdown diagnostic @ {signal_name} ==='; "
         "echo '--- date ---'; date -u +%Y-%m-%dT%H:%M:%SZ; "
         "echo '--- ps (top 60 by cpu, comm only) ---'; "
-        "ps -eo pid,ppid,user,pcpu,pmem,stat,comm --sort=-pcpu 2>/dev/null | head -60; "
+        # ``sort`` instead of GNU ``--sort=-pcpu`` so BSD ps (macOS) produces a listing too; the header
+        # line is echoed first so ``sort`` does not bury it among the 0.0-cpu rows.
+        "ps -eo pid,ppid,user,pcpu,pmem,stat,comm 2>/dev/null | { IFS= read -r h; echo \"$h\"; sort -nrk4; } | head -60; "
         f"echo '--- pstree of self ---'; pstree -pl {self_pid} 2>/dev/null | head -40 || true; "
-        "echo '--- /proc/loadavg ---'; cat /proc/loadavg 2>/dev/null || true; "
+        "echo '--- loadavg ---'; cat /proc/loadavg 2>/dev/null || sysctl -n vm.loadavg 2>/dev/null || true; "
         "echo '--- recent dmesg (oom/killed) ---'; "
         "dmesg -T 2>/dev/null | tail -20 || journalctl --user -n 20 --no-pager 2>/dev/null | tail -20 || true; "
         "echo '=== end ==='"
@@ -150,9 +153,13 @@ def spawn_async_diagnostic(log_path: Path, signal_name: str, *,
         return None
     with contextlib.suppress(OSError):  # tighten logs created 0644 by earlier releases
         os.fchmod(fd, 0o600)
+    # GNU ``timeout`` (Homebrew: ``gtimeout``) is absent from stock macOS; without it the detached
+    # script still cannot block teardown, so run it unbounded rather than skip the diagnostic.
+    timeout_bin = shutil.which("timeout") or shutil.which("gtimeout")
+    bound = [timeout_bin, f"{timeout_seconds:.0f}"] if timeout_bin else []
     try:  # start_new_session: outlive systemd killing our cgroup (KillMode=control-group) to flush
         return subprocess.Popen(
-            ["timeout", f"{timeout_seconds:.0f}", "bash", "-c", script], stdout=fd,
+            [*bound, "bash", "-c", script], stdout=fd,
             stderr=subprocess.STDOUT, stdin=subprocess.DEVNULL, start_new_session=True,
             close_fds=True).pid
     except OSError:
diff --git a/gateway/slash_commands.py b/gateway/slash_commands.py
index 25e3ab1cfd..6d47e1740c 100644
--- a/gateway/slash_commands.py
+++ b/gateway/slash_commands.py
@@ -215,7 +215,7 @@ class GatewaySlashCommandsMixin(
         OWN transport (profile-aware, fail-closed) — ``self.adapters`` is the default profile's map."""
         if not event.source:
             return None, None
-        return self._adapter_for_source(event.source), self._session_key_for_source(event.source)
+        return self._delivery_adapter_for(event.source), self._session_key_for_source(event.source)
 
     def _telegramized_command_reply(self, event: MessageEvent, text: str) -> str:
         from gateway.run import _telegramize_command_mentions
@@ -259,7 +259,7 @@ class GatewaySlashCommandsMixin(
         (WeCom msgtype:"stream"), which need it sent directly with control-lane metadata (reliable
         proactive send, not the finalized reply stream). ``is not True``: mocks auto-create attrs."""
         source = event.source
-        adapter = self._adapter_for_source(source)  # the receiving bot, not the default profile's
+        adapter = self._delivery_adapter_for(source)  # the receiving bot, not the default profile's
         if adapter:
             adapter.resume_typing_for_chat(source.chat_id)  # agent is about to continue
         if getattr(adapter, "SUPPORTS_NATIVE_STREAMING", False) is not True:
@@ -606,7 +606,7 @@ class GatewaySlashCommandsMixin(
             return t("gateway.set_home.save_failed", error="Missing logical platform")
         via_relay = getattr(source, "delivered_via_upstream_relay", False) is True
         if via_relay:
-            adapter_for_source = getattr(self, "_adapter_for_source", None)
+            adapter_for_source = getattr(self, "_intake_adapter_for", None)
             relay_adapter = adapter_for_source(source) if callable(adapter_for_source) else None
             fronts_platform = getattr(relay_adapter, "fronts_platform", None)
             if (source.platform in {None, Platform.LOCAL, Platform.RELAY}
@@ -647,7 +647,7 @@ class GatewaySlashCommandsMixin(
         # independent /voice state.
         # See #75198.
         voice_key = self._voice_key_for_source(event.source)
-        adapter = self._adapter_for_source(event.source)
+        adapter = self._delivery_adapter_for(event.source)
 
         def _set_mode(mode: str) -> None:
             self._voice_mode[voice_key] = mode
@@ -845,7 +845,7 @@ class GatewaySlashCommandsMixin(
         except Exception:
             parent_agent = None
         _thread_metadata = self._reply_metadata(event)
-        adapter = self._adapter_for_source(source)
+        adapter = self._delivery_adapter_for(source)
         preview = _preview(question)
 
         async def _run_side_question() -> None:
@@ -988,7 +988,7 @@ class GatewaySlashCommandsMixin(
             # adapter refresh below doesn't keep a stale value and keep interrupting.
             self._busy_text_mode = self._load_busy_text_mode()
 
-        adapter = self._adapter_for_source(event.source)
+        adapter = self._delivery_adapter_for(event.source)
         if adapter is not None:
             adapter._busy_text_mode = self._effective_busy_text_mode(event.source)
         return EphemeralReply(
diff --git a/gateway/slash_commands_model.py b/gateway/slash_commands_model.py
index 1491e62fb6..b4804f0baf 100644
--- a/gateway/slash_commands_model.py
+++ b/gateway/slash_commands_model.py
@@ -368,7 +368,7 @@ class GatewayModelCommandsMixin:
             current_model=ctx.current_model, user_providers=ctx.user_provs,
             custom_providers=ctx.custom_provs, excluded_providers=ctx.excluded_provs,
         )
-        adapter = self._adapter_for_source(ctx.source)
+        adapter = self._delivery_adapter_for(ctx.source)
         if adapter is not None and getattr(type(adapter), "send_model_picker", None) is not None:
             async def _picker_switch(model_id: str, provider_slug: str) -> str:
                 # The picker callback binds the raw event source (pre-normalization).
@@ -618,7 +618,7 @@ class GatewayModelCommandsMixin:
     ) -> bool:
         """Send an interactive choice picker when the adapter *type* supports it (the /model gate);
         a failed send returns False (text fallback) instead of erroring."""
-        adapter = self._adapter_for_source(event.source)
+        adapter = self._delivery_adapter_for(event.source)
         if adapter is None or getattr(type(adapter), "send_choice_picker", None) is None:
             return False
         try:
diff --git a/gateway/slash_commands_session.py b/gateway/slash_commands_session.py
index 33cef5f1e3..054c5999e6 100644
--- a/gateway/slash_commands_session.py
+++ b/gateway/slash_commands_session.py
@@ -740,7 +740,7 @@ class GatewaySessionCommandsMixin:
 
             await asyncio.to_thread(_render_and_write)
             # Profile-aware: under multiplex the requester's bot lives in _profile_adapters, not self.adapters.
-            adapter = self._adapter_for_source(source)
+            adapter = self._delivery_adapter_for(source)
             if not adapter:
                 return "Platform adapter not found to send the document."
             await adapter.send_document(chat_id=source.chat_id, file_path=temp_path,
diff --git a/hermes_cli/config_defaults.py b/hermes_cli/config_defaults.py
index d383fd5d23..4d53b23421 100644
--- a/hermes_cli/config_defaults.py
+++ b/hermes_cli/config_defaults.py
@@ -2255,6 +2255,11 @@ DEFAULT_CONFIG = {
         # Missing server binaries: auto = install via npm/go/pip into <HERMES_HOME>/lsp/bin/ on
         # first use; manual = only binaries on PATH; off = alias for manual.
         "install_strategy": "auto",
+        # Node package manager for the npm-recipe servers: npm | pnpm | yarn. Installs still land in
+        # <HERMES_HOME>/lsp/node_modules; a configured manager that is not installed, or an unknown
+        # value, skips the install (no silent fallback to npm) so a pnpm/yarn supply-chain policy is
+        # never bypassed.
+        "package_manager": "npm",
         # Idle seconds before a server is shut down (respawned on demand), so long- running
         # processes don't accumulate stale children (hundreds of MB + pipe FDs each) across
         # worktrees. 0 = keep servers for process lifetime.
@@ -2262,6 +2267,9 @@ DEFAULT_CONFIG = {
         # Per-server overrides keyed by registry server_id (pyright, gopls...): disabled: true;
         # command: ["path/to/server", "--stdio"] (bypasses auto- install); env: {...};
         # initialization_options: {...} (merged into LSP initializationOptions).
+        # A key that is NOT a built-in id declares a custom server (matched before the built-ins):
+        # command: ["my-ls", "--stdio"]; extensions: [".ext"]; optional root_markers: [...],
+        # language_id: "..." (didOpen languageId), description: "...". Manual install only.
         "servers": {},
     },
     # X (Twitter) Search via xAI's x_search Responses tool. Registers when xAI creds exist
diff --git a/hermes_cli/gateway.py b/hermes_cli/gateway.py
index 3eef1c1643..5fd76ea073 100644
--- a/hermes_cli/gateway.py
+++ b/hermes_cli/gateway.py
@@ -788,13 +788,20 @@ def find_profile_gateway_processes(exclude_pids: set | None = None, *, strict: b
     return processes
 
 
+def _scm_service_field(service, field: str):
+    """psutil ``WindowsService`` exposes getters as methods; ``as_dict()`` covers objects without them."""
+    getter = getattr(service, field, None)
+    return getter() if callable(getter) else service.as_dict().get(field)
+
+
 def find_windows_gateway_services(
     *, psutil_module=None, profile_processes: list[ProfileGatewayProcess] | None = None
 ) -> list[WindowsGatewayService]:
-    """Profile gateways supervised by real Windows services. Service-logon processes may hide their
-    command lines, so identity = Hermes's own PID file + a parent chain ending at a running SCM service
-    PID. The whole service subtree is returned so the Desktop preflight exempts exactly what the
-    updater stops through the SCM."""
+    """Profile gateways supervised by real, Hermes-owned Windows services. Service-logon processes may
+    hide their command lines, so identity = Hermes's own PID file + a parent chain ending at a running
+    SCM service PID whose name or binary path is Hermes's (``gateway_windows.hermes_owns_windows_service``).
+    The whole service subtree is returned so the Desktop preflight exempts exactly what the updater stops
+    through the SCM; a gateway under any other service (a Scheduled Task's svchost) is a plain process."""
     if sys.platform != "win32":
         return []
     try:
@@ -802,26 +809,38 @@ def find_windows_gateway_services(
             import psutil as psutil_module  # type: ignore[no-redef]  # noqa: PLC0415
         if profile_processes is None:
             profile_processes = find_profile_gateway_processes(strict=True)
+        from hermes_cli.gateway_windows import hermes_owns_windows_service, hermes_service_roots
+
+        hermes_roots = hermes_service_roots()
         service_names_by_pid: dict[int, set[str]] = {}
         indeterminate_services_by_pid: dict[int, list[tuple[str, object]]] = {}
         for service in psutil_module.win_service_iter():
             try:
-                if all(callable(getattr(service, field, None)) for field in ("name", "status", "pid")):
-                    service_name = str(service.name() or "")
-                    service_status = service.status()
-                    service_pid = int(service.pid() or 0)
-                else:
-                    data = service.as_dict()
-                    service_name = str(data.get("name") or "")
-                    service_status = data.get("status")
-                    service_pid = int(data.get("pid") or 0)
+                service_name = str(_scm_service_field(service, "name") or "")
+                if not service_name:
+                    raise RuntimeError("SCM service has an empty name")
+                # Ownership before state: an OS service above the gateway (Task Scheduler's svchost for a
+                # task-launched gateway, BITS mid-transition) is never its supervisor, so neither its
+                # PID nor its status may steer the pause. Only Hermes-owned services reach the guards below.
+                # The name alone settles Hermes-named services; binpath (QueryServiceConfig) is asked only
+                # for the rest, and a service that refuses even that to this user is one this user could
+                # not `sc stop` either — never Hermes's, never a reason to abort the enumeration.
+                owned = hermes_owns_windows_service(service_name, "", hermes_roots)
+                if not owned:
+                    try:
+                        service_binpath = str(_scm_service_field(service, "binpath") or "")
+                    except psutil_module.AccessDenied:
+                        continue
+                    owned = hermes_owns_windows_service(service_name, service_binpath, hermes_roots)
+                if not owned:
+                    continue
+                service_status = _scm_service_field(service, "status")
+                service_pid = int(_scm_service_field(service, "pid") or 0)
             except FileNotFoundError:
                 # Deleted between enumeration and inspection.
                 continue
             except Exception as exc:
                 raise RuntimeError("SCM service inspection failed") from exc
-            if not service_name:
-                raise RuntimeError("SCM service has an empty name")
             if service_status == "stopped":
                 continue
             if service_status != "running":
diff --git a/hermes_cli/gateway_windows.py b/hermes_cli/gateway_windows.py
index 7c589ab4fc..6f1449d547 100644
--- a/hermes_cli/gateway_windows.py
+++ b/hermes_cli/gateway_windows.py
@@ -77,6 +77,29 @@ def _hermes_home() -> Path:
     return Path(get_hermes_home())
 
 
+def hermes_service_roots() -> tuple[str, ...]:
+    """Directories a Hermes-owned SCM service binary lives under: the checkout (its ``venv`` included),
+    the running interpreter's ``Scripts`` dir (``hermes.exe`` shim) and the ``gateway-service`` launcher dir."""
+    project_root = Path(__file__).resolve().parent.parent
+    return (str(project_root), str(Path(sys.executable).parent), str(_hermes_home() / "gateway-service"))
+
+
+def _normalize_windows_path(value: str) -> str:
+    return value.strip().lstrip('"').replace("\\", "/").rstrip("/").casefold()
+
+
+def hermes_owns_windows_service(name: str, binpath: str, hermes_roots: tuple[str, ...]) -> bool:
+    """Positive ownership of an SCM service: Hermes-named (``hermes*``) or its binary path starts under a
+    Hermes root. Pure so it is testable off-Windows. A Scheduled-Task-launched gateway descends from
+    ``svchost.exe`` hosting ``Schedule``; without this gate the updater took Task Scheduler for the
+    gateway's supervisor and ``sc.exe stop Schedule`` aborted every update (#97208)."""
+    normalized_name = "".join(char for char in name.casefold() if char.isalnum())
+    if normalized_name.startswith("hermes"):
+        return True
+    candidate = _normalize_windows_path(binpath)
+    return any(candidate.startswith(_normalize_windows_path(root) + "/") for root in hermes_roots if root)
+
+
 def _preserve_hermes_home_path(path: str | Path) -> str:
     r"""Render Hermes-owned paths under the configured HERMES_HOME spelling.
 
diff --git a/hermes_cli/kanban_db_workspace.py b/hermes_cli/kanban_db_workspace.py
index ff19b76b91..b37e472878 100644
--- a/hermes_cli/kanban_db_workspace.py
+++ b/hermes_cli/kanban_db_workspace.py
@@ -17,6 +17,8 @@ from typing import Optional
 from typing import TYPE_CHECKING
 import contextlib
 
+from hermes_cli.worktree_ops import release_lsp_clients
+
 if TYPE_CHECKING:
     from hermes_cli.kanban_db import Task
 
@@ -152,6 +154,7 @@ def _cleanup_workspace(conn: sqlite3.Connection, task_id: str) -> None:
             # source tree; without this, completion would rmtree the user's data.
             # See #28818.
             if _is_managed_scratch_path(wp):
+                release_lsp_clients(str(wp))
                 shutil.rmtree(wp, ignore_errors=True)
                 _kb._log.debug("Removed scratch workspace: %s", wp)
             else:
@@ -223,6 +226,7 @@ def _cleanup_worktree_workspace(
                 return
         # No --force: git's own dirty guard re-verifies at removal time, so if
         # the tree became dirty since our check (TOCTOU) removal fails safe.
+        release_lsp_clients(str(worktree_path))
         result = _git(repo_root, "worktree", "remove", str(wp), timeout=60)
         if result.returncode != 0:
             # Windows can retain a directory handle briefly after cwd changes.
@@ -269,6 +273,7 @@ def _try_cleanup_parent_workspaces(conn: sqlite3.Connection, task_id: str) -> No
                 continue
             wp = Path(row["workspace_path"])
             if wp.is_dir() and _is_managed_scratch_path(wp):
+                release_lsp_clients(str(wp))
                 shutil.rmtree(wp, ignore_errors=True)
                 _kb._log.debug("Deferred cleanup: removed parent %s scratch workspace: %s", parent_id, wp)
     except Exception:
diff --git a/hermes_cli/update_handoff.py b/hermes_cli/update_handoff.py
index 368d5eddc5..c435d79c72 100644
--- a/hermes_cli/update_handoff.py
+++ b/hermes_cli/update_handoff.py
@@ -17,6 +17,7 @@ import json
 import os
 import subprocess
 import sys
+import time
 from pathlib import Path
 from typing import Any
 
diff --git a/hermes_cli/worktree_ops.py b/hermes_cli/worktree_ops.py
index f96f9c7ac0..ee1e85933d 100644
--- a/hermes_cli/worktree_ops.py
+++ b/hermes_cli/worktree_ops.py
@@ -79,6 +79,20 @@ def _path_is_within_root(path: Path, root: Path) -> bool:
         return False
 
 
+def release_lsp_clients(wt_path: str) -> None:
+    """Shut down this process's language servers for ``wt_path`` before ``git worktree remove``.
+
+    A gateway outlives the sessions it runs, so without this the ``(server, root)`` client for the
+    removed tree stays registered (tsserver heaps of several GiB pointed at a deleted worktree).
+    Best-effort: LSP trouble must never block worktree removal.
+    """
+    try:
+        from agent.lsp import release_workspace
+        release_workspace(wt_path)
+    except Exception as e:
+        logger.debug("LSP release for worktree %s failed: %s", wt_path, e)
+
+
 def _cleanup_failed_worktree_add(repo_root: str, wt_path: Path, branch_name: str) -> None:
     """Sweep the leftovers of a failed/timed-out ``git worktree add`` (fail-soft).
 
diff --git a/plugins/memory/hindsight/__init__.py b/plugins/memory/hindsight/__init__.py
index 23c9356472..3f379d46b0 100644
--- a/plugins/memory/hindsight/__init__.py
+++ b/plugins/memory/hindsight/__init__.py
@@ -1040,7 +1040,12 @@ class HindsightMemoryProvider(MemoryProvider):
         # Advance the watermark only after the delta is queued so a later retain
         # doesn't re-ship turns already handed to the writer.
         if update_mode == "append":
-            self._last_retained_turn_count = len(self._session_turns)
+            # The job above holds its own copy, and append retains (here and flush-on-switch) only
+            # ever read the un-retained tail — so drop shipped turns instead of pinning every turn
+            # of a never-ending session (#62950). Overwrite mode resends the whole session and
+            # must keep them all.
+            self._session_turns.clear()
+            self._last_retained_turn_count = 0
 
     def _enqueue_retain(self, job: Callable[[], None]) -> None:
         """Hand *job* to the (lazily started) writer and arm the atexit drain."""
diff --git a/plugins/platforms/slack/adapter.py b/plugins/platforms/slack/adapter.py
index 2532c02f44..2eb16476c6 100644
--- a/plugins/platforms/slack/adapter.py
+++ b/plugins/platforms/slack/adapter.py
@@ -5977,13 +5977,13 @@ class SlackAdapter(BasePlatformAdapter):
         except Exception:
             return None
 
-    @staticmethod
     def _thread_session_source(
-        channel_id: str, thread_ts: str, user_id: str, team_id: str, chat_type: str) -> Any:
-        from gateway.session import SessionSource
-        return SessionSource(
-            platform=Platform.SLACK, chat_id=channel_id, chat_type=chat_type, user_id=user_id,
-            thread_id=thread_ts, scope_id=team_id or None)
+        self, channel_id: str, thread_ts: str, user_id: str, team_id: str, chat_type: str) -> Any:
+        # ``build_source``: transport provenance + profile route, so the thread key canonicalizes
+        # like the message that started the thread.
+        return self.build_source(
+            chat_id=channel_id, chat_type=chat_type, user_id=user_id, thread_id=thread_ts,
+            scope_id=team_id or None)
 
     def _thread_rehydration_key(
         self, channel_id: str, thread_ts: str, user_id: str, team_id: str = "") -> str:
diff --git a/plugins/platforms/telegram/adapter.py b/plugins/platforms/telegram/adapter.py
index 3d64430f7e..818e6b369c 100644
--- a/plugins/platforms/telegram/adapter.py
+++ b/plugins/platforms/telegram/adapter.py
@@ -6311,6 +6311,8 @@ class TelegramAdapter(BasePlatformAdapter):
 
     async def _route_photo_event(self, msg, event: MessageEvent) -> None:
         """Album items debounce on media_group_id; singles go through the photo burst batcher."""
+        if self._drop_unresolved(event):  # identity FIRST: the batch lane is derived from it
+            return
         media_group_id = getattr(msg, "media_group_id", None)
         if media_group_id:
             await self._queue_media_group_event(str(media_group_id), event)
diff --git a/tests/agent/lsp/_mock_lsp_server.py b/tests/agent/lsp/_mock_lsp_server.py
index a12a963204..5dbd41202b 100644
--- a/tests/agent/lsp/_mock_lsp_server.py
+++ b/tests/agent/lsp/_mock_lsp_server.py
@@ -141,6 +141,12 @@ def main():
                     "message": "synthetic error from mock-lsp",
                 }
             ]
+            if script == "silent":
+                # Never publishes diagnostics and the pull endpoint is
+                # rejected (below).  Models a slow server that only
+                # re-reports after a didChange it never receives — the
+                # baseline snapshot has to wait out its full budget.
+                continue
             if script == "stale":
                 # Ghost scenario: publish an error for the ORIGINAL
                 # content, then never publish again after edits.
@@ -180,7 +186,7 @@ def main():
             continue
 
         if msg.get("method") == "textDocument/diagnostic":
-            if script in {"stale", "slow_push", "versionless"}:
+            if script in {"stale", "slow_push", "versionless", "silent"}:
                 # These scripts model push-only servers so the ghost
                 # can't be papered over by the pull channel.
                 write_message(
diff --git a/tests/agent/lsp/test_client_e2e.py b/tests/agent/lsp/test_client_e2e.py
index 6864008b31..a42cb1f4bb 100644
--- a/tests/agent/lsp/test_client_e2e.py
+++ b/tests/agent/lsp/test_client_e2e.py
@@ -36,7 +36,7 @@ def _client(workspace: Path, script: str = "clean") -> LSPClient:
 async def test_client_lifecycle_clean(tmp_path: Path):
     """Full lifecycle: spawn, initialize, open, get clean diagnostics, shutdown."""
     f = tmp_path / "x.py"
-    f.write_text("print('hi')\n")
+    f.write_text("print('hi')\n", encoding="utf-8")
 
     client = _client(tmp_path, "clean")
     await client.start()
@@ -55,7 +55,7 @@ async def test_client_lifecycle_clean(tmp_path: Path):
 @pytest.mark.asyncio
 async def test_client_receives_published_errors(tmp_path: Path):
     f = tmp_path / "x.py"
-    f.write_text("print('hi')\n")
+    f.write_text("print('hi')\n", encoding="utf-8")
 
     client = _client(tmp_path, "errors")
     await client.start()
@@ -98,7 +98,7 @@ async def test_reader_failure_retires_client_and_rejects_later_work(
     tmp_path: Path, script: str
 ):
     f = tmp_path / "x.py"
-    f.write_text("print('hi')\n")
+    f.write_text("print('hi')\n", encoding="utf-8")
 
     client = _client(tmp_path, script)
     await client.start()
@@ -124,3 +124,60 @@ async def test_reader_failure_retires_client_and_rejects_later_work(
             )
     finally:
         await client.shutdown()
+
+
+@pytest.mark.asyncio
+async def test_shutdown_never_signals_a_server_that_honours_exit(tmp_path: Path):
+    """A server that exits on the protocol ``exit`` must not be SIGTERMed on top of it (#72944:
+    on Darwin the reaped PID can already belong to another process)."""
+    client = _client(tmp_path, "clean")
+    await client.start()
+    proc = client._proc
+    assert proc is not None
+    signals: list[str] = []
+    real_terminate, real_kill = proc.terminate, proc.kill
+    proc.terminate = lambda: (signals.append("terminate"), real_terminate())  # type: ignore[method-assign]
+    proc.kill = lambda: (signals.append("kill"), real_kill())  # type: ignore[method-assign]
+
+    await client.shutdown()
+
+    assert signals == []
+    assert proc.returncode == 0
+
+
+@pytest.mark.asyncio
+async def test_docs_cache_is_lru_bounded_and_reopens_evicted(tmp_path: Path, monkeypatch):
+    """`_docs` never exceeds MAX_TRACKED_FILES; an evicted file is didClose'd and re-didOpen'ed
+    (version 0) with diagnostics flowing again, so the cap is invisible to callers."""
+    import agent.lsp.client as client_mod
+
+    monkeypatch.setattr(client_mod, "MAX_TRACKED_FILES", 3)
+    files = [tmp_path / f"f{i}.py" for i in range(5)]
+    for f in files:
+        f.write_text("print('hi')\n", encoding="utf-8")
+
+    client = _client(tmp_path, "errors")
+    real_send = client._send_notification
+    sent: list = []
+
+    async def _spy(method, params):
+        sent.append((method, params))
+        await real_send(method, params)
+
+    monkeypatch.setattr(client, "_send_notification", _spy)
+    await client.start()
+    try:
+        for f in files:
+            await client.open_file(str(f), language_id="python")
+        assert len(client._docs) == 3
+        assert str(files[0]) not in client._docs  # least recently touched went first
+        # The server releases its mirror too: every evicted doc got a didClose on the wire.
+        closed = [p["textDocument"]["uri"] for m, p in sent if m == "textDocument/didClose"]
+        assert closed == [client_mod.file_uri(str(files[0])), client_mod.file_uri(str(files[1]))]
+        version = await client.open_file(str(files[0]), language_id="python")
+        assert version == 0  # fresh didOpen, not a didChange against dropped state
+        assert len(client._docs) == 3
+        await client.wait_for_diagnostics(str(files[0]), version, mode="document")
+        assert client.diagnostics_for(str(files[0]))
+    finally:
+        await client.shutdown()
diff --git a/tests/agent/lsp/test_compound_extensions.py b/tests/agent/lsp/test_compound_extensions.py
new file mode 100644
index 0000000000..6a73e18feb
--- /dev/null
+++ b/tests/agent/lsp/test_compound_extensions.py
@@ -0,0 +1,17 @@
+"""Compound extensions (``.blade.php``) route to their own server; the last segment alone keeps its server."""
+from agent.lsp.servers import ServerContext, find_server_for_file, language_id_for
+
+
+def test_blade_templates_route_to_laravel_lsp_and_plain_php_stays_on_intelephense(monkeypatch, tmp_path):
+    blade = "/app/resources/views/Home.BLADE.php"
+    assert find_server_for_file(blade).server_id == "laravel-lsp"
+    assert language_id_for(blade) == "blade"
+    assert find_server_for_file("/app/app/Models/User.php").server_id == "intelephense"
+    assert language_id_for("/app/app/Models/User.php") == "php"
+    # Manual-install server: spawns `laravel-lsp lsp` only when the binary resolves; None otherwise.
+    srv = find_server_for_file(blade)
+    monkeypatch.setattr("agent.lsp.servers._which", lambda *names: None)
+    assert srv.build_spawn(str(tmp_path), ServerContext(str(tmp_path), install_strategy="manual")) is None
+    monkeypatch.setattr("agent.lsp.servers._which", lambda *names: "/usr/local/bin/laravel-lsp")
+    spec = srv.build_spawn(str(tmp_path), ServerContext(str(tmp_path), install_strategy="manual"))
+    assert spec.command == ["/usr/local/bin/laravel-lsp", "lsp"]
diff --git a/tests/agent/lsp/test_custom_servers.py b/tests/agent/lsp/test_custom_servers.py
new file mode 100644
index 0000000000..895ceb8904
--- /dev/null
+++ b/tests/agent/lsp/test_custom_servers.py
@@ -0,0 +1,70 @@
+"""Config-declared LSP servers (``lsp.servers.<id>`` with ``extensions``) route files and spawn like built-ins."""
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+from unittest.mock import patch
+
+import pytest
+
+from agent.lsp.manager import LSPService
+from agent.lsp.servers import SERVERS, ServerContext, custom_servers, find_server_for_file, language_id_for
+
+_MOCK = os.path.join(os.path.dirname(__file__), "_mock_lsp_server.py")
+
+
+def test_custom_server_precedes_builtins_and_carries_language_id():
+    cfg = {
+        "pyright": {"disabled": True},  # override of a built-in id is NOT a custom server
+        "blade": {"command": [sys.executable, _MOCK], "extensions": [".PHP"], "language_id": "blade"},
+        "broken": {"command": "not-a-list", "extensions": [".zzz"]},  # malformed → skipped, not fatal
+    }
+    custom = custom_servers(cfg)
+    assert [s.server_id for s in custom] == ["blade"]
+    registry = [*custom, *SERVERS]
+    assert find_server_for_file("/w/index.php", registry).server_id == "blade"  # custom wins over intelephense
+    assert find_server_for_file("/w/index.php").server_id == "intelephense"  # built-in registry untouched
+    assert language_id_for("/w/index.php", custom[0]) == "blade"
+    assert language_id_for("/w/index.php") == "php"
+    spec = custom[0].build_spawn("/w", ServerContext("/w", install_strategy="manual"))
+    assert spec is not None and spec.command == [sys.executable, _MOCK]
+
+
+@pytest.mark.timeout(60)
+def test_service_gets_diagnostics_from_config_declared_server(tmp_path, monkeypatch):
+    """End to end from config.yaml: the only production path from ``lsp.servers`` to a running server."""
+    from tools.environments.local import LocalEnvironment
+    from tools.file_operations import ShellFileOperations
+
+    home = tmp_path / "home"
+    home.mkdir()
+    (home / "config.yaml").write_text(json.dumps({"lsp": {
+        "install_strategy": "manual", "wait_timeout": 5.0, "idle_timeout": 0,
+        "servers": {"panache": {"command": [sys.executable, _MOCK], "extensions": [".pnch"],
+                                "env": {"MOCK_LSP_SCRIPT": "errors"}}},
+    }}), encoding="utf-8")
+    monkeypatch.setenv("HERMES_HOME", str(home))
+    ws = tmp_path / "ws"
+    ws.mkdir()
+    subprocess.run(["git", "init", "-q", str(ws)], check=True)
+    target = ws / "doc.pnch"
+    target.write_text("hello\n", encoding="utf-8")
+    (ws / "x.rs").write_text("fn main() {}\n", encoding="utf-8")
+    svc = LSPService.create_from_config()
+    assert svc is not None
+    try:
+        assert svc.enabled_for(str(target))
+        diags = svc.get_diagnostics_sync(str(target))
+        assert diags and diags[0]["source"] == "mock-lsp"
+        # Control: a built-in extension still routes to the registry entry, not the custom server.
+        assert svc._server_for(str(ws / "x.rs")).server_id == "rust-analyzer"
+        # The write path captures pre-write content for the custom extension only via the service.
+        fops = ShellFileOperations(LocalEnvironment())
+        with patch.object(fops, "_lsp_service", return_value=svc):
+            assert fops._lsp_handles_extension(".pnch")
+        with patch.object(fops, "_lsp_service", return_value=None):
+            assert not fops._lsp_handles_extension(".pnch") and fops._lsp_handles_extension(".rs")
+    finally:
+        svc.shutdown()
diff --git a/tests/agent/lsp/test_diagnostics_field.py b/tests/agent/lsp/test_diagnostics_field.py
index 55410f9b02..d9c3f12993 100644
--- a/tests/agent/lsp/test_diagnostics_field.py
+++ b/tests/agent/lsp/test_diagnostics_field.py
@@ -6,7 +6,7 @@ having LSP output prepended to the lint string.
 """
 from __future__ import annotations
 
-from unittest.mock import patch
+from unittest.mock import MagicMock, patch
 
 
 from tools.environments.local import LocalEnvironment
@@ -80,6 +80,22 @@ def test_write_file_skips_lsp_when_syntax_failed(tmp_path):
     assert res.lint["status"] == "error"
 
 
+def test_maybe_lsp_diagnostics_swallows_enabled_for_failure(tmp_path):
+    """``_maybe_lsp_diagnostics`` gates through the guarded ``_lsp_will_handle``
+    helper, so a workspace-resolution failure (e.g. the process cwd was removed
+    under a running worker) degrades to "no LSP for this write" instead of
+    surfacing as an error from a write that already landed on disk."""
+    fops = ShellFileOperations(LocalEnvironment(cwd=str(tmp_path)))
+
+    with patch.object(fops, "_lsp_service") as mock_service:
+        mock_service.return_value.enabled_for = MagicMock(
+            side_effect=FileNotFoundError(2, "No such file or directory")
+        )
+        result = fops._maybe_lsp_diagnostics(str(tmp_path / "x.py"))
+
+    assert result == ""
+
+
 # ---------------------------------------------------------------------------
 # patch_replace propagates the field from the inner write_file
 # ---------------------------------------------------------------------------
diff --git a/tests/agent/lsp/test_eventlog.py b/tests/agent/lsp/test_eventlog.py
index e0de352d47..d7016c43db 100644
--- a/tests/agent/lsp/test_eventlog.py
+++ b/tests/agent/lsp/test_eventlog.py
@@ -134,3 +134,15 @@ def test_short_path_keeps_absolute_when_outside(tmp_path, monkeypatch):
     assert out == "/var/log/foo.txt" or not out.startswith("..")
 
 
+
+
+def test_announce_bucket_is_capped(caplog_lsp, monkeypatch):
+    """Per-file dedup keys stop at _ANNOUNCE_CAP: the bucket resets (re-firing the first-seen line once)
+    rather than holding every file path a long-running process ever touched."""
+    monkeypatch.setattr(eventlog, "_ANNOUNCE_CAP", 4)
+    for i in range(6):
+        eventlog.log_no_project_root("pyright", f"/proj/f{i}.py")
+    assert len(eventlog._announced_no_root) <= 4
+    eventlog.log_no_project_root("pyright", "/proj/f5.py")  # still deduped after the reset
+    info = [r.getMessage() for r in caplog_lsp.records if r.levelno == logging.INFO]
+    assert info.count("lsp[pyright] no project root for /proj/f5.py") == 1
diff --git a/tests/agent/lsp/test_install_and_lint_fixes.py b/tests/agent/lsp/test_install_and_lint_fixes.py
index c3c61e5283..73f8e7936f 100644
--- a/tests/agent/lsp/test_install_and_lint_fixes.py
+++ b/tests/agent/lsp/test_install_and_lint_fixes.py
@@ -104,5 +104,37 @@ def test_check_lint_returns_error_for_real_ts_type_errors(tmp_path, monkeypatch)
     assert "TS2322" in lint.output
 
 
+def test_lsp_package_manager_config_selects_installer_argv_and_never_falls_back_silently(tmp_path, monkeypatch):
+    """``lsp.package_manager`` picks the Node installer (staging-dir semantics kept); a configured manager
+    that is missing or unknown skips the install instead of quietly using npm (a typo must not bypass policy)."""
+    from unittest.mock import MagicMock
+
+    from agent.lsp import install as install_mod
+
+    monkeypatch.setenv("HERMES_HOME", str(tmp_path))
+    staging = str(install_mod.hermes_lsp_bin_dir().parent)
+    cfg = {"lsp": {}}
+    monkeypatch.setattr("hermes_cli.config.load_config_readonly", lambda: cfg)
+    runs = []
+    monkeypatch.setattr(install_mod.subprocess, "run", lambda cmd, **kw: (runs.append(cmd), MagicMock(returncode=0, stderr=""))[1])
+    present = {"npm": "/usr/bin/npm", "pnpm": "/usr/bin/pnpm", "yarn": "/usr/bin/yarn"}
+    monkeypatch.setattr(install_mod, "find_node_executable", lambda name: present.get(name))
+
+    cfg["lsp"] = {"package_manager": "pnpm"}
+    install_mod._install_npm("pyright", "pyright-langserver")
+    assert runs[-1] == ["/usr/bin/pnpm", "add", "--dir", staging, "pyright"]
+
+    cfg["lsp"] = {"package_manager": "yarn"}  # global --cwd: valid on Yarn Classic and Berry
+    install_mod._install_npm("pyright", "pyright-langserver")
+    assert runs[-1] == ["/usr/bin/yarn", "--cwd", staging, "add", "pyright"]
+
+    cfg["lsp"] = {"package_manager": "pnmp"}  # unknown (typo) → fail closed, no npm run
+    assert install_mod._install_npm("pyright", "pyright-langserver") is None
+    del present["yarn"]
+    cfg["lsp"] = {"package_manager": "yarn"}  # configured but absent → no install, no npm run
+    assert install_mod._install_npm("pyright", "pyright-langserver") is None
+    assert len(runs) == 2
+
+
 if __name__ == "__main__":  # pragma: no cover
     pytest.main([__file__, "-v"])
diff --git a/tests/agent/lsp/test_manager_locking.py b/tests/agent/lsp/test_manager_locking.py
index da7e5d42d4..622a6506a6 100644
--- a/tests/agent/lsp/test_manager_locking.py
+++ b/tests/agent/lsp/test_manager_locking.py
@@ -57,3 +57,42 @@ def test_reused_multiroot_client_attaches_outside_state_lock(monkeypatch):
     result = asyncio.run(service._get_or_spawn("/repo/worktree-b/example.py"))
 
     assert result is client
+
+
+def test_delta_baseline_is_capped_by_write_recency(monkeypatch):
+    """Driven through the production entry points (``snapshot_baseline`` before a write, ``_apply_delta``
+    rolling the baseline forward after one): baselines beyond _DELTA_BASELINE_CAP evict the path
+    written longest ago, and re-touching a path refreshes it instead of aging it out."""
+    service = LSPService(enabled=False, wait_mode="document", wait_timeout=0.1,
+                         install_strategy="manual", idle_timeout=0)
+    monkeypatch.setattr(service, "enabled_for", lambda _p: True)
+    server_diags: list = []
+
+    class _Loop:  # stands in for the (unstarted) background loop; returns the server's current diagnostics
+        def run(self, coro, timeout=None):
+            coro.close()
+            return list(server_diags)
+
+    monkeypatch.setattr(service, "_loop", _Loop())
+
+    class _LockedDict(dict):  # every mutation of the shared baseline dict must run under _state_lock
+        def __setitem__(self, k, v):
+            assert service._state_lock.locked()
+            super().__setitem__(k, v)
+
+        def __delitem__(self, k):
+            assert service._state_lock.locked()
+            super().__delitem__(k)
+
+    service._delta_baseline = _LockedDict()
+    cap = manager._DELTA_BASELINE_CAP
+    for i in range(cap):
+        service.snapshot_baseline(f"/repo/f{i}.py")
+    server_diags.append({"message": "rewritten"})
+    assert service._apply_delta("/repo/f0.py", [{"message": "rewritten"}], None) == [{"message": "rewritten"}]
+    server_diags.clear()
+    service.snapshot_baseline("/repo/new.py")
+    assert len(service._delta_baseline) == cap
+    assert "/repo/f1.py" not in service._delta_baseline
+    assert service._delta_baseline["/repo/f0.py"] == [{"message": "rewritten"}]
+    assert "/repo/new.py" in service._delta_baseline
diff --git a/tests/agent/lsp/test_service.py b/tests/agent/lsp/test_service.py
index ef5ab70adc..cfb46dfb66 100644
--- a/tests/agent/lsp/test_service.py
+++ b/tests/agent/lsp/test_service.py
@@ -8,6 +8,7 @@ on.
 from __future__ import annotations
 
 import asyncio
+import os
 import sys
 import time
 from pathlib import Path
@@ -84,6 +85,95 @@ def mock_pyright(monkeypatch, tmp_path):
         pass
 
 
+@pytest.fixture
+def mock_pyright_silent(monkeypatch, tmp_path):
+    """Install the silent mock as ``pyright`` (never pushes diagnostics).
+
+    The silent server accepts the open but never publishes diagnostics
+    for the pre-edit content and rejects the pull channel, so the
+    baseline snapshot has to wait out its full budget — exactly the
+    slow-server shape from the wait_timeout report.
+    """
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    (repo / ".git").mkdir()
+    (repo / "pyproject.toml").write_text("")
+    monkeypatch.chdir(str(repo))
+    gen = _install_mock_server(monkeypatch, "silent", "pyright")
+    next(gen)
+    yield repo
+    try:
+        next(gen)
+    except StopIteration:
+        pass
+
+
+def test_snapshot_baseline_honors_wait_timeout(mock_pyright_silent):
+    """``snapshot_baseline`` must wait at most ``lsp.wait_timeout``, not
+    the hardcoded client fallback of 5s.
+
+    Regression for the report that a 2s wait_timeout was ignored by the
+    baseline path: the wait ran without a timeout and fell back to
+    ``DIAGNOSTICS_DOCUMENT_WAIT`` (5s).  The silent mock never pushes,
+    so the elapsed time directly exposes the effective wait budget.
+    """
+    repo = mock_pyright_silent
+    f = repo / "x.py"
+    f.write_text("print('hi')\n")
+
+    svc = LSPService(
+        enabled=True,
+        wait_mode="document",
+        wait_timeout=2.0,
+        install_strategy="manual",
+    )
+    try:
+        start = time.monotonic()
+        svc.snapshot_baseline(str(f))
+        elapsed = time.monotonic() - start
+
+        # The wait is deadline-based: it always runs the full budget
+        # (never less than wait_timeout) and the server never pushes,
+        # so both bounds are stable under load.
+        assert elapsed >= 1.5, f"baseline returned before the wait budget: {elapsed:.2f}s"
+        assert elapsed < 4.5, (
+            f"baseline ignored wait_timeout=2.0 and ran the 5s fallback: {elapsed:.2f}s"
+        )
+        assert svc.get_status()["broken"] == []
+        # No fresh data pre-edit -> empty (never stale) baseline.
+        assert svc._delta_baseline[os.path.abspath(str(f))] == []
+    finally:
+        svc.shutdown()
+
+
+def test_snapshot_baseline_honors_wait_timeout_above_default(mock_pyright_silent):
+    """A ``wait_timeout`` above the 5s client default must also reach the
+    baseline wait (it was silently truncated to 5s), and the outer join
+    budget must scale with it so the slow-but-alive server is not marked broken.
+    """
+    repo = mock_pyright_silent
+    f = repo / "x.py"
+    f.write_text("print('hi')\n")
+
+    svc = LSPService(
+        enabled=True,
+        wait_mode="document",
+        wait_timeout=7.0,
+        install_strategy="manual",
+    )
+    try:
+        start = time.monotonic()
+        svc.snapshot_baseline(str(f))
+        elapsed = time.monotonic() - start
+
+        assert elapsed >= 6.5, f"baseline truncated to the 5s client default: {elapsed:.2f}s"
+        assert elapsed < 9.5, f"baseline overran the scaled join budget: {elapsed:.2f}s"
+        # A slow-but-alive server must not be marked broken.
+        assert svc.get_status()["broken"] == []
+    finally:
+        svc.shutdown()
+
+
 
 
 
diff --git a/tests/agent/lsp/test_vue_server.py b/tests/agent/lsp/test_vue_server.py
new file mode 100644
index 0000000000..dc7e58fa0d
--- /dev/null
+++ b/tests/agent/lsp/test_vue_server.py
@@ -0,0 +1,70 @@
+"""Tests for the Vue server registration.
+
+``@vue/language-server`` 3.x only works behind a client-hosted tsserver tunnel
+(``tsserver/request`` notifications) that Hermes's generic client does not
+run, so it never publishes diagnostics.  Hermes pins the self-hosting 2.x line
+and starts it with ``vue.hybridMode`` off plus an explicit JS TypeScript SDK.
+"""
+from __future__ import annotations
+
+import json
+import os
+
+import pytest
+
+from agent.lsp.servers import ServerContext, find_server_for_file
+
+
+def _stage(tmp_path, monkeypatch, vue_version: str, *, js_sdk: bool):
+    """Fake ``<HERMES_HOME>/lsp`` tree: a staged launcher, the Vue package, optionally a JS TypeScript SDK."""
+    monkeypatch.setenv("HERMES_HOME", str(tmp_path))
+    node_modules = tmp_path / "lsp" / "node_modules"
+    pkg = node_modules / "@vue" / "language-server"
+    (pkg / "bin").mkdir(parents=True)
+    (pkg / "package.json").write_text(json.dumps({"version": vue_version}), encoding="utf-8")
+    launcher = pkg / "bin" / "vue-language-server.js"
+    launcher.write_text("#!/usr/bin/env node\n", encoding="utf-8")
+    launcher.chmod(0o755)
+    (tmp_path / "lsp" / "bin").mkdir()
+    staged = tmp_path / "lsp" / "bin" / "vue-language-server"
+    staged.write_text(launcher.read_text(encoding="utf-8"), encoding="utf-8")  # copied like the Windows path, not symlinked
+    staged.chmod(0o755)
+    if js_sdk:
+        (node_modules / "typescript" / "lib").mkdir(parents=True)
+        (node_modules / "typescript" / "lib" / "typescript.js").write_text("", encoding="utf-8")
+    return str(staged)
+
+
+@pytest.mark.parametrize("vue_version, js_sdk, spawns", [("2.2.12", True, True), ("3.3.11", True, False), ("2.2.12", False, False)])
+def test_vue_spawns_only_a_self_hosting_server_with_a_js_typescript_sdk(tmp_path, monkeypatch, vue_version, js_sdk, spawns):
+    """2.x + JS SDK → spawn with ``hybridMode`` off and ``tsdk`` pointing at that SDK; a 3.x install
+    (tunnel-only) or a missing/Go-only TypeScript must be skipped instead of spawning a server that
+    can never publish diagnostics."""
+    _stage(tmp_path, monkeypatch, vue_version, js_sdk=js_sdk)
+    root = tmp_path / "project"
+    root.mkdir()
+    ctx = ServerContext(workspace_root=str(root), install_strategy="manual")
+    spec = find_server_for_file("App.vue").build_spawn(str(root), ctx)
+    if not spawns:
+        assert spec is None
+        return
+    assert spec.command[1:] == ["--stdio"]
+    assert spec.initialization_options["vue"] == {"hybridMode": False}
+    tsdk = spec.initialization_options["typescript"]["tsdk"]
+    assert os.path.isfile(os.path.join(tsdk, "typescript.js"))
+
+
+def test_js_toolchain_recipes_pin_a_javascript_typescript_sdk():
+    """Both TypeScript-hosting recipes co-install a JS-based TypeScript line (7+ is the Go port with no
+    ``tsserver.js``), and the Vue recipe stays below the tunnel-only 3.x major."""
+    from agent.lsp.install import INSTALL_RECIPES
+
+    def major(spec: str, name: str) -> int:
+        assert spec.startswith(f"{name}@"), spec  # unpinned = floats onto the next major
+        return int(spec[len(name) + 1:].split(".")[0])
+
+    vue, tsls = INSTALL_RECIPES["@vue/language-server"], INSTALL_RECIPES["typescript-language-server"]
+    assert major(vue["pkg"], "@vue/language-server") < 3
+    for recipe in (vue, tsls):
+        sdk = [p for p in recipe.get("extra_pkgs") or [] if p.split("@")[0] == "typescript"]
+        assert sdk and major(sdk[0], "typescript") < 7
diff --git a/tests/agent/lsp/test_windows_binary_resolution.py b/tests/agent/lsp/test_windows_binary_resolution.py
new file mode 100644
index 0000000000..b7ba51e3b1
--- /dev/null
+++ b/tests/agent/lsp/test_windows_binary_resolution.py
@@ -0,0 +1,57 @@
+"""Windows binary resolution must prefer the runnable ``.cmd``/``.exe``/``.bat`` wrapper over npm's
+POSIX ``#!/bin/sh`` shim, which shares the bare name and fails ``CreateProcess`` with WinError 193."""
+
+import os
+import subprocess
+from pathlib import Path
+
+import pytest
+
+from agent.lsp import install, servers
+
+
+def _npm_shim_pair(bin_dir: Path, name: str) -> Path:
+    """npm's Windows layout: POSIX shim under the bare name, runnable ``.cmd`` beside it (both X_OK)."""
+    bin_dir.mkdir(parents=True, exist_ok=True)
+    shim = bin_dir / name
+    shim.write_text("#!/bin/sh\nexec node \"$0.js\" \"$@\"\n", encoding="utf-8")
+    cmd = bin_dir / f"{name}.cmd"
+    cmd.write_text("@echo off\r\necho wrapper-ran\r\n", encoding="utf-8")
+    for p in (shim, cmd):
+        os.chmod(p, 0o755)
+    return cmd
+
+
+def test_windows_resolution_picks_cmd_wrapper_from_npm_bin_over_posix_shim(tmp_path: Path, monkeypatch):
+    """Drives the production entry with ``is_windows`` as data (no sys.platform patch): the pair
+    lives where npm leaves it (``lsp/node_modules/.bin``), and pyright's langserver sibling keeps
+    the resolved suffix instead of falling onto the bare shim."""
+    monkeypatch.setattr(install, "hermes_lsp_bin_dir", lambda: tmp_path / "bin")
+    (tmp_path / "bin").mkdir()
+    cmd = _npm_shim_pair(tmp_path / "node_modules" / ".bin", "tool")
+
+    assert install._existing_binary("tool", is_windows=True) == str(cmd)
+    # POSIX resolution never looks in npm's bin dir and never appends wrappers.
+    assert install._existing_binary("tool", is_windows=False) is None
+
+    pyright_cmd = _npm_shim_pair(tmp_path / "node_modules" / ".bin", "pyright")
+    langserver_cmd = _npm_shim_pair(tmp_path / "node_modules" / ".bin", "pyright-langserver")
+    ctx = servers.ServerContext(workspace_root=str(tmp_path), binary_overrides={"pyright": [str(pyright_cmd)]})
+    spec = servers._spawn_pyright(str(tmp_path), ctx)
+    assert spec is not None and spec.command[0] == str(langserver_cmd)
+
+
+@pytest.mark.windows_only
+def test_existing_binary_resolves_runnable_cmd_over_posix_shim(tmp_path: Path, monkeypatch):
+    """Live: staging dir holds npm's shim AND its .cmd; the resolved path must actually run."""
+    monkeypatch.setattr(install, "hermes_lsp_bin_dir", lambda: tmp_path)
+    shim = tmp_path / "tool"
+    shim.write_text("#!/bin/sh\nexec node \"$0.js\" \"$@\"\n", encoding="utf-8")
+    (tmp_path / "tool.cmd").write_text("@echo off\r\necho wrapper-ran\r\n", encoding="utf-8")
+
+    resolved = install._existing_binary("tool")
+
+    assert resolved == str(tmp_path / "tool.cmd")
+    out = subprocess.run([str(resolved)], capture_output=True, text=True, encoding="utf-8", errors="replace",
+                         check=True, stdin=subprocess.DEVNULL)
+    assert "wrapper-ran" in out.stdout
diff --git a/tests/agent/lsp/test_workspace.py b/tests/agent/lsp/test_workspace.py
index 801148cc35..6af70d3c08 100644
--- a/tests/agent/lsp/test_workspace.py
+++ b/tests/agent/lsp/test_workspace.py
@@ -24,8 +24,6 @@ def _clear():
     clear_cache()
 
 
-
-
 def test_find_git_worktree_finds_dotgit(tmp_path: Path):
     repo = tmp_path / "repo"
     repo.mkdir()
@@ -35,17 +33,11 @@ def test_find_git_worktree_finds_dotgit(tmp_path: Path):
     assert find_git_worktree(str(sub)) == str(repo)
 
 
-
-
-
-
-
-
 def test_nearest_root_finds_first_marker(tmp_path: Path):
     root = tmp_path / "p"
     deep = root / "src" / "pkg"
     deep.mkdir(parents=True)
-    (root / "pyproject.toml").write_text("")
+    (root / "pyproject.toml").write_text("", encoding="utf-8")
     found = nearest_root(str(deep / "mod.py"), ["pyproject.toml"])
     assert found == str(root)
 
@@ -56,22 +48,18 @@ def test_nearest_root_skips_package_dirs(tmp_path: Path):
     root = tmp_path / "p"
     pkg = root / "hermes_cli"
     pkg.mkdir(parents=True)
-    (root / "pyproject.toml").write_text("")
-    (pkg / "__init__.py").write_text("")
-    (pkg / "setup.py").write_text("")
+    (root / "pyproject.toml").write_text("", encoding="utf-8")
+    (pkg / "__init__.py").write_text("", encoding="utf-8")
+    (pkg / "setup.py").write_text("", encoding="utf-8")
     found = nearest_root(str(pkg / "main.py"), ["pyproject.toml", "setup.py"])
     assert found == str(root)
 
 
-
-
-
-
 def test_resolve_workspace_for_file_uses_cwd_first(tmp_path: Path, monkeypatch):
     repo = tmp_path / "repo"
     (repo / ".git").mkdir(parents=True)
     file_path = repo / "x.py"
-    file_path.write_text("")
+    file_path.write_text("", encoding="utf-8")
     # cwd is inside the repo
     monkeypatch.chdir(str(repo))
     root, gated = resolve_workspace_for_file(str(file_path))
@@ -79,8 +67,30 @@ def test_resolve_workspace_for_file_uses_cwd_first(tmp_path: Path, monkeypatch):
     assert gated is True
 
 
+def test_resolve_workspace_for_file_survives_deleted_cwd(tmp_path: Path, monkeypatch):
+    """A removed process cwd must read as "no anchor", not raise — the LSP
+    workspace resolver runs inside a write tool and must never break a write
+    that already landed on disk."""
+    repo = tmp_path / "repo"
+    (repo / ".git").mkdir(parents=True)
+    file_path = repo / "x.py"
+    file_path.write_text("")
+    scratch = tmp_path / "scratch"
+    scratch.mkdir()
+    monkeypatch.chdir(scratch)
+    scratch.rmdir()
+    with pytest.raises(OSError):
+        os.getcwd()
 
+    root, gated = resolve_workspace_for_file(str(file_path))
 
+    assert root == str(repo)
+    assert gated is True
+    # The diagnostics path logs through eventlog; its cwd-relative shortener must
+    # not raise either, or the write succeeds with diagnostics silently dropped.
+    from agent.lsp.eventlog import _short_path
+
+    assert _short_path(str(file_path)) == str(file_path)
 
 
 @pytest.mark.platforms("linux")
@@ -96,3 +106,15 @@ def test_normalize_path_expands_tilde(monkeypatch):
         expected_base = "/home/user"
     p = normalize_path("~/x.py")
     assert p == os.path.abspath(os.path.join(expected_base, "x.py"))
+
+
+def test_find_git_worktree_cache_is_capped(tmp_path: Path, monkeypatch):
+    """The start-dir cache resets past _WORKSPACE_CACHE_CAP instead of growing per distinct dir touched."""
+    import agent.lsp.workspace as ws
+
+    monkeypatch.setattr(ws, "_WORKSPACE_CACHE_CAP", 4)
+    for i in range(6):
+        d = tmp_path / f"d{i}"
+        d.mkdir()
+        assert find_git_worktree(str(d)) is None
+    assert len(ws._workspace_cache) <= 4
diff --git a/tests/agent/lsp/test_workspace_release.py b/tests/agent/lsp/test_workspace_release.py
new file mode 100644
index 0000000000..8b3ff02f00
--- /dev/null
+++ b/tests/agent/lsp/test_workspace_release.py
@@ -0,0 +1,194 @@
+"""Workspace-scoped teardown: removed worktrees and deleted roots must not keep language servers alive.
+
+A gateway outlives the coding sessions it runs, so a ``(server, root)`` client that survives its
+worktree is an unbounded leak (multi-GiB tsserver heaps for trees that no longer exist).
+"""
+from __future__ import annotations
+
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+import agent.lsp
+from agent.lsp.manager import LSPService
+from agent.lsp.servers import SERVERS, ServerContext, ServerDef, SpawnSpec
+from agent.lsp.workspace import clear_cache
+
+MOCK_SERVER = str(Path(__file__).parent / "_mock_lsp_server.py")
+
+
+def _git(*args: str, cwd: Path) -> str:
+    res = subprocess.run(["git", *args], cwd=str(cwd), capture_output=True, text=True, encoding="utf-8",
+                         errors="replace", timeout=60)
+    assert res.returncode == 0, f"git {' '.join(args)} failed: {res.stderr}"
+    return res.stdout.strip()
+
+
+def _seed_project(root: Path) -> Path:
+    """A Python project the mock ``pyright`` will attach to."""
+    (root / "pyproject.toml").write_text("", encoding="utf-8")
+    (root / "x.py").write_text("x = 1\n", encoding="utf-8")
+    return root
+
+
+def _make_repo(tmp_path: Path, name: str) -> Path:
+    repo = tmp_path / name
+    repo.mkdir()
+    (repo / ".git").mkdir()
+    return _seed_project(repo)
+
+
+@pytest.fixture
+def mock_pyright(request):
+    """Install the mock as ``pyright``; ``request.param`` selects the multi-root shape."""
+    idx = next(i for i, s in enumerate(SERVERS) if s.server_id == "pyright")
+    original = SERVERS[idx]
+
+    def _spawn(root: str, ctx: ServerContext) -> SpawnSpec:
+        return SpawnSpec(command=[sys.executable, MOCK_SERVER], workspace_root=root, cwd=root,
+                         env={"MOCK_LSP_SCRIPT": "errors"}, initialization_options={})
+
+    SERVERS[idx] = ServerDef(
+        server_id="pyright", extensions=original.extensions, resolve_root=lambda fp, ws: ws,
+        build_spawn=_spawn, seed_first_push=False, description="mock pyright",
+        multi_root=getattr(request, "param", False),
+    )
+    clear_cache()
+    yield
+    SERVERS[idx] = original
+    clear_cache()
+
+
+def _service() -> LSPService:
+    return LSPService(enabled=True, wait_mode="document", wait_timeout=3.0, install_strategy="manual",
+                      idle_timeout=600.0)
+
+
+@pytest.fixture
+def project(tmp_path: Path) -> Path:
+    """A pushed-clean project repo: every worktree-removal path agrees it holds no work."""
+    origin = tmp_path / "origin.git"
+    _git("init", "-q", "--bare", str(origin), cwd=tmp_path)
+    repo = tmp_path / "project"
+    _git("clone", "-q", str(origin), str(repo), cwd=tmp_path)
+    _git("config", "user.email", "t@example.com", cwd=repo)
+    _git("config", "user.name", "t", cwd=repo)
+    _seed_project(repo)
+    _git("add", "-A", cwd=repo)
+    _git("commit", "-q", "-m", "init", cwd=repo)
+    _git("push", "-q", "origin", "HEAD", cwd=repo)
+    return repo
+
+
+def _linked_worktree(project: Path, tmp_path: Path) -> Path:
+    wt = tmp_path / "wt"
+    _git("worktree", "add", "-q", "-b", "wt/t1", str(wt), "HEAD", cwd=project)
+    return wt
+
+
+# Production removal paths; each returns (root that goes away, sibling root that stays, remove()).
+def _kanban_worktree(project, tmp_path, monkeypatch):
+    from hermes_cli import kanban_db_workspace as kbw
+    wt = _linked_worktree(project, tmp_path)
+    return wt, project, lambda: kbw._cleanup_worktree_workspace("t1", str(wt), "wt/t1")
+
+
+def _cli_worktree(project, tmp_path, monkeypatch):
+    import cli
+    wt = _linked_worktree(project, tmp_path)
+    info = {"path": str(wt), "branch": "wt/t1", "repo_root": str(project)}
+    return wt, project, lambda: cli._cleanup_worktree(info)
+
+
+def _subagent_worktree(project, tmp_path, monkeypatch):
+    from tools.subagent_worktree import finalize_subagent_worktree
+    wt = _linked_worktree(project, tmp_path)
+    info = {"path": str(wt), "branch": "wt/t1", "repo_root": str(project),
+            "base_commit": _git("rev-parse", "HEAD", cwd=project)}
+
+    def remove():
+        assert finalize_subagent_worktree(info)["pruned"] is True
+    return wt, project, remove
+
+
+def _kanban_scratch(project, tmp_path, monkeypatch):
+    from hermes_cli import kanban_db as kb
+    from hermes_cli import kanban_db_connect as kbc
+    from hermes_cli import kanban_db_workspace as kbw
+    home = tmp_path / ".hermes"
+    home.mkdir()
+    monkeypatch.setenv("HERMES_HOME", str(home))
+    monkeypatch.setattr(Path, "home", lambda: tmp_path)
+    kb.init_db()
+    with kbc.connect() as conn:
+        tid = kb.create_task(conn, title="scratch")
+        ws = kbw.resolve_workspace(kb.get_task(conn, tid))
+        kbw.set_workspace_path(conn, tid, ws)
+    (ws / ".git").mkdir()  # the worker cloned a project into its scratch dir
+    _seed_project(ws)
+
+    def remove():
+        with kbc.connect() as conn:
+            assert kb.complete_task(conn, tid, result="ok")
+    return ws, project, remove
+
+
+@pytest.mark.parametrize("mock_pyright", [False, True], ids=["single-root", "multi-root"], indirect=True)
+@pytest.mark.parametrize("entry", [_kanban_worktree, _cli_worktree, _subagent_worktree, _kanban_scratch],
+                         ids=lambda f: f.__name__.strip("_"))
+def test_workspace_removal_releases_only_its_language_servers(entry, mock_pyright, project, tmp_path,
+                                                                 monkeypatch):
+    """Every in-process workspace-removal path (kanban worktree/scratch cleanup, ``hermes -w`` exit, the
+    delegate_task worktree prune) shuts down (single-root) or detaches (multi-root) exactly the removed
+    root's servers BEFORE the tree goes: the sibling keeps serving diagnostics, the released state is gone
+    everywhere, and a repeat release is a no-op."""
+    gone, kept, remove = entry(project, tmp_path, monkeypatch)
+    gone_s, kept_s = str(gone.resolve()), str(kept.resolve())
+    svc = _service()
+    monkeypatch.setattr(agent.lsp, "_service", svc)  # the process-wide singleton the removal paths reach
+    try:
+        svc.snapshot_baseline(str(gone / "x.py"))
+        assert svc.get_diagnostics_sync(str(gone / "x.py"), delta=False)
+        assert svc.get_diagnostics_sync(str(kept / "x.py"), delta=False)
+        clients = dict(svc._clients)
+        procs = {key: c._proc for key, c in clients.items()}  # asyncio subprocess handles
+
+        remove()
+
+        assert not gone.exists(), "the production removal path must have removed the tree"
+        assert all(gone_s not in f for c in svc._clients.values() for f in c.workspace_folders)
+        assert all(not p.startswith(gone_s) for p in svc._delta_baseline)
+        if len(clients) == 2:  # single-root: the released process is gone, the sibling's is not
+            (gone_key,) = [k for k in clients if k[1] == gone_s]
+            assert gone_key not in svc._clients and gone_key not in svc._last_used
+            assert procs[gone_key].returncode is not None, "released server process must have exited"
+        else:  # multi-root: one shared process, only the folder was dropped
+            (client,) = svc._clients.values()
+            assert client.workspace_folders == [kept_s] and client.is_running
+        assert svc.release_workspace(gone_s) == 0
+        assert svc.get_diagnostics_sync(str(kept / "x.py"), delta=False)
+    finally:
+        svc.shutdown()
+
+
+def test_reaper_shuts_down_client_whose_root_was_deleted(mock_pyright, tmp_path):
+    """A root deleted outside Hermes is reaped on the next sweep even though the client is not idle."""
+    repo = _make_repo(tmp_path, "repo")
+    svc = _service()
+    try:
+        assert svc.get_diagnostics_sync(str(repo / "x.py"), delta=False)
+        (key,) = svc._clients
+        proc = svc._clients[key]._proc
+
+        svc._loop.run(svc._reap_idle_once(), timeout=10.0)
+        assert key in svc._clients, "an existing, recently used root must survive the sweep"
+
+        shutil.rmtree(repo)
+        svc._loop.run(svc._reap_idle_once(), timeout=10.0)
+        assert key not in svc._clients and key not in svc._last_used
+        assert proc.returncode is not None, "reaped server process must have exited"
+    finally:
+        svc.shutdown()
diff --git a/tests/agent/test_anthropic_borrowed_row_authority.py b/tests/agent/test_anthropic_borrowed_row_authority.py
index 1d320378f3..938a1d25b4 100644
--- a/tests/agent/test_anthropic_borrowed_row_authority.py
+++ b/tests/agent/test_anthropic_borrowed_row_authority.py
@@ -163,9 +163,9 @@ def test_refresh_from_persisted_sanitized_row_keeps_the_full_pair(
 
     real_write = AA._write_claude_code_credentials
 
-    def _counting_write(access_token, refresh_token, expires_at_ms):
+    def _counting_write(access_token, refresh_token, expires_at_ms, **kwargs):
         writes.append(refresh_token)
-        return real_write(access_token, refresh_token, expires_at_ms)
+        return real_write(access_token, refresh_token, expires_at_ms, **kwargs)
 
     monkeypatch.setattr(AA, "refresh_anthropic_oauth_pure", _counting_refresh)
     monkeypatch.setattr(AA, "_write_claude_code_credentials", _counting_write)
diff --git a/tests/agent/test_anthropic_keychain.py b/tests/agent/test_anthropic_keychain.py
index a8271394aa..1029f1006d 100644
--- a/tests/agent/test_anthropic_keychain.py
+++ b/tests/agent/test_anthropic_keychain.py
@@ -1,13 +1,23 @@
 """Tests for Bug #12905 fixes in agent/anthropic_adapter.py — macOS Keychain support."""
 
 import json
+import platform
+import subprocess
 import threading
 import time
 from unittest.mock import patch, MagicMock
 
 import pytest
 
-from agent.anthropic_credentials import _read_claude_code_credentials_from_keychain, read_claude_code_credentials, _refresh_oauth_token
+from agent.anthropic_credentials import (
+    _read_claude_code_credentials_from_keychain,
+    read_claude_code_credentials,
+    _refresh_oauth_token,
+    _find_claude_code_keychain_item,
+    _keychain_mirror_command,
+    _merge_keychain_credential_payload,
+    _mirror_claude_code_credentials_to_keychain,
+)
 
 
 # This module exercises the reader itself with explicit platform and subprocess
@@ -343,3 +353,102 @@ class TestRefreshOAuthTokenAdoptsFreshCredential:
         assert results == {"a": "fresh-access", "b": "fresh-access"}
         assert calls == ["stale-refresh"], calls
 
+
+class TestMergeKeychainCredentialPayload:
+    """``_merge_keychain_credential_payload`` — the pure merge a Keychain refresh write
+    performs over the existing entry (#98334): rotate the token triple, keep everything
+    Claude Code stores beside it."""
+
+    def test_rotates_triple_and_keeps_every_sibling(self):
+        existing = {
+            "claudeAiOauth": {
+                "accessToken": "old-access", "refreshToken": "old-refresh", "expiresAt": 1,
+                "scopes": ["user:inference", "user:profile"], "subscriptionType": "max",
+            },
+            "rateLimitTier": "tier-1",
+            # Claude Code keeps its MCP server OAuth tokens in the same item; a refresh that
+            # dropped them would log the user out of every MCP server at once.
+            "mcpOAuth": {f"srv{i}": {"accessToken": f"t{i}"} for i in range(24)},
+        }
+        merged = _merge_keychain_credential_payload(existing, "new-access", "new-refresh", 42)
+        oauth = merged["claudeAiOauth"]
+        assert (oauth["accessToken"], oauth["refreshToken"], oauth["expiresAt"]) == ("new-access", "new-refresh", 42)
+        # Everything except the rotated triple is byte-identical to the input.
+        assert {k: v for k, v in oauth.items() if k not in ("accessToken", "refreshToken", "expiresAt")} == {
+            "scopes": ["user:inference", "user:profile"], "subscriptionType": "max"}
+        assert {k: v for k, v in merged.items() if k != "claudeAiOauth"} == {
+            k: v for k, v in existing.items() if k != "claudeAiOauth"}
+        assert existing["claudeAiOauth"]["refreshToken"] == "old-refresh"  # input not mutated
+
+
+class TestKeychainMirrorCommand:
+    """``_keychain_mirror_command`` — host-agnostic: it builds the ``security`` invocation
+    without running it."""
+
+    def test_secret_travels_hex_encoded_on_stdin_under_the_items_own_account(self):
+        payload = {"claudeAiOauth": {"accessToken": "sk-ant-oat01-new", "refreshToken": 'r"q\\x'}, "mcpOAuth": {"a": 1}}
+        argv, line = _keychain_mirror_command("alice smith", payload)
+
+        # ``security -i`` reads the command from stdin: nothing secret on argv.
+        assert argv == ["security", "-i"]
+        assert "sk-ant-oat01-new" not in line and "-w" not in line.split()
+        # -U updates the item Claude Code reads (matched on account + service), never a second one.
+        assert line.startswith('add-generic-password -U -a "alice smith" -s "Claude Code-credentials" -X ')
+        hex_blob = line.split(" -X ", 1)[1].strip()
+        assert json.loads(bytes.fromhex(hex_blob)) == payload
+
+
+class TestFindClaudeCodeKeychainItem:
+    """``_find_claude_code_keychain_item`` parses one ``find-generic-password -g`` call. ``security``
+    prints plain-ASCII attributes quoted but UNescaped, anything else as ``0x<HEX>  "<echo>"``."""
+
+    @pytest.mark.macos_only
+    @pytest.mark.parametrize(
+        "acct_line, expected_account",
+        [
+            ('    "acct"<blob>="bob"', "bob"),
+            ('    "acct"<blob>="my "user" name"', 'my "user" name'),  # embedded quote, printed raw
+            ('    "acct"<blob>=0x616C2269636520C3BC  "al\\"ice \\303\\274"', 'al"ice \u00fc'),  # non-ASCII → hex form
+        ],
+    )
+    def test_reads_account_and_payload_in_both_output_encodings(self, monkeypatch, acct_line, expected_account):
+        payload = {"claudeAiOauth": {"refreshToken": "r"}, "mcpOAuth": {"a": 1}}
+        fake = MagicMock(returncode=0, stdout=f'keychain: "/Users/x/Library/Keychains/login.keychain-db"\n{acct_line}\n',
+                         stderr=f"password: 0x{json.dumps(payload).encode().hex()}  \"...\"\n")
+        monkeypatch.setattr(subprocess, "run", lambda argv, **k: fake)
+
+        assert _find_claude_code_keychain_item() == (expected_account, payload)
+
+
+class TestMirrorClaudeCodeCredentialsToKeychain:
+    """The #98334 write mirror shells out to ``security``; ``subprocess.run`` is mocked so no
+    real Keychain is touched."""
+
+    @pytest.mark.macos_only
+    def test_no_write_when_no_entry_exists(self, monkeypatch):
+        """Never create a Keychain item the user has not."""
+        monkeypatch.setattr("agent.anthropic_credentials._find_claude_code_keychain_item", lambda: None)
+        run = MagicMock(return_value=MagicMock(returncode=0))
+        monkeypatch.setattr(subprocess, "run", run)
+
+        _mirror_claude_code_credentials_to_keychain("a", "b", 1, spent_refresh_token="old")
+
+        run.assert_not_called()
+
+    @pytest.mark.macos_only
+    def test_only_the_item_holding_the_spent_pair_is_updated(self, monkeypatch):
+        """A different pair in the Keychain is another login or a rotation Claude Code already made;
+        overwriting it would be the bug in the other direction."""
+        item = ("bob", {"claudeAiOauth": {"accessToken": "A0", "refreshToken": "R0"}})
+        monkeypatch.setattr("agent.anthropic_credentials._find_claude_code_keychain_item", lambda: item)
+        run = MagicMock(return_value=MagicMock(returncode=0))
+        monkeypatch.setattr(subprocess, "run", run)
+
+        _mirror_claude_code_credentials_to_keychain("A1", "R1", 1, spent_refresh_token="not-R0")
+        run.assert_not_called()
+
+        _mirror_claude_code_credentials_to_keychain("A1", "R1", 1, spent_refresh_token="R0")
+        (argv,), kwargs = run.call_args
+        assert argv == ["security", "-i"]
+        assert json.loads(bytes.fromhex(kwargs["input"].split(" -X ", 1)[1].strip()))["claudeAiOauth"] == {
+            "accessToken": "A1", "refreshToken": "R1", "expiresAt": 1}
diff --git a/tests/agent/test_auxiliary_client.py b/tests/agent/test_auxiliary_client.py
index 5551ad5dc4..c5865f6e7f 100644
--- a/tests/agent/test_auxiliary_client.py
+++ b/tests/agent/test_auxiliary_client.py
@@ -2940,7 +2940,8 @@ class TestAuxiliaryAuthRefreshRetry:
             assert cache_key not in aux._client_cache  # evicted, not closed (in-flight users)
 
         mock_refresh_oauth.assert_called_once_with("refresh-token", use_json=False)
-        mock_write.assert_called_once_with("fresh-token", "refresh-token-2", 9999999999999)
+        mock_write.assert_called_once_with(
+            "fresh-token", "refresh-token-2", 9999999999999, spent_refresh_token="refresh-token")
         stale_client.close.assert_not_called()
 
     def test_refresh_provider_credentials_remints_vertex_token_and_evicts_cache(self):
diff --git a/tests/agent/test_degenerate_final_recovery.py b/tests/agent/test_degenerate_final_recovery.py
new file mode 100644
index 0000000000..5bfd654a6f
--- /dev/null
+++ b/tests/agent/test_degenerate_final_recovery.py
@@ -0,0 +1,132 @@
+"""Degenerate-final recovery (#103483).
+
+Provider-side collapse: a turn executes its tool work correctly, then ends on ``finish_reason=stop``
+with an ENTIRE visible answer that is a fragment — a stray wrong-script word (``пар``), a token
+starting mid-punctuation (``?warming up``). Before the fix the loop accepted the fragment as the
+answer, the turn reported ``completed``, and an unattended job silently abandoned the task.
+
+The guard rides the existing ack-continuation path: same scope knob (``agent.intent_ack_continuation``,
+default ``auto`` = Responses transports), same bounded per-turn counter, same durable interim +
+nudge rows. Shape alone cannot prove a collapse, so the predicate is narrow and the nudge asks for
+the same answer again when it WAS complete — a false positive costs one call, never the answer.
+"""
+
+from __future__ import annotations
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from agent.agent_runtime_helpers import looks_like_degenerate_final
+from agent.conversation_loop import _DEGENERATE_FINAL_NUDGE
+
+
+@pytest.fixture()
+def loop_agent():
+    """AIAgent with a mocked OpenAI client (mirrors test_dropped_tool_call_recovery)."""
+    from run_agent import AIAgent
+    with (
+        patch("model_tools.get_tool_definitions", return_value=[]),
+        patch("model_tools.check_toolset_requirements", return_value={}),
+        patch("agent.process_bootstrap.OpenAI"),
+    ):
+        agent = AIAgent(
+            api_key="test-key-1234567890",
+            base_url="https://openrouter.ai/api/v1",
+            quiet_mode=True,
+            skip_context_files=True,
+            skip_memory=True,
+        )
+        agent.client = MagicMock()
+        agent._cached_system_prompt = "You are helpful."
+        agent._use_prompt_caching = False
+        agent.tool_delay = 0
+        agent.compression_enabled = False
+        agent.save_trajectories = False
+        # Explicit opt-in: the loop tests exercise the mechanism, not the transport-scoped default.
+        agent._intent_ack_continuation = True
+        return agent
+
+
+def _run(agent, stages):
+    agent.client.chat.completions.create.side_effect = stages
+    with (
+        patch.object(agent, "_persist_session"),
+        patch.object(agent, "_save_trajectory"),
+        patch.object(agent, "_cleanup_task_resources"),
+        patch("model_tools.handle_function_call", return_value="ok"),
+    ):
+        return agent.run_conversation("build the workbook")
+
+
+def _tool_round(call_id):
+    from tests.agent.test_run_agent import _mock_response, _mock_tool_call
+    return _mock_response(
+        content="", finish_reason="tool_calls",
+        tool_calls=[_mock_tool_call(name="web_search", arguments="{}", call_id=call_id)],
+    )
+
+
+def _final(text):
+    from tests.agent.test_run_agent import _mock_response
+    return _mock_response(content=text, finish_reason="stop")
+
+
+def _user_rows_sent(agent, call_index):
+    kwargs = agent.client.chat.completions.create.call_args_list[call_index].kwargs
+    return [m["content"] for m in kwargs["messages"] if m.get("role") == "user"]
+
+
+class TestFragmentAfterToolWork:
+    def test_fragment_after_tool_work_reprompts_instead_of_exiting(self, loop_agent):
+        result = _run(loop_agent, [_tool_round("call_1"), _final("пар"), _final("Workbook built: 3 sheets.")])
+
+        assert result["final_response"] == "Workbook built: 3 sheets."
+        assert loop_agent.client.chat.completions.create.call_count == 3
+        # The re-prompt carried the degenerate-final nudge, not the generic ack nudge.
+        assert _user_rows_sent(loop_agent, 2)[-1] == _DEGENERATE_FINAL_NUDGE
+        # The fragment stays in the transcript as an interim row, the nudge right after it.
+        contents = [m.get("content") for m in result["messages"]]
+        assert contents.index("пар") + 1 == contents.index(_DEGENERATE_FINAL_NUDGE)
+
+    def test_persistent_collapse_is_bounded_and_keeps_the_fragment(self, loop_agent):
+        """One re-prompt per collapse: the nudge row closes the tool-work window, so a second
+        fragment is the answer — today's behaviour, never a loop."""
+        result = _run(loop_agent, [_tool_round("call_1"), _final("пар"), _final("?warming up")])
+
+        assert loop_agent.client.chat.completions.create.call_count == 3
+        assert result["final_response"] == "?warming up"
+
+    def test_fragment_without_tool_work_is_a_plain_answer(self, loop_agent):
+        """A chat-only turn that answers tersely is not a collapse; nothing is re-prompted."""
+        result = _run(loop_agent, [_final("пар")])
+
+        assert loop_agent.client.chat.completions.create.call_count == 1
+        assert result["final_response"] == "пар"
+
+
+class TestLooksLikeDegenerateFinal:
+    EN = "Build the workbook and report back."
+
+    @pytest.mark.parametrize("text", ["пар", "?warming up", ",and", "ошибка", "!warming"])
+    def test_fragments_in_an_english_conversation(self, text):
+        assert looks_like_degenerate_final(text, user_message=self.EN)
+
+    @pytest.mark.parametrize("text", [
+        # Terse legitimate answers that reviewers showed a shape-only guard re-prompting (#111472).
+        "42", "SQLite", "report.csv", "3.14159", "€12.50", "你好。", "Done.", "True", "a51143fbbe",
+        "2026-09-19", "/tmp/out.log", "$5", "#123", "-1", "(a)", ".env", "~/x", "+1", "✅",
+        ":8080", "::1", ":)", ";;", ":=", "}", "N/A", "**Done**", "`ok`", "{}", "null",
+        "Reading is a skill", "The answer is 43.", "x" * 25, "",
+    ])
+    def test_terse_answers_are_not_fragments(self, text):
+        assert not looks_like_degenerate_final(text, user_message=self.EN)
+
+    @pytest.mark.parametrize("prompt, text", [
+        ("把工作簿建好然后告诉我", "是"), ("把工作簿建好然后告诉我", "已完成"),
+        ("Собери таблицу и отчитайся", "Готово"), ("Собери таблицу и отчитайся", "да"),
+        ("ワークブックを作って報告して", "はい"), ("أنشئ المصنف ثم أخبرني", "تم"),
+        ([{"type": "text", "text": "Собери таблицу"}], "нет"),  # multi-part user content
+    ])
+    def test_terse_answers_in_the_users_own_script_are_not_fragments(self, prompt, text):
+        assert not looks_like_degenerate_final(text, user_message=prompt)
diff --git a/tests/agent/test_ollama_num_ctx.py b/tests/agent/test_ollama_num_ctx.py
index d4f9b8607f..bffb9ef2c4 100644
--- a/tests/agent/test_ollama_num_ctx.py
+++ b/tests/agent/test_ollama_num_ctx.py
@@ -7,6 +7,8 @@ Covers:
 
 from unittest.mock import patch, MagicMock
 
+import pytest
+
 
 from agent.model_metadata import query_ollama_num_ctx, query_ollama_supports_vision
 
@@ -138,39 +140,40 @@ class TestQueryOllamaSupportsVision:
 # ═══════════════════════════════════════════════════════════════════════
 
 
+def _build_agent(cfg, probed_ctx, base_url="http://localhost:11434/v1"):
+    import agent.context_compressor as cc_mod
+    with (
+        patch("model_tools.get_tool_definitions", return_value=[]),
+        patch("model_tools.check_toolset_requirements", return_value={}),
+        patch("agent.process_bootstrap.OpenAI"),
+        patch("hermes_cli.config.load_config", return_value=cfg),
+        patch("hermes_cli.config.load_config_readonly", return_value=cfg),
+        patch(
+            "agent.model_metadata.get_model_context_length",
+            return_value=probed_ctx,
+        ),
+        patch.object(
+            cc_mod, "get_model_context_length", return_value=probed_ctx,
+        ),
+    ):
+        from run_agent import AIAgent
+        return AIAgent(
+            model="gemma3:27b",
+            api_key="ollama",
+            base_url=base_url,
+            quiet_mode=True,
+            skip_context_files=True,
+            skip_memory=True,
+        )
+
+
 class TestCompressorClampsToNumCtx:
     """A config setting ONLY model.ollama_num_ctx (no model.context_length)
     must not leave the compressor targeting the probed model window while
     requests run at the smaller served num_ctx."""
 
-    def _build_agent(self, cfg, probed_ctx):
-        import agent.context_compressor as cc_mod
-        with (
-            patch("model_tools.get_tool_definitions", return_value=[]),
-            patch("model_tools.check_toolset_requirements", return_value={}),
-            patch("agent.process_bootstrap.OpenAI"),
-            patch("hermes_cli.config.load_config", return_value=cfg),
-            patch("hermes_cli.config.load_config_readonly", return_value=cfg),
-            patch(
-                "agent.model_metadata.get_model_context_length",
-                return_value=probed_ctx,
-            ),
-            patch.object(
-                cc_mod, "get_model_context_length", return_value=probed_ctx,
-            ),
-        ):
-            from run_agent import AIAgent
-            return AIAgent(
-                model="gemma3:27b",
-                api_key="ollama",
-                base_url="http://localhost:11434/v1",
-                quiet_mode=True,
-                skip_context_files=True,
-                skip_memory=True,
-            )
-
     def test_num_ctx_only_config_clamps_compressor_window(self):
-        agent = self._build_agent(
+        agent = _build_agent(
             {"agent": {}, "model": {"ollama_num_ctx": 65536}}, probed_ctx=262144
         )
         assert agent._ollama_num_ctx == 65536
@@ -181,9 +184,26 @@ class TestCompressorClampsToNumCtx:
         assert agent.context_compressor.threshold_tokens < 65536
 
     def test_larger_num_ctx_does_not_inflate_compressor_window(self):
-        agent = self._build_agent(
+        agent = _build_agent(
             {"agent": {}, "model": {"ollama_num_ctx": 131072}}, probed_ctx=65536
         )
         # num_ctx above the resolved window must not RAISE the compressor
         # window: the clamp is one-directional.
         assert agent.context_compressor.context_length == 65536
+
+
+class TestServedNumCtxSatisfiesTheFloor:
+    """#100437: the 64K floor judges the window a local Ollama server actually serves. A Modelfile
+    or model.ollama_num_ctx at 64K+ is usable even when the GGUF metadata advertises 40K, so
+    construction must succeed; the compressor still targets the smaller probed window."""
+
+    def test_explicit_num_ctx_above_the_floor_admits_a_small_metadata_window(self):
+        agent = _build_agent({"agent": {}, "model": {"ollama_num_ctx": 65536}}, probed_ctx=40960)
+        assert agent._ollama_num_ctx == 65536
+        assert agent.context_compressor.context_length == 40960  # one-directional clamp unchanged
+
+    def test_served_window_counts_only_for_a_local_endpoint(self):
+        """Only a local server honours num_ctx; a stale override must not admit a hosted 40K model."""
+        with pytest.raises(ValueError, match="below the minimum"):
+            _build_agent({"agent": {}, "model": {"ollama_num_ctx": 65536}}, probed_ctx=40960,
+                         base_url="https://openrouter.ai/api/v1")
diff --git a/tests/conftest.py b/tests/conftest.py
index 1c17732365..665eb81536 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -754,6 +754,14 @@ def _neutralize_macos_keychain_creds(request, monkeypatch):
         lambda *_args, **_kwargs: None,
         raising=False,
     )
+    # The #98334 refresh write also mirrors into the Keychain; keep that out of
+    # the real store in any test that hasn't explicitly opted in.
+    monkeypatch.setattr(
+        _mod,
+        "_mirror_claude_code_credentials_to_keychain",
+        lambda *_args, **_kwargs: None,
+        raising=False,
+    )
     return None
 
 
diff --git a/tests/gateway/relay/test_relay_threads.py b/tests/gateway/relay/test_relay_threads.py
index a456f6059e..41b1808384 100644
--- a/tests/gateway/relay/test_relay_threads.py
+++ b/tests/gateway/relay/test_relay_threads.py
@@ -360,7 +360,7 @@ def _mk_runner_stub():
         def __init__(self, adapter):
             self.adapters = {Platform.RELAY: adapter}
 
-        def _adapter_for_source(self, source):
+        def _delivery_adapter_for(self, source):
             return self.adapters.get(Platform.RELAY)
 
     return _Stub
diff --git a/tests/gateway/test_background_command.py b/tests/gateway/test_background_command.py
index 85071be9a9..6ee1ecfd22 100644
--- a/tests/gateway/test_background_command.py
+++ b/tests/gateway/test_background_command.py
@@ -260,7 +260,7 @@ class TestHandleBtwCommand:
         runner._reply_anchor_for_event = MagicMock(return_value=None)
         runner._thread_metadata_for_source = MagicMock(return_value=None)
         mock_adapter = AsyncMock()
-        runner._adapter_for_source = MagicMock(return_value=mock_adapter)
+        runner._delivery_adapter_for = MagicMock(return_value=mock_adapter)
 
         event = _make_event(text="/btw which file was that?")
 
diff --git a/tests/gateway/test_bot_loop_guard.py b/tests/gateway/test_bot_loop_guard.py
index 96aaeac0c4..8b9052bf83 100644
--- a/tests/gateway/test_bot_loop_guard.py
+++ b/tests/gateway/test_bot_loop_guard.py
@@ -124,7 +124,7 @@ async def test_busy_path_counts_a_bot_message_once_before_steering(monkeypatch,
     runner._effective_busy_input_mode = lambda source: "steer"
     runner._effective_busy_text_mode = lambda source: "steer"
     runner._route_plaintext_approval_while_busy = AsyncMock(return_value=False)
-    runner._adapter_for_source = lambda source: SimpleNamespace(_pending_messages={})
+    runner._delivery_adapter_for = lambda source: SimpleNamespace(_pending_messages={})
     runner._peek_session_state = lambda key: SimpleNamespace(turn=SimpleNamespace(agent=object()))
     steer = AsyncMock(return_value=SimpleNamespace(effective_mode="steer", redirected=False, steered=True))
     runner._resolve_busy_steer_or_redirect = steer
diff --git a/tests/gateway/test_busy_session_ack.py b/tests/gateway/test_busy_session_ack.py
index eb3eae9ec8..fb0f0e0c7c 100644
--- a/tests/gateway/test_busy_session_ack.py
+++ b/tests/gateway/test_busy_session_ack.py
@@ -540,7 +540,7 @@ class TestLongRunningNotificationOwnership:
             return SimpleNamespace(success=False)
 
         adapter.edit_message = AsyncMock(side_effect=_edit_then_restart)
-        runner._adapter_for_source = lambda source: adapter
+        runner._delivery_adapter_for = lambda source: adapter
         runner._agent_activity_summary = staticmethod(lambda agent: None)
         agent = MagicMock()
         runner._running_agents["sess"] = agent
diff --git a/tests/gateway/test_choice_picker.py b/tests/gateway/test_choice_picker.py
index 701c6416d5..f789739a0f 100644
--- a/tests/gateway/test_choice_picker.py
+++ b/tests/gateway/test_choice_picker.py
@@ -63,7 +63,7 @@ def _make_runner(adapter=None):
     runner.hooks.loaded_hooks = []
     runner._session_db = None
     runner._get_or_create_gateway_honcho = lambda session_key: (None, None)
-    runner._adapter_for_source = lambda source: adapter
+    runner._delivery_adapter_for = lambda source: adapter
     runner._thread_metadata_for_source = lambda source, anchor=None: {}
     runner._reply_anchor_for_event = lambda event: None
     return runner
diff --git a/tests/gateway/test_clarify_thread_followup_not_swallowed.py b/tests/gateway/test_clarify_thread_followup_not_swallowed.py
index e730878dc1..1ca05e90e1 100644
--- a/tests/gateway/test_clarify_thread_followup_not_swallowed.py
+++ b/tests/gateway/test_clarify_thread_followup_not_swallowed.py
@@ -99,7 +99,7 @@ def _make_runner(adapter):
     runner._scale_to_zero_note_real_inbound = lambda: None
     runner._is_user_authorized = lambda source: True
     runner._session_key_for_source = lambda source: SESSION_KEY
-    runner._adapter_for_source = lambda source: adapter
+    runner._delivery_adapter_for = lambda source: adapter
     runner._update_prompt_pending = {}
     return runner
 
diff --git a/tests/gateway/test_decline_fallback_suppression.py b/tests/gateway/test_decline_fallback_suppression.py
index b4f83ad738..9a463303c0 100644
--- a/tests/gateway/test_decline_fallback_suppression.py
+++ b/tests/gateway/test_decline_fallback_suppression.py
@@ -120,7 +120,7 @@ def _busy(adapter: _ConfirmAdapter):
     from gateway.run_busy import GatewayBusySessionMixin
 
     busy = object.__new__(GatewayBusySessionMixin)
-    busy._adapter_for_source = lambda _s: adapter
+    busy._delivery_adapter_for = lambda _s: adapter
     busy._thread_metadata_for_source = lambda _s, _a: {}
     busy._reply_anchor_for_event = lambda _e: None
     busy._session_key_for_source = lambda _s: "sk1"
diff --git a/tests/gateway/test_delivery_ledger_producer.py b/tests/gateway/test_delivery_ledger_producer.py
index f80983f37d..645e79951d 100644
--- a/tests/gateway/test_delivery_ledger_producer.py
+++ b/tests/gateway/test_delivery_ledger_producer.py
@@ -132,7 +132,7 @@ class TestProducerHook:
         replacement = _Adapter()
         replacement._owner_profile = "reviewer"
         runner = MagicMock()
-        runner._adapter_for_source.side_effect = [adapter, replacement]
+        runner._delivery_adapter_for.side_effect = [adapter, replacement]
         runner._redeliver_failed_obligations_for_platform = AsyncMock(return_value=1)
         adapter.gateway_runner = runner
         adapter.send = AsyncMock(
diff --git a/tests/gateway/test_discord_triggering_note_persistence.py b/tests/gateway/test_discord_triggering_note_persistence.py
index 46c1b0e7f0..403d2a35a9 100644
--- a/tests/gateway/test_discord_triggering_note_persistence.py
+++ b/tests/gateway/test_discord_triggering_note_persistence.py
@@ -66,7 +66,7 @@ async def test_queued_followup_persists_authored_text():
     note = discord_triggering_note("6002")
     runner._prepare_profile_scoped_inbound_message_text = AsyncMock(return_value=f"{note}\n\nthe follow-up")
     runner._reply_anchor_for_event = MagicMock(return_value=None)
-    runner._adapter_for_source = MagicMock(return_value=None)
+    runner._delivery_adapter_for = MagicMock(return_value=None)
     runner._refresh_agent_cache_message_count = AsyncMock()
     source = _discord_source()
     turn_ctx = SimpleNamespace(
diff --git a/tests/gateway/test_gateway_silence_tokens.py b/tests/gateway/test_gateway_silence_tokens.py
index 4f5a6c8bd6..b4287179ef 100644
--- a/tests/gateway/test_gateway_silence_tokens.py
+++ b/tests/gateway/test_gateway_silence_tokens.py
@@ -197,7 +197,7 @@ async def test_queued_terminal_turn_owns_the_silence_verdict(monkeypatch, tmp_pa
     runner._is_goal_continuation_event = MagicMock(return_value=False)
     runner._session_key_for_source = MagicMock(return_value="agent:main:telegram:group:-1001:12345")
     runner._prepare_profile_scoped_inbound_message_text = AsyncMock(return_value="follow-up")
-    runner._adapter_for_source = MagicMock(return_value=None)
+    runner._delivery_adapter_for = MagicMock(return_value=None)
     runner._refresh_agent_cache_message_count = AsyncMock()
     turn_ctx = SimpleNamespace(
         source=_source(), session_id="sid", session_key="agent:main:telegram:group:-1001:12345",
diff --git a/tests/gateway/test_heartbeat_acceptance.py b/tests/gateway/test_heartbeat_acceptance.py
index 7471dfb192..8157a839bf 100644
--- a/tests/gateway/test_heartbeat_acceptance.py
+++ b/tests/gateway/test_heartbeat_acceptance.py
@@ -19,7 +19,7 @@ async def test_cancelled_admission_is_refunded_but_started_execution_is_not():
     runner._run_in_executor_with_context = asyncio.to_thread
     adapter = WireAdapter(PlatformConfig(enabled=True, typing_indicator=False), Platform.TELEGRAM)
     adapter.wire = []
-    runner._adapter_for_source = lambda source: adapter
+    runner._delivery_adapter_for = lambda source: adapter
     source = SessionSource(platform=Platform.TELEGRAM, chat_id='42', user_id='42')
     key = build_session_key(source)
     watch = {key: (source, 'cancel-test')}
@@ -60,7 +60,7 @@ async def test_runner_rejection_does_not_consume_tick_or_overwrite_replacement()
     runner._run_in_executor_with_context = asyncio.to_thread
     adapter = WireAdapter(PlatformConfig(enabled=True, typing_indicator=False), Platform.TELEGRAM)
     adapter.wire = []
-    runner._adapter_for_source = lambda source: adapter
+    runner._delivery_adapter_for = lambda source: adapter
     source = SessionSource(platform=Platform.TELEGRAM, chat_id='42', user_id='42')
     key = build_session_key(source)
     watch = {key: (source, 'rejected-test')}
diff --git a/tests/gateway/test_heartbeat_execution_ownership.py b/tests/gateway/test_heartbeat_execution_ownership.py
index fb9336c413..8b53154a44 100644
--- a/tests/gateway/test_heartbeat_execution_ownership.py
+++ b/tests/gateway/test_heartbeat_execution_ownership.py
@@ -22,7 +22,7 @@ async def test_admitted_heartbeat_executes_only_in_own_conversation(tmp_path, bo
     runner.session_store = SessionStore(tmp_path / "sessions", runner.config)
     adapter = WireAdapter(PlatformConfig(enabled=True, typing_indicator=False), Platform.TELEGRAM)
     adapter.wire = []
-    runner._adapter_for_source = lambda source: adapter
+    runner._delivery_adapter_for = lambda source: adapter
     runner._is_telegram_topic_lane = lambda source: False
     runner._cache_session_source = lambda *args: None
     runner._clear_session_env = lambda tokens: None
diff --git a/tests/gateway/test_heartbeat_poller.py b/tests/gateway/test_heartbeat_poller.py
index 2aa981f621..f6e5b99f47 100644
--- a/tests/gateway/test_heartbeat_poller.py
+++ b/tests/gateway/test_heartbeat_poller.py
@@ -43,7 +43,7 @@ def poller(monkeypatch):
     adapter = _HeartbeatAdapter(PlatformConfig(enabled=True, typing_indicator=False), Platform.TELEGRAM)
     runner = object.__new__(GatewayRunner)
     runner._running_agents = {}
-    runner._adapter_for_source = lambda source: adapter
+    runner._delivery_adapter_for = lambda source: adapter
     runner._run_in_executor_with_context = asyncio.to_thread
     watch = {key: (source, "heartbeat-session")}
     HeartbeatManager("heartbeat-session").set("check status", 60)
@@ -96,9 +96,9 @@ async def test_unavailable_or_busy_session_leaves_persisted_tick_due(poller):
     original = HeartbeatManager("heartbeat-session").state.to_json()
     user = MessageEvent(text="user follow-up", source=watch[key][0])
     # Missing adapter and missing handler must not consume a due tick.
-    runner._adapter_for_source = lambda source: None
+    runner._delivery_adapter_for = lambda source: None
     await runner._heartbeat_poll_once(watch)
-    runner._adapter_for_source = lambda source: adapter
+    runner._delivery_adapter_for = lambda source: adapter
     await runner._heartbeat_poll_once(watch)
 
     async def handler(event):
diff --git a/tests/gateway/test_heartbeat_watch_lifecycle.py b/tests/gateway/test_heartbeat_watch_lifecycle.py
index 1d8ecd30cf..bdac2e165e 100644
--- a/tests/gateway/test_heartbeat_watch_lifecycle.py
+++ b/tests/gateway/test_heartbeat_watch_lifecycle.py
@@ -30,7 +30,7 @@ async def test_watches_read_and_admit_in_each_owner_profile(tmp_path, monkeypatc
             rows.append((event.source.profile, str(get_hermes_home()), event.text))
             self._active_sessions[event.metadata['gateway_session_key']] = True
 
-    runner._adapter_for_source = lambda source: Adapter()
+    runner._delivery_adapter_for = lambda source: Adapter()
     watch = {}
     for name in ('alpha', 'beta'):
         home = tmp_path / '.hermes' / 'profiles' / name
@@ -64,7 +64,7 @@ async def test_watch_tracks_rotated_route_owner_without_reviving_parent():
             events.append(event)
             self._active_sessions['route'] = True
 
-    runner._adapter_for_source = lambda source: Adapter()
+    runner._delivery_adapter_for = lambda source: Adapter()
     await runner._warm_goals_session_db('test')
     save_heartbeat('parent', HeartbeatState(prompt='follow rotation', interval_seconds=60, created_at=1))
     assert migrate_heartbeat_to_session('parent', 'child')
diff --git a/tests/gateway/test_heartbeat_watch_restore.py b/tests/gateway/test_heartbeat_watch_restore.py
index 0e6195ebb8..88e6dbff56 100644
--- a/tests/gateway/test_heartbeat_watch_restore.py
+++ b/tests/gateway/test_heartbeat_watch_restore.py
@@ -51,7 +51,7 @@ async def test_restore_retries_persisted_routes_in_their_own_profiles(tmp_path,
         runner._heartbeat_watch = {}
         runner._start_heartbeat_poller = lambda: None
         runner._profile_name_for_source = lambda source, adapter_profile=None: source.profile
-        runner._adapter_for_source = lambda source: object()
+        runner._delivery_adapter_for = lambda source: object()
         runner._run_in_executor_with_context = asyncio.to_thread
         original = runner.session_store.list_sessions
         with monkeypatch.context() as patch:
diff --git a/tests/gateway/test_identity_canonical_ingress.py b/tests/gateway/test_identity_canonical_ingress.py
new file mode 100644
index 0000000000..80c49b1844
--- /dev/null
+++ b/tests/gateway/test_identity_canonical_ingress.py
@@ -0,0 +1,181 @@
+"""Identity is canonicalized FIRST on every ingress path (#88715 phase 3).
+
+Two Telegram bots on one multiplexed gateway see the same ``chat.id == user.id`` for a DM with the
+same human; every adapter-side lane (batch dict, ``_active_sessions``, the busy guard, control
+commands, clarify replies) must be keyed by the receiving bot's identity before anything else
+derives a key. Real ``GatewayRunner`` resolvers, real ``BasePlatformAdapter`` ingress, temp home.
+"""
+
+import asyncio
+from types import SimpleNamespace
+from unittest.mock import patch
+
+import pytest
+
+from gateway.config import GatewayConfig, Platform, PlatformConfig
+from gateway.pairing import PairingStore
+from gateway.platforms.base import BasePlatformAdapter, MessageEvent, MessageType
+from gateway.profile_routing import parse_profile_routes
+from gateway.session_identity import identity_of
+
+UID = "72719239"  # Telegram DM: chat.id == user.id, identical for every bot
+
+
+class _Stub(BasePlatformAdapter):
+    pass
+
+
+_Stub.__abstractmethods__ = frozenset()
+
+
+def _adapter(runner, owner=None):
+    adapter = _Stub.__new__(_Stub)
+    BasePlatformAdapter.__init__(adapter, PlatformConfig(enabled=True, extra={}), Platform.TELEGRAM)
+    adapter.gateway_runner = runner
+    adapter._session_store = SimpleNamespace(_resolve_profile_for_key=lambda s: "default")
+    if owner:
+        adapter.set_owner_profile(owner)
+    return adapter
+
+
+@pytest.fixture
+def rig(tmp_path, monkeypatch):
+    """Default home owns bot A; ``team_b`` owns bot B; satellite ``ops`` is routed through bot A
+    for chat 5150; a route to unserved ``ghost`` for chat 4040."""
+    from gateway.run import GatewayRunner
+
+    home = tmp_path / "hh"
+    for name in ("ops", "team_b"):
+        (home / "profiles" / name).mkdir(parents=True)
+    monkeypatch.setenv("HERMES_HOME", str(home))
+    runner = object.__new__(GatewayRunner)
+    runner.config = GatewayConfig(multiplex_profiles=True)
+    runner.config.platforms = {Platform.TELEGRAM: PlatformConfig(enabled=True, extra={})}
+    runner.config.profile_routes = parse_profile_routes([
+        {"name": "ops-dm", "platform": "telegram", "profile": "ops", "chat_id": "5150"},
+        {"name": "ghost", "platform": "telegram", "profile": "ghost", "chat_id": "4040"},
+    ])
+    runner.pairing_store = PairingStore(profile="default")
+    runner.pairing_stores = {}
+    runner._primary_profile_name = "default"
+    bot_a, bot_b = _adapter(runner), _adapter(runner, owner="team_b")
+    runner.adapters = {Platform.TELEGRAM: bot_a}
+    runner._profile_adapters = {"team_b": {Platform.TELEGRAM: bot_b}, "ops": {}}
+    served = [("default", home), ("ops", home / "profiles" / "ops"), ("team_b", home / "profiles" / "team_b")]
+    with patch("hermes_cli.profiles.profiles_to_serve", return_value=served), \
+            patch("hermes_cli.profiles.get_profile_dir", side_effect=lambda n: home if n == "default" else home / "profiles" / n), \
+            patch("hermes_cli.profiles.profile_exists", return_value=True):
+        yield SimpleNamespace(runner=runner, home=home, bot_a=bot_a, bot_b=bot_b)
+
+
+def _event(adapter, chat_id, text, **kw):
+    source = adapter.build_source(chat_id=chat_id, chat_type="dm", user_id=chat_id)
+    return MessageEvent(text=text, message_type=MessageType.TEXT, source=source, message_id="m", **kw)
+
+
+async def _hold(adapter, key):
+    guard = asyncio.Event()
+    adapter._active_sessions[key] = guard
+    adapter._session_tasks[key] = asyncio.create_task(asyncio.sleep(30))
+    return guard
+
+
+@pytest.mark.asyncio
+async def test_two_bots_same_chat_have_distinct_lanes_and_stop_cannot_cross(rig):
+    """Acceptance row A: the same human DMs both bots. Batching, the active-session guard and a
+    ``/stop`` all resolve on the receiving bot's lane; ``/stop`` on A never touches B's run, and the
+    clarify reply on A resolves A's pending prompt, not B's."""
+    seen = []
+
+    async def handler(event):
+        seen.append((identity_of(event.source).transport_profile, event.text))
+        return None
+
+    for bot in (rig.bot_a, rig.bot_b):
+        bot.set_message_handler(handler)
+
+    ev_a, ev_b = _event(rig.bot_a, UID, "hello A"), _event(rig.bot_b, UID, "hello B")
+    rig.bot_a._enqueue_text_event(ev_a)
+    rig.bot_b._enqueue_text_event(ev_b)
+    key_a, key_b = rig.bot_a._event_session_key(ev_a), rig.bot_b._event_session_key(ev_b)
+    assert key_a == f"agent:main:telegram:dm:{UID}" and key_b == f"agent:team_b:telegram:dm:{UID}"
+    assert list(rig.bot_a._pending_text_batches) == [key_a] and list(rig.bot_b._pending_text_batches) == [key_b]
+    # The identity was pinned BEFORE the key was derived, and the two lanes never share a source.
+    assert identity_of(ev_a.source).transport_profile == "default"
+    assert identity_of(ev_b.source).transport_profile == "team_b"
+    for bot in (rig.bot_a, rig.bot_b):
+        for task in list(bot._pending_text_batch_tasks.values()):
+            task.cancel()
+        bot._pending_text_batches.clear()
+
+    # Both bots busy on "their" chat; /stop on A interrupts A's guard only and B's task survives.
+    guard_a, guard_b = await _hold(rig.bot_a, key_a), await _hold(rig.bot_b, key_b)
+    task_b = rig.bot_b._session_tasks[key_b]
+    await rig.bot_a.handle_message(_event(rig.bot_a, UID, "/stop", allow_gateway_control=True))
+    await asyncio.sleep(0)
+    assert seen == [("default", "/stop")]
+    assert key_a not in rig.bot_a._session_tasks
+    assert rig.bot_b._session_tasks[key_b] is task_b and not task_b.cancelled()
+    assert rig.bot_b._active_sessions[key_b] is guard_b and not guard_b.is_set()
+    assert not guard_a.is_set()  # the command path replaced A's guard; the run was cancelled, not flagged
+
+    # Clarify: pending prompts on both lanes; the plain-text answer on A resolves A only.
+    from tools import clarify_gateway
+    clarify_gateway.register("c-a", key_a, "Which?", ["x", "y"])
+    clarify_gateway.register("c-b", key_b, "Which?", ["x", "y"])
+    clarify_gateway.mark_awaiting_text("c-a")
+    clarify_gateway.mark_awaiting_text("c-b")
+    try:
+        await _hold(rig.bot_a, key_a)
+        await rig.bot_a.handle_message(_event(rig.bot_a, UID, "x", allow_gateway_control=True))
+        assert seen[-1] == ("default", "x")  # routed through A's inline clarify intercept
+        assert clarify_gateway.get_pending_for_session(key_b, include_choice_prompts=True) is not None
+        assert key_b not in rig.bot_a._pending_messages and key_a not in rig.bot_b._pending_messages
+    finally:
+        clarify_gateway.clear_session(key_a)
+        clarify_gateway.clear_session(key_b)
+        for bot in (rig.bot_a, rig.bot_b):
+            for task in bot._session_tasks.values():
+                task.cancel()
+
+
+@pytest.mark.asyncio
+async def test_shared_bot_routed_chat_runs_as_satellite_and_unserved_route_is_dropped_everywhere(rig):
+    """Acceptance row B: a chat routed through the shared bot to satellite ``ops`` keys into
+    ``agent:ops`` on every ingress path (fresh, batch, busy) while the transport stays the receiving
+    bot. A route to an unserved profile is dropped at every path — never ``agent:main``."""
+    calls = []
+
+    async def handler(event):
+        calls.append(event.text)
+        return None
+
+    async def busy(event, session_key):
+        calls.append(("busy", session_key, identity_of(event.source).runtime_profile))
+        return True
+
+    rig.bot_a.set_message_handler(handler)
+    rig.bot_a.set_busy_session_handler(busy)
+
+    routed = _event(rig.bot_a, "5150", "hi ops")
+    key = rig.bot_a._event_session_key(routed)
+    identity = identity_of(routed.source)
+    assert key == "agent:ops:telegram:dm:5150"
+    assert (identity.transport_profile, identity.runtime_profile) == ("default", "ops")
+    assert identity.adapter() is rig.bot_a and identity.runtime_home == rig.home / "profiles" / "ops"
+
+    await _hold(rig.bot_a, key)
+    await rig.bot_a.handle_message(_event(rig.bot_a, "5150", "follow-up"))
+    assert calls[-1] == ("busy", key, "ops")
+
+    # Unserved route: fresh, batched, busy and control paths all drop; no lane is created or touched.
+    main_key = "agent:main:telegram:dm:4040"
+    guard = await _hold(rig.bot_a, main_key)
+    for text, kw in (("hello", {}), ("/stop", {"allow_gateway_control": True})):
+        await rig.bot_a.handle_message(_event(rig.bot_a, "4040", text, **kw))
+    rig.bot_a._enqueue_text_event(_event(rig.bot_a, "4040", "chunk"))
+    assert calls == [("busy", key, "ops")]
+    assert not rig.bot_a._pending_text_batches and main_key not in rig.bot_a._pending_messages
+    assert rig.bot_a._active_sessions[main_key] is guard and main_key in rig.bot_a._session_tasks
+    for task in rig.bot_a._session_tasks.values():
+        task.cancel()
diff --git a/tests/gateway/test_kanban_routed_transport.py b/tests/gateway/test_kanban_routed_transport.py
index 9e9ddb4583..5c9043d078 100644
--- a/tests/gateway/test_kanban_routed_transport.py
+++ b/tests/gateway/test_kanban_routed_transport.py
@@ -84,7 +84,7 @@ def test_exact_routed_profile_delivers_once_on_its_authorized_transport(tmp_path
     source = primary.handled[0].source
     assert (source.profile, source.guild_id, source.scope_id, source.parent_chat_id) == (
         "yuki", "guild", "guild", "parent")
-    assert runner._adapter_for_source(source) is primary
+    assert runner._delivery_adapter_for(source) is primary
     assert not collect(runner)
 
     # A connected secondary owns its credential even where the primary route matches.
@@ -96,7 +96,7 @@ def test_exact_routed_profile_delivers_once_on_its_authorized_transport(tmp_path
     assert len(primary.sent) == 1
     assert len(secondary.sent) == len(secondary.handled) == 1
     assert secondary.handled[0].source.scope_id == "guild"
-    assert runner._adapter_for_source(secondary.handled[0].source) is secondary
+    assert runner._delivery_adapter_for(secondary.handled[0].source) is secondary
     assert not unseen(task)
 
 
diff --git a/tests/gateway/test_kanban_wake_acceptance.py b/tests/gateway/test_kanban_wake_acceptance.py
index b3046f20a5..bf1834cdbd 100644
--- a/tests/gateway/test_kanban_wake_acceptance.py
+++ b/tests/gateway/test_kanban_wake_acceptance.py
@@ -26,7 +26,7 @@ def setup_route(raft=False):
     runner = object.__new__(GatewayRunner)
     runner._running_agents = {}
     runner.adapters = {adapter.platform: adapter}
-    runner._adapter_for_source = lambda source: adapter
+    runner._delivery_adapter_for = lambda source: adapter
     runner._kanban_dispatcher_lock_handle = object()
     source = SessionSource(platform=adapter.platform, chat_id="42", user_id="42", chat_type="dm")
     return runner, adapter, source, build_session_key(source)
diff --git a/tests/gateway/test_multiplex_routing_authz.py b/tests/gateway/test_multiplex_routing_authz.py
index 0b004105d2..c1abfcbfd4 100644
--- a/tests/gateway/test_multiplex_routing_authz.py
+++ b/tests/gateway/test_multiplex_routing_authz.py
@@ -123,7 +123,7 @@ def test_shared_bot_satellite_resolves_primary_transport_for_restored_sources(mu
     sources (no transport ref); a disconnected secondary that owns a credential stays fail-closed."""
     restored = SessionSource(platform=Platform.TELEGRAM, chat_id="72719239", chat_type="dm", user_id="7", profile="ops")
     assert mux.runner._authorization_adapter(Platform.TELEGRAM, "ops") is mux.primary
-    assert mux.runner._adapter_for_source(restored) is mux.primary
+    assert mux.runner._delivery_adapter_for(restored) is mux.primary
     assert mux.runner._resolve_injection_adapter("telegram", restored) is mux.primary
     mux.runner._profile_adapters["team_b"] = {}  # team_b's bot is down: never borrow the primary
     assert mux.runner._authorization_adapter(Platform.TELEGRAM, "team_b") is None
diff --git a/tests/gateway/test_multiplex_transport_matrix.py b/tests/gateway/test_multiplex_transport_matrix.py
new file mode 100644
index 0000000000..fd2b7b27d2
--- /dev/null
+++ b/tests/gateway/test_multiplex_transport_matrix.py
@@ -0,0 +1,156 @@
+"""The intake / delivery transport matrix (#88715 phase 4; gateway/AGENTS.md § Profile scope).
+
+Real ``GatewayRunner`` resolvers against a temp ``HERMES_HOME`` with three served profiles:
+``default`` (shared bot), ``ops`` (satellite routed through the shared bot) and ``team_b`` (its own
+bot). Every row is asserted in one fixture so the two historical fixes (#69246 shared transport
+preserved, #70625 route-override egress) cannot drift apart again.
+"""
+
+import weakref
+from types import SimpleNamespace
+from unittest.mock import patch
+
+import pytest
+
+from gateway.config import GatewayConfig, Platform, PlatformConfig
+from gateway.pairing import PairingStore
+from gateway.platforms.base import BasePlatformAdapter
+from gateway.profile_routing import parse_profile_routes
+from gateway.session import SessionSource
+from gateway.session_identity import resolve_identity
+
+
+class _Stub(BasePlatformAdapter):
+    pass
+
+
+_Stub.__abstractmethods__ = frozenset()
+
+
+def _stub(platform, runner, label):
+    adapter = _Stub.__new__(_Stub)
+    adapter.platform, adapter.gateway_runner, adapter.label = platform, runner, label
+    adapter.config = PlatformConfig(enabled=True, extra={})
+    adapter._pending_messages, adapter._active_sessions = {}, {}
+    return adapter
+
+
+def _runner(*, multiplex, routes=()):
+    from gateway.run import GatewayRunner
+
+    runner = object.__new__(GatewayRunner)
+    runner.config = GatewayConfig(multiplex_profiles=multiplex)
+    runner.config.platforms = {Platform.TELEGRAM: PlatformConfig(enabled=True, extra={})}
+    runner.config.profile_routes = parse_profile_routes(list(routes))
+    runner.pairing_store = PairingStore(profile="default")
+    runner.pairing_stores = {}
+    runner._primary_profile_name = "default"
+    primary = _stub(Platform.TELEGRAM, runner, "PRIMARY")
+    team_b = _stub(Platform.TELEGRAM, runner, "TEAM_B")
+    team_b.set_owner_profile("team_b")
+    runner.adapters = {Platform.TELEGRAM: primary}
+    runner._profile_adapters = {"team_b": {Platform.TELEGRAM: team_b}, "ops": {}}
+    return SimpleNamespace(runner=runner, primary=primary, team_b=team_b)
+
+
+@pytest.fixture
+def mux(tmp_path, monkeypatch):
+    home = tmp_path / "hh"
+    for name in ("ops", "team_b"):
+        (home / "profiles" / name).mkdir(parents=True)
+    monkeypatch.setenv("HERMES_HOME", str(home))
+    served = [("default", home), ("ops", home / "profiles" / "ops"), ("team_b", home / "profiles" / "team_b")]
+    rig = _runner(multiplex=True, routes=[
+        # shared credential → satellite (#69246)
+        {"name": "ops-dm", "platform": "telegram", "profile": "ops", "chat_id": "72719239"},
+        # per-credential source → a profile that owns its own bot (#70625, decision D1)
+        {"name": "team-b-via-shared", "platform": "telegram", "profile": "team_b", "chat_id": "555"},
+        # secondary-owned transport → default (the inverse row)
+        {"name": "default-via-team-b", "platform": "telegram", "profile": "default", "chat_id": "999",
+         "bot_profile": "team_b"},
+    ])
+    rig.home = home
+    with patch("hermes_cli.profiles.profiles_to_serve", return_value=served), \
+            patch("hermes_cli.profiles.get_profile_dir",
+                  side_effect=lambda n: home if n == "default" else home / "profiles" / n), \
+            patch("hermes_cli.profiles.profile_exists", return_value=True):
+        yield rig
+
+
+def _live(rig, adapter, chat_id, **resolve_kwargs):
+    source = adapter.build_source(chat_id=chat_id, chat_type="dm", user_id=chat_id)
+    identity = resolve_identity(source, runner=rig.runner, **resolve_kwargs)
+    return source, identity
+
+
+def test_live_rows_reply_through_the_receiving_bot_whatever_the_runtime(mux):
+    """Rows 1–4 of the matrix: with live provenance, intake and delivery are BOTH the receiving
+    adapter; only the runtime (profile, namespace, home) follows the route."""
+    r = mux.runner
+    # per-credential, no route: owner on every axis
+    own, own_id = _live(mux, mux.team_b, "1", transport_profile="team_b")
+    assert (own_id.transport_profile, own_id.runtime_profile) == ("team_b", "team_b")
+    assert r._intake_adapter_for(own) is r._delivery_adapter_for(own) is mux.team_b
+
+    # shared credential → satellite: runtime ops, transport stays the shared bot (#69246)
+    sat, sat_id = _live(mux, mux.primary, "72719239")
+    assert (sat_id.transport_profile, sat_id.runtime_profile) == ("default", "ops")
+    assert r._intake_adapter_for(sat) is r._delivery_adapter_for(sat) is mux.primary
+    assert r._session_key_for_source(sat) == "agent:ops:telegram:dm:72719239"
+
+    # per-credential source routed to a profile that owns a bot: runtime team_b, reply via the
+    # bot that received it — conversation continuity (D1), not the routed profile's bot (#70625).
+    override, override_id = _live(mux, mux.primary, "555")
+    assert (override_id.transport_profile, override_id.runtime_profile) == ("default", "team_b")
+    assert override_id.runtime_home == mux.home / "profiles" / "team_b"
+    assert r._intake_adapter_for(override) is r._delivery_adapter_for(override) is mux.primary
+
+    # secondary-owned transport → default: agent:main key, default home, reply via the secondary bot
+    inverse, inverse_id = _live(mux, mux.team_b, "999", transport_profile="team_b")
+    assert (inverse_id.transport_profile, inverse_id.runtime_profile) == ("team_b", "default")
+    assert inverse_id.runtime_home == mux.home and inverse_id.namespace == "agent:main"
+    assert r._intake_adapter_for(inverse) is r._delivery_adapter_for(inverse) is mux.team_b
+    assert mux.team_b._source_session_key(inverse) == "agent:main:telegram:dm:999"
+
+    # Provenance survives a reconnect: the transport ref dies, the identity still names the bot.
+    replacement = _stub(Platform.TELEGRAM, r, "PRIMARY2")
+    r.adapters = {Platform.TELEGRAM: replacement}
+    assert r._intake_adapter_for(sat) is r._delivery_adapter_for(sat) is replacement
+
+
+def test_restored_rows_fail_closed_on_intake_and_deliver_only_via_a_unique_owner(mux, tmp_path, monkeypatch):
+    """Row 5: no live provenance → intake is ``None`` (nothing may re-dispatch or apply intake
+    policy); delivery goes to the unique owner of ``(platform, runtime)`` — the primary for a
+    shared-bot satellite, a secondary's own bot, ``None`` when that bot is down (never the default
+    bot). Outside multiplexing the one adapter is the receiver by construction."""
+    r = mux.runner
+
+    def restored(profile):
+        return SessionSource(platform=Platform.TELEGRAM, chat_id="42", chat_type="dm", user_id="42", profile=profile)
+
+    for profile, owner in ((None, mux.primary), ("ops", mux.primary), ("team_b", mux.team_b)):
+        assert r._intake_adapter_for(restored(profile)) is None, profile
+        assert r._delivery_adapter_for(restored(profile)) is owner, profile
+    # The admitting allowlist for a restored source is its delivering bot's (auto-resume, injection).
+    assert r._authorization_home_for_source(restored("team_b")) == mux.home / "profiles" / "team_b"
+    assert r._authorization_home_for_source(restored("ops")) == mux.home
+
+    # team_b's bot failed to connect and is queued for reconnect: it owns a credential, so the
+    # route that also names it through the shared bot must not turn it into a satellite.
+    r._profile_adapters["team_b"] = {}
+    r._profile_failed_platforms = {"team_b": {Platform.TELEGRAM: {}}}
+    assert r._delivery_adapter_for(restored("team_b")) is None
+    assert r._authorization_home_for_source(restored("team_b")) is None
+
+    # A dead transport ref with no identity is a restored row too, never a lookup by runtime.
+    stale = restored("ops")
+    stale._transport_adapter_ref = weakref.ref(_stub(Platform.TELEGRAM, r, "GONE"))
+    assert r._intake_adapter_for(stale) is None and r._delivery_adapter_for(stale) is mux.primary
+
+    solo_home = tmp_path / "solo"
+    solo_home.mkdir()
+    monkeypatch.setenv("HERMES_HOME", str(solo_home))
+    solo = _runner(multiplex=False)
+    bare = SessionSource(platform=Platform.TELEGRAM, chat_id="42", chat_type="dm", user_id="42")
+    assert solo.runner._intake_adapter_for(bare) is solo.runner._delivery_adapter_for(bare) is solo.primary
+    assert solo.runner._intake_adapter_for(None) is None and solo.runner._delivery_adapter_for(None) is None
diff --git a/tests/gateway/test_notice_rendering.py b/tests/gateway/test_notice_rendering.py
index 8a387683a5..a0ec7bc68c 100644
--- a/tests/gateway/test_notice_rendering.py
+++ b/tests/gateway/test_notice_rendering.py
@@ -99,7 +99,7 @@ def _make_source(platform_value="telegram", chat_id="555", user_id="u1"):
     src.user_id = user_id
     # Real SessionSource.profile is None (single-profile) or a str; a MagicMock
     # auto-attribute would read as a truthy "stamped profile" and trip the
-    # fail-closed path in _adapter_for_source (see AGENTS.md pitfall #17).
+    # fail-closed path in _delivery_adapter_for (see AGENTS.md pitfall #17).
     src.profile = None
     return src
 
diff --git a/tests/gateway/test_profile_resolution.py b/tests/gateway/test_profile_resolution.py
index d3dbc2031c..8356dcd033 100644
--- a/tests/gateway/test_profile_resolution.py
+++ b/tests/gateway/test_profile_resolution.py
@@ -24,6 +24,10 @@ def mock_runner():
     runner._resolve_profile_home_for_source = GatewayRunner._resolve_profile_home_for_source.__get__(runner)
     # _handle_message's ingress gates (profile route rejection) live in this helper.
     runner._hm_admit_event = GatewayRunner._hm_admit_event.__get__(runner)
+    # The identity seam the gate canonicalizes through; a hand-built source has no transport owner.
+    runner._canonicalize = GatewayRunner._canonicalize.__get__(runner)
+    runner._transport_owner = lambda _source: None
+    runner._primary_profile_name = "default"
     return runner
 
 
diff --git a/tests/gateway/test_queued_final_ledger.py b/tests/gateway/test_queued_final_ledger.py
index 2287791633..cdae71b341 100644
--- a/tests/gateway/test_queued_final_ledger.py
+++ b/tests/gateway/test_queued_final_ledger.py
@@ -70,7 +70,7 @@ def _telegram_adapter(send_result=None):
 
     adapter = TelegramAdapter(PlatformConfig(enabled=True, token="test-token", extra={}))
     runner = MagicMock()
-    runner._adapter_for_source = MagicMock(return_value=adapter)
+    runner._delivery_adapter_for = MagicMock(return_value=adapter)
     runner._schedule_flood_redelivery = MagicMock(return_value=187.0)
     adapter.gateway_runner = runner
     adapter.send = AsyncMock(return_value=send_result or SendResult(success=True, message_id="900"))
@@ -204,7 +204,7 @@ def _chain_runner_and_ctx(followup_return):
     runner._session_key_for_source = MagicMock(return_value=TOPIC_SESSION_KEY)
     runner._prepare_profile_scoped_inbound_message_text = AsyncMock(return_value="the follow-up")
     runner._reply_anchor_for_event = MagicMock(return_value=None)
-    runner._adapter_for_source = MagicMock(return_value=None)
+    runner._delivery_adapter_for = MagicMock(return_value=None)
     runner._refresh_agent_cache_message_count = AsyncMock()
     topic = _source(chat_id="-1001", thread_id="7", chat_type="supergroup")
     turn_ctx = SimpleNamespace(
@@ -232,7 +232,7 @@ async def test_a_chained_queued_turn_carries_its_own_inbound_id():
     runner._session_key_for_source = MagicMock(return_value=TOPIC_SESSION_KEY)
     runner._prepare_profile_scoped_inbound_message_text = AsyncMock(return_value="the follow-up")
     runner._reply_anchor_for_event = MagicMock(return_value=None)   # forum topic: no anchor
-    runner._adapter_for_source = MagicMock(return_value=None)
+    runner._delivery_adapter_for = MagicMock(return_value=None)
     runner._refresh_agent_cache_message_count = AsyncMock()
     topic = _source(chat_id="-1001", thread_id="7", chat_type="supergroup")
     turn_ctx = SimpleNamespace(
@@ -325,7 +325,7 @@ async def test_ephemeral_delete_targets_the_adapter_that_sent_the_final(tmp_path
     sender._schedule_ephemeral_delete = MagicMock()
     replacement._schedule_ephemeral_delete = MagicMock()
     live = {"adapter": sender}
-    sender.gateway_runner._adapter_for_source = MagicMock(side_effect=lambda _s: live["adapter"])
+    sender.gateway_runner._delivery_adapter_for = MagicMock(side_effect=lambda _s: live["adapter"])
 
     async def swap_then_send(*args, **kwargs):
         live["adapter"] = replacement  # reconnect lands while the send is in flight
diff --git a/tests/gateway/test_session_stall_watchdog.py b/tests/gateway/test_session_stall_watchdog.py
index 6e57ab80ef..4b512b1a7f 100644
--- a/tests/gateway/test_session_stall_watchdog.py
+++ b/tests/gateway/test_session_stall_watchdog.py
@@ -289,7 +289,7 @@ async def test_check_session_stalls_queued_events_overflow_notifies():
     event = _pending_event()
     runner._queued_events[session_key] = [event]
     runner._running_agents[session_key] = _FakeAgent(time.time() - 120)
-    runner._adapter_for_source = lambda source: adapter
+    runner._delivery_adapter_for = lambda source: adapter
 
     assert await runner._check_session_stalls(60) == 1
     assert adapter.sent and "/new" in adapter.sent[0]["content"]
diff --git a/tests/gateway/test_session_title_rename_lane.py b/tests/gateway/test_session_title_rename_lane.py
index f1008b9748..683d36bd93 100644
--- a/tests/gateway/test_session_title_rename_lane.py
+++ b/tests/gateway/test_session_title_rename_lane.py
@@ -84,7 +84,7 @@ async def test_native_thread_rename_passes_only_the_initial_name_guard():
         def __init__(self, adapter):
             self.adapters = {Platform.DISCORD: adapter}
 
-        def _adapter_for_source(self, source):
+        def _delivery_adapter_for(self, source):
             return self.adapters[source.platform]
 
     source = types.SimpleNamespace(
diff --git a/tests/gateway/test_shutdown_forensics.py b/tests/gateway/test_shutdown_forensics.py
index 4ff1ad2947..b6b4776e83 100644
--- a/tests/gateway/test_shutdown_forensics.py
+++ b/tests/gateway/test_shutdown_forensics.py
@@ -127,13 +127,17 @@ class TestArgvFreePersistence:
 # ---------------------------------------------------------------------------
 
 class TestSpawnAsyncDiagnostic:
-    # The diagnostic wraps its script in GNU coreutils ``timeout`` and the script
-    # body is Linux-only (``ps -eo ... comm``, ``/proc/loadavg``, ``dmesg``,
-    # ``pstree``). On hosts without ``timeout`` (macOS) Popen raises and the
-    # producer returns None by design (fail-soft), so the spawn can only be
-    # observed on Linux.
     @pytest.mark.platforms("linux")
     def test_spawns_subprocess_and_writes_output(self, tmp_path):
+        self._assert_diagnostic_written(tmp_path)
+
+    @pytest.mark.macos_only
+    def test_spawns_without_gnu_timeout_on_macos(self, tmp_path):
+        """Stock macOS has no ``timeout`` binary and BSD ``ps``; the diagnostic still lands."""
+        self._assert_diagnostic_written(tmp_path)
+
+    @staticmethod
+    def _assert_diagnostic_written(tmp_path):
         log_path = tmp_path / "diag.log"
         pid = sf.spawn_async_diagnostic(log_path, "SIGTERM", timeout_seconds=3.0)
         assert pid is not None and pid > 0
@@ -157,6 +161,10 @@ class TestSpawnAsyncDiagnostic:
         contents = log_path.read_text(encoding="utf-8", errors="replace")
         assert "shutdown diagnostic" in contents
         assert "SIGTERM" in contents
+        lines = contents.splitlines()
+        ps_section = lines[lines.index("--- ps (top 60 by cpu, comm only) ---") + 1:]
+        assert ps_section and ps_section[0].split()[:2] == ["PID", "PPID"], \
+            "ps column header must lead the listing, not sort as a 0.0-cpu row"
 
     @pytest.mark.platforms("linux")
     def test_diagnostic_log_omits_child_argv_and_is_owner_only(self, tmp_path, child_with_secret_argv):
diff --git a/tests/gateway/test_slack.py b/tests/gateway/test_slack.py
index 790014273f..e805195313 100644
--- a/tests/gateway/test_slack.py
+++ b/tests/gateway/test_slack.py
@@ -2638,7 +2638,7 @@ class TestFormatMessage:
 
         args = {"target": target, "pattern": pattern}
         ctx = SimpleNamespace(source=None, progress_mode="all", last_was_terminal_block=[False])
-        runner = SimpleNamespace(_adapter_for_source=lambda source: adapter)
+        runner = SimpleNamespace(_delivery_adapter_for=lambda source: adapter)
         message = TurnRunner(runner, ctx)._progress_build_message("search_files", pattern, args)
         client = adapter._app.client
         client.chat_postMessage.return_value = {"ok": True, "ts": "123.456"}
diff --git a/tests/gateway/test_streaming_tts_consumer.py b/tests/gateway/test_streaming_tts_consumer.py
index 95893da118..bb5349ea48 100644
--- a/tests/gateway/test_streaming_tts_consumer.py
+++ b/tests/gateway/test_streaming_tts_consumer.py
@@ -253,7 +253,7 @@ def gateway_tts_turn(monkeypatch, tmp_path):
         )
         runner = SimpleNamespace(
             config=SimpleNamespace(streaming=StreamingConfig()),
-            _adapter_for_source=lambda source: adapter,
+            _delivery_adapter_for=lambda source: adapter,
             _build_stream_consumer_config=lambda *args, **kwargs: (StreamConsumerConfig(), None),
         )
         _, delta, interim, _ = TurnRunner(runner, ctx)._setup_stream_consumer("realtime")
diff --git a/tests/gateway/test_streaming_tts_gateway_regression.py b/tests/gateway/test_streaming_tts_gateway_regression.py
index fa6fb5e2c4..2d646b7b26 100644
--- a/tests/gateway/test_streaming_tts_gateway_regression.py
+++ b/tests/gateway/test_streaming_tts_gateway_regression.py
@@ -133,7 +133,7 @@ def test_run_agent_voice_turn_no_name_error(monkeypatch, tmp_path):
     # finalisation path still runs with streaming_tts_consumer_holder[0]=None.
     monkeypatch.setattr(
         gateway_run.GatewayRunner,
-        "_adapter_for_source",
+        "_delivery_adapter_for",
         lambda self, source: None,
     )
 
diff --git a/tests/gateway/test_subagent_failure_notice.py b/tests/gateway/test_subagent_failure_notice.py
index 4938ef8fe8..f69b813108 100644
--- a/tests/gateway/test_subagent_failure_notice.py
+++ b/tests/gateway/test_subagent_failure_notice.py
@@ -97,7 +97,7 @@ def _make_runner_and_captured(monkeypatch, run_still_current=True):
     captured: list[str] = []
 
     class _StubGatewayRunner:
-        def _adapter_for_source(self, source):
+        def _delivery_adapter_for(self, source):
             return None
 
         async def _deliver_platform_notice(self, source, content):
diff --git a/tests/gateway/test_tool_log_mode.py b/tests/gateway/test_tool_log_mode.py
index 1ce04a0416..0b6bcf96ec 100644
--- a/tests/gateway/test_tool_log_mode.py
+++ b/tests/gateway/test_tool_log_mode.py
@@ -40,49 +40,34 @@ class TestLogBranchSemantics:
 
 
 @pytest.mark.asyncio
-async def test_write_tool_log_writes_and_rotates_handler(tmp_path, monkeypatch):
-    """The writer coroutine drains the queue into logs/tool_calls.log."""
+async def test_write_tool_log_shares_one_logger_across_turns(tmp_path, monkeypatch):
+    """Two turns with distinct queues register no new Logger (loggerDict is process-lifetime) and
+    every line lands in tool_calls.log exactly once through the shared handler."""
+    import logging
+
     import gateway.run as gateway_run
+    from gateway.run_turn import GatewayTurnMixin
 
     monkeypatch.setattr(gateway_run, "_hermes_home", tmp_path)
-
-    log_queue: queue.Queue = queue.Queue()
-    log_queue.put("2026-07-02 10:00:00  terminal: \"echo hi\"")
-    log_queue.put("2026-07-02 10:00:01  read_file: \"foo.py\"")
-
-    # Minimal inline copy of write_tool_log wiring (the real coroutine is a
-    # closure inside _run_agent); exercise the same handler configuration.
-    import logging
-    from logging.handlers import RotatingFileHandler
-
-    from agent.redact import RedactingFormatter
-
-    log_dir = tmp_path / "logs"
-    log_dir.mkdir(parents=True, exist_ok=True)
-    handler = RotatingFileHandler(
-        log_dir / "tool_calls.log", maxBytes=5 * 1024 * 1024, backupCount=3,
-        encoding="utf-8",
-    )
-    handler.setFormatter(RedactingFormatter("%(message)s"))
-    tool_logger = logging.getLogger(f"hermes.tool_calls.test.{id(log_queue)}")
-    tool_logger.setLevel(logging.INFO)
-    tool_logger.propagate = False
-    tool_logger.addHandler(handler)
+    shared = logging.getLogger("hermes.tool_calls")
+    for h in list(shared.handlers):
+        shared.removeHandler(h)
+        h.close()
+    before = set(logging.Logger.manager.loggerDict)
+    queues = []
     try:
-        while True:
-            try:
-                tool_logger.info("%s", log_queue.get_nowait())
-            except queue.Empty:
-                break
+        for i in range(2):
+            q: queue.Queue = queue.Queue()
+            queues.append(q)  # kept alive: distinct id()s, the shape the per-turn name leaked on
+            q.put(f"2026-09-18 10:00:0{i}  terminal: \"echo {i}\"")
+            task = asyncio.ensure_future(GatewayTurnMixin._run_agent_write_tool_log(None, q))
+            await asyncio.sleep(0.05)
+            task.cancel()
+            await task  # the writer swallows the cancel after draining
+        assert set(logging.Logger.manager.loggerDict) - before <= {"hermes.tool_calls"}
+        lines = (tmp_path / "logs" / "tool_calls.log").read_text(encoding="utf-8").splitlines()
+        assert [l.split()[-1] for l in lines] == ['0"', '1"']
     finally:
-        tool_logger.removeHandler(handler)
-        handler.flush()
-        handler.close()
-
-    content = (log_dir / "tool_calls.log").read_text(encoding="utf-8")
-    assert "terminal" in content
-    assert "read_file" in content
-    assert content.count("\n") == 2
-    await asyncio.sleep(0)  # keep the asyncio marker honest
-
-
+        for h in list(shared.handlers):
+            shared.removeHandler(h)
+            h.close()
diff --git a/tests/gateway/test_turn_context.py b/tests/gateway/test_turn_context.py
index 33db480e8b..6d2fa166dc 100644
--- a/tests/gateway/test_turn_context.py
+++ b/tests/gateway/test_turn_context.py
@@ -24,7 +24,7 @@ def _make_runner(ctx):
     from gateway.run_turn_runner import TurnRunner
 
     class _StubGatewayRunner:
-        def _adapter_for_source(self, source):
+        def _delivery_adapter_for(self, source):
             return None
 
     return TurnRunner(_StubGatewayRunner(), ctx)
diff --git a/tests/gateway/test_warning_notifications.py b/tests/gateway/test_warning_notifications.py
index 46b06bef01..e62ae1a580 100644
--- a/tests/gateway/test_warning_notifications.py
+++ b/tests/gateway/test_warning_notifications.py
@@ -62,7 +62,7 @@ def test_warning_opt_out_preserves_other_delivery(tmp_path, monkeypatch, platfor
     source = SessionSource(platform=platform, chat_id="chat", user_id="user", thread_id=thread_id)
     gateway = object.__new__(GatewayRunner)
     gateway.config = None
-    gateway._adapter_for_source = lambda source: adapter
+    gateway._delivery_adapter_for = lambda source: adapter
     gateway._thread_metadata_for_source = lambda source: {"thread_id": source.thread_id} if source.thread_id else {}
     ctx = TurnContext(source=source, user_config=config, _run_still_current=lambda: True,
                       _status_adapter=adapter, _status_chat_id=source.chat_id,
@@ -115,7 +115,7 @@ def test_direct_warning_delivery_keeps_failure_state(tmp_path, monkeypatch, enab
     adapter = RecordingAdapter()
     source = SessionSource(platform=Platform.SLACK, chat_id="chat", user_id="user")
     gateway = object.__new__(GatewayRunner)
-    gateway._adapter_for_source = lambda source: adapter
+    gateway._delivery_adapter_for = lambda source: adapter
     gateway._session_db_init_error = "database is locked"
     gateway._session_db_handle_cache = None
     gateway._home_channel_transports = lambda: [(Platform.SLACK, None, SimpleNamespace(chat_id="chat"), adapter)]
diff --git a/tests/gateway/test_warning_notifications_transport.py b/tests/gateway/test_warning_notifications_transport.py
index f296c28c6f..ce116d4eef 100644
--- a/tests/gateway/test_warning_notifications_transport.py
+++ b/tests/gateway/test_warning_notifications_transport.py
@@ -56,7 +56,7 @@ def test_warning_policy_reaches_slack_transport(tmp_path, monkeypatch, relay, th
         client.chat_update.side_effect = post
     gateway = object.__new__(GatewayRunner)
     gateway.config = None
-    gateway._adapter_for_source = lambda source: adapter
+    gateway._delivery_adapter_for = lambda source: adapter
     gateway._thread_metadata_for_source = lambda source: metadata
     ctx = TurnContext(source=source, user_config=_load_gateway_config(), _run_still_current=lambda: True,
                       _status_adapter=adapter, _status_chat_id="D1", _status_thread_metadata=metadata)
@@ -97,6 +97,6 @@ def test_profile_config_isolated_for_callbacks_and_direct_warnings(tmp_path, mon
             adapter = RecordingAdapter()
             adapter.send = AsyncMock()
             gateway = object.__new__(GatewayRunner)
-            gateway._adapter_for_source = lambda source: adapter
+            gateway._delivery_adapter_for = lambda source: adapter
             asyncio.run(gateway._hmwa_hygiene_notify(source, {}, "Compression failed", "failure"))
             assert adapter.send.await_count == int(expected)
diff --git a/tests/gateway/test_webhook_route_toolsets.py b/tests/gateway/test_webhook_route_toolsets.py
index a830444f47..220eabb9b6 100644
--- a/tests/gateway/test_webhook_route_toolsets.py
+++ b/tests/gateway/test_webhook_route_toolsets.py
@@ -42,7 +42,7 @@ def _make_adapter(routes):
 
 def _make_runner(adapter):
     gr = object.__new__(GatewayRunner)
-    gr._adapter_for_source = lambda source: adapter
+    gr._delivery_adapter_for = lambda source: adapter
     return gr
 
 
diff --git a/tests/hermes_cli/test_gateway.py b/tests/hermes_cli/test_gateway.py
index 4bdaab1a7e..5d67b5316d 100644
--- a/tests/hermes_cli/test_gateway.py
+++ b/tests/hermes_cli/test_gateway.py
@@ -1297,6 +1297,60 @@ def test_find_windows_gateway_services_rejects_transitional_ancestor(monkeypatch
         )
 
 
+@pytest.mark.windows_only
+def test_find_windows_gateway_services_ignores_task_scheduler_ancestor(monkeypatch):
+    """gateway <- cmd.exe <- svchost.exe(Schedule) <- services.exe: the Task Scheduler host is not the
+    gateway's supervisor, so a task-launched gateway is a plain process (#97208); the same tree under a
+    Hermes-owned service (by binary path) stays SCM-supervised."""
+    import psutil
+    import hermes_cli.gateway_windows as gateway_windows
+
+    monkeypatch.setattr(gateway_windows, "hermes_service_roots", lambda: (r"C:\hermes\hermes-agent",))
+    profile = SimpleNamespace(profile="default", pid=18480, create_time=18480.0)
+
+    class FakeService:
+        def __init__(self, name, binpath):
+            self._name, self._binpath = name, binpath
+
+        def as_dict(self):
+            return {"name": self._name, "binpath": self._binpath, "pid": 2360, "status": "running"}
+
+    class FakeProcess:
+        def __init__(self, pid):
+            self.pid = pid
+
+        def parents(self):
+            return [FakeProcess(12296), FakeProcess(2360), FakeProcess(4)]
+
+        def children(self, recursive=False):
+            assert self.pid == 2360 and recursive is True
+            return [FakeProcess(12296), FakeProcess(18480)]
+
+        def create_time(self):
+            return float(self.pid)
+
+    def run(service):
+        return gateway.find_windows_gateway_services(
+            psutil_module=SimpleNamespace(
+                win_service_iter=lambda: [service], Process=FakeProcess, AccessDenied=psutil.AccessDenied),
+            profile_processes=[profile],
+        )
+
+    assert run(FakeService("Schedule", r"C:\Windows\system32\svchost.exe -k netsvcs -p -s Schedule")) == []
+    owned = run(FakeService("gw", r'"C:\hermes\hermes-agent\venv\Scripts\hermes.exe" gateway run'))
+    assert [(s.name, s.service_pid, s.gateway_pid) for s in owned] == [("gw", 2360, 18480)]
+
+    # QueryServiceConfig denied to this user (hardened third-party service): not Hermes's, and never a
+    # reason to abort the whole enumeration; a Hermes-NAMED service is settled without asking binpath.
+    class DeniedConfigService(FakeService):
+        def binpath(self):
+            raise psutil.AccessDenied(2360, self._name)
+
+    assert run(DeniedConfigService("Hardened", "")) == []
+    named = run(DeniedConfigService("HermesGateway", ""))
+    assert [(s.name, s.service_pid, s.gateway_pid) for s in named] == [("HermesGateway", 2360, 18480)]
+
+
 def test_find_windows_gateway_services_rejects_shared_service_host_pid(monkeypatch):
     """A shared host PID cannot prove which service owns the gateway subtree."""
     monkeypatch.setattr(gateway.sys, "platform", "win32")
@@ -1323,7 +1377,10 @@ def test_find_windows_gateway_services_rejects_shared_service_host_pid(monkeypat
             return float(self.pid)
 
     fake_psutil = SimpleNamespace(
-        win_service_iter=lambda: [FakeService("ServiceA"), FakeService("ServiceB")],
+        win_service_iter=lambda: [
+            FakeService("HermesGatewayA"),
+            FakeService("HermesGatewayB"),
+        ],
         Process=FakeProcess,
     )
 
diff --git a/tests/hermes_cli/test_gateway_windows.py b/tests/hermes_cli/test_gateway_windows.py
index 64ee166a8f..f393f7ef51 100644
--- a/tests/hermes_cli/test_gateway_windows.py
+++ b/tests/hermes_cli/test_gateway_windows.py
@@ -581,3 +581,23 @@ def test_start_on_tty_hands_both_answers_to_install_and_honours_the_env_opt_out(
 
 
 
+
+
+def test_hermes_owns_windows_service_requires_name_or_binary_under_a_hermes_root():
+    """Task Scheduler (``Schedule`` in svchost) above a task-launched gateway is never its supervisor;
+    a service is Hermes-owned only by a ``hermes*`` name or a binary under the install (#97208)."""
+    roots = (
+        r"C:\Users\kaize\AppData\Local\hermes\hermes-agent",
+        r"C:\Users\kaize\AppData\Local\hermes\hermes-agent\venv\Scripts",
+        r"C:\Users\kaize\AppData\Local\hermes\gateway-service",
+    )
+    owns = gateway_windows.hermes_owns_windows_service
+
+    assert not owns("Schedule", r"C:\Windows\system32\svchost.exe -k netsvcs -p -s Schedule", roots)
+    assert not owns("BITS", r"C:\Windows\System32\svchost.exe -k netsvcs -p -s BITS", roots)
+    assert not owns("Other", r"C:\Users\kaize\AppData\Local\hermes\hermes-agent-fork\run.exe", roots)
+
+    assert owns("HermesGateway", r"C:\nssm\nssm.exe", roots)
+    assert owns("Hermes_Gateway_derek", "", roots)
+    assert owns("gw", r'"C:\Users\KAIZE\AppData\Local\hermes\hermes-agent\venv\Scripts\hermes.exe" gateway run', roots)
+    assert owns("gw", r"C:\Users\kaize\AppData\Local\hermes\gateway-service\Hermes_Gateway.cmd", roots)
diff --git a/tests/plugins/memory/test_hindsight_provider.py b/tests/plugins/memory/test_hindsight_provider.py
index b00f6fa68e..0659473faa 100644
--- a/tests/plugins/memory/test_hindsight_provider.py
+++ b/tests/plugins/memory/test_hindsight_provider.py
@@ -1695,3 +1695,24 @@ class TestMultiplexBackgroundScope:
                 t.join(timeout=5)
         assert created == ["p1-secret"]
         p.shutdown()
+
+
+def test_append_mode_trims_retained_turns_without_dropping_any(provider, monkeypatch):
+    """Append retains ship only the delta, so retained turns leave `_session_turns` (a never-ending
+    session no longer pins every turn) while every turn is still shipped exactly once."""
+    provider._auto_retain = True
+    provider._retain_every_n_turns = 3
+    monkeypatch.setattr(provider, "_ensure_writer", lambda: None)
+    monkeypatch.setattr(provider, "_register_atexit", lambda: None)
+    monkeypatch.setattr(provider, "_resolve_retain_target", lambda doc: ("doc", "append"))
+    shipped: list[str] = []
+    monkeypatch.setattr(provider, "_make_turn_retain_job",
+                        lambda turns, **kw: (lambda: shipped.extend(turns)))
+    provider._retain_queue = MagicMock(put=lambda job: job())
+
+    for i in range(7):
+        provider.sync_turn(f"user {i}", f"assistant {i}")
+
+    assert len(provider._session_turns) == 1  # only the un-retained tail (turn 7)
+    assert provider._last_retained_turn_count == 0
+    assert len(shipped) == 6 and len(set(shipped)) == 6
diff --git a/tests/tools/test_tts_container_repair.py b/tests/tools/test_tts_container_repair.py
index d4f898fc1b..35c266efc4 100644
--- a/tests/tools/test_tts_container_repair.py
+++ b/tests/tools/test_tts_container_repair.py
@@ -67,13 +67,16 @@ class TestRepairOggContainer:
 
         if not _shutil.which("ffmpeg"):
             pytest.skip("ffmpeg not installed")
-        # Synthesize a real tiny mp3 with ffmpeg, misname it .ogg
+        # Synthesize a real tiny mp3 with ffmpeg, misname it .ogg. "Available" means the binary
+        # runs AND carries the encoder: CI runners have shipped an ffmpeg on PATH that exits 127.
         p = tmp_path / "v.ogg"
-        _sp.run(
+        synth = _sp.run(
             ["ffmpeg", "-f", "lavfi", "-i", "sine=frequency=440:duration=0.3",
              "-acodec", "libmp3lame", "-f", "mp3", str(p), "-y"],
-            capture_output=True, check=True,
+            capture_output=True, check=False,
         )
+        if synth.returncode != 0:
+            pytest.skip(f"ffmpeg on PATH cannot synthesize mp3 (exit {synth.returncode})")
         assert _sniff_audio_container(str(p)) == "mp3"
         result = _repair_ogg_container(str(p))
         assert result == str(p)
diff --git a/tests/tui_gateway/test_out_of_band_history_adoption.py b/tests/tui_gateway/test_out_of_band_history_adoption.py
new file mode 100644
index 0000000000..84717521ea
--- /dev/null
+++ b/tests/tui_gateway/test_out_of_band_history_adoption.py
@@ -0,0 +1,71 @@
+"""Regression for #42962: a turn another surface (Telegram, cron) appended to a live desktop/TUI session must
+reach the model on the next local prompt, not only the repainted transcript."""
+
+import contextlib
+import threading
+
+from hermes_state import SessionDB
+from tui_gateway import server
+
+
+def _bind_db(monkeypatch, db):
+    @contextlib.contextmanager
+    def _owner_db(session):
+        yield db
+    monkeypatch.setattr(server, "_session_db", _owner_db)
+
+
+def _seed(tmp_path):
+    db = SessionDB(tmp_path / "state.db")
+    db.create_session("s1", source="desktop")
+    db.append_message("s1", "user", "My codeword is MANGO.", timestamp=1.0)
+    db.append_message("s1", "assistant", "OK", timestamp=2.0)
+    # What the agent's own flush leaves in memory: the rows stamped with their durable ids.
+    history = db.get_messages_as_conversation("s1", include_row_ids=True)
+    return db, {"session_key": "s1", "history": history, "history_lock": threading.Lock(), "history_version": 0}
+
+
+def test_next_turn_adopts_rows_another_writer_appended(tmp_path, monkeypatch):
+    db, session = _seed(tmp_path)
+    _bind_db(monkeypatch, db)
+    # A Telegram turn lands on the same session while the desktop is idle; its reply repeats an
+    # earlier one verbatim, so a text anchor would have mis-cut here — the row id boundary must not.
+    db.append_message("s1", "user", "My second codeword is KIWI.", timestamp=3.0)
+    db.append_message("s1", "assistant", "OK", timestamp=4.0)
+    # This turn's own prompt is already durable at submit (#111868) and must NOT be adopted as foreign.
+    own = db.append_message("s1", "user", "List every codeword.", timestamp=5.0)
+    session["_submit_user_row"] = {"role": "user", "content": "List every codeword.", "_row_id": own}
+
+    server._adopt_out_of_band_turns(session)
+
+    assert [m["content"] for m in session["history"]] == [
+        "My codeword is MANGO.", "OK", "My second codeword is KIWI.", "OK"]
+    assert session["history_version"] == 1
+    # Adopted rows are stamped: a second pass (next turn) finds nothing new.
+    server._adopt_out_of_band_turns(session)
+    assert len(session["history"]) == 4 and session["history_version"] == 1
+
+
+def test_compaction_epochs(tmp_path, monkeypatch):
+    """A local compaction re-stamps the in-memory dicts with the re-inserted rows' ids, so nothing sits above
+    the boundary. A compaction by ANOTHER surface rewrites the transcript under us: the summary shows up as a
+    foreign row and the history is re-hydrated from the DB instead of appended to."""
+    db, session = _seed(tmp_path)
+    _bind_db(monkeypatch, db)
+    local = [{"role": "assistant", "content": "summary of MANGO", "_compressed_summary": True}, session["history"][-1]]
+    db.archive_and_compact("s1", local, tail_count=1)
+    session["history"] = local
+    server._adopt_out_of_band_turns(session)
+    assert [m.get("_row_id") for m in session["history"]] == [3, 4] and session["history_version"] == 0
+
+    remote = [{"role": "assistant", "content": "summary of MANGO", "_compressed_summary": True},
+              {"role": "user", "content": "Repeat it"}, {"role": "assistant", "content": "MANGO"}]  # its own copies
+    db.archive_and_compact("s1", remote, tail_count=1)
+    db.append_message("s1", "user", "KIWI")
+    db.append_message("s1", "assistant", "OK")
+    own = db.append_message("s1", "user", "List every codeword")
+    session["_submit_user_row"] = {"role": "user", "content": "List every codeword", "_row_id": own}
+    server._adopt_out_of_band_turns(session)
+
+    assert [m["content"] for m in session["history"]] == ["summary of MANGO", "Repeat it", "MANGO", "KIWI", "OK"]
+    assert session["history"][0].get("_compressed_summary") and session["history_version"] == 1
diff --git a/tests/tui_gateway/test_slash_fuzzy.py b/tests/tui_gateway/test_slash_fuzzy.py
index 287019d91b..648602f1ca 100644
--- a/tests/tui_gateway/test_slash_fuzzy.py
+++ b/tests/tui_gateway/test_slash_fuzzy.py
@@ -118,3 +118,28 @@ def test_rank_slash_completions_ties_break_on_usage_then_name():
         score_of=lambda item: 1.0,
     )
     assert [item["text"] for item in ranked] == ["/alpha", "/beta"]
+
+
+def test_repo_file_cache_sweeps_expired_roots_on_write(tmp_path, monkeypatch):
+    """A root queried once and never again is dropped by the next write past its TTL — the TTL
+    used to be checked only on read, pinning every worktree listing for the process lifetime."""
+    import time
+
+    import tui_gateway.server as server
+
+    now = [1000.0]
+    monkeypatch.setattr(time, "monotonic", lambda: now[0])
+    roots = []
+    for i in range(3):
+        root = tmp_path / f"wt{i}"
+        root.mkdir()
+        (root / "a.py").write_text("")
+        roots.append(str(root))
+    server._fuzzy_cache.clear()
+    server._list_repo_files(roots[0])
+    now[0] += server._FUZZY_CACHE_TTL_S / 2
+    server._list_repo_files(roots[1])  # still fresh when the next write happens
+    now[0] += server._FUZZY_CACHE_TTL_S / 2 + 0.1  # roots[0] expired, roots[1] not
+    server._list_repo_files(roots[2])
+    assert set(server._fuzzy_cache) == {roots[1], roots[2]}
+    server._fuzzy_cache.clear()
diff --git a/tests/tui_gateway/test_tui_gateway_server.py b/tests/tui_gateway/test_tui_gateway_server.py
index 13d0dc8717..9f7e8cbbe5 100644
--- a/tests/tui_gateway/test_tui_gateway_server.py
+++ b/tests/tui_gateway/test_tui_gateway_server.py
@@ -19666,39 +19666,77 @@ def test_reap_idle_sessions_closes_only_evictable(monkeypatch):
         server._sessions.clear()
 
 
-def test_reap_idle_sessions_calls_periodic_trim(monkeypatch):
-    """The idle reaper must call trim_memory every scan, even with no victims."""
-    trim_calls = []
+def _periodic_trim_calls(monkeypatch):
+    """Stub the reaper's side effects and capture trim_memory calls (delayed import → patch the module attr)."""
+    import hermes_cli.mem_trim as mem_trim
+
+    calls = []
     monkeypatch.setattr(server, "_session_pending_kind", lambda sid: "")
     monkeypatch.setattr(server, "_close_session_by_id", lambda *a, **k: None)
     monkeypatch.setattr(server, "_enforce_session_cap", lambda: None)
     monkeypatch.setattr(server, "_reclaim_orphaned_leases", lambda: None)
+    monkeypatch.setattr(mem_trim, "trim_memory", lambda **kw: calls.append(kw.get("reason", "")) or True)
+    return calls
 
-    # Patch the delayed import path: the function does
-    # `from hermes_cli.mem_trim import trim_memory` at call time.
-    import hermes_cli.mem_trim as mem_trim
 
-    monkeypatch.setattr(
-        mem_trim, "trim_memory",
-        lambda **kw: trim_calls.append(kw.get("reason", "")) or True,
-    )
+def test_periodic_trim_deferred_while_a_session_is_busy_or_attached(monkeypatch):
+    """The gen-2 collect + malloc_trim stalls the loop for its whole duration (#58576): it must not run
+    while any session is mid-turn or still holds a live client, whatever the other sessions look like."""
+    calls = _periodic_trim_calls(monkeypatch)
+    now = time.time()
+    live = types.SimpleNamespace(_closed=False)
+    for busy in ({"running": True}, {"transport": live}):
+        server._sessions.clear()
+        server._sessions["idle"] = _idle_evictable_session(now)
+        server._sessions["busy"] = _idle_evictable_session(now) | busy
+        try:
+            server._reap_idle_sessions()
+            assert calls == [], busy
+        finally:
+            server._sessions.clear()
 
+
+def test_periodic_trim_runs_once_every_session_is_quiescent(monkeypatch):
+    """Every quiescent scan trims, even with no victims: no sessions at all, or only recent (not yet
+    TTL-evictable) sessions that are detached and idle."""
+    calls = _periodic_trim_calls(monkeypatch)
+    now = time.time()
+    for sessions in ({}, {"parked": _idle_evictable_session(now) | {"last_active": now, "created_at": now}}):
+        calls.clear()
+        server._sessions.clear()
+        server._sessions.update(sessions)
+        try:
+            server._reap_idle_sessions()
+            assert calls == ["idle reaper periodic trim"], sessions
+        finally:
+            server._sessions.clear()
+
+
+def test_turn_completion_trim_skips_while_another_session_is_running(monkeypatch):
+    """The finishing session is still marked running when _finish_turn runs, so only OTHER sessions gate its
+    trim: a sole session trims at every turn end; a second in-flight turn defers it (#58576)."""
+    calls = _periodic_trim_calls(monkeypatch)
+    monkeypatch.setattr(server, "_clear_session_context", lambda tokens: None)
+    now = time.time()
+    own = _idle_evictable_session(now) | {"running": True, "transport": types.SimpleNamespace(_closed=False)}
     server._sessions.clear()
+    server._sessions["own"] = own
     try:
-        server._reap_idle_sessions()
-        assert len(trim_calls) == 1
-        assert trim_calls[0] == "idle reaper periodic trim"
+        server._finish_turn("own", own, server._TurnRun(agent=None, one_turn_restore=None, terminal_callback=None, receipt_committed=True))
+        assert calls == ["tui turn completion"]
+
+        calls.clear()
+        server._sessions["other"] = _idle_evictable_session(now) | {"running": True}
+        server._finish_turn("own", own, server._TurnRun(agent=None, one_turn_restore=None, terminal_callback=None, receipt_committed=True))
+        assert calls == []
     finally:
         server._sessions.clear()
 
 
 def test_reap_idle_sessions_logs_trim_failure(monkeypatch, caplog):
-    monkeypatch.setattr(server, "_session_pending_kind", lambda sid: "")
-    monkeypatch.setattr(server, "_close_session_by_id", lambda *a, **k: None)
-    monkeypatch.setattr(server, "_enforce_session_cap", lambda: None)
-    monkeypatch.setattr(server, "_reclaim_orphaned_leases", lambda: None)
     import hermes_cli.mem_trim as mem_trim
 
+    _periodic_trim_calls(monkeypatch)
     monkeypatch.setattr(mem_trim, "trim_memory", lambda **_kw: (_ for _ in ()).throw(RuntimeError("boom")))
     server._sessions.clear()
     try:
diff --git a/tests/website/test_extract_skills.py b/tests/website/test_extract_skills.py
index cbe13cc16b..0cb2c20281 100644
--- a/tests/website/test_extract_skills.py
+++ b/tests/website/test_extract_skills.py
@@ -34,21 +34,6 @@ def mod():
     return module
 
 
-@pytest.mark.parametrize("directory,source,prefix", [
-    ("skills", "built-in", "NousResearch/hermes-agent/skills"),
-    ("optional-skills", "optional", "official"),
-])
-def test_local_skills_publish_exact_install_target(mod, tmp_path, monkeypatch, directory, source, prefix):
-    skill = tmp_path / directory / "creative" / "nested" / "example"
-    skill.mkdir(parents=True)
-    (skill / "SKILL.md").write_text("---\nname: Different Display Name\n---\nExample.")
-    monkeypatch.setattr(mod, "REPO_ROOT", str(tmp_path))
-    [entry] = mod.extract_local_skills()
-    expected = f"{prefix}/creative/nested/example"
-    assert entry["installIdentifier"] == expected
-    assert entry["installCmd"] == f"hermes skills install {expected}"
-
-
 # --------------------------------------------------------------------------
 # _source_url
 # --------------------------------------------------------------------------
diff --git a/tools/file_operations_lint.py b/tools/file_operations_lint.py
index fb5d23da8a..d875f98a84 100644
--- a/tools/file_operations_lint.py
+++ b/tools/file_operations_lint.py
@@ -217,12 +217,15 @@ class LintMixin:
             return None
 
     def _lsp_handles_extension(self, ext: str) -> bool:
-        """True iff some registered LSP server claims ``ext`` (static registry
-        only; safe on remote backends). Decides whether pre-write content is
-        worth capturing for the line-shift map."""
+        """True iff the active service (config-declared servers included) or, without one,
+        the static registry claims ``ext``. Decides whether pre-write content is worth
+        capturing for the line-shift map."""
         if not ext:
             return False
         try:
+            svc = self._lsp_service()
+            if svc is not None:
+                return svc.handles_extension(ext)
             from agent.lsp.servers import SERVERS
         except Exception:  # noqa: BLE001
             return False
@@ -273,7 +276,7 @@ class LintMixin:
         remaps baseline diagnostics into post-edit coordinates; otherwise every
         pre-existing diagnostic below an inserted line would look new."""
         svc = self._lsp_service()
-        if svc is None or not svc.enabled_for(path):
+        if svc is None or not self._lsp_will_handle(path):
             return ""
         line_shift = None
         if pre_content is not None and post_content is not None and pre_content != post_content:
diff --git a/tools/subagent_worktree.py b/tools/subagent_worktree.py
index 9b1e4add6a..b30dc5bbc3 100644
--- a/tools/subagent_worktree.py
+++ b/tools/subagent_worktree.py
@@ -168,6 +168,8 @@ def finalize_subagent_worktree(info: Dict[str, str], *, prune: bool = True) -> D
     if prune and payload["commits"] == 0 and not payload["dirty"]:
         cwd = info.get("repo_root", "") or path
         try:
+            from hermes_cli.worktree_ops import release_lsp_clients
+            release_lsp_clients(path)  # the child ran in-process: its language servers are ours
             removed = _run_git(["worktree", "remove", "--force", path], cwd=cwd)
             if removed.returncode == 0:
                 _run_git(["branch", "-D", branch], cwd=cwd)
diff --git a/tui_gateway/methods_complete_helpers.py b/tui_gateway/methods_complete_helpers.py
index b4ea31533a..d64d64e152 100644
--- a/tui_gateway/methods_complete_helpers.py
+++ b/tui_gateway/methods_complete_helpers.py
@@ -70,6 +70,10 @@ def _list_repo_files(root: str) -> list[str]:
     if not files:
         files = list(islice(_walk_repo_files(root), _FUZZY_CACHE_MAX_FILES))
     with _fuzzy_cache_lock:
+        # The TTL is only consulted on read, so a root that stops being queried (one .worktrees/<id>
+        # root per worktree flow, MBs each) would stay pinned for the process lifetime (#62950).
+        for stale in [r for r, (ts, _) in _fuzzy_cache.items() if now - ts >= _FUZZY_CACHE_TTL_S]:
+            del _fuzzy_cache[stale]
         _fuzzy_cache[root] = (now, files)
     return files
 
diff --git a/tui_gateway/prompt_turn.py b/tui_gateway/prompt_turn.py
index b06a99dade..103b79937e 100644
--- a/tui_gateway/prompt_turn.py
+++ b/tui_gateway/prompt_turn.py
@@ -487,6 +487,52 @@ class _TurnRun:
     receipt_attempted: bool = False
 
 
+def _adopt_out_of_band_turns(session: dict) -> None:
+    """Fold turns another surface appended to this session (Telegram reply, cron run) into the model-facing
+    history before the turn snapshots it. The desktop already repaints them from the DB (#86588); without
+    this the next prompt still ran on the in-memory history and the model never saw them (#42962).
+    Foreign rows are the active rows between the highest ``_row_id`` the agent's own flushes stamped onto
+    the in-memory messages (``sync_flushed_message_markers``; a local compaction re-stamps them too) and
+    this turn's own user row, which ``_persist_submit_user_row`` already wrote (#111868). When a foreign
+    row is a compaction summary the other surface rewrote the transcript under us, so the in-memory history
+    is stale from the root and is re-hydrated from the DB the way ``session.resume`` does. Nothing stamped
+    yet (seeded branch before its first turn) means nothing to adopt; a cold resume arrives stamped."""
+    with session["history_lock"]:
+        history, version = list(session.get("history") or ()), int(session.get("history_version", 0))
+    seen = max((rid for m in history if isinstance(m, dict) and (rid := _message_row_id(m)) is not None),
+               default=None)
+    if seen is None:
+        return
+    ceiling = _message_row_id(session.get("_submit_user_row") or {})
+
+    def _below_ceiling(rid) -> bool:
+        return isinstance(rid, int) and (ceiling is None or rid < ceiling)
+
+    def _foreign(rid) -> bool:
+        return _below_ceiling(rid) and rid > seen
+    # Keyset probe first: the common turn has nothing to adopt and must not pay a full transcript decode.
+    with _session_db(session) as db:
+        try:
+            newer = db.get_messages(session["session_key"], after_id=seen) if db is not None else []
+        except Exception:
+            logger.debug("out-of-band history probe failed; turn runs on the in-memory history", exc_info=True)
+            return
+    newer = [row for row in newer if _foreign(row.get("id"))]
+    if not newer:
+        return
+    rewritten = any(row.get("_compressed_summary") for row in newer)
+    rows = _load_durable_truncation_history(session, repair_alternation=rewritten) or []
+    keep = _below_ceiling if rewritten else _foreign
+    tail = canonicalize_replay_history([m for m in rows if keep(_message_row_id(m))])
+    if not tail:
+        return
+    with session["history_lock"]:
+        if int(session.get("history_version", 0)) != version:
+            return  # /compress, a rewind or a pivot marker landed meanwhile; the next turn re-derives
+        session["history"] = tail if rewritten else history + tail
+        session["history_version"] = version + 1
+
+
 def _prepare_turn_input(sid: str, session: dict, st: _TurnRun, text: Any, images: list[str]):
     """Bind scopes, sync the agent, snapshot history, build the run message; returns
     ``(prompt, run_message, cols, streamer)`` or None when @-expansion was refused.
@@ -520,6 +566,7 @@ def _prepare_turn_input(sid: str, session: dict, st: _TurnRun, text: Any, images
         _sync_agent_model_with_config(sid, session)
         _sync_agent_compression_with_config(sid, session)
     _sync_bot_capabilities(sid, session)  # Bot Chat: adopt Settings->Capabilities edits
+    _adopt_out_of_band_turns(session)
     st.agent = agent = session["agent"]
     # Snapshot after the model sync: a deferred switch's history mutation belongs to this turn.
     with session["history_lock"]:
@@ -799,7 +846,9 @@ def _finish_turn(sid: str, session: dict, st: _TurnRun) -> None:
         run_kwargs.clear()
     try:  # while the profile HERMES_HOME override is still active (session's own config)
         from hermes_cli.mem_trim import trim_memory
-        trim_memory(reason="tui turn completion")
+        # The finishing session is still marked running here; every OTHER session must be idle (#58576).
+        if _sessions_quiescent(exclude=sid):
+            trim_memory(reason="tui turn completion")
     except Exception:
         logger.debug("post-turn memory trim failed", exc_info=True)
     if st.thinking_started:
diff --git a/tui_gateway/session_reaper.py b/tui_gateway/session_reaper.py
index f825b99641..081f0cf6c9 100644
--- a/tui_gateway/session_reaper.py
+++ b/tui_gateway/session_reaper.py
@@ -160,6 +160,18 @@ def _session_is_lru_evictable(sid: str, session: dict) -> bool:
     return _transport_is_dead(session.get("transport"))
 
 
+def _sessions_quiescent(exclude: str | None = None) -> bool:
+    """No session but ``exclude`` is mid-turn, building, awaiting input, holding live delegations, or on a live
+    transport. A non-forced memory trim holds the GIL (gc.collect) and every glibc arena lock (malloc_trim) for
+    its whole duration — 20-50 s on multi-GB heaps — which stalls the event loop, drops WS clients past the
+    write deadline and interrupts their turns (#58576); this is the moment it costs no other session. The
+    predicate is advisory (a turn can start right after), so the per-session checks — one may read state.db —
+    run outside ``_sessions_lock``."""
+    with _sessions_lock:
+        others = [(sid, s) for sid, s in _sessions.items() if sid != exclude]
+    return all(_session_is_lru_evictable(sid, s) for sid, s in others)
+
+
 def _session_is_evictable(sid: str, session: dict, now: float) -> bool:
     """TTL eviction: the LRU exemptions plus idle-for-TTL AND older-than-TTL."""
     if not _session_is_lru_evictable(sid, session):
@@ -185,7 +197,11 @@ def _reap_idle_sessions() -> None:
     _enforce_session_cap()
     _reclaim_orphaned_leases()
     # Long-lived processes: gen2 GC rarely runs at steady state and glibc retains freed pages as RSS, so trim
-    # every scan to prevent unbounded RSS growth over days/weeks.
+    # every quiescent scan to prevent unbounded RSS growth over days/weeks. Forced trims (agent close, cache
+    # pressure) are unaffected.
+    if not _sessions_quiescent():
+        logger.debug("idle reaper periodic trim deferred: a session is busy or attached")
+        return
     try:
         from hermes_cli.mem_trim import trim_memory
         trim_memory(reason="idle reaper periodic trim")
diff --git a/website/docs/developer-guide/multiplexing-gateway.md b/website/docs/developer-guide/multiplexing-gateway.md
index a16a05fde4..dea5122e7d 100644
--- a/website/docs/developer-guide/multiplexing-gateway.md
+++ b/website/docs/developer-guide/multiplexing-gateway.md
@@ -179,12 +179,48 @@ weak `transport` ref to the receiving adapter. `"default"` is spelled out;
 raises `IdentityUnresolved` and the event is dropped.
 
 Adapters also carry `_owner_profile` (installed at adapter configuration time,
-before any inbound event) because adapter ingress runs before the runner pins
-the identity; `_session_key_profile` resolves identity → source stamp → owner
-profile → store resolver. Text/media batching, active-session tracking, and the
-busy-session guard are all keyed per lane, so two bots sharing a chat do not
-share a session lane. Copy a source with `session_identity.replace_source`, not
-`dataclasses.replace`, or the copy loses its transport and identity.
+before any inbound event). Every ingress path canonicalizes the identity FIRST
+— `BasePlatformAdapter._canonicalize` runs at `handle_message`, text/photo/album
+batching, the busy path and every adapter-derived session key; the runner's
+per-profile and default handlers, the auth-check callback and the shared
+`_handle_message` gate do the same — so no lane is keyed before the receiving
+bot is known. Text/media batching, active-session tracking, the busy-session
+guard, `/stop` `/new` `/reset` and clarify replies are all keyed per lane, so
+two bots sharing a chat do not share a session lane and a control command on one
+bot cannot reach the other's run. A route to an unserved profile is dropped with
+one WARNING at the first seam it reaches, never keyed into `agent:main`. Copy a
+source with `session_identity.replace_source`, not `dataclasses.replace`, or the
+copy loses its transport and identity.
+
+## Intake vs delivery: which bot acts on an event
+
+Two runner seams answer the two questions a multiplexed gateway keeps
+conflating (`gateway/authz_mixin.py`):
+
+- `_intake_adapter_for(source)` — the bot that **received** the event. Live
+  provenance only: the transport ref `build_source` pinned, the process-level
+  relay adapter for relay-delivered events, or the adapter currently
+  registered for the identity's `transport_profile` after a reconnect. It
+  gates intake policy (Slack ignored channels, relay fronting, re-dispatch of
+  a queued live event) and returns `None` for a source with no live
+  provenance — nothing may re-admit a restored row on a guessed bot.
+- `_delivery_adapter_for(source)` — the bot that **answers**: sends, edits,
+  typing, progress, pickers, pending-message slots. The receiving bot whenever
+  it is known; otherwise the unique owner of `(platform, runtime_profile)` —
+  a secondary's own adapter, the primary for a shared-bot satellite, and
+  `None` for a secondary whose bot is disconnected (it never borrows the
+  default bot).
+
+| Topology | Runtime (`runtime_profile`, key namespace, home) | Intake | Delivery |
+| --- | --- | --- | --- |
+| Per-credential bot, no route | The bot's own profile | Owner adapter | Owner adapter |
+| Shared credential → satellite via `profile_routes` | Routed profile | Receiving (shared) adapter | Receiving adapter; after a restart the satellite still drains through the primary |
+| Shared bot → a profile that owns its own bot | Routed profile | Receiving adapter | Receiving adapter — the conversation stays with the bot the user wrote to |
+| Secondary-owned bot → `default` (`bot_profile: <secondary>`) | `default` (`agent:main`, default home) | Receiving (secondary) adapter | Receiving adapter |
+| Restored / synthetic source, no live provenance | Stored `source.profile` | **None** (fail closed) | Unique owner of `(platform, runtime)`, else `None` |
+
+Outside multiplexing there is one adapter per platform, so both seams return
+it. `tests/gateway/test_multiplex_transport_matrix.py` asserts every row.
 
 ## Control plane
 
diff --git a/website/docs/user-guide/desktop.md b/website/docs/user-guide/desktop.md
index 4e3863790f..5d4f70a76a 100644
--- a/website/docs/user-guide/desktop.md
+++ b/website/docs/user-guide/desktop.md
@@ -221,43 +221,13 @@ When you have two or more [profiles](./profiles.md), the config-backed settings
 
 The app also surfaces the broader Hermes management surface so you don't have to drop to a terminal:
 
-- **Skills** — open **Capabilities → Skills** to manage [skills](./features/skills.md). **Installed** shows the selected profile's actual skills and enable/disable state. **Browse** searches the same full published catalog as the public Skills Hub, with cards by default and an optional list/detail view.
-- **Plugins** — **Capabilities → Plugins** uses the same **Installed / Browse** layout. Installed combines actual app-level desktop plugins with agent plugins from the selected profile; Browse shows the public [Plugin Catalog](./features/plugin-catalog.md). Search stays at the top, and the tab switch and actions share one row on both pages.
+- **Skills** — browse, install, and manage [skills](./features/skills.md). The Skills tab lists your installed skills with enable/disable toggles, and below them the full built-in optional-skills catalog that ships with Hermes — each entry has a one-click **Install** button that flips the row into the installed list once it finishes.
 - **Memory graph (Star Map)** — type `/journey` (aliases `/learning`, `/memory-graph`) in chat to open an interactive constellation of learned skills and memories over time, with a playback scrubber. Nodes can be edited or deleted right from the panel (skills are archived, memories removed). See [Learning Journey](./features/memory.md#learning-journey-journey).
 - **Cron** — view and manage [scheduled jobs](../reference/cli-commands.md#hermes-cron).
 - **Profiles** — switch between [Hermes profiles](./profiles.md) (isolated config/skills/sessions).
 - **Messaging** — set up gateway channels. Telegram has a **Quick setup** card: click **Create with QR**, scan the code (or open the link) in Telegram, and Hermes creates the bot, detects your user ID for the allowlist, saves the credentials, and restarts the gateway for you. Any credential save, clear, or enable toggle keeps a **Restart now** banner on the page until the gateway has actually restarted; if a restart fails, the banner stays so you can retry or restart manually.
 - **Agents** and **Command Center** — orchestration surfaces for multi-agent work.
 
-Use the list and card icons at the right of the Browse filters to change layouts.
-The choice is remembered across Skills and Plugins. Search and filters stay in
-place; click a card to open its details or use its Install button directly.
-
-#### Where Browse gets its data
-
-These are native Desktop views, **not embedded website pages**. Desktop and
-the public website consume the same generated CDN snapshots:
-
-| Catalog | Public docs alias | Desktop fetch URL |
-|---|---|---|
-| Skills | [`/docs/api/skills.json`](https://hermes-agent.nousresearch.com/docs/api/skills.json) | `https://nousresearch.github.io/hermes-agent/docs/api/skills.json` |
-| Plugins | [`/docs/api/plugins.json`](https://hermes-agent.nousresearch.com/docs/api/plugins.json) | `https://nousresearch.github.io/hermes-agent/docs/api/plugins.json` |
-
-The skills snapshot combines `skills/`, `optional-skills/`, and the centralized
-skills index. The plugin snapshot comes from `plugin-catalog/*.yaml` and cached star
-counts; the same publish supplies the installer's removed-entry list. Browsing does not make live
-GitHub API calls or fetch plugin/skill source repositories. **Installed** is
-separate: its state comes from the selected profile's backend and the app's
-desktop-plugin registry, not those public snapshots.
-
-The public hubs' **Install in Hermes** buttons open `hermes://skill/install`
-or `hermes://plugin/install` links and require confirmation in Desktop. Use
-an updated Desktop build for the skill route and plugin catalog parameters;
-the cards retain copyable CLI commands if the app is missing or too old. See
-[skill links](./features/skills.md#install-from-the-website) and
-[plugin links](./features/plugins.md#one-click-install-links-desktop) for the
-parameters and review flow.
-
 ### Bot Mode (built in)
 
 **Bot Mode** ships with the app and is on by default: a "one chat per agent"
@@ -510,8 +480,8 @@ hot-reloads every save. Manage installed plugins live in **Capabilities → Plug
 See [Desktop Plugin SDK](../developer-guide/desktop-plugin-sdk.md) for the full
 reference. (This is separate from the [web dashboard plugin system](./features/extending-the-dashboard.md).)
 
-**Capabilities → Plugins → Installed** shows the actual installed state:
-**one list entry per plugin**, with Desktop and Agent controls in its detail pane.
+**Capabilities → Plugins** is the one place for everything that extends
+Hermes: **one row per plugin**, with two switch columns.
 
 - A plugin can extend **this app**, **the agent**, or **both** — the badge on
   each row says which, inferred from what the package contains (`plugin.yaml`
@@ -538,14 +508,13 @@ reference. (This is separate from the [web dashboard plugin system](./features/e
   [Accent Picker](https://github.com/NousResearch/hermes-desktop-accent-picker)
   install from their own repos via **Install from Git**.
 
-Switch to **Browse** for the native [Plugin Catalog](./features/plugin-catalog.md).
-Both Browse and **Install from Git** open the review-then-install dialog. For
-an agent-plugin catalog install, the backend resolves the catalog name to its
-reviewed pin; a link's `sha` is display metadata, not an override. This does
-not guarantee a pinned standalone desktop-plugin install. **Install from Git**
-also offers **Pin to commit** for agent-plugin installs (a full 40-character
-SHA, including private repositories); pinned agent plugins show a
-`pinned @ <sha8>` badge. Old `Settings → Plugins` links redirect here.
+Discovery sits underneath: the live [Plugin Catalog](./features/plugin-catalog.md)
+picker installs reviewed entries at their pinned commit into the selected
+profile, and **Install from Git** takes any other repository through the same
+review-then-install dialog; its optional **Pin to commit** field installs one
+exact 40-character commit SHA (private repos included), and pinned plugins
+carry a `pinned @ <sha8>` badge in the list. Old `Settings → Plugins` links
+redirect here.
 
 ## Troubleshooting
 
diff --git a/website/docs/user-guide/features/lsp.md b/website/docs/user-guide/features/lsp.md
index c34ac0e9c0..0a77a35e77 100644
--- a/website/docs/user-guide/features/lsp.md
+++ b/website/docs/user-guide/features/lsp.md
@@ -72,6 +72,7 @@ agent sees a syntax-clean file with semantic problems as
 | YAML | `yaml-language-server` | npm |
 | Lua | `lua-language-server` | manual (GitHub releases) |
 | PHP | `intelephense` | npm |
+| Laravel Blade (`.blade.php`) | `laravel-lsp` | manual (composer) |
 | OCaml | `ocaml-lsp` | manual (opam) |
 | Dockerfile | `dockerfile-language-server-nodejs` | npm |
 | Terraform | `terraform-ls` | manual |
@@ -115,12 +116,39 @@ host. Setup:
 bundle is missing you'll see a one-time warning in the logs with the
 download link.
 
+### Laravel Blade
+
+`.blade.php` templates go to [laravel-lsp](https://github.com/laravel/lsp)
+(Blade, Eloquent, Facades) while plain `.php` files stay with
+intelephense. Install it once with Composer and make sure the binary
+is on PATH (or pin it with `lsp.servers.laravel-lsp.command`):
+
+```bash
+composer global require laravel/lsp
+export PATH="$HOME/.config/composer/vendor/bin:$PATH"
+```
+
+Hermes launches it as `laravel-lsp lsp` (stdio). There is no
+auto-install recipe; `hermes lsp status` shows `manual-only` until the
+binary is found.
+
 A few servers are installed alongside a peer dependency that npm
-won't auto-pull. The current case is `typescript-language-server`,
-which requires the `typescript` SDK importable from the same
-`node_modules` tree — Hermes installs both packages together when you
-run `hermes lsp install typescript` or auto-install fires on first
-use.
+won't auto-pull. `typescript-language-server` and `@vue/language-server`
+require the `typescript` SDK importable from the same `node_modules`
+tree — Hermes installs `typescript@6` (the last JavaScript-based line;
+TypeScript 7 is the Go port and ships no `tsserver.js`) together with
+the server when you run `hermes lsp install typescript` /
+`hermes lsp install vue-language-server` or auto-install fires on first use.
+
+Vue is pinned to `@vue/language-server@2`, started with
+`vue.hybridMode: false` so it hosts its own TypeScript service. The 3.x
+line only works behind a client-hosted `tsserver` tunnel (the VS Code /
+Neovim setup) that Hermes's generic client does not run, so it never
+publishes diagnostics. If an earlier Hermes installed 3.x, the log shows a
+one-time `vue-language-server: ... 3.x` warning; delete
+`<HERMES_HOME>/lsp/node_modules/@vue` and `<HERMES_HOME>/lsp/bin/vue-language-server*`,
+then run `hermes lsp install vue-language-server` (the recipe co-installs the
+TypeScript SDK).
 
 ## CLI
 
@@ -151,8 +179,9 @@ lsp:
 
   # How long to wait for diagnostics after each write.
   wait_mode: document      # "document" or "full"
-  # Max seconds to wait for the server to re-check the file after an
-  # edit. Only *fresh* diagnostics (produced for the post-edit
+  # Max seconds to wait for the server on each of the two waits an
+  # edit makes: the pre-edit baseline snapshot and the post-edit
+  # re-check. Only *fresh* diagnostics (produced for the post-edit
   # content) are ever reported; if the server doesn't finish within
   # this budget, the edit reports "no LSP data" rather than stale
   # errors from before the edit. Raise this for slow servers on big
@@ -164,6 +193,20 @@ lsp:
   #   manual  — only use binaries already on PATH
   install_strategy: auto
 
+  # Node package manager for the npm-based servers: npm (default), pnpm
+  # or yarn. Installs still land in <HERMES_HOME>/lsp/node_modules; a
+  # manager that is configured but not installed — or a value outside
+  # npm|pnpm|yarn — skips the install with a warning instead of silently
+  # using npm, so a pnpm/yarn supply-chain policy (minimumReleaseAge,
+  # allowBuilds, …) is never bypassed. Yarn Berry (2+): its default PnP
+  # linker writes no node_modules/.bin, so set `nodeLinker: node-modules`
+  # in <HERMES_HOME>/lsp/.yarnrc.yml. pnpm 11 blocks git-hosted transitive
+  # deps by default (ERR_PNPM_EXOTIC_SUBDEP); @vue/language-server 2.x pulls
+  # one in, so under pnpm that server is skipped with the pnpm error in the
+  # log — install it once with npm, or relax block-exotic-subdeps in
+  # <HERMES_HOME>/lsp/.npmrc if your policy allows it.
+  package_manager: npm
+
   # How long an unused language-server client stays alive (seconds).
   # Idle servers are shut down automatically and respawned on the next
   # relevant file operation. Set to 0 to disable idle reaping and keep
@@ -196,6 +239,32 @@ lsp:
   `initializationOptions` payload sent in the `initialize`
   handshake. Server-specific; consult the language server's docs.
 
+### Custom servers
+
+Any `lsp.servers` key that is **not** a built-in server id declares
+your own language server. It needs `command` and `extensions`; the
+other keys are optional. Custom servers are matched *before* the
+built-ins, so they can also take over an extension Hermes already
+handles.
+
+```yaml
+lsp:
+  servers:
+    panache:
+      command: ["panache-lsp", "--stdio"]   # PATH lookup or an absolute/~ path
+      extensions: [".pnch"]                 # or basenames like "Justfile"
+      root_markers: ["panache.toml"]        # nearest dir with one of these; default: workspace root
+      language_id: "panache"                # didOpen languageId; default: derived from the extension
+      description: "Panache markdown"
+      env: { PANACHE_LOG: "warn" }          # same optional keys as built-ins
+      initialization_options: {}
+```
+
+Custom servers are never auto-installed: put the binary on PATH (or
+give an absolute path) and `hermes lsp status` lists it as
+`installed`. A malformed entry is logged and skipped without
+affecting the other servers.
+
 ## Installation locations
 
 When `install_strategy: auto`, Hermes installs binaries into
@@ -220,7 +289,9 @@ The LSP layer adds a few milliseconds to clean writes when no
 diagnostics are emitted. When diagnostics are emitted, the wait
 budget is `wait_timeout` seconds — typically the server responds in
 tens of milliseconds for pyright/tsserver and a few seconds for
-rust-analyzer mid-indexing.
+rust-analyzer mid-indexing. Each edit waits twice (a pre-edit
+baseline snapshot for the delta, then the post-edit re-check), so a
+server that never answers costs at most `2 × wait_timeout` per edit.
 
 Diagnostics are **freshness-gated**: a result only counts when the
 server produced it for the content of the current edit (a
@@ -237,6 +308,16 @@ respawned automatically on the next relevant file operation. Set
 `idle_timeout: 0` to disable reaping and hold every server's index warm
 for the life of the process.
 
+Servers are also released when their workspace goes away, even if they
+are not idle: removing a Hermes-managed worktree (`hermes -w` session
+end, Kanban task cleanup, a delegated subagent's pruned worktree) shuts
+down that tree's language servers before `git worktree remove` runs, and
+the periodic sweep shuts down any server whose project root no longer
+exists on disk (deleted outside Hermes). The sweep is part of the idle
+reaper, so `idle_timeout: 0` also disables deleted-root reaping; the
+worktree-removal release always runs. A multi-root server only drops the
+vanished folder and keeps serving its sibling roots.
+
 Servers that support multi-root workspaces (currently pyright) run as a
 **single process** per Hermes process: the first Python project spawns
 it, and every further project root — for example sibling git worktrees
diff --git a/website/docs/user-guide/features/plugin-catalog.md b/website/docs/user-guide/features/plugin-catalog.md
index 73a5f96373..84654d45ff 100644
--- a/website/docs/user-guide/features/plugin-catalog.md
+++ b/website/docs/user-guide/features/plugin-catalog.md
@@ -2,7 +2,7 @@
 sidebar_position: 13
 sidebar_label: "Plugin Catalog"
 title: "Plugin Catalog"
-description: "Browse and install reviewed, SHA-pinned Hermes plugins from the curated catalog"
+description: "Give Hermes new powers with reviewed plugins you can install in one click"
 ---
 
 # Plugin Catalog
@@ -17,36 +17,13 @@ hermes plugins install <name>
 Browse it visually at **[/docs/plugins](/plugins)** — entries are shelved by
 category (Memory, Desktop, Platforms, Web & Browser, Tools, Voice, Automation,
 Models), with search, tier filters (Official / Community), capability chips, and
-**Install in Hermes** buttons and copyable CLI commands for every entry.
-
-In Desktop, open **Capabilities → Plugins → Browse** for the native catalog
-view. It is not an embedded website. **Installed** is a separate tab backed
-by the app's desktop-plugin registry and the selected profile's agent-plugin
-state, rather than catalog metadata. Skills uses the same **Installed / Browse**
-layout; search stays at the top and the tab switch and actions share one row.
-Browse defaults to cards. The list and card icons beside the filters switch
-layouts, preserving search and filters and remembering the choice across both
-catalogs.
+copyable install commands for every entry.
 
 The catalog complements — it does not replace — the existing
 [plugin system](plugins.md). Anything you can install from the catalog is a
 normal plugin under the hood; the catalog just adds discovery and a review
 layer on top.
 
-### Published browse data
-
-The website and Desktop read the same generated CDN snapshot:
-[`https://hermes-agent.nousresearch.com/docs/api/plugins.json`](https://hermes-agent.nousresearch.com/docs/api/plugins.json).
-Desktop fetches it through
-`https://nousresearch.github.io/hermes-agent/docs/api/plugins.json`; the public
-docs alias serves the same data. The docs build reads `plugin-catalog/*.yaml`
-and adds cached repository star counts. It also publishes the installer's
-removed-entry list. Neither
-Browse view crawls source repositories or queries the GitHub API live.
-
-This browse snapshot is distinct from the installer's
-[`plugin-catalog.json`](#live-refresh), which resolves catalog names and pins.
-
 ## What's in an entry
 
 Each catalog entry is a small YAML file in the
@@ -104,24 +81,6 @@ repository. Review the code of anything you give credentials to.
 
 ## Installing from the catalog
 
-On the website, **Install in Hermes** opens a protocol link of this form:
-
-```text
-hermes://plugin/install?repo=owner%2Frepo&catalog_name=example-plugin&sha=0123456789abcdef0123456789abcdef01234567
-```
-
-`repo` is URL-encoded, including any `#subdir`. Desktop asks you to review the
-source, destination and components before confirming; the link does not
-auto-install. For the agent-plugin component, the backend resolves
-`catalog_name` to its reviewed pin. The link's `sha` is **display metadata
-only**, not authority to choose or override a commit, and it is not a pin
-guarantee for a standalone desktop plugin.
-
-Use an updated Desktop build for the catalog parameters (and for the public
-Skills Hub's new `hermes://skill/install?identifier=...` route). Older builds
-may only understand repository-only plugin links. The expanded cards retain
-CLI commands, so you can install by catalog name without Desktop:
-
 ```bash
 # Install a reviewed catalog entry by name (checks out the pinned SHA)
 hermes plugins install <name>
diff --git a/website/docs/user-guide/features/plugins.md b/website/docs/user-guide/features/plugins.md
index 8739bfb8a9..47f8067ca9 100644
--- a/website/docs/user-guide/features/plugins.md
+++ b/website/docs/user-guide/features/plugins.md
@@ -191,11 +191,10 @@ plugin; choose a new exact commit explicitly with
 profile-local install metadata contains no config values, environment values,
 secrets, or capability grants.
 
-The same agent-plugin pin is available in Hermes Desktop: **Capabilities →
-Plugins → Install from Git** has a *Pin to commit* field that takes the full
-40-character SHA, and **Installed** shows a `pinned @ <sha8>` badge on pinned
-agent plugins. This does not guarantee a pinned standalone desktop-plugin
-install. `hermes plugins list` prints
+The same pin is available in Hermes Desktop: **Skills → Plugins → Install from
+Git** has a *Pin to commit* field that takes the full 40-character SHA, and the
+plugins list shows a `pinned @ <sha8>` badge on every pinned install so a team
+can confirm everyone is running the same commit. `hermes plugins list` prints
 the pin in its Source column (`git pinned@<sha8>`). Pins work for private
 repositories too, through the same stored credentials described below.
 
@@ -425,27 +424,6 @@ Ordinary Hermes application updates preserve user plugin directories, including
 wrapper files and external sidecar links. Explicit plugin updates or removals
 can change those files. See [Package management](../../reference/package-management.md)
 and the [plugin authoring guide](../../developer-guide/plugins/index.md#lazy-install-optional-python-dependencies).
-### Installed and Browse in Desktop
-
-Open **Capabilities → Plugins**. **Installed** reads the app's desktop-plugin
-registry and the selected profile's actual agent-plugin state, combining both
-halves in one row where appropriate. It is not a list of catalog entries
-assumed to be installed. **Browse** is a native catalog view, not an embedded
-website; it uses the same **Installed / Browse** tabs as Skills, with search
-at the top and the tab switch and actions on one row. Browse defaults to cards,
-with list and card icons at the right of the filters. The layout choice is shared
-with Skills and remembered. Click a card to read its details; Install opens the
-existing review-then-install dialog.
-
-Desktop and the public [Plugin Catalog](/plugins) consume the same CDN
-snapshot, [`/docs/api/plugins.json`](https://hermes-agent.nousresearch.com/docs/api/plugins.json).
-The public alias serves the same data as Desktop's fetch URL,
-`https://nousresearch.github.io/hermes-agent/docs/api/plugins.json`. The docs
-build generates it from `plugin-catalog/*.yaml` and cached star counts. The
-same publish also supplies the removed-entry list used by the installer.
-Browsing does not query GitHub live or fetch source repos;
-the installer retrieves code only as part of the separate install flow.
-
 ### One-click install links (Desktop)
 
 Hermes Desktop registers the `hermes://` URL scheme, so a website, README, or
@@ -472,23 +450,6 @@ Plugins → Install from Git**. Legacy `hermes://plugin-agent/…` and
 `hermes://plugin-desktop/…` URLs route into the same dialog. In dev builds
 (`npm run dev`) the scheme is `hermes-dev://`.
 
-The public [Plugin Catalog](/plugins) includes **Install in Hermes** on every
-card. Catalog links carry `catalog_name`, a URL-encoded `repo` (including
-`#subdir` when present), and `sha`:
-
-```text
-hermes://plugin/install?repo=owner%2Frepo&catalog_name=example-plugin&sha=0123456789abcdef0123456789abcdef01234567
-```
-
-The SHA parameter is display metadata only. For the agent-plugin install,
-the backend resolves `catalog_name` to its reviewed pin when you confirm;
-the link cannot override that pin. Do not treat the displayed SHA as a pin
-guarantee for a standalone desktop plugin. These catalog parameters require
-an updated Desktop build; older builds may only understand the repository
-link. If the app is missing or too old, update Desktop or use the copyable
-`hermes plugins install <catalog-name>` command in the expanded card to retain
-catalog resolution.
-
 Websites need no SDK — a normal anchor works:
 
 ```html
diff --git a/website/docs/user-guide/features/skills.md b/website/docs/user-guide/features/skills.md
index 07522d5e62..3f6662e530 100644
--- a/website/docs/user-guide/features/skills.md
+++ b/website/docs/user-guide/features/skills.md
@@ -17,55 +17,6 @@ See also:
 - [Bundled Skills Catalog](../../reference/skills-catalog.md)
 - [Official Optional Skills Catalog](../../reference/optional-skills-catalog.md)
 
-## Browse and install in Desktop
-
-Open **Capabilities → Skills** and switch between **Installed** and **Browse**.
-Search stays at the top; the tab switch and actions share one row.
-**Installed** reads the selected profile's actual skills and enabled state;
-it is not inferred from the public catalog. **Browse** is a native catalog UI,
-not an embedded website or a second, smaller catalog. Cards are the default;
-the list and card icons at the right of the filters switch layouts without
-clearing search or filters. The choice is remembered across Skills and Plugins.
-Click a card for details or use its Install button directly.
-
-Desktop and the public [Skills Hub](/skills) read the same published CDN
-snapshot: [`/docs/api/skills.json`](https://hermes-agent.nousresearch.com/docs/api/skills.json).
-The public docs alias serves the same snapshot as Desktop's fetch URL,
-`https://nousresearch.github.io/hermes-agent/docs/api/skills.json`. The docs
-build generates it from bundled `skills/`, `optional-skills/`, and the
-centralized skills index. Browsing does not crawl GitHub or query upstream
-marketplaces live; installation still retrieves the selected skill through
-its source's installer.
-
-### Install from the website
-
-The Skills Hub has an **Install in Hermes** button on each installable card. It opens the
-installed Hermes Desktop app with a URL-encoded, source-qualified skill target:
-for example, `official/...` for optional skills or `clawhub/...` for ClawHub.
-Bundled skills use an explicit repository path rather than an ambiguous bare
-name. When an older snapshot lacks that explicit bundled target, the website
-omits its install link and native Browse disables installation rather than
-resolving an ambiguous name. The next docs publish supplies those targets.
-The same target is used by native Browse and the card's CLI fallback:
-
-```text
-hermes://skill/install?identifier=official%2Fsecurity%2F1password
-```
-
-Hermes shows **Install “skill-name”?** with separate **Source** and **Install to**
-rows. Cancel makes no changes. After confirmation, the same dialog shows
-**Installing…**, then **Installed** and a completion notification. Errors stay
-in the dialog so you can read them and retry. Installation uses the existing
-Skills Hub pipeline, including security scanning, action logs, and installed-list
-refresh. If you switch profile or connection while the confirmation is open,
-reopen the link for the new destination. Changes apply to
-new sessions; a link cannot bypass scanning or select a different profile.
-
-The public links use `hermes://`, not the development-only `hermes-dev://`
-scheme. The `skill/install` route requires an updated Desktop build. If the
-app is missing or the link is not recognized, update Desktop or expand the
-card to copy its CLI install command instead.
-
 ## Starting with a blank slate
 
 By default every profile is seeded with the bundled skill catalog, and each `hermes update` adds any newly bundled skills. If you want a profile with **no bundled skills** — and that stays empty across updates — you have two paths:
diff --git a/website/docs/user-guide/windows-native.md b/website/docs/user-guide/windows-native.md
index aec6abda7b..b5764e83ac 100644
--- a/website/docs/user-guide/windows-native.md
+++ b/website/docs/user-guide/windows-native.md
@@ -238,7 +238,7 @@ Login auto-start is only ever installed on an explicit answer: `hermes gateway i
 
 ### Why not a Windows Service?
 
-Services require admin rights to install and tie the gateway's lifecycle to machine boot, not user login. The typical Hermes user wants: log in → gateway available, log out → gateway gone. Scheduled Tasks do exactly that without elevation. If you genuinely want a service, use `nssm` or `sc create` manually — but you probably don't.
+Services require admin rights to install and tie the gateway's lifecycle to machine boot, not user login. The typical Hermes user wants: log in → gateway available, log out → gateway gone. Scheduled Tasks do exactly that without elevation. If you genuinely want a service, use `nssm` or `sc create` manually — but you probably don't. If you do, name it `Hermes*` or point its binary path inside the Hermes install (`venv\Scripts\hermes.exe`, the checkout, or `gateway-service\`): `hermes update` stops and restarts only services it can positively identify as Hermes-owned through the Service Control Manager, and pauses a Scheduled-Task-launched gateway by PID (Task Scheduler itself is never touched).
 
 ## Data layout
 
diff --git a/website/scripts/extract-skills.py b/website/scripts/extract-skills.py
index b57276aefa..1a0ef30e88 100644
--- a/website/scripts/extract-skills.py
+++ b/website/scripts/extract-skills.py
@@ -313,11 +313,6 @@ def extract_local_skills():
                 elif isinstance(cmds, str) and cmds.strip():
                     commands = [cmds.strip()]
 
-            rel_id = rel.replace(os.sep, "/")
-            install_identifier = (
-                f"official/{rel_id}" if source_label == "optional"
-                else f"NousResearch/hermes-agent/skills/{rel_id}"
-            )
             skills.append({
                 "name": fm.get("name", os.path.basename(root)),
                 "description": fm.get("description", ""),
@@ -333,8 +328,6 @@ def extract_local_skills():
                 "envVars": env_vars,
                 "commands": commands,
                 "docsPath": _docs_page_path(rel, source_label),
-                "installIdentifier": install_identifier,
-                "installCmd": f"hermes skills install {install_identifier}",
             })
 
     return skills
@@ -445,7 +438,6 @@ def extract_unified_index_skills():
             "docsPath": "",
             "identifier": identifier,
             "installCmd": install_cmd,
-            "installIdentifier": install_cmd.removeprefix("hermes skills install "),
             "sourceUrl": source_url,
         })
 
diff --git a/website/src/pages/plugins/index.tsx b/website/src/pages/plugins/index.tsx
index d55bedcf87..751a1570db 100644
--- a/website/src/pages/plugins/index.tsx
+++ b/website/src/pages/plugins/index.tsx
@@ -2,7 +2,6 @@ import React, { useState, useMemo, useCallback, useRef, useEffect } from "react"
 import Layout from "@theme/Layout";
 import Link from "@docusaurus/Link";
 import styles from "./styles.module.css";
-import { pluginCatalogInstallUrl } from "../../../../apps/shared/src/catalog-install";
 
 interface PluginCapabilities {
   providesTools?: string[];
@@ -191,7 +190,6 @@ function PluginCard({
   const hookCount = caps.providesHooks?.length || 0;
   const middlewareCount = caps.providesMiddleware?.length || 0;
   const pinUrl = `${plugin.repo.replace(/\.git$/, "").replace(/\/$/, "")}/tree/${plugin.sha}`;
-  const installUrl = pluginCatalogInstallUrl(plugin);
 
   return (
     <div
@@ -290,7 +288,7 @@ function PluginCard({
           ))}
         </div>
 
-        {onPick ? (
+        {onPick && (
           <button
             className={styles.pickBtn}
             onClick={(e) => {
@@ -300,14 +298,6 @@ function PluginCard({
           >
             + Add to this Agent
           </button>
-        ) : (
-          <a
-            className={styles.pickBtn}
-            href={installUrl}
-            onClick={(e) => e.stopPropagation()}
-          >
-            Install in Hermes
-          </a>
         )}
 
         {expanded && (
@@ -386,14 +376,29 @@ function PluginCard({
   );
 }
 
-function StatCard({ value, label, color }: { value: number; label: string; color: string }) {
+const TRUST_ICONS = {
+  check: "M4 10.5l3.5 3.5L16 5.5",
+  lock: "M6 9V7a4 4 0 118 0v2M5 9h10v8H5z",
+  download: "M10 3v10m0 0l-4-4m4 4l4-4M4 17h12",
+} as const;
+
+function TrustChip({ icon, text }: { icon: keyof typeof TRUST_ICONS; text: string }) {
   return (
-    <div className={styles.stat}>
-      <span className={styles.statValue} style={{ color }}>
-        {value}
-      </span>
-      <span className={styles.statLabel}>{label}</span>
-    </div>
+    <li className={styles.trustChip}>
+      <svg
+        className={styles.trustIcon}
+        viewBox="0 0 20 20"
+        fill="none"
+        stroke="currentColor"
+        strokeWidth="2"
+        strokeLinecap="round"
+        strokeLinejoin="round"
+        aria-hidden="true"
+      >
+        <path d={TRUST_ICONS[icon]} />
+      </svg>
+      {text}
+    </li>
   );
 }
 
@@ -567,7 +572,7 @@ export default function PluginCatalogPage() {
   return (
     <Layout
       title="Plugin Catalog"
-      description="Browse reviewed, SHA-pinned plugins for Hermes Agent"
+      description="Give Hermes new powers: reviewed plugins you can install in one click"
     >
       <div className={`${styles.page} ${pickerMode ? styles.pickerMode : ""}`}>
         <header className={styles.hero}>
@@ -584,7 +589,8 @@ export default function PluginCatalogPage() {
               </span>
             </nav>
             <p className={styles.heroSub}>
-              Reviewed, SHA-pinned plugins. Open in Hermes Desktop to review and install, or copy the CLI command.
+              Give Hermes new powers. Memory, voice, messaging, browsing, Desktop panes and more,
+              built by the community and reviewed by the Hermes team before it reaches you.
               {loadError && (
                 <span style={{ color: "#f87171", marginLeft: 8 }}>
                   · failed to load catalog ({loadError})
@@ -592,41 +598,27 @@ export default function PluginCatalogPage() {
               )}
             </p>
             {meta.generatedAt && !catalogEmpty && (
-              <p className={styles.heroSub} style={{ fontSize: "0.85rem", opacity: 0.75 }}>
-                Catalog refreshed{" "}
-                <span title={meta.generatedAt}>
+              <p className={styles.heroMeta}>
+                {allPlugins.length} plugins across {Object.keys(categoryCounts).length} categories
+                {" · "}updated{" "}
+                <span
+                  title={
+                    meta.starsFetchedAt
+                      ? `Catalog ${meta.generatedAt}; popularity ranking as of ${meta.starsFetchedAt}`
+                      : meta.generatedAt
+                  }
+                >
                   {formatRelativeTime(meta.generatedAt) || "recently"}
                 </span>
-                {meta.starsFetchedAt && (
-                  <>
-                    {" · "}ranked by GitHub stars as of{" "}
-                    <span title={meta.starsFetchedAt}>
-                      {formatRelativeTime(meta.starsFetchedAt) || "recently"}
-                    </span>
-                  </>
-                )}
               </p>
             )}
 
             {!catalogEmpty && (
-              <div className={styles.statsRow}>
-                <StatCard
-                  value={allPlugins.filter((p) => p.tier === "official").length}
-                  label="Official"
-                  color="#ffd700"
-                />
-                <StatCard
-                  value={allPlugins.filter((p) => p.tier === "community").length}
-                  label="Community"
-                  color="#94a3b8"
-                />
-                <StatCard
-                  value={Object.keys(categoryCounts).length}
-                  label="Categories"
-                  color="#7dd3fc"
-                />
-                <StatCard value={meta.removedCount ?? 0} label="Removed" color="#f87171" />
-              </div>
+              <ul className={styles.trustRow} aria-label="What every listing gets you">
+                <TrustChip icon="check" text="Reviewed by the Hermes team" />
+                <TrustChip icon="lock" text="Installs exactly the version we reviewed" />
+                <TrustChip icon="download" text="One click from Hermes Desktop" />
+              </ul>
             )}
           </div>
         </header>
@@ -650,7 +642,8 @@ export default function PluginCatalogPage() {
               <input
                 ref={searchRef}
                 type="text"
-                placeholder='Search plugins... (press "/" to focus)'
+                placeholder="Search plugins by name or by what you want Hermes to do"
+                title='Tip: press "/" to jump here'
                 value={search}
                 onChange={(e) => setSearch(e.target.value)}
                 className={styles.searchInput}
diff --git a/website/src/pages/plugins/styles.module.css b/website/src/pages/plugins/styles.module.css
index 25df654837..70f3f05694 100644
--- a/website/src/pages/plugins/styles.module.css
+++ b/website/src/pages/plugins/styles.module.css
@@ -43,6 +43,10 @@
   margin-bottom: 0.75rem;
 }
 
+[data-theme="light"] .heroEyebrow {
+  color: #a8860a;
+}
+
 .heroTitle {
   font-size: 3rem;
   font-weight: 700;
@@ -94,32 +98,41 @@
   color: #ffd700;
 }
 
-.statsRow {
+.heroMeta {
+  font-size: 0.85rem;
+  color: var(--ifm-font-color-secondary, #9a968e);
+  opacity: 0.8;
+  margin: -0.75rem 0 1.5rem;
+}
+
+/* Three promises every listing carries; replaces the registry-style counters. */
+.trustRow {
   display: flex;
   justify-content: center;
-  gap: 2.5rem;
+  gap: 0.6rem;
   flex-wrap: wrap;
+  list-style: none;
+  margin: 0 -6rem;
+  padding: 0;
 }
 
-.stat {
-  display: flex;
-  flex-direction: column;
+.trustChip {
+  display: inline-flex;
   align-items: center;
-  gap: 0.2rem;
+  gap: 0.5rem;
+  padding: 0.45rem 0.9rem;
+  border-radius: 999px;
+  border: 1px solid rgba(255, 215, 0, 0.18);
+  background: rgba(255, 215, 0, 0.05);
+  font-size: 0.88rem;
+  color: var(--ifm-font-color-base);
 }
 
-.statValue {
-  font-family: "JetBrains Mono", monospace;
-  font-size: 1.6rem;
-  font-weight: 700;
-  line-height: 1;
-}
-
-.statLabel {
-  font-size: 0.72rem;
-  letter-spacing: 0.06em;
-  text-transform: uppercase;
-  color: var(--ifm-font-color-secondary, #9a968e);
+.trustIcon {
+  width: 1rem;
+  height: 1rem;
+  flex: none;
+  color: #ffd700;
 }
 
 .controlsBar {
@@ -159,14 +172,18 @@
   padding: 0.7rem 2.5rem 0.7rem 2.6rem;
   font-size: 0.95rem;
   font-family: "DM Sans", sans-serif;
-  border: 1px solid rgba(255, 215, 0, 0.12);
+  border: 1px solid rgba(255, 215, 0, 0.18);
   border-radius: 10px;
-  background: rgba(15, 15, 24, 0.6);
+  background: var(--ifm-background-surface-color, #fff);
   color: var(--ifm-font-color-base, #e8e4dc);
   outline: none;
   transition: border-color 0.2s, box-shadow 0.2s;
 }
 
+[data-theme="dark"] .searchInput {
+  background: rgba(15, 15, 24, 0.6);
+}
+
 .searchInput:focus {
   border-color: rgba(255, 215, 0, 0.4);
   box-shadow: 0 0 0 3px rgba(255, 215, 0, 0.06);
@@ -850,12 +867,13 @@
     font-size: 2rem;
   }
 
-  .statsRow {
-    gap: 1.5rem;
+  .trustRow {
+    gap: 0.4rem;
   }
 
-  .statValue {
-    font-size: 1.25rem;
+  .trustChip {
+    font-size: 0.8rem;
+    padding: 0.35rem 0.7rem;
   }
 
   .controlsBar {
@@ -905,19 +923,11 @@
   color: var(--ifm-color-primary);
   font-size: 0.85rem;
   font-weight: 600;
-  text-align: center;
-  text-decoration: none;
   cursor: pointer;
   transition: background 0.15s ease, color 0.15s ease;
 }
 
 .pickBtn:hover {
   background: var(--ifm-color-primary);
-  color: var(--ifm-color-emphasis-0);
-  text-decoration: none;
-}
-
-.pickBtn:focus-visible {
-  outline: 2px solid var(--ifm-color-primary);
-  outline-offset: 2px;
+  color: #fff;
 }
diff --git a/website/src/pages/skills/index.tsx b/website/src/pages/skills/index.tsx
index b143beec77..8bc022524d 100644
--- a/website/src/pages/skills/index.tsx
+++ b/website/src/pages/skills/index.tsx
@@ -2,7 +2,6 @@ import React, { useState, useMemo, useCallback, useRef, useEffect } from "react"
 import Layout from "@theme/Layout";
 import Link from "@docusaurus/Link";
 import styles from "./styles.module.css";
-import { skillCatalogInstallIdentifier, skillCatalogInstallUrl } from "../../../../apps/shared/src/catalog-install";
 
 interface Skill {
   name: string;
@@ -20,7 +19,6 @@ interface Skill {
   commands?: string[];
   docsPath?: string;
   identifier?: string;
-  installIdentifier?: string;
   installCmd?: string;
   /** Clickable URL to the skill's origin (repo / detail page). Synthesized
    *  in extract-skills.py for community skills that have no generated docs
@@ -302,7 +300,6 @@ function SkillCard({
 }) {
   const src = SOURCE_CONFIG[skill.source] || SOURCE_CONFIG["optional"];
   const icon = CATEGORY_ICONS[skill.category] || "\u{1F4E6}";
-  const installUrl = skillCatalogInstallUrl(skill);
 
   return (
     <div
@@ -354,16 +351,6 @@ function SkillCard({
           ))}
         </div>
 
-        {!onPick && installUrl && (
-          <a
-            className={styles.pickBtn}
-            href={installUrl}
-            onClick={(e) => e.stopPropagation()}
-          >
-            Install in Hermes
-          </a>
-        )}
-
         {expanded && (
           <div className={styles.cardDetail}>
             {skill.overview && (
@@ -432,9 +419,9 @@ function SkillCard({
               </div>
             )}
             <div className={styles.installHint}>
-              <code>{skill.installCmd || `hermes skills install ${skillCatalogInstallIdentifier(skill) || skill.name}`}</code>
+              <code>{skill.installCmd || `hermes skills install ${skill.name}`}</code>
               <CopyButton
-                text={skill.installCmd || `hermes skills install ${skillCatalogInstallIdentifier(skill) || skill.name}`}
+                text={skill.installCmd || `hermes skills install ${skill.name}`}
               />
             </div>
             {onPick ? (
@@ -534,8 +521,8 @@ export default function SkillsDashboard() {
         {
           type: "hermes-skill-pick",
           name: skill.name,
-          identifier: skillCatalogInstallIdentifier(skill) || skill.name,
-          installCmd: skill.installCmd || `hermes skills install ${skillCatalogInstallIdentifier(skill) || skill.name}`,
+          identifier: skill.identifier || skill.name,
+          installCmd: skill.installCmd || `hermes skills install ${skill.name}`,
           source: skill.source,
         },
         "*"
@@ -713,7 +700,7 @@ export default function SkillsDashboard() {
               <strong className={styles.heroAccent}>
                 {data ? allSkillsLocal.length.toLocaleString() : "…"}
               </strong>{" "}
-              skills across {sources.length - 1} registries. Open in Hermes Desktop to review and install, or copy the CLI command.
+              skills across {sources.length - 1} registries
               {loadError && (
                 <span style={{ color: "#f87171", marginLeft: 8 }}>
                   · failed to load catalog ({loadError})
diff --git a/website/src/pages/skills/styles.module.css b/website/src/pages/skills/styles.module.css
index e0ada5625c..559089dc27 100644
--- a/website/src/pages/skills/styles.module.css
+++ b/website/src/pages/skills/styles.module.css
@@ -1030,8 +1030,6 @@
   color: var(--ifm-color-primary);
   font-size: 0.85rem;
   font-weight: 600;
-  text-align: center;
-  text-decoration: none;
   cursor: pointer;
   transition: background 0.15s ease, color 0.15s ease;
 }
@@ -1040,10 +1038,4 @@
   background: var(--ifm-color-primary);
   /* --ifm-background-color is transparent in light mode (#91491). */
   color: var(--ifm-color-emphasis-0, #f7f8fa);
-  text-decoration: none;
-}
-
-.pickBtn:focus-visible {
-  outline: 2px solid var(--ifm-color-primary);
-  outline-offset: 2px;
 }