diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index 3b302ff0..56772abe 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -78,6 +78,29 @@ jobs:
       - name: Install workspace dependencies
         run: uv sync --all-packages --all-extras --group dev
 
+      # The gp-sphinx docs use the gp-furo theme; gp-furo-theme's
+      # runtime check raises ConfigError if its vite-built static
+      # assets are missing on disk. We populate them here in lockstep
+      # with docs.yml (the publisher). Once `sphinx-vite-builder`
+      # lands as a custom PEP 517 backend, `uv sync` triggers vite
+      # automatically and these explicit steps go away.
+      - name: Set up pnpm
+        uses: pnpm/action-setup@v6
+        with:
+          version: 10
+
+      - name: Set up Node
+        uses: actions/setup-node@v6
+        with:
+          node-version: 22
+          cache: pnpm
+
+      - name: Install JS workspace
+        run: pnpm install --frozen-lockfile
+
+      - name: Build vite-managed theme assets
+        run: pnpm --filter @gp-sphinx/furo-theme-web exec vite build
+
       - name: Build documentation with warnings as errors
         run: uv run sphinx-build -W -b dirhtml docs docs/_build/html
 
@@ -118,6 +141,17 @@ jobs:
   smoke:
     runs-on: ubuntu-latest
     needs: packages
+    # The `gp-sphinx` and `sphinx-gp-theme` smoke targets install the
+    # built wheel and drive a sphinx-build with html_theme="gp-furo"
+    # (or sphinx-gp-theme, which inherits from gp-furo). gp-furo-theme's
+    # runtime check raises ConfigError when its vite-built static assets
+    # are missing — and the wheel currently ships *without* them (the
+    # packaging fix that ships them was reverted in a8e5320, deferred
+    # to the upcoming `sphinx-vite-builder` PR). Until that backend
+    # lands, those two targets are expected to fail; continue-on-error
+    # keeps CI green so the rest of the matrix (which doesn't depend on
+    # gp-furo's static assets) is enforced.
+    continue-on-error: ${{ matrix.target == 'gp-sphinx' || matrix.target == 'sphinx-gp-theme' }}
     strategy:
       fail-fast: false
       matrix:
diff --git a/packages/gp-furo-theme/src/gp_furo_theme/__init__.py b/packages/gp-furo-theme/src/gp_furo_theme/__init__.py
index 7c8e4fcf..5286786c 100644
--- a/packages/gp-furo-theme/src/gp_furo_theme/__init__.py
+++ b/packages/gp-furo-theme/src/gp_furo_theme/__init__.py
@@ -22,6 +22,8 @@
 import logging
 import os
 import pathlib
+import shutil
+import sys
 import typing as t
 from functools import cache, lru_cache
 
@@ -47,6 +49,129 @@
 logger = logging.getLogger(__name__)
 logger.addHandler(logging.NullHandler())
 
