@@ -0,0 +1,58 @@
+"""Collection-name collision refusal — the single choke point every route/router/
+finder generator path goes through (called once, in ``run_gen``, over the full
+entity set BEFORE any generator runs).
+
+Two DISTINCT entities/projections pluralizing to the SAME API-surface collection
+name (REST path, generated router module/finder names) is reachable from stock
+metadata now that :func:`metaobjects.apidocs.naming.pluralize` no longer doubles an
+already-plural word: ``Address`` (not already-plural: legacy-pluralizes to
+``Addresses``) and ``Addresses`` (already-plural: left unchanged, ALSO
+``Addresses``) collide, where before the fix they did not (``Addresses`` legacy-
+pluralized to ``Addresseses``). Silently letting two entities share one collection
+name would mean whichever generator runs second silently wins, or a straight
+duplicate-module/route registration two files downstream of the real cause. This
+refuses at the one place that can see the WHOLE set, with a message naming both
+entities and the colliding name.
+"""
+from __future__ import annotations
+
+from metaobjects.apidocs.naming import pluralize
+from metaobjects.errors import ErrorCode
+from metaobjects.meta.core.object.meta_object import MetaObject
+from metaobjects.meta.core.object.object_constants import OBJECT_SUBTYPE_VALUE
+
+ERR_COLLECTION_NAME_COLLISION = ErrorCode.ERR_COLLECTION_NAME_COLLISION.value
+
+
+def assert_no_collection_name_collisions(entities: list[MetaObject]) -> None:
+    """Refuse a generation run in which two DISTINCT entities/projections pluralize
+    to the same API-surface collection name.
+
+    Scope: every object EXCEPT ``object.value`` (a value object never gets a route,
+    router module, or finder name — it is pure shape, so it cannot collide on any of
+    those). A TPH subtype IS included: it gets its own generated names against the
+    shared base table, so two subtypes (or a subtype and an unrelated top-level
+    entity) sharing a pluralized name collide on those generated symbols exactly as
+    two top-level entities would.
+
+    A PURE function of the entity set — never of traversal order: the reported pair
+    is deterministic (first-seen-by-input-order "owner" of a plural; raised as soon
+    as a second, different entity claims the same plural).
+    """
+    owner_of_plural: dict[str, MetaObject] = {}
+    for obj in entities:
+        if obj.sub_type == OBJECT_SUBTYPE_VALUE:
+            continue
+        plural = pluralize(obj.name)
+        existing = owner_of_plural.get(plural)
+        if existing is not None:
+            if existing.resolution_key() != obj.resolution_key():
+                raise ValueError(
+                    f"{ERR_COLLECTION_NAME_COLLISION}: \"{existing.name}\" and \"{obj.name}\" both "
+                    f'pluralize to the API-surface collection name "{plural}" (REST path, generated '
+                    "router module/finder names) — rename one entity so its pluralized name is "
+                    "distinct. Default PHYSICAL table names are unaffected by this rule and are not "
+                    "involved in the collision."
+                )
+        else:
+            owner_of_plural[plural] = obj
@@ -10,6 +10,7 @@
 from metaobjects.meta.meta_data import MetaData
 from metaobjects.meta.core.object.meta_object import MetaObject
 from metaobjects.shared.base_types import TYPE_OBJECT
+from .collection_name_collision import assert_no_collection_name_collisions
 from .config import GenConfig
 from .constants import generated_package_init
 from .generator import GenContext, Generator
