@@ -12,7 +12,7 @@ class PlainModuleRenderState:
     last_render_module: PlainModule
     last_render_frid: str | None
     change: PlainModule | None = None
-    change_type: Literal["spec_change", "code_change"] | None = None
+    change_type: Literal["spec_change", "code_change", "missing_conformance_tests"] | None = None
 
 
 @dataclass
@@ -56,6 +56,19 @@ def code_change(plain_module: PlainModule) -> PlainModule | None:
     return None
 
 
+def archive_missing_conformance_tests(plain_module: PlainModule, render_conformance_tests: bool) -> PlainModule | None:
+    """Return the first module available only as a "<module>.module" archive that has no conformance
+    tests while conformance testing is enabled. Such an archive cannot be consumed as-is (regression
+    needs the tests), so the module must be re-rendered."""
+    if not render_conformance_tests:
+        return None
+    all_modules = plain_module.all_required_modules + [plain_module]
+    for _module in all_modules:
+        if _module.is_archived_only() and not _module.archive_has_conformance_tests():
+            return _module
+    return None
+
+
 def module_comes_before_or_equal(
     all_required_modules: list[PlainModule],
     module1: PlainModule,
@@ -70,15 +83,24 @@ def module_comes_before_or_equal(
     raise ValueError(f"Module {module1.module_name} and {module2.module_name} not found in {all_required_modules}")
 
 
-def get_plain_module_render_state(plain_module: PlainModule) -> PlainModuleRenderState | None:
+def get_plain_module_render_state(
+    plain_module: PlainModule, render_conformance_tests: bool = False
+) -> PlainModuleRenderState | None:
     sc = spec_change(plain_module)
     cc = code_change(plain_module)
+    mt = archive_missing_conformance_tests(plain_module, render_conformance_tests)
     all_required_modules = plain_module.all_required_modules
     last_rendered_module_name, last_rendered_frid = plain_module.get_module_render_status()
-    if last_rendered_module_name is None and last_rendered_frid is None:
+    if last_rendered_module_name is None and last_rendered_frid is None and mt is None:
         return None
 
-    if last_rendered_module_name == plain_module.module_name:
+    if last_rendered_module_name is None:
+        # Nothing has been rendered yet, but an archived module blocks consumption (no tests).
+        # Anchor the state on that module so the user is prompted to re-render it.
+        assert mt is not None  # guaranteed by the early return above
+        module = mt
+        last_rendered_frid = None
+    elif last_rendered_module_name == plain_module.module_name:
         module = plain_module
     else:
         found_module: PlainModule | None = None
@@ -99,6 +121,13 @@ def get_plain_module_render_state(plain_module: PlainModule) -> PlainModuleRende
         change_type=None,
     )
 
+    # An archive that lacks conformance tests (while testing is enabled) is a hard blocker: it cannot
+    # be consumed as-is, so it takes precedence over spec/code changes.
+    if mt is not None:
+        pr.change = mt
+        pr.change_type = "missing_conformance_tests"
+        return pr
+
     if sc is None and cc is None:
         return pr
 
@@ -129,6 +158,8 @@ def get_all_affected_modules_from_change(
             start_module = plain_module.get_next_module(plain_module_render_state.change.module_name)
         else:
             start_module = plain_module_render_state.change
+    elif plain_module_render_state.change_type == "missing_conformance_tests":
+        start_module = plain_module_render_state.change
     else:
         raise ValueError(f"Unknown change type: {plain_module_render_state.change_type}")
 
 
@@ -216,7 +216,11 @@ def render(  # noqa: C901
 
     # A built module can be distributed as a "<module>.module" zip archive instead of an unpacked directory.
     # Extract any such module to a scratch location up front. Scratch dirs are removed in main()'s finally.
+    # Skip an archive-only module that lacks conformance tests while testing is enabled: it cannot be
+    # consumed as-is, so leave it unmaterialized so it is detected below as needing a re-render.
     for module in plain_module.all_required_modules + [plain_module]:
+        if args.render_conformance_tests and module.is_archived_only() and not module.archive_has_conformance_tests():
+            continue
         module.materialize()
 
     # The module_metadata file lives outside the code git repo. That means that a crash mid-render can leave it
@@ -227,7 +231,7 @@ def render(  # noqa: C901
 
     render_choice = None
     if render_range is None:
-        plain_module_render_state = get_plain_module_render_state(plain_module)
+        plain_module_render_state = get_plain_module_render_state(plain_module, args.render_conformance_tests)
         if plain_module_render_state is not None:
             render_choices = get_render_choices(plain_module, plain_module_render_state, args.force_render)
             ask_user = True
 
@@ -50,34 +50,44 @@ def get_module_tests_folder(modules_base_folder: str, module_name: str) -> str:
     return os.path.join(modules_base_folder, module_name, MODULE_TESTS_SUBFOLDER)
 
 
-def _validate_module_tree(root: str, archive_path: str) -> None:
-    """Verify an extracted module tree has valid code/ and tests/ git repositories."""
-    for subfolder in (MODULE_CODE_SUBFOLDER, MODULE_TESTS_SUBFOLDER):
-        repo_path = os.path.join(root, subfolder)
-        if not os.path.isdir(repo_path):
-            raise InvalidModuleArchiveError(
-                f"Module archive '{archive_path}' is missing the '{subfolder}/' folder at its root. "
-                "The archive must contain the module folder's contents (code/, tests/, ...) at its "
-                "root, not nested under a top-level directory."
-            )
-        if not os.path.isdir(os.path.join(repo_path, ".git")):
+def _validate_module_repo(repo_path: str, subfolder: str, archive_path: str) -> None:
+    """Validate one extracted git repo (code/ or tests/) inside a module archive."""
+    if not os.path.isdir(os.path.join(repo_path, ".git")):
+        raise InvalidModuleArchiveError(
+            f"Module archive '{archive_path}' has no git repository in '{subfolder}/' "
+            "(the archive must include the '.git' directory)."
+        )
+    try:
+        repo = Repo(repo_path)
+        if repo.bare or repo.head.is_detached:
             raise InvalidModuleArchiveError(
-                f"Module archive '{archive_path}' has no git repository in '{subfolder}/' "
-                "(the archive must include the '.git' directory)."
+                f"The git repository in '{subfolder}/' of module archive '{archive_path}' "
+                "must be a working tree checked out on a branch."
             )
-        try:
-            repo = Repo(repo_path)
-            if repo.bare or repo.head.is_detached:
-                raise InvalidModuleArchiveError(
-                    f"The git repository in '{subfolder}/' of module archive '{archive_path}' "
-                    "must be a working tree checked out on a branch."
-                )
-        except InvalidModuleArchiveError:
-            raise
-        except Exception as e:
-            raise InvalidModuleArchiveError(
-                f"The git repository in '{subfolder}/' of module archive '{archive_path}' is invalid: {e}"
-            ) from e
+    except InvalidModuleArchiveError:
+        raise
+    except Exception as e:
+        raise InvalidModuleArchiveError(
+            f"The git repository in '{subfolder}/' of module archive '{archive_path}' is invalid: {e}"
+        ) from e
+
+
+def _validate_module_tree(root: str, archive_path: str) -> None:
+    """Verify an extracted module tree. ``code/`` is required. ``tests/`` is optional: a module
+    rendered without a conformance-tests script has no tests folder, so its archive has none either.
+    When ``tests/`` is present it must be a valid git repo."""
+    code_path = os.path.join(root, MODULE_CODE_SUBFOLDER)
+    if not os.path.isdir(code_path):
+        raise InvalidModuleArchiveError(
+            f"Module archive '{archive_path}' is missing the '{MODULE_CODE_SUBFOLDER}/' folder at its root. "
+            "The archive must contain the module folder's contents (code/, optionally tests/, ...) at its "
+            "root, not nested under a top-level directory."
+        )
+    _validate_module_repo(code_path, MODULE_CODE_SUBFOLDER, archive_path)
+
+    tests_path = os.path.join(root, MODULE_TESTS_SUBFOLDER)
+    if os.path.isdir(tests_path):
+        _validate_module_repo(tests_path, MODULE_TESTS_SUBFOLDER, archive_path)
 
 
 def _extract_module_archive(archive_path: str, dest: str) -> None:
@@ -199,6 +209,15 @@ def has_module_archive(self) -> bool:
     def is_archived_only(self) -> bool:
         return not os.path.isdir(self._default_module_folder) and self.has_module_archive()
 
+    def archive_has_conformance_tests(self) -> bool:
+        """True if the "<module>.module" archive contains a tests/ folder. A module rendered without
+        a conformance-tests script has no tests/, so its archive has none either."""
+        if not self.has_module_archive() or not zipfile.is_zipfile(self.module_archive_path):
+            return False
+        prefix = MODULE_TESTS_SUBFOLDER + "/"
+        with zipfile.ZipFile(self.module_archive_path) as zf:
+            return any(name.startswith(prefix) for name in zf.namelist())
+
     def materialize(self) -> None:
         """Make an archive-only module readable without populating plain_modules/<module>/.
 
 
@@ -554,6 +554,38 @@ def test_code_hash_is_location_independent(fixtures_dir):
         assert mod_a.get_module_code_hash() == mod_b.get_module_code_hash()
 
 
+def test_archive_has_conformance_tests(solo_module):
+    _setup_full_module(solo_module)  # code/ + tests/
+    _archive_module(solo_module)
+    assert solo_module.archive_has_conformance_tests() is True
+
+
+def test_code_only_archive_materializes_without_tests(solo_module):
+    """A module rendered with conformance tests off has no tests/, so its archive has none. It must
+    still validate and materialize (tests/ is optional)."""
+    _init_repo_with_finished_frid(solo_module.module_build_folder, solo_module.module_name, "1")
+    _write_metadata(solo_module, {"source_hash": "seed"})
+    _archive_module(solo_module)  # code/ + .codeplain, no tests/
+
+    assert solo_module.archive_has_conformance_tests() is False
+    assert solo_module.is_archived_only()
+
+    solo_module.materialize()  # must not raise
+    assert os.path.isdir(os.path.join(solo_module.module_build_folder, ".git"))
+    assert not os.path.isdir(solo_module.module_conformance_tests_folder)
+    solo_module.cleanup_scratch()
+
+
+def test_ensure_module_unpacked_code_only_archive(solo_module):
+    _init_repo_with_finished_frid(solo_module.module_build_folder, solo_module.module_name, "1")
+    _archive_module(solo_module)  # code/ only
+
+    solo_module.ensure_module_unpacked()
+    assert os.path.isdir(os.path.join(solo_module._default_module_folder, "code", ".git"))
+    assert not os.path.isdir(os.path.join(solo_module._default_module_folder, "tests"))
+    assert not os.path.exists(solo_module.module_archive_path)
+
+
 def test_materialize_rejects_non_zip(solo_module):
     with open(solo_module.module_archive_path, "w") as f:
         f.write("not a zip")
 
@@ -19,6 +19,7 @@
 import pytest
 
 from git_utils import FUNCTIONAL_REQUIREMENT_FINISHED_COMMIT_MESSAGE, add_all_files_and_commit, init_git_repo
+from partial_rendering import archive_missing_conformance_tests, get_plain_module_render_state, get_render_choices
 from plain_modules import PlainModule
 from render_machine.actions.prepare_repositories import PrepareRepositories
 from render_machine.conformance_tests import CONFORMANCE_TESTS_DEFINITION_FILE_NAME, ConformanceTests
@@ -183,6 +184,43 @@ def test_full_render_clones_from_archived_required_module(root_module):
     previous.cleanup_scratch()
 
 
+def test_archive_missing_conformance_tests_detects_code_only_required_module(root_module):
+    """A required module shipped as a code-only .module (no tests/) is flagged only when conformance
+    testing is enabled."""
+    previous = root_module.required_modules[-1]
+    _init_repo_with_finished_frid(previous.module_build_folder, previous.module_name)
+    _archive_module(previous)  # code/ only, no tests/
+
+    assert archive_missing_conformance_tests(root_module, True) is previous
+    assert archive_missing_conformance_tests(root_module, False) is None
+
+
+def test_archive_with_tests_not_flagged(root_module):
+    previous = root_module.required_modules[-1]
+    _init_repo_with_finished_frid(previous.module_build_folder, previous.module_name)
+    _init_repo_with_finished_frid(previous.module_conformance_tests_folder, previous.module_name)
+    _archive_module(previous)  # code/ + tests/
+
+    assert archive_missing_conformance_tests(root_module, True) is None
+
+
+def test_render_state_flags_missing_tests_and_offers_rerender(root_module):
+    """A code-only archive (conformance on) surfaces a 'missing_conformance_tests' render state with
+    a rerender choice and a quit choice."""
+    previous = root_module.required_modules[-1]
+    _init_repo_with_finished_frid(previous.module_build_folder, previous.module_name)
+    _archive_module(previous)  # code/ only
+
+    state = get_plain_module_render_state(root_module, render_conformance_tests=True)
+    assert state is not None
+    assert state.change_type == "missing_conformance_tests"
+    assert state.change.module_name == previous.module_name
+
+    choice_types = {c.choice_type for c in get_render_choices(root_module, state).values()}
+    assert "quit" in choice_types
+    assert "rerender_affected" in choice_types
+
+
 def test_conformance_tests_resolver_overrides_default(tmp_build_folder):
     """A resolver maps an archived required module's name to its resolved (scratch) tests folder;
     unknown names fall back to the default base-folder path."""
 
@@ -118,21 +118,38 @@ def on_mount(self) -> None:
         info_panel.mount(change_box)
 
         if pr.change:
-            title_start = "Spec changes" if pr.change_type == "spec_change" else "Code changes"
             is_required_module = pr.change.module_name != self.plain_module.module_name
-            change_box.mount(
-                Label(
-                    f"--- {title_start} detected in {'required ' if is_required_module else 'current '}module [#5593FF]{pr.change.module_name}[/] ---",
-                    classes="rendering-info-row",
+            module_kind = "required " if is_required_module else "current "
+            if pr.change_type == "missing_conformance_tests":
+                change_box.mount(
+                    Label(
+                        f"--- Conformance tests missing from the archive of {module_kind}module "
+                        f"[#5593FF]{pr.change.module_name}[/] ---",
+                        classes="rendering-info-row",
+                    )
                 )
-            )
-            if is_required_module:
                 change_box.mount(
                     Label(
-                        f"{title_start} in a required module may affect the current module",
+                        "The .module archive has no conformance tests but testing is enabled; "
+                        "the module must be re-rendered (its .module file will be removed).",
                         classes="rendering-info-title",
                     )
                 )
+            else:
+                title_start = "Spec changes" if pr.change_type == "spec_change" else "Code changes"
+                change_box.mount(
+                    Label(
+                        f"--- {title_start} detected in {module_kind}module [#5593FF]{pr.change.module_name}[/] ---",
+                        classes="rendering-info-row",
+                    )
+                )
+                if is_required_module:
+                    change_box.mount(
+                        Label(
+                            f"{title_start} in a required module may affect the current module",
+                            classes="rendering-info-title",
+                        )
+                    )
 
         elif pr.last_render_module.is_module_fully_rendered():
             change_box.mount(Label("The current module is fully rendered.", classes="rendering-info-title"))