cycode 3.25.1.dev6__py3-none-any.whl → 3.25.2.dev2__py3-none-any.whl

cycode/__init__.py

@@ -5,4 +5,4 @@ import time as _time
 # end-to-end scan duration from the moment the user actually triggered it.
 _BOOT_WALL: float = _time.time()
 
-__version__ = '3.25.1.dev6'  # DON'T TOUCH. Placeholder. Will be filled automatically on poetry build from Git Tag
+__version__ = '3.25.2.dev2'  # DON'T TOUCH. Placeholder. Will be filled automatically on poetry build from Git Tag

cycode/cli/app.py

@@ -1,7 +1,7 @@
 import importlib
 import logging
 import sys
-from typing import Annotated, Optional
+from typing import Annotated
 
 import click
 import typer
@@ -51,13 +51,12 @@ _SUBAPP_MODULES: dict[str, str] = {
     'auth': 'cycode.cli.apps.auth',
     'configure': 'cycode.cli.apps.configure',
     'ignore': 'cycode.cli.apps.ignore',
+    'mcp': 'cycode.cli.apps.mcp',
     'report': 'cycode.cli.apps.report',
     'import': 'cycode.cli.apps.report_import',
     'scan': 'cycode.cli.apps.scan',
     'status': 'cycode.cli.apps.status',
 }
