@@ -35,23 +35,22 @@ def get_ide(name: str) -> IDE:
     return ide
 
 
-def collect_all_session_contexts() -> tuple[dict[str, dict], dict]:
+def collect_all_session_contexts() -> tuple[list[dict], dict]:
     """Sweep every registered IDE's session context, regardless of which IDE triggered the hook.
 
-    Returns ``(config_files_by_ide, plugins)``: the global MCP config file of each IDE that has
-    one (keyed by IDE name), and the enabled plugins merged across IDEs (first registered IDE
-    wins on a duplicate plugin key - plugins are IDE-agnostic marketplace artifacts).
+    Returns ``(config_files, plugins)``: the global MCP config files of every IDE, and the
+    enabled plugins merged across IDEs (first registered IDE wins on a duplicate plugin key -
+    plugins are IDE-agnostic marketplace artifacts).
     """
-    config_files_by_ide: dict[str, dict] = {}
+    config_files: list[dict] = []
     plugins: dict = {}
     for ide in IDES.values():
-        global_config_file, enabled_plugins = ide.get_session_context()
-        if global_config_file:
-            config_files_by_ide[ide.name] = global_config_file
+        global_config_files, enabled_plugins = ide.get_session_context()
+        config_files.extend(global_config_files)
         for plugin_key, plugin in (enabled_plugins or {}).items():
             plugins.setdefault(plugin_key, plugin)
 
-    return config_files_by_ide, plugins
+    return config_files, plugins
 
 
 def collect_all_skills() -> list[dict]:
 
@@ -42,17 +42,17 @@ def load_plugin_json(path: Path) -> Optional[dict]:
         return None
 
 
-def build_global_config_file(path: Path, mcp_servers: Optional[dict]) -> Optional[dict]:
+def build_global_config_files(path: Path, mcp_servers: Optional[dict]) -> list[dict]:
     """Wrap a global (non-plugin) MCP config into the session-context file shape.
 
-    Returns ``{"path": <full path>, "content": <{"mcpServers": ...} JSON>}`` when
-    there are servers, else ``None``. ``content`` is normalized to the canonical
+    Returns ``[{"path": <full path>, "content": <{"mcpServers": ...} JSON>}]`` when
+    there are servers, else ``[]``. ``content`` is normalized to the canonical
     ``{"mcpServers": {...}}`` shape, dropping everything else in the source file.
     """
-    servers = mcp_servers or {}
+    servers = mcp_servers if isinstance(mcp_servers, dict) else {}
     if not servers:
