@@ -19,7 +19,7 @@
 from importlib.metadata import version as _pkg_version
 from typing import Any
 
-from skillspector.graph_proxy import graph
+from skillspector.graph_proxy import graph, restore_package_graph_export
 
 __version__ = _pkg_version("skillspector")
 
@@ -40,7 +40,13 @@ def create_graph() -> Any:
     """Build and return a new SkillSpector workflow graph."""
     from skillspector.graph import create_graph as build_graph
 
-    return build_graph()
+    try:
+        return build_graph()
+    finally:
+        # Importing the submodule shadows the lazy proxy on the package;
+        # restore the documented export even when this factory is the first
+        # graph access.
+        restore_package_graph_export()
 
 
 __all__ = ["create_graph", "graph", "__version__"]
@@ -21,6 +21,8 @@
 
 from __future__ import annotations
 
+from typing import Any
+
 from langgraph.graph import END, START, StateGraph
 
 from skillspector.inspection_ledger import guard_analyzer_node
@@ -86,3 +88,18 @@ def create_graph():
 
 
 graph = create_graph()
+
+
+def __getattr__(name: str) -> Any:
+    """Delegate invokable graph API when this module shadows the package export.
+
+    Importing ``skillspector.graph`` directly assigns this module to the
+    parent package's ``graph`` attribute (the import system sets it after
+    module execution, so it cannot be restored from here). Delegating
+    ``invoke``/``ainvoke``/``stream`` keeps ``skillspector.graph`` invokable
+    in that import order; prefer ``from skillspector import graph`` for the
+    lazy proxy instead.
+    """
+    if name in {"invoke", "ainvoke", "stream", "astream", "batch", "abatch"}:
+        return getattr(graph, name)
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
@@ -49,4 +49,18 @@ def __getattr__(self, name: str) -> Any:
         return getattr(self._get_compiled(), name)
 
 
+def restore_package_graph_export() -> None:
+    """Re-assert the lazy proxy as the package-level ``graph`` export.
+
+    Importing the ``skillspector.graph`` submodule assigns the module object
+    to the parent package's ``graph`` attribute, shadowing this proxy. Call
+    this after any eager submodule import (the ``create_graph()`` factory
+    wrapper, ``mcp_server``) so ``skillspector.graph`` stays invokable
+    regardless of import order.
+    """
+    import skillspector as _pkg
+
+    _pkg.graph = graph
+
+
 graph = LazyGraph()
@@ -35,13 +35,20 @@
 from skillspector.cleanup import cleanup_result
 from skillspector.constants import RISK_THRESHOLD
 from skillspector.graph import graph
+from skillspector.graph_proxy import restore_package_graph_export
 from skillspector.inspection_ledger import LedgerReason
 from skillspector.llm_utils import is_llm_available
 from skillspector.logging_config import get_logger
 from skillspector.nodes.analyzers import ANALYZER_MODULES
 from skillspector.semantic_runtime import llm_runtime_available, semantic_runtime_accounting
 from skillspector.suppression import effective_findings
 
+# Importing `skillspector.graph` above assigns the submodule to the parent
+# package's `graph` attribute, shadowing the documented lazy proxy. Restore
+# the proxy so `skillspector.graph` stays invokable when MCP is imported
+# before any other graph access.
+restore_package_graph_export()
+
 if TYPE_CHECKING:
     from mcp.server.fastmcp import FastMCP
 
 
@@ -5,39 +5,62 @@
 
 from __future__ import annotations
 
+import importlib
 import sys
-import types
-from types import SimpleNamespace
+
+import pytest
 
 import skillspector
 from skillspector.graph_proxy import LazyGraph
 from skillspector.graph_proxy import graph as lazy_graph
 
 
-def test_package_graph_export_survives_submodule_load() -> None:
-    """Re-import after lazy load still exposes an invokable package export.
+@pytest.fixture
+def _graph_import_state(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Snapshot and restore all shared graph import state.
 
-    Closes rng1995 review on #436: importing the graph submodule must not leave
-    later `skillspector.graph` consumers with a non-invokable module object.
+    Closes rng1995/yashrajp22 reviews on #436: graph import-order tests must
+    exercise the real factory/import paths without leaking ``sys.modules``
+    entries, the package ``graph`` attribute, or ``LazyGraph`` compiled
+    state into other tests.
     """
-    compiled = SimpleNamespace(invoke=lambda state: state)
-    submodule = types.ModuleType("skillspector.graph")
-    submodule.graph = compiled  # type: ignore[attr-defined]
-
-    # CLI tests monkeypatch ``skillspector.cli.graph.invoke``; undo restores the
-    # real bound method on this shared singleton and bypasses ``__getattr__``.
+    monkeypatch.delitem(sys.modules, "skillspector.graph", raising=False)
+    monkeypatch.delitem(sys.modules, "skillspector.mcp_server", raising=False)
+    monkeypatch.setattr(skillspector, "graph", lazy_graph, raising=False)
+    monkeypatch.setattr(lazy_graph, "_compiled", None, raising=False)
+    # A leaked instance attribute would shadow __getattr__ delegation;
+    # drop it so the proxy is pristine (nothing to restore: the pristine
+    # singleton carries no such attribute).
     lazy_graph.__dict__.pop("invoke", None)
-    lazy_graph._compiled = compiled
-    skillspector.graph = lazy_graph
 
-    # Importing the compiled submodule replaces the package export with the module.
-    skillspector.graph = submodule
-    sys.modules["skillspector.graph"] = submodule
 
-    # graph_proxy._get_compiled restores the documented lazy export afterward.
-    skillspector.graph = lazy_graph
-    sys.modules["skillspector"].graph = lazy_graph
+def _assert_graph_export_invokable() -> None:
+    exported = skillspector.graph
+    for name in ("invoke", "ainvoke", "stream"):
+        assert callable(getattr(exported, name)), (
+            f"skillspector.graph lost {name} after import-order change"
+        )
+
+
+def test_create_graph_first_preserves_lazy_export(
+    _graph_import_state: None,
+) -> None:
+    """rng1995 #436: create_graph() as first access keeps the lazy export."""
+    skillspector.create_graph()
+    assert isinstance(skillspector.graph, LazyGraph)
+    _assert_graph_export_invokable()
+
 
+def test_mcp_import_first_preserves_lazy_export(_graph_import_state: None) -> None:
+    """yashrajp22 #436: importing MCP first keeps the lazy export."""
+    importlib.import_module("skillspector.mcp_server")
     assert isinstance(skillspector.graph, LazyGraph)
-    assert lazy_graph.invoke({"ok": True}) == {"ok": True}
-    assert skillspector.graph.invoke({"again": 1}) == {"again": 1}
+    _assert_graph_export_invokable()
+
+
+def test_direct_submodule_import_keeps_graph_invokable(
+    _graph_import_state: None,
+) -> None:
+    """yashrajp22 #436: direct submodule import keeps skillspector.graph invokable."""
+    importlib.import_module("skillspector.graph")
+    _assert_graph_export_invokable()