@@ -107,6 +108,10 @@ def run_gen(
     if not safe:
         return result
 
+    # Refuse before any generator runs — the one choke point that sees the WHOLE
+    # entity set every route/router-emitting generator below reads from.
+    assert_no_collection_name_collisions(safe)
+
     emitted: dict[str, tuple[str, str]] = {}  # full_path -> (content, generated_by)
     for gen in generators:
         ctx = GenContext(
 
@@ -200,6 +200,12 @@ class ErrorCode(str, Enum):
     # Codegen (ADR-0044): two value-object FQNs in one payload artifact derive the same
     # emitted record name even after package-qualification. Peer of ERR_VAR_NOT_ON_PAYLOAD.
     ERR_PAYLOAD_NAME_COLLISION = "ERR_PAYLOAD_NAME_COLLISION"
+    # Codegen: two DISTINCT entities/projections in one generation run pluralize to the
+    # SAME API-surface collection name (route path, generated router/finder names) —
+    # e.g. "Address" and "Addresses" both resolving to "Addresses". A codegen-time (not
+    # loader) error, peer of ERR_PAYLOAD_NAME_COLLISION: refused rather than silently
+    # letting one entity's route win.
+    ERR_COLLECTION_NAME_COLLISION = "ERR_COLLECTION_NAME_COLLISION"
     ERR_OUTPUT_TAG_MISSING = "ERR_OUTPUT_TAG_MISSING"
     # SP-H Unit9 — @filterable: true on a field subtype with no filter-operator
     # band (e.g. field.object). Would silently generate an empty-ops filter.
 
@@ -0,0 +1,109 @@
+"""assert_no_collection_name_collisions — the single choke point every route/router
+generator path goes through (called once, in run_gen, over the full entity set
+BEFORE any generator runs). See collection_name_collision.py's module docstring.
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from metaobjects import MetaDataLoader
+from metaobjects.meta.core.object.meta_object import MetaObject
+from metaobjects.shared.base_types import TYPE_OBJECT
+from metaobjects.codegen.collection_name_collision import (
+    ERR_COLLECTION_NAME_COLLISION,
+    assert_no_collection_name_collisions,
+)
+
+_NAMING_CONFORMANCE_FIXTURE = (
+    Path(__file__).parents[4] / "fixtures" / "naming-conformance" / "already-plural-pluralize.json"
+)
+
+
+def _entities(tmp_path: Path, *names: str) -> list:
+    children = [
+        {
+            "object.entity": {
+                "name": name,
+                "children": [
+                    {"source.rdb": {"@table": name.lower()}},
+                    {"field.long": {"name": "id"}},
+                    {"identity.primary": {"@fields": "id"}},
+                ],
+            }
+        }
+        for name in names
+    ]
+    meta_dir = tmp_path / "meta"
+    meta_dir.mkdir(parents=True, exist_ok=True)
+    (meta_dir / "meta.json").write_text(
+        json.dumps({"metadata.root": {"package": "acme", "children": children}})
+    )
+    root = MetaDataLoader.from_directory(meta_dir).root
+    return [c for c in root.own_children() if c.type == TYPE_OBJECT and isinstance(c, MetaObject)]
+
+
+def _entity_and_value(tmp_path: Path, entity_name: str, value_name: str) -> list:
+    doc = {
+        "metadata.root": {
+            "package": "acme",
+            "children": [
+                {
+                    "object.entity": {
+                        "name": entity_name,
+                        "children": [
+                            {"source.rdb": {"@table": entity_name.lower()}},
+                            {"field.long": {"name": "id"}},
+                            {"identity.primary": {"@fields": "id"}},
+                        ],
+                    }
+                },
+                {
+                    "object.value": {
+                        "name": value_name,
+                        "children": [{"field.string": {"name": "text"}}],
+                    }
+                },
+            ],
+        }
+    }
+    meta_dir = tmp_path / "meta"
+    meta_dir.mkdir(parents=True, exist_ok=True)
+    (meta_dir / "meta.json").write_text(json.dumps(doc))
+    root = MetaDataLoader.from_directory(meta_dir).root
+    return [c for c in root.own_children() if c.type == TYPE_OBJECT and isinstance(c, MetaObject)]
+
+
+def test_does_not_raise_for_distinct_plurals(tmp_path: Path) -> None:
+    assert_no_collection_name_collisions(_entities(tmp_path, "Post", "Author", "Category"))
+
+
+def test_raises_for_address_and_addresses(tmp_path: Path) -> None:
+    with pytest.raises(ValueError) as exc_info:
+        assert_no_collection_name_collisions(_entities(tmp_path, "Address", "Addresses"))
+    msg = str(exc_info.value)
+    assert ERR_COLLECTION_NAME_COLLISION in msg
+    assert "Address" in msg
+    assert "Addresses" in msg
+
+
+def test_raises_for_order_and_orders(tmp_path: Path) -> None:
+    with pytest.raises(ValueError):
+        assert_no_collection_name_collisions(_entities(tmp_path, "Order", "Orders"))
+
+
+def test_excludes_value_objects(tmp_path: Path) -> None:
+    # "Address" (entity) pluralizes to "Addresses"; an unrelated object.value named
+    # "Addresses" never gets a route, so it must not trip this.
+    assert_no_collection_name_collisions(_entity_and_value(tmp_path, "Address", "Addresses"))
+
+
+def test_naming_conformance_collision_cases_are_refused(tmp_path: Path) -> None:
+    cases = json.loads(_NAMING_CONFORMANCE_FIXTURE.read_text())["collisionCases"]
+    for i, case in enumerate(cases):
+        with pytest.raises(ValueError):
+            assert_no_collection_name_collisions(
+                _entities(tmp_path / str(i), case["entityA"], case["entityB"])
+            )
@@ -210,3 +210,24 @@ def test_the_no_manifest_refusal_leads_with_the_performable_remedy(tmp_path: Pat
     assert "--baseline=adopt" in msgs[0]
     # What it must no longer do: prescribe committing a file this project cannot produce.
     assert "Commit '.metaobjects/.gen-state/.hashes.json' and re-run" not in msgs[0]
+
+
+def test_run_gen_refuses_a_model_with_colliding_collection_names(tmp_path: Path) -> None:
+    """Integration-level: proves the collision gate is wired into the real entry
+    point (run_gen), not just callable as a standalone function. Address +
+    Addresses both pluralize to "Addresses" — reachable now that an already-
+    plural entity name is no longer double-pluralized."""
+    root = _load(tmp_path / "meta", {"metadata.root": {"package": "acme", "children": [
+        {"object.entity": {"name": "Address", "children": [
+            {"source.rdb": {"@table": "address"}},
+            {"field.long": {"name": "id"}},
+            {"identity.primary": {"@fields": "id"}},
+        ]}},
+        {"object.entity": {"name": "Addresses", "children": [
+            {"source.rdb": {"@table": "addresses"}},
+            {"field.long": {"name": "id"}},
+            {"identity.primary": {"@fields": "id"}},
+        ]}},
+    ]}})
+    with pytest.raises(ValueError):
+        run_gen(GenConfig(out_dir=str(tmp_path / "out")), root, generators=[entity_model()])