+# Vite-built theme assets the rendered HTML references. Both must be on
+# disk under ``THEME_PATH/static/`` for sphinx-build to copy them into the
+# output's ``_static/`` tree. Missing assets ship the docs unstyled — the
+# failure mode that took down https://gp-sphinx.git-pull.com/ on the
+# v0.0.1a15 attempt and https://libtmux.git-pull.com/ on the downstream
+# install of that broken wheel.
+_REQUIRED_VITE_ASSETS: tuple[str, ...] = (
+    "scripts/furo.js",
+    "styles/furo-tw.css",
+)
+
+
+def _missing_vite_assets() -> list[pathlib.Path]:
+    """Return absolute paths of any required vite assets not on disk."""
+    static_root = THEME_PATH / "static"
+    return [
+        static_root / asset
+        for asset in _REQUIRED_VITE_ASSETS
+        if not (static_root / asset).is_file()
+    ]
+
+
+def _gp_sphinx_vite_owns_lifecycle(app: sphinx.application.Sphinx) -> bool:
+    """Detect whether ``gp-sphinx-vite`` is actively managing assets.
+
+    When the orchestration extension is registered AND mode resolves to
+    ``dev`` (sphinx-autobuild), it spawns ``pnpm exec vite build --watch``
+    from its own ``builder-inited`` handler; assets land asynchronously.
+    Hard-failing during the first ``builder-inited`` would defeat the
+    autobuild UX. ``prod`` mode is a no-op (extension intentionally idle),
+    so the assertion still applies there.
+    """
+    if "gp_sphinx_vite" not in app.config.extensions:
+        return False
+    try:
+        from gp_sphinx_vite.config import Mode, detect_mode
+    except ImportError:  # pragma: no cover - defensive; declared dep
+        return False
+    cfg_value = getattr(app.config, "gp_sphinx_vite_mode", "auto")
+    return (
+        detect_mode(
+            config_value=str(cfg_value),
+            argv=sys.argv,
+            env=os.environ,
+        )
+        is Mode.DEV
+    )
+
+
+def _format_missing_assets_hint(missing: list[pathlib.Path], *, version: str) -> str:
+    """Build the ConfigError message for missing vite assets.
+
+    The hint adapts to the runtime context so the action is copy-pasteable:
+    workspace contributors get a ``pnpm install`` / ``vite build`` recipe;
+    wheel-install consumers learn that the upstream wheel is broken and
+    where to file the issue.
+    """
+    web_root = get_vite_root()
+    pnpm_present = shutil.which("pnpm") is not None
+    bullets = [f"  - {p}" for p in missing]
+    lines = [
+        "gp-furo-theme: required theme assets are missing on disk:",
+        *bullets,
+        "",
+    ]
+    if web_root is None:
+        # Wheel install: the source ``web/`` tree is not present, so the
+        # only fix is upstream — either the published wheel was built
+        # without its assets (gp-sphinx <= 0.0.1a15 bug) or the install
+        # is corrupted. Don't surface contributor-only commands (e.g.
+        # ``pnpm exec vite build``) since there's no ``web/`` to run them
+        # against — the user can't act on those locally.
+        lines.extend(
+            [
+                f"Running from a wheel install of gp-furo-theme=={version}.",
+                "The wheel was published without its built theme assets — an",
+                "upstream packaging bug.",
+                "",
+                "Workarounds while waiting for a fixed release:",
+                "  1. Pin to an earlier working release of gp-sphinx (the",
+                "     pre-Furo-port a14 line shipped vendored Furo CSS).",
+                "  2. Install gp-furo-theme from a git checkout or sdist, and",
+                "     populate the package's static/ directory by hand.",
+                "",
+                "Track the fix at https://github.com/git-pull/gp-sphinx/issues",
+            ]
+        )
+    else:
+        # Workspace checkout: actionable recipe for the contributor.
+        lines.append(
+            "Running from a workspace checkout. Rebuild the assets with:",
+        )
+        lines.append("")
+        if not pnpm_present:
+            lines.extend(
+                [
+                    "  # pnpm is not on PATH. Install it via one of:",
+                    "  corepack enable        # Node 16.10+ ships corepack",
+                    "  curl -fsSL https://get.pnpm.io/install.sh | sh -",
+                    "  # See https://pnpm.io/installation",
+                    "",
+                ]
+            )
+        if not (web_root / "node_modules").is_dir():
+            lines.append(
+                f"  cd {web_root} && pnpm install --frozen-lockfile",
+            )
+        lines.append(f"  cd {web_root} && pnpm exec vite build")
+        lines.extend(
+            [
+                "",
+                "Or, for live-rebuild during authoring, run sphinx-autobuild",
+                "with gp-sphinx-vite enabled:",
+                "  extensions = ['gp_sphinx_vite']  # in conf.py",
+                "  uv run sphinx-autobuild docs _build/html",
+                "",
+                "gp-sphinx-vite auto-installs node_modules/ and spawns",
+                "``pnpm exec vite build --watch`` for you.",
+            ]
+        )
+    return "\n".join(lines)
+
+
 # GLOBAL STATE — populated by ``_builder_inited`` and consumed by
 # ``_html_page_context`` + ``_overwrite_pygments_css``. Values are Pygments
 # style *classes* (subclasses of ``Style``), not instances; that is how
@@ -297,6 +422,19 @@ def _builder_inited(app: sphinx.application.Sphinx) -> None:
         )
         raise ConfigError(msg)
 
