@@ -551,7 +551,12 @@ All in `PM/commonTest`, so they run wherever the interpreter loads.
   first checks it with the N-7 gate, and a type error stops the import with the gate's diagnostics before
   any of the module's code runs. Release builds rely on the build gate (#20) and skip it. Results are cached
   by file content, so an unchanged module is not checked again. There are no per-call runtime type checks:
-  compiled and interpreted code behave exactly as CPython does (N-8). `Status: planned` (#183).
+  compiled and interpreted code behave exactly as CPython does (N-8). Form: `typedpython.importgate.install(source_roots)`
+  puts a meta path finder first on `sys.meta_path` (`uninstall()` removes it; `install_from_env()` installs it
+  when `TYPEDPYTHON_IMPORT_GATE` lists source roots). Only modules whose source file lies under a root are
+  checked; the stdlib and dependencies never are. A gate error raises `ImportGateError` (an `ImportError`
+  with `.diagnostics`) before the module runs. Results are cached in memory by file content hash, failures
+  included. `Status: implemented`, `python-multiplatform-ksp/src/test/python/test_importgate.py`.
 - **N-8** TypedPython compilation to C (INTENT §1.4; design §4.3; #41). `@compiled` (a builtin name, no
   import, #42) and a first-line `# typedpython: compiled` mark functions; the compiler lowers them
   through the typed IR (`typedpython/ir.py`) to C against the CPython C API and builds an extension with
 
@@ -0,0 +1,96 @@
+"""Development-mode import gate (SPEC N-7b, #183).
+
+`install(source_roots)` puts a meta path finder first on `sys.meta_path`. When a module whose source
+file lies under one of the roots is imported, the finder runs the N-7 gate (`gate.check`, the checker
+behind `python -m typedpython check`) on that file before the import machinery executes it. A type
+error raises `ImportGateError`, an `ImportError` carrying the diagnostics, and none of the module's
+code runs. Modules outside the roots (the stdlib, dependencies) are never checked.
+
+Results are cached in memory by the SHA-256 of the file content, so an unchanged module is not
+checked again (a failing result is cached too). Release builds never call `install`.
+"""
+from __future__ import annotations
+
+import hashlib
+import os
+import sys
+from collections.abc import Sequence
+from importlib import machinery
+from importlib.abc import MetaPathFinder
+from pathlib import Path
+from types import ModuleType
+
+from typedpython import gate
+from typedpython.diagnostic import Diagnostic
+
+ENV_VAR = "TYPEDPYTHON_IMPORT_GATE"  # source roots separated by os.pathsep
+
+
+class ImportGateError(ImportError):
+    """A project module failed the type gate; `diagnostics` holds the gate's errors."""
+
+    def __init__(self, path: str, diagnostics: Sequence[Diagnostic], name: str | None = None) -> None:
+        self.diagnostics = list(diagnostics)
+        lines = [f"{d.path}:{d.line}:{d.column}: {d.message} [{d.rule}]" for d in self.diagnostics]
+        super().__init__(
+            f"type gate rejected {path}; the module was not run:\n" + "\n".join(lines),
+            name=name, path=path,
+        )
+
+
+def _run_gate(paths: Sequence[Path], search_paths: Sequence[Path]) -> list[Diagnostic]:
+    """The checker seam: tests count its invocations."""
+    return gate.check(paths, mode="checked", search_paths=search_paths)
+
+
+class ImportGateFinder(MetaPathFinder):
+    def __init__(self, source_roots: Sequence[Path]) -> None:
+        self.roots = [Path(r).resolve() for r in source_roots]
+        self._cache: dict[str, tuple[str, list[Diagnostic]]] = {}
+
+    def find_spec(
+        self, fullname: str, path: Sequence[str] | None, target: ModuleType | None = None,
+    ) -> machinery.ModuleSpec | None:
+        spec = machinery.PathFinder.find_spec(fullname, path)
+        origin = spec.origin if spec is not None else None
+        if spec is None or origin is None or not origin.endswith(".py"):
+            return None  # not project source: let the normal finders handle it
+        file = Path(origin).resolve()
+        if not any(file.is_relative_to(root) for root in self.roots):
+            return None
+        errors = self._errors(file)
+        if errors:
+            raise ImportGateError(str(file), errors, name=fullname)
+        return spec
+
+    def _errors(self, file: Path) -> list[Diagnostic]:
+        digest = hashlib.sha256(file.read_bytes()).hexdigest()
+        key = str(file)
+        cached = self._cache.get(key)
+        if cached is not None and cached[0] == digest:
+            return cached[1]
+        errors = [d for d in _run_gate([file], self.roots) if d.severity == "error"]
+        self._cache[key] = (digest, errors)
+        return errors
+
+
+def install(source_roots: Sequence[str | Path]) -> ImportGateFinder:
+    """Install the gate for modules under `source_roots`, replacing an installed one."""
+    uninstall()
+    finder = ImportGateFinder([Path(r) for r in source_roots])
+    sys.meta_path.insert(0, finder)
+    return finder
+
+
+def uninstall() -> None:
+    """Remove the gate; imports are then ungated."""
+    sys.meta_path[:] = [f for f in sys.meta_path if not isinstance(f, ImportGateFinder)]
+
+
+def install_from_env() -> bool:
+    """Development-mode switch: install when `TYPEDPYTHON_IMPORT_GATE` lists source roots."""
+    roots = [r for r in os.environ.get(ENV_VAR, "").split(os.pathsep) if r]
+    if not roots:
+        return False
+    install(roots)
+    return True
@@ -177,3 +177,9 @@ per-interpreter counter that only grows and, once it wraps to 0, assigns nothing
 gets at most MAX_VERSIONS_PER_CLASS (1000) tags. So a tag never repeats within an interpreter and a
 class whose tags are exhausted keeps 0 (never current). Py_TPFLAGS_VALID_VERSION_TAG is "Unused.
 Legacy flag" in 3.14 (never set) and is not consulted.
+
+## Development-mode import gate (Python API, not C; SPEC N-7b)
+    typedpython.importgate.install(source_roots)   # meta path finder; checks project modules before they run
+    typedpython.importgate.uninstall()
+    typedpython.importgate.install_from_env()      # installs when TYPEDPYTHON_IMPORT_GATE=<roots, os.pathsep-separated>
+A type error raises `ImportGateError` (an `ImportError`, `.diagnostics` holds the gate's errors) and the module's code does not run. Only files under the roots are checked; results are cached by content hash. Do not call it in release builds.
@@ -0,0 +1,144 @@
+"""Import-time type gate (SPEC N-7b, #183): development-mode import hook."""
+from __future__ import annotations
+
+import importlib
+import sys
+
+import pytest
+
+from typedpython import gate, importgate
+
+BAD = """\
+from pathlib import Path
+Path(__file__).with_name("marker.txt").write_text("ran")
+
+def f(x: int) -> int:
+    return x
+
+f("not an int")
+"""
+
+GOOD = "VALUE: int = 1\n"
+
+
+@pytest.fixture
+def project(tmp_path, monkeypatch):
+    """A fresh source root on sys.path; the hook and imported modules are cleaned up afterwards."""
+    root = tmp_path / "src"
+    root.mkdir()
+    monkeypatch.syspath_prepend(str(root))
+    before = set(sys.modules)
+    yield root
+    importgate.uninstall()
+    for name in set(sys.modules) - before:
+        del sys.modules[name]
+    importlib.invalidate_caches()
+
+
+@pytest.fixture
+def calls(monkeypatch):
+    """Paths handed to the checker, one list per checker invocation (the seam)."""
+    seen: list[list[str]] = []
+    real = importgate._run_gate
+
+    def counting(paths, search_paths):
+        seen.append([str(p) for p in paths])
+        return real(paths, search_paths)
+
+    monkeypatch.setattr(importgate, "_run_gate", counting)
+    return seen
+
+
+def test_type_error_stops_import_before_module_code_runs(project):
+    (project / "bad_mod.py").write_text(BAD)
+    importgate.install([project])
+    with pytest.raises(ImportError) as info:
+        importlib.import_module("bad_mod")
+    assert isinstance(info.value, importgate.ImportGateError)
+    assert info.value.diagnostics
+    assert all(d.severity == "error" for d in info.value.diagnostics)
+    assert "bad_mod.py" in str(info.value)
+    assert not (project / "marker.txt").exists()
+    assert "bad_mod" not in sys.modules
+
+
+def test_same_module_imports_without_the_hook(project):
+    (project / "bad_mod2.py").write_text(BAD)
+    importlib.import_module("bad_mod2")
+    assert (project / "marker.txt").exists()
+
+
+def test_uninstall_restores_normal_import(project):
+    (project / "bad_mod3.py").write_text(BAD)
+    importgate.install([project])
+    importgate.uninstall()
+    importlib.import_module("bad_mod3")
+    assert (project / "marker.txt").exists()
+
+
+def test_clean_module_imports_and_is_cached_by_content(project, calls):
+    path = project / "good_mod.py"
+    path.write_text(GOOD)
+    importgate.install([project])
+    mod = importlib.import_module("good_mod")
+    assert mod.VALUE == 1
+    assert len(calls) == 1
+
+    del sys.modules["good_mod"]
+    importlib.import_module("good_mod")
+    assert len(calls) == 1, "an unchanged module must not be checked again"
+
+    del sys.modules["good_mod"]
+    path.write_text("VALUE: int = 2\n")
+    assert importlib.import_module("good_mod").VALUE == 2
+    assert len(calls) == 2, "changed content must be re-checked"
+
+
+def test_failing_result_is_cached_too(project, calls):
+    (project / "bad_mod4.py").write_text(BAD)
+    importgate.install([project])
+    for _ in range(2):
+        with pytest.raises(importgate.ImportGateError):
+            importlib.import_module("bad_mod4")
+    assert len(calls) == 1
+
+
+def test_modules_outside_source_roots_and_stdlib_are_not_checked(project, tmp_path, monkeypatch, calls):
+    other = tmp_path / "deps"
+    other.mkdir()
+    (other / "dep_mod.py").write_text(BAD.replace("marker.txt", "dep_marker.txt"))
+    monkeypatch.syspath_prepend(str(other))
+    importgate.install([project])
+    importlib.import_module("dep_mod")  # a type error, but outside the roots
+    importlib.import_module("colorsys")  # stdlib
+    assert calls == []
+    assert (other / "dep_marker.txt").exists()
+
+
+def test_package_submodule_under_root_is_checked(project, calls):
+    pkg = project / "pkg"
+    pkg.mkdir()
+    (pkg / "__init__.py").write_text("")
+    (pkg / "sub.py").write_text("def f(x):\n    return x\n")
+    importgate.install([project])
+    with pytest.raises(importgate.ImportGateError):
+        importlib.import_module("pkg.sub")
+    assert any(p.endswith("sub.py") for c in calls for p in c)
+
+
+def test_install_twice_installs_one_finder(project):
+    importgate.install([project])
+    importgate.install([project])
+    assert sum(isinstance(f, importgate.ImportGateFinder) for f in sys.meta_path) == 1
+    importgate.uninstall()
+    assert not any(isinstance(f, importgate.ImportGateFinder) for f in sys.meta_path)
+
+
+def test_install_from_env(project, monkeypatch):
+    monkeypatch.delenv(importgate.ENV_VAR, raising=False)
+    assert importgate.install_from_env() is False
+    monkeypatch.setenv(importgate.ENV_VAR, str(project))
+    assert importgate.install_from_env() is True
+    (project / "bad_mod5.py").write_text(BAD)
+    with pytest.raises(importgate.ImportGateError):
+        importlib.import_module("bad_mod5")