LiteX용 엔드투엔드 MCP 시뮬레이션 테스트 및 전용 CI job

```python
# test/tools/test_litex_mcp_sim.py
import json
import os
import socket
import subprocess
import sys
import time

import pytest

pytestmark = pytest.mark.skipif(
    os.environ.get("LITEX_MCP_SIM_TEST") != "1",
    reason="Set LITEX_MCP_SIM_TEST=1 to run the litex_mcp simulation test",
)


def _require(name):
    try:
        __import__(name)
    except ImportError:
        pytest.skip(f"{name} not available")


def _free_port():
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
        s.bind(("127.0.0.1", 0))
        return s.getsockname()[1]


def _wait_for_port(port, timeout=120.0):
    deadline = time.time() + timeout
    while time.time() < deadline:
        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
            s.settimeout(1.0)
            try:
                s.connect(("127.0.0.1", port))
                return True
            except OSError:
                time.sleep(0.5)
    return False


def _result_payload(result):
    if hasattr(result, "model_dump"):
        return result.model_dump(by_alias=True)
    return result


def _tool_text(result):
    payload = _result_payload(result)
    content = payload.get("content") or []
    parts = []
    for item in content:
        if isinstance(item, dict) and item.get("type") == "text":
            parts.append(item.get("text", ""))
    return "\n".join(parts)


def test_litex_mcp_simulation():
    _require("mcp")
    if not _has_verilator():
        pytest.skip("Verilator not available")

    from mcp import ClientSession, StdioServerParameters
    from mcp.client.stdio import stdio_client

    uart_port = _free_port()
    server_port = _free_port()

    env = dict(os.environ)
    env["PYTHONPATH"] = os.pathsep.join(
        p for p in [os.getcwd(), env.get("PYTHONPATH", "")] if p
    )

    params = StdioServerParameters(
        command="litex_mcp",
        args=["--allow-write"],
        env=env,
    )

    import anyio

    async def run():
        async with stdio_client(params) as (read, write):
            async with ClientSession(read, write) as session:
                await session.initialize()

                start = await session.call_tool(
                    "litex_sim_start",
                    {
                        "cpu": "vexriscv",
                        "extra_args": [
                            "--uart-name=crossover+uartbone",
                            "--uart-tcp",
                            str(uart_port),
                        ],
                    },
                )
                start_payload = _result_payload(start)
                if start_payload.get("isError"):
                    pytest.fail(f"litex_sim_start failed: {_tool_text(start)}")

                if not _wait_for_port(uart_port, timeout=180.0):
                    log_tail = _tool_text(
                        await session.call_tool("litex_sim_log", {"tail": 50})
                    )
                    pytest.fail(
                        "Simulation did not start listening on UART port.\n"
                        f"Log tail:\n{log_tail}"
                    )

                srv = await session.call_tool(
                    "litex_server_start",
                    {"port": server_port},
                )
                if _result_payload(srv).get("isError"):
                    pytest.fail(f"litex_server_start failed: {_tool_text(srv)}")

                connected = False
                last_err = ""
                for _ in range(30):
                    conn = await session.call_tool(
                        "litex_connect",
                        {"host": "127.0.0.1", "port": server_port},
                    )
                    if not _result_payload(conn).get("isError"):
                        connected = True
                        break
                    last_err = _tool_text(conn)
                    time.sleep(1.0)
                if not connected:
                    pytest.fail(f"litex_connect never accepted: {last_err}")

                write = await session.call_tool(
                    "litex_write",
                    {"name": "ctrl_scratch", "value": 0xDEADBEEF},
                )
                if _result_payload(write).get("isError"):
                    pytest.fail(f"litex_write failed: {_tool_text(write)}")

                read = await session.call_tool(
                    "litex_read",
                    {"name": "ctrl_scratch"},
                )
                if _result_payload(read).get("isError"):
                    pytest.fail(f"litex_read failed: {_tool_text(read)}")
                assert "deadbeef" in _tool_text(read).lower()

                help_out = await session.call_tool(
                    "litex_console_command",
                    {"command": "help"},
                )
                if _result_payload(help_out).get("isError"):
                    pytest.fail(f"console help failed: {_tool_text(help_out)}")
                assert _tool_text(help_out).strip()

                tools = await session.list_tools()
                tool_names = {t.name for t in tools.tools}
                if "litex_build_info" in tool_names:
                    info = await session.call_tool("litex_build_info", {})
                    assert not _result_payload(info).get("isError")

    anyio.run(run)


def _has_verilator():
    try:
        subprocess.run(
            ["verilator", "--version"],
            check=True,
            capture_output=True,
        )
        return True
    except (OSError, subprocess.CalledProcessError):
        return False
```

```yaml
# .github/workflows/ci.yml (add the `mcp` job; leave build shards, .test_durations generation and docs job unchanged)
  mcp:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Set up Python 3.11
        uses: actions/setup-python@v5
        with:
          python-version: "3.11"

      - name: Set up Python 3.9 for cached Verilator install
        uses: actions/setup-python@v5
        with:
          python-version: "3.9"

      - name: Install MCP SDK
        run: pip install mcp

      - name: Install gcc-riscv64-unknown-elf
        run: |
          sudo apt-get update
          sudo apt-get install -y gcc-riscv64-unknown-elf

      - name: Set up ccache
        uses: hendrikmuhs/ccache-action@v1

      - name: Restore Verilator cache
        uses: actions/cache@v4
        with:
          path: ~/.cache/verilator
          key: verilator-${{ runner.os }}-${{ hashFiles('.github/workflows/ci.yml') }}

      - name: Install Verilator
        run: |
          if [ ! -x ~/.cache/verilator/bin/verilator ]; then
            sudo apt-get install -y verilator
          fi

      - name: Build LiteX
        run: python -m litex_boards.targets --config=standard

      - name: Run MCP tool tests (blocking)
        run: python -m pytest test/tools/test_litex_mcp.py -v

      - name: Run build report tests (blocking)
        run: python -m pytest test/build/test_report.py -v

      # The simulation test is non-blocking: the UART crossover console
      # occasionally times out waiting for the BIOS prompt under CI load,
      # which is a known flakiness unrelated to the MCP tooling itself.
      - name: Run MCP simulation test (non-blocking)
        continue-on-error: true
        env:
          LITEX_MCP_SIM_TEST: "1"
        run: python -m pytest test/tools/test_litex_mcp_sim.py -v
```