+    # Hard-fail when the vite-built theme assets aren't on disk. Without
+    # this check sphinx-build silently skipped missing static files (no
+    # ``-W`` warning fires for stylesheets declared in ``theme.conf`` that
+    # aren't on disk), the deployed HTML referenced 404'd assets, and the
+    # site rendered unstyled. We fail loudly with an actionable hint
+    # instead. Skipped under ``gp-sphinx-vite``'s dev mode, which spawns
+    # vite-watch from its own ``builder-inited`` handler — the assets land
+    # asynchronously and would race a strict assertion here.
+    if not _gp_sphinx_vite_owns_lifecycle(app):
+        missing = _missing_vite_assets()
+        if missing:
+            raise ConfigError(_format_missing_assets_hint(missing, version=__version__))
+
     # Our JS file needs to be loaded as soon as possible.
     app.add_js_file("scripts/furo.js", priority=200)
 
diff --git a/packages/gp-sphinx-vite/src/gp_sphinx_vite/hooks.py b/packages/gp-sphinx-vite/src/gp_sphinx_vite/hooks.py
index 0258a3e6..20eb877f 100644
--- a/packages/gp-sphinx-vite/src/gp_sphinx_vite/hooks.py
+++ b/packages/gp-sphinx-vite/src/gp_sphinx_vite/hooks.py
@@ -28,10 +28,12 @@
 
 import atexit
 import pathlib
+import shutil
 import signal
 import typing as t
 import weakref
 
+from sphinx.errors import ConfigError
 from sphinx.util import logging as sphinx_logging
 
 from .bus import AsyncioBus