-        return None
-    return {'path': str(path), 'content': json.dumps({'mcpServers': servers})}
+        return []
+    return [{'path': str(path), 'content': json.dumps({'mcpServers': servers})}]
 
 
 def walk_enabled_plugins(
 
@@ -176,19 +176,19 @@ def get_user_email(self) -> Optional[str]:
         """
         return None
 
-    def get_session_context(self) -> tuple[Optional[dict], dict]:
-        """Return ``(global_config_file, enabled_plugins)`` for session-context reporting.
+    def get_session_context(self) -> tuple[list[dict], dict]:
+        """Return ``(global_config_files, enabled_plugins)`` for session-context reporting.
 
-        ``global_config_file`` is the IDE's global (non-plugin) MCP config as
-        ``{"path": <full path>, "content": <normalized {"mcpServers": ...} JSON>}``,
-        or ``None`` when there is no global MCP config. ``enabled_plugins`` maps each
-        enabled plugin key to its metadata (including its own ``mcp_config_file``
-        content and ``mcp_config_file_path``).
+        ``global_config_files`` are the IDE's global (non-plugin) MCP configs, each as
+        ``{"path": <full path>, "content": <normalized {"mcpServers": ...} JSON>}``;
+        empty when there is none. ``enabled_plugins`` maps each enabled plugin key to
+        its metadata (including its own ``mcp_config_file`` content and
+        ``mcp_config_file_path``).
 
-        Default: ``(None, {})`` (no plugin system, no discoverable MCP config).
+        Default: ``([], {})`` (no plugin system, no discoverable MCP config).
         Override to surface MCP/plugin inventory.
         """
-        return None, {}
+        return [], {}
 
     def get_skills(self) -> list[dict]:
         """Return the IDE's user-scope skills as ``[{"path", "content"}]``.
@@ -198,7 +198,7 @@ def get_skills(self) -> list[dict]:
         read these files off endpoints can only ever return raw content.
 
         Kept separate from ``get_session_context`` rather than folded into its
-        ``global_config_file`` slot, which is normalized to an MCP server map.
+        ``global_config_files``, which are normalized to an MCP server map.
 
         Default: ``[]`` (the IDE has no skill system). Override to surface skills.
         """
 
@@ -1,14 +1,15 @@
 """Claude Code IDE integration for AI guardrails."""
 
 import json
+import re
 from collections.abc import Iterator
 from copy import deepcopy
 from pathlib import Path
 from typing import ClassVar, Optional
 
 from cycode.cli.apps.ai_guardrails.consts import CYCODE_SCAN_PROMPT_COMMAND, CYCODE_SESSION_START_COMMAND
 from cycode.cli.apps.ai_guardrails.ides._plugin_utils import (
-    build_global_config_file,
+    build_global_config_files,
     load_plugin_json,
     resolve_cached_plugin_dir,
     walk_enabled_plugins,
@@ -253,6 +254,41 @@ def _locate(plugin_name: str, marketplace_name: str) -> Optional[Path]:
     )
 
 
+def _sanitize_mcp_name(name: str) -> str:
+    """Mirrors how Claude Code sanitizes a server name inside a tool name."""
+    return re.sub(r'[^a-z0-9_-]', '_', name.lower())
+
+
+def _local_mcp_servers(config: Optional[dict], cwd: Optional[str]) -> Iterator[tuple[str, str]]:
+    """Yield ``(name as Claude Code namespaces it, config key)`` for each locally configured MCP server."""
+    sources = []
+    if config:
+        sources.append(get_mcp_servers(config))
+        if cwd:
+            sources.append(((config.get('projects') or {}).get(cwd) or {}).get('mcpServers'))
+    if cwd:
+        sources.append((load_plugin_json(Path(cwd) / '.mcp.json') or {}).get('mcpServers'))
+    for servers in sources:
+        if isinstance(servers, dict):
+            for name in servers:
+                yield name, name
+
+    settings = load_claude_settings()
+    for plugin_key, entry in (resolve_plugins(settings) if settings else {}).items():
+        plugin_name = plugin_key.split('@', 1)[0]
+        for server in entry.get('mcp_server_names') or []:
+            yield f'plugin_{plugin_name}_{server}', server
+
+
+def _resolve_mcp_server_name(server: str, config: Optional[dict], cwd: Optional[str]) -> str:
+    """Map the server segment of ``mcp__<server>__<tool>`` back to its config key; unknown names pass through."""
+    wanted = _sanitize_mcp_name(server)
+    for namespaced, name in _local_mcp_servers(config, cwd):
+        if _sanitize_mcp_name(namespaced) == wanted:
+            return name
+    return server
+
+
 # --- IDE integration ----------------------------------------------------------
 
 
@@ -339,6 +375,8 @@ def parse_hook_payload(self, raw_payload: dict) -> AIHookPayload:
 
         config = load_claude_config()
         ide_user_email = _email_from_config(config) if config else None
+        if mcp_server_name:
+            mcp_server_name = _resolve_mcp_server_name(mcp_server_name, config, raw_payload.get('cwd'))
 
         return AIHookPayload(
             event_name=canonical_event,
@@ -396,14 +434,14 @@ def get_user_email(self) -> Optional[str]:
         config = load_claude_config()
         return _email_from_config(config) if config else None
 
-    def get_session_context(self) -> tuple[Optional[dict], dict]:
+    def get_session_context(self) -> tuple[list[dict], dict]:
         config = load_claude_config()
-        global_config_file = build_global_config_file(_CLAUDE_CONFIG_PATH, get_mcp_servers(config)) if config else None
+        global_config_files = build_global_config_files(_CLAUDE_CONFIG_PATH, get_mcp_servers(config)) if config else []
 
         settings = load_claude_settings()
         enriched_plugins = resolve_plugins(settings) if settings else {}
 
-        return global_config_file, enriched_plugins
+        return global_config_files, enriched_plugins
 
     def get_skills(self) -> list[dict]:
         return walk_skill_dirs(_claude_skills_dir())
@@ -2,7 +2,9 @@
 
 import json
 import os
+import re
 import sys
+from collections.abc import Iterator
 from pathlib import Path
 from typing import ClassVar, Optional
 
@@ -15,7 +17,7 @@
 
 from cycode.cli.apps.ai_guardrails.consts import CYCODE_SCAN_PROMPT_COMMAND, CYCODE_SESSION_START_COMMAND
 from cycode.cli.apps.ai_guardrails.ides._plugin_utils import (
-    build_global_config_file,
+    build_global_config_files,
     load_plugin_json,
     resolve_cached_plugin_dir,
     walk_enabled_plugins,
@@ -158,6 +160,42 @@ def _resolve_codex_plugins(config: dict) -> dict:
     )
 
 
+def _sanitize_mcp_name(name: str) -> str:
+    """Mirrors how Codex sanitizes a server name into a tool namespace."""
+    return re.sub(r'[^A-Za-z0-9_]', '_', name) or '_'
+
+
+def _local_mcp_server_names() -> Iterator[str]:
+    """Yield the config key of each locally configured Codex MCP server, plugin servers included."""
+    config = _load_codex_config()
+    if not config:
+        return
+    servers = config.get('mcp_servers')
+    if isinstance(servers, dict):
+        yield from servers
+    for entry in _resolve_codex_plugins(config).values():
+        yield from entry.get('mcp_server_names') or []
+
+
+def _split_mcp_tool_name(tool_name: str) -> tuple[Optional[str], Optional[str]]:
+    """Split ``mcp__<namespace>__<tool>`` into ``(server config key, tool)``; unknown namespaces split on ``__``."""
+    rest = tool_name[len('mcp__') :]
+    names = list(_local_mcp_server_names())
+    # Codex appends `_<12 hex>` to a namespace on collision or length overflow.
+    for suffix in ('__', r'_+[0-9a-f]{12}__'):
+        best: Optional[tuple[int, str]] = None
+        for name in names:
+            namespace = _sanitize_mcp_name(name).rstrip('_')
+            match = namespace and re.match(re.escape(namespace) + suffix, rest)
+            if match and (best is None or match.end() > best[0]):
+                best = (match.end(), name)
+        if best:
+            return best[1], rest[best[0] :]
+
+    parts = tool_name.split('__')
+    return (parts[1] if len(parts) >= 2 else None), (parts[2] if len(parts) >= 3 else None)
+
+
 def _enable_codex_hooks_feature(scope: str, repo_path: Optional[Path] = None) -> tuple[bool, str]:
     """Set ``[features] hooks = true`` in Codex's ``config.toml``.
 
@@ -247,12 +285,8 @@ def parse_hook_payload(self, raw_payload: dict) -> AIHookPayload:
         mcp_server_name = None
         mcp_tool_name = None
         mcp_arguments = None
-        if tool_name.startswith('mcp__'):
-            parts = tool_name.split('__')
-            if len(parts) >= 2:
-                mcp_server_name = parts[1]
-            if len(parts) >= 3:
-                mcp_tool_name = parts[2]
+        if canonical_event == AiHookEventType.MCP_EXECUTION:
+            mcp_server_name, mcp_tool_name = _split_mcp_tool_name(tool_name)
             mcp_arguments = tool_input
 
         return AIHookPayload(
@@ -302,17 +336,17 @@ def build_session_payload(self, raw_payload: dict) -> AIHookPayload:
     def get_user_email(self) -> Optional[str]:
         return _email_from_auth()
 
-    def get_session_context(self) -> tuple[Optional[dict], dict]:
+    def get_session_context(self) -> tuple[list[dict], dict]:
         config = _load_codex_config()
         if not config:
-            return None, {}
+            return [], {}
         # Codex stores MCP servers under `[mcp_servers.<name>]`; the global config
         # file becomes its own session-context file. Plugins (via
         # `[plugins."<plugin>@<marketplace>"]`) carry their own config files.
         config_path = _codex_config_toml_path('user')
-        global_config_file = build_global_config_file(config_path, config.get('mcp_servers'))
+        global_config_files = build_global_config_files(config_path, config.get('mcp_servers'))
         enriched_plugins = _resolve_codex_plugins(config)
-        return global_config_file, enriched_plugins
+        return global_config_files, enriched_plugins
 
     def get_skills(self) -> list[dict]:
         return walk_skill_dirs(_codex_skills_dir())
@@ -33,7 +33,7 @@
 
 from cycode.cli.apps.ai_guardrails.consts import CYCODE_SCAN_PROMPT_COMMAND, CYCODE_SESSION_START_COMMAND
 from cycode.cli.apps.ai_guardrails.ides._plugin_utils import (
-    build_global_config_file,
+    build_global_config_files,
     load_plugin_json,
     walk_enabled_plugins,
 )
@@ -283,6 +283,15 @@ def _collect_installed_plugins() -> dict:
 # --- MCP tool-name splitting ------------------------------------------------------
 
 
+def _global_mcp_server_maps() -> list[tuple[Path, object]]:
+    """``(path, servers)`` of each runtime's global MCP config: VS Code's ``servers``, the agent's ``mcpServers``."""
+    agent_config_path = _copilot_home() / _AGENT_MCP_CONFIG_FILENAME
+    return [
+        (_vscode_mcp_config_path(), (_load_vscode_mcp_config() or {}).get('servers')),
+        (agent_config_path, (_load_jsonc(agent_config_path) or {}).get('mcpServers')),
+    ]
+
+
 def _known_mcp_server_names() -> list[str]:
     """Config-declared MCP server names, across both runtimes' config files.
 
@@ -293,15 +302,7 @@ def _known_mcp_server_names() -> list[str]:
     Best-effort inventory: servers contributed by extensions, ``chat.mcp.discovery``
     imports, dev containers, or non-default profiles are not discoverable from disk.
     """
-    config = _load_vscode_mcp_config()
-    servers = (config or {}).get('servers')
-    names = list(servers.keys()) if isinstance(servers, dict) else []
-
-    agent_config = _load_jsonc(_copilot_home() / _AGENT_MCP_CONFIG_FILENAME) or {}
-    agent_servers = agent_config.get('mcpServers')
-    if isinstance(agent_servers, dict):
-        names.extend(agent_servers.keys())
-
+    names = [name for _, servers in _global_mcp_server_maps() if isinstance(servers, dict) for name in servers]
     for plugin in _collect_installed_plugins().values():
         names.extend(plugin.get('mcp_server_names') or [])
     return names
@@ -485,14 +486,11 @@ def build_session_payload(self, raw_payload: dict) -> AIHookPayload:
             source=raw_payload.get('source'),
         )
 
-    def get_session_context(self) -> tuple[Optional[dict], dict]:
-        # VS Code's mcp.json uses `servers` as its top-level key; normalized to the
-        # canonical mcpServers shape by build_global_config_file.
-        config = _load_vscode_mcp_config()
-        global_config_file = (
-            build_global_config_file(_vscode_mcp_config_path(), config.get('servers')) if config else None
-        )
-        return global_config_file, _collect_installed_plugins()
+    def get_session_context(self) -> tuple[list[dict], dict]:
+        global_config_files = [
+            file for path, servers in _global_mcp_server_maps() for file in build_global_config_files(path, servers)
+        ]
+        return global_config_files, _collect_installed_plugins()
 
     def get_skills(self) -> list[dict]:
         return walk_skill_dirs(_copilot_skills_dir())