-if sys.version_info >= (3, 10):
-    _SUBAPP_MODULES['mcp'] = 'cycode.cli.apps.mcp'
 
 # Aliases: alternate spellings that resolve to a primary subcommand key.
 _SUBAPP_ALIASES: dict[str, str] = {
@@ -80,7 +79,7 @@ _ROOT_OPTS_WITH_VALUE = frozenset(
 )
 
 
-def _detect_invocation() -> tuple[Optional[str], Optional[str]]:
+def _detect_invocation() -> tuple[str | None, str | None]:
     """Return (top-level-subapp, second-level-subcommand) parsed from sys.argv.
 
     Both values may be None: when no positional arg matches a known subapp,
@@ -113,7 +112,7 @@ def _detect_invocation() -> tuple[Optional[str], Optional[str]]:
 _INVOKED_SUBAPP, _INVOKED_SUBCOMMAND = _detect_invocation()
 
 
-def _register_subapps(only: Optional[str]) -> None:
+def _register_subapps(only: str | None) -> None:
     if only is not None:
         app.add_typer(importlib.import_module(_SUBAPP_MODULES[only]).app)
         return
@@ -189,32 +188,32 @@ def app_callback(
         OutputTypeOption, typer.Option('--output', '-o', case_sensitive=False, help='Specify the output type.')
     ] = OutputTypeOption.RICH,
     user_agent: Annotated[
-        Optional[str],
+        str | None,
         typer.Option(hidden=True, help='Characteristic JSON object that lets servers identify the application.'),
     ] = None,
     client_secret: Annotated[
-        Optional[str],
+        str | None,
         typer.Option(
             help='Specify a Cycode client secret for this specific scan execution.',
             rich_help_panel=_AUTH_RICH_HELP_PANEL,
         ),
     ] = None,
     client_id: Annotated[
-        Optional[str],
+        str | None,
         typer.Option(
             help='Specify a Cycode client ID for this specific scan execution.',
             rich_help_panel=_AUTH_RICH_HELP_PANEL,
         ),
     ] = None,
     id_token: Annotated[
-        Optional[str],
+        str | None,
         typer.Option(
             help='Specify a Cycode OIDC ID token for this specific scan execution.',
             rich_help_panel=_AUTH_RICH_HELP_PANEL,
         ),
     ] = None,
     _: Annotated[
-        Optional[bool],
+        bool | None,
         typer.Option(
             '--install-completion',
             callback=install_callback,

cycode/cli/apps/activation_manager.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 from cycode import __version__
 from cycode.cli.config import configuration_manager
@@ -13,13 +13,13 @@ logger = get_logger('Activation Manager')
 _CLI_CLIENT_NAME = 'cli'
 
 
-def _get_client_and_version(plugin_app_name: Optional[str], plugin_app_version: Optional[str]) -> tuple[str, str]:
+def _get_client_and_version(plugin_app_name: str | None, plugin_app_version: str | None) -> tuple[str, str]:
     return plugin_app_name or _CLI_CLIENT_NAME, plugin_app_version or __version__
 
 
 def should_report_cli_activation(
-    plugin_app_name: Optional[str] = None,
-    plugin_app_version: Optional[str] = None,
+    plugin_app_name: str | None = None,
+    plugin_app_version: str | None = None,
 ) -> bool:
     client, version = _get_client_and_version(plugin_app_name, plugin_app_version)
     return configuration_manager.get_last_reported_activation_version(client) != version
@@ -27,8 +27,8 @@ def should_report_cli_activation(
 
 def report_cli_activation(
     cycode_client: 'CycodeClientBase',
-    plugin_app_name: Optional[str] = None,
-    plugin_app_version: Optional[str] = None,
+    plugin_app_name: str | None = None,
+    plugin_app_version: str | None = None,
 ) -> None:
     """Report CLI/IDE activation to the backend if the (client, version) pair is new.
 

cycode/cli/apps/ai_guardrails/command_utils.py

@@ -2,7 +2,6 @@
 
 import os
 from pathlib import Path
-from typing import Optional
 
 import typer
 from rich.console import Console
@@ -18,7 +17,7 @@ def validate_scope(scope: str, allowed_scopes: tuple[str, ...] = ('user', 'repo'
         raise typer.Exit(1)
 
 
-def resolve_repo_path(scope: str, repo_path: Optional[Path]) -> Optional[Path]:
+def resolve_repo_path(scope: str, repo_path: Path | None) -> Path | None:
     """Default repo_path to cwd for 'repo' scope; leave None for 'user' scope."""
     if scope == 'repo' and repo_path is None:
         return Path(os.getcwd())

cycode/cli/apps/ai_guardrails/hooks_manager.py

@@ -8,7 +8,6 @@ agent-agnostic.
 import copy
 import json
 from pathlib import Path
-from typing import Optional
 
 import yaml
 
@@ -47,7 +46,7 @@ def is_cycode_hook_entry(entry: dict) -> bool:
     return False
 
 
-def _strip_cycode_from_entry(entry: dict) -> Optional[dict]:
+def _strip_cycode_from_entry(entry: dict) -> dict | None:
     """Remove Cycode hooks from ``entry`` and return the remainder.
 
     Returns ``None`` when nothing useful remains (Cursor-flat Cycode entry, or
@@ -72,7 +71,7 @@ def _strip_cycode_from_entry(entry: dict) -> Optional[dict]:
     return entry
 
 
-def _load_hooks_file(hooks_path: Path) -> Optional[dict]:
+def _load_hooks_file(hooks_path: Path) -> dict | None:
     if not hooks_path.exists():
         return None
     try:
@@ -102,7 +101,7 @@ def _load_policy_dict(policy_path: Path) -> dict:
     return {**copy.deepcopy(DEFAULT_POLICY), **existing}
 
 
-def create_policy_file(scope: str, repo_path: Optional[Path] = None) -> tuple[bool, str]:
+def create_policy_file(scope: str, repo_path: Path | None = None) -> tuple[bool, str]:
     """Create or update the ai-guardrails.yaml policy file (operational knobs only).
 
     Enforcement mode and sensitive-path globs are platform-managed; those keys are stripped
@@ -125,7 +124,7 @@ def create_policy_file(scope: str, repo_path: Optional[Path] = None) -> tuple[bo
 def install_hooks(
     ide: IDE,
     scope: str = 'user',
-    repo_path: Optional[Path] = None,
+    repo_path: Path | None = None,
 ) -> tuple[bool, str]:
     """Install Cycode AI guardrails hooks for ``ide``."""
     hooks_path = ide.settings_path(scope, repo_path)
@@ -197,7 +196,7 @@ def _persist_uninstall(hooks_path: Path, existing: dict, modified: bool) -> tupl
     return True, f'Cycode hooks removed from: {hooks_path}'
 
 
-def uninstall_hooks(ide: IDE, scope: str = 'user', repo_path: Optional[Path] = None) -> tuple[bool, str]:
+def uninstall_hooks(ide: IDE, scope: str = 'user', repo_path: Path | None = None) -> tuple[bool, str]:
     """Remove Cycode AI guardrails hooks for ``ide``."""
     hooks_path = ide.settings_path(scope, repo_path)
 
@@ -218,7 +217,7 @@ def uninstall_hooks(ide: IDE, scope: str = 'user', repo_path: Optional[Path] = N
     return True, message
 
 
-def get_hooks_status(ide: IDE, scope: str = 'user', repo_path: Optional[Path] = None) -> dict:
+def get_hooks_status(ide: IDE, scope: str = 'user', repo_path: Path | None = None) -> dict:
     """Return installation status of Cycode hooks for ``ide``."""
     hooks_path = ide.settings_path(scope, repo_path)
 

cycode/cli/apps/ai_guardrails/ides/__init__.py

@@ -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]:

cycode/cli/apps/ai_guardrails/ides/_plugin_utils.py

@@ -7,15 +7,16 @@ supplies the two callables that vary (``locate_dir`` + ``read_plugin``).
 """
 
 import json
+from collections.abc import Callable
 from pathlib import Path
-from typing import Any, Callable, Optional
+from typing import Any
 
 from cycode.logger import get_logger
 
 logger = get_logger('AI Guardrails Plugins')
 
 
-def resolve_cached_plugin_dir(cache_root: Path, marketplace: str, plugin_name: str) -> Optional[Path]:
+def resolve_cached_plugin_dir(cache_root: Path, marketplace: str, plugin_name: str) -> Path | None:
     """Find ``<cache_root>/<marketplace>/<plugin>/<version-or-hash>/``.
 
     Both Claude Code and Codex cache installed plugin content in this layout (the trailing
@@ -31,7 +32,7 @@ def resolve_cached_plugin_dir(cache_root: Path, marketplace: str, plugin_name: s
     return max(candidates, key=lambda d: (d.stat().st_mtime, d.name))
 
 
-def load_plugin_json(path: Path) -> Optional[dict]:
+def load_plugin_json(path: Path) -> dict | None:
     """Load a JSON file inside a plugin directory; None if missing or invalid."""
     if not path.exists():
         return None
@@ -42,23 +43,23 @@ 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: dict | None) -> 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(
     plugin_entries: dict[str, Any],
     is_enabled: Callable[[Any], bool],
-    locate_dir: Callable[[str, str], Optional[Path]],
+    locate_dir: Callable[[str, str], Path | None],
     read_plugin: Callable[[Path], tuple[dict, dict]],
 ) -> dict:
     """Iterate enabled plugins and build their inventory metadata.

cycode/cli/apps/ai_guardrails/ides/_skill_utils.py

@@ -11,7 +11,6 @@ the device its MCP inventory as well.
 """
 
 from pathlib import Path
-from typing import Optional
 
 from cycode.logger import get_logger
 
@@ -32,7 +31,7 @@ MAX_SKILL_FILE_BYTES = 256 * 1024
 MAX_SKILLS_PER_ROOT = 200
 
 
-def _read_skill_file(skill_file: Path) -> Optional[dict]:
+def _read_skill_file(skill_file: Path) -> dict | None:
     """Read one ``SKILL.md`` into the session-context file shape, or None if unusable."""
     try:
         size = skill_file.stat().st_size

cycode/cli/apps/ai_guardrails/ides/base.py

@@ -18,7 +18,7 @@ from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from enum import Enum
 from pathlib import Path
-from typing import ClassVar, Optional
+from typing import ClassVar
 
 from cycode.cli.apps.ai_guardrails.scan.payload import AIHookPayload
 from cycode.cli.apps.ai_guardrails.scan.types import AiHookEventType
@@ -44,17 +44,15 @@ class HookDecision:
 
     action: DecisionAction
     event_type: AiHookEventType
-    user_message: Optional[str] = None
-    agent_message: Optional[str] = None
+    user_message: str | None = None
+    agent_message: str | None = None
 
     @classmethod
     def allow(cls, event_type: AiHookEventType) -> 'HookDecision':
         return cls(action=DecisionAction.ALLOW, event_type=event_type)
 
     @classmethod
-    def deny(
-        cls, event_type: AiHookEventType, user_message: str, agent_message: Optional[str] = None
-    ) -> 'HookDecision':
+    def deny(cls, event_type: AiHookEventType, user_message: str, agent_message: str | None = None) -> 'HookDecision':
         return cls(
             action=DecisionAction.DENY,
             event_type=event_type,
@@ -63,7 +61,7 @@ class HookDecision:
         )
 
     @classmethod
-    def ask(cls, event_type: AiHookEventType, user_message: str, agent_message: Optional[str] = None) -> 'HookDecision':
+    def ask(cls, event_type: AiHookEventType, user_message: str, agent_message: str | None = None) -> 'HookDecision':
         return cls(
             action=DecisionAction.ASK,
             event_type=event_type,
@@ -92,7 +90,7 @@ class IDE(ABC):
     # --- install / status ---
 
     @abstractmethod
-    def settings_path(self, scope: str, repo_path: Optional[Path] = None) -> Path:
+    def settings_path(self, scope: str, repo_path: Path | None = None) -> Path:
         """Return the hooks/settings file path for the given scope.
 
         `scope` is 'user' or 'repo'. `repo_path` is required when scope == 'repo'.
@@ -108,7 +106,7 @@ class IDE(ABC):
         ``hooks_manager`` can treat them uniformly.
         """
 
-    def post_install(self, scope: str, repo_path: Optional[Path] = None) -> tuple[bool, str]:
+    def post_install(self, scope: str, repo_path: Path | None = None) -> tuple[bool, str]:
         """Run IDE-specific actions after the hooks file is written.
 
         Default: no-op success. Override to perform extra setup that doesn't
@@ -120,7 +118,7 @@ class IDE(ABC):
         """
         return True, ''
 
-    def post_uninstall(self, scope: str, repo_path: Optional[Path] = None) -> tuple[bool, str]:
+    def post_uninstall(self, scope: str, repo_path: Path | None = None) -> tuple[bool, str]:
         """Run IDE-specific cleanup after the hooks file is removed.
 
         Default: no-op success. Override to undo whatever ``post_install``
@@ -169,26 +167,26 @@ class IDE(ABC):
         """
         return AIHookPayload(ide_provider=self.name)
 
-    def get_user_email(self) -> Optional[str]:
+    def get_user_email(self) -> str | None:
         """Best-effort read of the user's email from IDE-specific config.
 
         Default: None. Override if the IDE stores a usable account locally.
         """
         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 +196,7 @@ class IDE(ABC):
         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.
         """

cycode/cli/apps/ai_guardrails/ides/claude_code.py

@@ -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 typing import ClassVar
 
 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,
@@ -79,12 +80,12 @@ def _reverse_readline(path: Path, buf_size: int = 8192) -> Iterator[str]:
             yield buffer.decode('utf-8', errors='replace')
 
 
-def _extract_model(entry: dict) -> Optional[str]:
+def _extract_model(entry: dict) -> str | None:
     """Extract model from a transcript entry (top level or nested in message)."""
     return entry.get('model') or (entry.get('message') or {}).get('model')
 
 
-def _extract_generation_id(entry: dict) -> Optional[str]:
+def _extract_generation_id(entry: dict) -> str | None:
     """Extract generation ID from a user-type transcript entry."""
     if entry.get('type') == 'user':
         return entry.get('uuid')
@@ -93,7 +94,7 @@ def _extract_generation_id(entry: dict) -> Optional[str]:
 
 def extract_from_claude_transcript(
     transcript_path: str,
-) -> tuple[Optional[str], Optional[str], Optional[str]]:
+) -> tuple[str | None, str | None, str | None]:
     """Extract ``(ide_version, model, generation_id)`` from a transcript.
 
     The transcript is a JSONL file scanned from end → start so the most recent
@@ -134,7 +135,7 @@ def extract_from_claude_transcript(
 # --- ~/.claude.json + ~/.claude/settings.json parsing -------------------------
 
 
-def load_claude_config(config_path: Optional[Path] = None) -> Optional[dict]:
+def load_claude_config(config_path: Path | None = None) -> dict | None:
     """Load and parse `~/.claude.json`. Returns None if missing/invalid."""
     path = config_path or _CLAUDE_CONFIG_PATH
     if not path.exists():
@@ -147,17 +148,17 @@ def load_claude_config(config_path: Optional[Path] = None) -> Optional[dict]:
         return None
 
 
-def _email_from_config(config: dict) -> Optional[str]:
+def _email_from_config(config: dict) -> str | None:
     """Read ``oauthAccount.emailAddress`` from a parsed Claude config."""
     return config.get('oauthAccount', {}).get('emailAddress')
 
 
-def get_mcp_servers(config: dict) -> Optional[dict]:
+def get_mcp_servers(config: dict) -> dict | None:
     """Read ``mcpServers`` from a parsed Claude config."""
     return config.get('mcpServers')
 
 
-def load_claude_settings(settings_path: Optional[Path] = None) -> Optional[dict]:
+def load_claude_settings(settings_path: Path | None = None) -> dict | None:
     """Load and parse `~/.claude/settings.json`. Returns None if missing/invalid."""
     path = settings_path or _CLAUDE_SETTINGS_PATH
     if not path.exists():
@@ -184,7 +185,7 @@ def _plugins_cache_dir() -> Path:
     return Path.home() / '.claude' / 'plugins' / 'cache'
 
 
-def _resolve_marketplace_path(marketplace: dict) -> Optional[Path]:
+def _resolve_marketplace_path(marketplace: dict) -> Path | None:
     """Resolve filesystem path for a directory-type marketplace."""
     source = marketplace.get('source', {})
     if source.get('source') != 'directory':
@@ -235,7 +236,7 @@ def resolve_plugins(settings: dict) -> dict:
     enabled = settings.get('enabledPlugins') or {}
     marketplaces = settings.get('extraKnownMarketplaces') or {}
 
-    def _locate(plugin_name: str, marketplace_name: str) -> Optional[Path]:
+    def _locate(plugin_name: str, marketplace_name: str) -> 'Path | None':
         # Directory-type marketplaces point straight at the plugin source; every other source
         # type (git, github, ...) is cloned into the local plugin cache.
         marketplace = marketplaces.get(marketplace_name)
@@ -253,6 +254,41 @@ def resolve_plugins(settings: dict) -> dict:
     )
 
 
+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: dict | None, cwd: str | None) -> 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: dict | None, cwd: str | None) -> 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 ----------------------------------------------------------
 
 
@@ -261,7 +297,7 @@ class ClaudeCode(IDE):
     display_name: ClassVar[str] = 'Claude Code'
     hook_events: ClassVar[list[str]] = list(_HOOK_EVENTS)
 
-    def settings_path(self, scope: str, repo_path: Optional[Path] = None) -> Path:
+    def settings_path(self, scope: str, repo_path: Path | None = None) -> Path:
         if scope == 'repo' and repo_path:
             return repo_path / _REPO_SUBDIR / _HOOKS_FILE_NAME
         return _USER_HOOKS_DIR / _HOOKS_FILE_NAME
@@ -339,6 +375,8 @@ class ClaudeCode(IDE):
 
         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,
@@ -392,18 +430,18 @@ class ClaudeCode(IDE):
             source=raw_payload.get('source'),
         )
 
-    def get_user_email(self) -> Optional[str]:
+    def get_user_email(self) -> str | None:
         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())