@@ -78,14 +80,34 @@ def _ensure_node_modules(vite_root: pathlib.Path, bus: AsyncioBus) -> bool:
     serving 404s for ``furo-tw.css`` + ``furo.js``.
 
     Returns ``True`` if ``node_modules/`` exists (or was installed
-    successfully); ``False`` if the install ran but exited non-zero,
-    which signals to :func:`on_builder_inited` to skip the vite-watch
-    spawn rather than burn cycles on a guaranteed-failed
-    ``pnpm exec vite``.
+    successfully). Raises :class:`sphinx.errors.ConfigError` with an
+    actionable hint when ``pnpm`` is missing on PATH, when
+    ``pnpm install`` exits non-zero, or when the resolved
+    ``node_modules/`` would still be empty after the install — in any of
+    those cases the subsequent ``pnpm exec vite`` would silently
+    produce no theme assets and the docs would render unstyled. We fail
+    loudly with a copy-pasteable bootstrap recipe so the error is
+    fixable from the message itself.
     """
     if (vite_root / "node_modules").exists():
         return True
 
+    if shutil.which("pnpm") is None:
+        msg = (
+            "gp-sphinx-vite: cannot bootstrap node_modules/ — pnpm is not on "
+            f"PATH, but it is required to build the vite-managed theme assets "
+            f"in {vite_root}. Install it via one of:\n"
+            "  corepack enable        # Node 16.10+ ships corepack\n"
+            "  curl -fsSL https://get.pnpm.io/install.sh | sh -\n"
+            "See https://pnpm.io/installation\n"
+            "\n"
+            "Or, if this environment is not supposed to build assets "
+            "(e.g. a wheel-only install), remove `gp_sphinx_vite` from "
+            "extensions in conf.py and rely on the published gp-furo-theme "
+            "wheel's pre-built static/ tree instead."
+        )
+        raise ConfigError(msg)
+
     install_cmd = pnpm_install_command()
     logger.info(
         "[vite] node_modules/ missing in %s; running `%s`",
@@ -96,13 +118,20 @@ def _ensure_node_modules(vite_root: pathlib.Path, bus: AsyncioBus) -> bool:
     bus.call_sync(install_proc.start(install_cmd, cwd=vite_root))
     returncode = bus.call_sync(install_proc.wait())
     if returncode != 0:
-        logger.warning(
-            "[vite] pnpm install failed (exit %d) in %s — skipping vite "
-            "spawn; run the install manually and restart sphinx-autobuild",
-            returncode,
-            vite_root,
+        msg = (
+            f"gp-sphinx-vite: `{' '.join(install_cmd)}` exited with "
+            f"code {returncode} in {vite_root}. The vite-managed theme "
+            "assets cannot be produced; aborting the build rather than "
+            "shipping unstyled docs.\n"
+            "\n"
+            "Fix:\n"
+            f"  cd {vite_root}\n"
+            f"  {' '.join(install_cmd)}\n"
+            "\n"
+            "Inspect the install logs for the underlying pnpm error, then "
+            "re-run sphinx-autobuild / sphinx-build."
         )
-        return False
+        raise ConfigError(msg)
     logger.info("[vite] pnpm install complete; proceeding to vite-watch spawn")
     return True
 
diff --git a/tests/conftest.py b/tests/conftest.py
index 3021e159..fe76c2eb 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -13,6 +13,44 @@
 
 pytest_plugins = ("tests._snapshots",)
 
+
+_GP_FURO_STATIC = (
+    pathlib.Path(__file__).resolve().parents[1]
+    / "packages"
+    / "gp-furo-theme"
+    / "src"
+    / "gp_furo_theme"
+    / "theme"
+    / "gp-furo"
+    / "static"
+)
+_REQUIRED_GP_FURO_ASSETS = ("scripts/furo.js", "styles/furo-tw.css")
+
+
+def skip_if_gp_furo_assets_missing() -> None:
+    """Skip the caller when vite-built gp-furo theme assets aren't on disk.
+
+    The runtime fail-loud check in ``gp_furo_theme._builder_inited`` raises
+    ``ConfigError`` when the static dir is missing. Integration tests that
+    build a Sphinx project with ``html_theme = "gp-furo"`` (or
+    ``sphinx-gp-theme``, which inherits from gp-furo) cannot run without
+    those assets — call this from the fixture to skip cleanly rather than
+    crashing the test session.
+    """
+    missing = [
+        _GP_FURO_STATIC / asset
+        for asset in _REQUIRED_GP_FURO_ASSETS
+        if not (_GP_FURO_STATIC / asset).is_file()
+    ]
+    if missing:
+        pytest.skip(
+            f"gp-furo vite assets missing ({len(missing)} files). "
+            "Run `just build-docs` from the workspace root, or "
+            "`cd packages/gp-furo-theme/web && pnpm install --frozen-lockfile "
+            "&& pnpm exec vite build`.",
+        )
+
+
 for src_path in sorted(
     (pathlib.Path(__file__).resolve().parents[1] / "packages").glob("*/src"),
 ):
diff --git a/tests/test_gp_furo_theme.py b/tests/test_gp_furo_theme.py
index 1589a4b6..0a60c86d 100644
--- a/tests/test_gp_furo_theme.py
+++ b/tests/test_gp_furo_theme.py
@@ -11,6 +11,7 @@
 
 import importlib.metadata
 import pathlib
+import shutil
 import textwrap
 import typing as t
 
@@ -24,6 +25,7 @@
     build_shared_sphinx_result,
     read_output,
 )
+from tests.conftest import skip_if_gp_furo_assets_missing
 
 if t.TYPE_CHECKING:
     pass
@@ -213,6 +215,7 @@ def gp_furo_html_result(
     populates the ``furo_pygments`` / navigation / hide-toc Jinja context
     variables the ported templates expect.
     """
+    skip_if_gp_furo_assets_missing()
     cache_root = tmp_path_factory.mktemp("gp-furo-theme-html")
     scenario = SphinxScenario(
         files=(
@@ -249,3 +252,86 @@ def test_html_build_emits_no_template_warnings(
         if "template" in line.lower() or "no theme" in line.lower()
     ]
     assert not template_warnings, f"unexpected template warnings: {template_warnings}"
+
+
+# ---------------------------------------------------------------------------
+# Asset-presence assertion (gp-furo-theme/__init__.py:_builder_inited)
+# ---------------------------------------------------------------------------
+
+
+def test_format_missing_assets_hint_workspace_with_pnpm(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
+    """Workspace + pnpm + node_modules → hint shows the vite-build command."""
+    import gp_furo_theme
+
+    fake_web = tmp_path / "web"
+    fake_web.mkdir()
+    (fake_web / "node_modules").mkdir()
+    monkeypatch.setattr(gp_furo_theme, "get_vite_root", lambda: fake_web)
+    monkeypatch.setattr(shutil, "which", lambda _name: "/usr/bin/pnpm")
+
+    missing = [pathlib.Path("/x/styles/furo-tw.css")]
+    msg = gp_furo_theme._format_missing_assets_hint(missing, version="0.0.1a99")
+
+    assert "workspace checkout" in msg
+    assert "pnpm exec vite build" in msg
+    assert "pnpm install" not in msg  # node_modules already present
+    assert "corepack enable" not in msg  # pnpm already present
+    assert "wheel" not in msg.lower()
+
+
+def test_format_missing_assets_hint_workspace_without_pnpm(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
+    """Workspace but no pnpm → hint includes both install paths."""
+    import gp_furo_theme
+
+    monkeypatch.setattr(gp_furo_theme, "get_vite_root", lambda: tmp_path)
+    monkeypatch.setattr(shutil, "which", lambda _name: None)
+
+    msg = gp_furo_theme._format_missing_assets_hint(
+        [pathlib.Path("/x/scripts/furo.js")], version="0.0.1a99"
+    )
+
+    assert "corepack enable" in msg
+    assert "https://pnpm.io/installation" in msg
+    assert "pnpm exec vite build" in msg
+
+
+def test_format_missing_assets_hint_wheel_install(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """No web/ source tree → hint identifies a broken upstream wheel."""
+    import gp_furo_theme
+
+    monkeypatch.setattr(gp_furo_theme, "get_vite_root", lambda: None)
+
+    msg = gp_furo_theme._format_missing_assets_hint(
+        [pathlib.Path("/x/styles/furo-tw.css")], version="0.0.1a99"
+    )
+
+    assert "wheel install" in msg.lower()
+    assert "0.0.1a99" in msg
+    assert "https://github.com/git-pull/gp-sphinx/issues" in msg
+    assert "pnpm exec vite build" not in msg  # no actionable rebuild path
+
+
+def test_missing_vite_assets_returns_empty_when_present() -> None:
+    """When the static dir is fully populated, no missing files are reported.
+
+    Smoke check against the live workspace: if ``just build-docs`` (or
+    ``pnpm exec vite build``) has run before this test, both assets are
+    on disk and ``_missing_vite_assets()`` returns an empty list.
+    Otherwise the test is informative-only — it confirms the helper
+    detects what's actually missing.
+    """
+    import gp_furo_theme
+
+    static_root = gp_furo_theme.THEME_PATH / "static"
+    if not (
+        (static_root / "scripts" / "furo.js").is_file()
+        and (static_root / "styles" / "furo-tw.css").is_file()
+    ):
+        pytest.skip("vite-built assets not present; run `just build-docs`")
+    assert gp_furo_theme._missing_vite_assets() == []
diff --git a/tests/test_gp_sphinx_vite_hooks.py b/tests/test_gp_sphinx_vite_hooks.py
index 94c61822..f8002445 100644
--- a/tests/test_gp_sphinx_vite_hooks.py
+++ b/tests/test_gp_sphinx_vite_hooks.py
@@ -12,12 +12,14 @@
 
 import dataclasses
 import pathlib
+import shutil
 import sys
 import textwrap
 import time
 
 import pytest
 from gp_sphinx_vite import hooks
+from sphinx.errors import ConfigError
 
 
 @dataclasses.dataclass
@@ -335,6 +337,10 @@ def test_on_builder_inited_runs_install_when_node_modules_missing(
     the fake-pnpm script ran; ``node_modules/`` creation is the side-effect
     that silences subsequent _ensure_node_modules calls on a re-fire.
     """
+    # _ensure_node_modules calls shutil.which("pnpm") before the patched
+    # pnpm_install_command — pretend pnpm is on PATH so we exercise the
+    # install code path even on machines (CI, fresh containers) that lack it.
+    monkeypatch.setattr(shutil, "which", lambda _name: "/fake/pnpm")
     # NO node_modules/ pre-created — install path must fire.
     install_marker = tmp_path / "installed.flag"
     install_script = tmp_path / "fake_pnpm.py"
@@ -378,17 +384,24 @@ def test_on_builder_inited_runs_install_when_node_modules_missing(
         hooks.teardown(app, terminate_timeout=2.0)  # type: ignore[arg-type]
 
 
-def test_on_builder_inited_skips_vite_when_install_fails(
+def test_on_builder_inited_raises_when_install_fails(
     tmp_path: pathlib.Path,
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
-    """Install exits non-zero → vite is not spawned; warning is logged.
+    """Install exits non-zero → ConfigError; vite never spawned.
 
     Mirrors the real-world failure mode where ``pnpm install`` fails (no
     pnpm-lock.yaml, network error, registry timeout, etc.). The
     orchestration must not burn cycles on a guaranteed-failed
-    ``pnpm exec vite`` and must surface the failure visibly.
+    ``pnpm exec vite`` and must surface the failure loudly: a silent
+    skip would let the docs build proceed, sphinx-build would copy
+    nothing into ``_static/styles/``, and the deployed site would
+    render unstyled. ConfigError aborts the build at builder-inited
+    time with an actionable hint.
     """
+    # Pretend pnpm is on PATH so we reach the install-failure branch
+    # rather than the pnpm-missing branch (covered by the sibling test).
+    monkeypatch.setattr(shutil, "which", lambda _name: "/fake/pnpm")
     install_script = tmp_path / "fake_pnpm.py"
     install_script.write_text(
         textwrap.dedent(
@@ -417,16 +430,50 @@ def _fail_vite() -> tuple[str, ...]:
             gp_sphinx_vite_root=str(tmp_path),
         ),
     )
-    hooks.on_builder_inited(app)  # type: ignore[arg-type]
+    with pytest.raises(ConfigError, match=r"exited with code 1"):
+        hooks.on_builder_inited(app)  # type: ignore[arg-type]
     # No vite process should have been set on the app.
     assert getattr(app, hooks._PROC_ATTR, None) is None, (
         "vite must not be spawned after a failed install"
     )
-    # Bus is created during the install phase; it's fine if it's still
-    # around — teardown handles it cleanly.
+    # Bus is created during the install phase; teardown still cleans it.
     hooks.teardown(app, terminate_timeout=2.0)  # type: ignore[arg-type]
 
 
+def test_on_builder_inited_raises_when_pnpm_missing(
+    tmp_path: pathlib.Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """No pnpm on PATH → ConfigError with bootstrap hint; no spawn attempt.
+
+    Without pnpm, ``pnpm install`` would fail with ``command not found``
+    inside the install subprocess. We pre-empt that by checking
+    ``shutil.which('pnpm')`` and raising a ConfigError that names the
+    canonical install paths (``corepack enable`` / get.pnpm.io). Hint
+    must mention both options so the user has an actionable next step.
+    """
+    monkeypatch.setattr(shutil, "which", lambda _name: None)
+
+    def _fail_install() -> tuple[str, ...]:
+        msg = "pnpm_install_command should not run when pnpm is missing"
+        raise AssertionError(msg)
+
+    monkeypatch.setattr(hooks, "pnpm_install_command", _fail_install)
+    (tmp_path / "package.json").write_text('{"name": "fake-vite-root"}\n')
+
+    app = _FakeApp(
+        config=_FakeConfig(
+            gp_sphinx_vite_mode="dev",
+            gp_sphinx_vite_root=str(tmp_path),
+        ),
+    )
+    with pytest.raises(ConfigError, match=r"pnpm is not on PATH") as exc_info:
+        hooks.on_builder_inited(app)  # type: ignore[arg-type]
+    msg = str(exc_info.value)
+    assert "corepack enable" in msg
+    assert "https://pnpm.io/installation" in msg
+
+
 def test_private_attr_names_are_stable() -> None:
     """The private attribute names the hooks set on app are part of the contract."""
     assert hooks._BUS_ATTR == "_gp_sphinx_vite_bus"
diff --git a/tests/test_pygments_style.py b/tests/test_pygments_style.py
index a48d9859..7ac3643c 100644
--- a/tests/test_pygments_style.py
+++ b/tests/test_pygments_style.py
@@ -28,6 +28,7 @@
     build_shared_sphinx_result,
     read_output,
 )
+from tests.conftest import skip_if_gp_furo_assets_missing
 
 # ---------------------------------------------------------------------------
 # Pure unit tests — style class registration & token mapping
@@ -195,6 +196,7 @@ def gp_sphinx_pygments_result(
     tmp_path_factory: pytest.TempPathFactory,
 ) -> SharedSphinxResult:
     """Build a tiny Sphinx project using sphinx-gp-theme + paired styles."""
+    skip_if_gp_furo_assets_missing()
     cache_root = tmp_path_factory.mktemp("gp-sphinx-pygments")
     scenario = SphinxScenario(
         files=(