metaobjects 0.24.4__tar.gz → 0.24.5__tar.gz

{metaobjects-0.24.4 → metaobjects-0.24.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: metaobjects
-Version: 0.24.4
+Version: 0.24.5
 Summary: Cross-language metadata standard: declare typed entities once, generate idiomatic drift-checked code across languages — Python port.
 Project-URL: Homepage, https://metaobjects.dev
 Project-URL: Repository, https://github.com/metaobjectsdev/metaobjects

{metaobjects-0.24.4 → metaobjects-0.24.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "metaobjects"
-version = "0.24.4"
+version = "0.24.5"
 description = "Cross-language metadata standard: declare typed entities once, generate idiomatic drift-checked code across languages — Python port."
 readme = "README.md"
 requires-python = ">=3.11"

{metaobjects-0.24.4 → metaobjects-0.24.5}/src/metaobjects/agent_context/scaffold.py

@@ -10,6 +10,7 @@ installed MetaObjects version.
 
 from __future__ import annotations
 
+import re
 from dataclasses import dataclass
 from importlib.metadata import PackageNotFoundError, version as _pkg_version
 
@@ -76,6 +77,61 @@ class Manifest:
         )
 
 
+# The sentinel a port stamps when it cannot resolve its own installed version.
+_UNRESOLVED_VERSION = "0.0.0"
+
+_RELEASE_RE = re.compile(r"^(\d+)\.(\d+)\.(\d+)$")
+
+
+def _release_series(version: object) -> tuple[int, int] | None:
+    """Ordered release coordinate ``(minor, patch)``, or ``None`` when not orderable.
+
+    The MAJOR is deliberately dropped. It is a per-registry constant, not information:
+    npm/PyPI/NuGet ship ``0.<m>.<p>`` and Maven Central the same ``<m>.<p>`` on its
+    historical major ``7``, so minor.patch IS the shared release coordinate across all
+    four ports.
+
+    ``None`` means "not orderable, so nudge", and deliberately covers prereleases
+    (``0.24.5-rc.1``), build metadata (``0.24.5+abc``) and the ``0.0.0`` sentinel. Each
+    must keep nudging: an RC-scaffolded context against a final release is still worth
+    refreshing, and an unknown install must never assert "in sync".
+    """
+    if not isinstance(version, str):
+        return None
+    v = version.strip()
+    if v == _UNRESOLVED_VERSION:
+        return None
+    m = _RELEASE_RE.match(v)
+    if m is None:
+        return None
+    return int(m.group(2)), int(m.group(3))
+
+
+def _context_is_ahead_of_install(generated_by: object, current_version: str) -> bool:
+    """True when the manifest was stamped by a release STRICTLY NEWER than the install.
+
+    The one exemption from "any drift nudges", and it exists because of the
+    publish-what-changed rule (docs/RELEASING.md): a registry publishes only when it has
+    a changed product file, so a port legitimately sits behind npm — while
+    ``meta agent-docs``, the canonical scaffolder for EVERY port, stamps the npm version
+    it was run from. A Python install at ``0.24.4`` whose context was scaffolded by npm
+    ``0.24.7`` is correct, and nudging it is issue #347 exactly: the remedy re-runs the
+    scaffolder, which re-stamps ``0.24.7``, so the advisory can never be satisfied and
+    fires on every build forever.
+
+    KNOWN BOUND, stated rather than hidden: ordering on minor.patch assumes both versions
+    sit in the same release SERIES. That holds for every release to date and after the
+    1.0/8.0 cut, but not ACROSS it — there a ``0.24.x`` context against a ``1.0.0``
+    install reads as "ahead" and the nudge is suppressed once. A missed advisory, never a
+    wrong action.
+    """
+    stamped = _release_series(generated_by)
+    installed = _release_series(current_version)
+    if stamped is None or installed is None:
+        return False  # not orderable → nudge
+    return stamped > installed
+
+
 def agent_context_staleness(
     manifest: dict[str, object] | None, current_version: str
 ) -> str | None:
@@ -85,15 +141,18 @@ def agent_context_staleness(
     is in sync — and a one-line advisory message otherwise. Pure + advisory:
     never raises, never blocks, never writes.
 
-    The comparison is **exact equality** on purpose: ANY drift nudges (a
-    re-scaffold is cheap + idempotent). Do NOT "fix" this into a semver compare —
-    a prerelease/build-metadata difference is still a reason to refresh.
+    The comparison is **exact equality** first: ANY drift nudges (a re-scaffold is
+    cheap + idempotent), so this is not a semver compare — a prerelease or
+    build-metadata difference is still a reason to refresh. See
+    ``_context_is_ahead_of_install`` for the ONE case that is exempt.
     """
     if manifest is None:
         return None  # no agent context here → nothing to nudge
     generated_by = manifest.get("generatedBy")
     if generated_by == current_version:
         return None  # in sync
+    if _context_is_ahead_of_install(generated_by, current_version):
+        return None  # scaffolded by a NEWER release than this install — see below
     frm = generated_by if generated_by else "an older MetaObjects"
     return (
         f"MetaObjects agent context was generated by {frm}; "

{metaobjects-0.24.4 → metaobjects-0.24.5}/src/metaobjects/codegen/config.py

@@ -3,6 +3,8 @@ from __future__ import annotations
 
 from dataclasses import dataclass, field
 
+from metaobjects.naming import DEFAULT_COLUMN_NAMING
+
 
 @dataclass
 class GenConfig:
@@ -23,5 +25,12 @@ class GenConfig:
     # maps a declaring metadata package ("acme::shop") to the Python import module; with a
     # single ``provided_enum_namespace`` fallback for the one-module case. A referenced
     # @provided enum whose package resolves to no module is a codegen-time error.
+    # How a field with no explicit `@column` becomes a physical column name
+    # ("literal" | "snake_case" | "kebab-case"). Config, never metadata: the same model
+    # must be able to drive a snake_case schema and a literal-column one. Defaults to
+    # `literal`, this port's historical behaviour — but `meta migrate`, which owns
+    # schema for EVERY port (ADR-0015), defaults to `snake_case`, so a project whose
+    # tables it created wants `snake_case` here or an explicit `@column` per field.
+    column_naming: str = DEFAULT_COLUMN_NAMING
     provided_enum_namespace: str | None = None
     provided_enum_packages: dict[str, str] = field(default_factory=dict)

{metaobjects-0.24.4 → metaobjects-0.24.5}/src/metaobjects/codegen/generators/entity_model.py

@@ -339,13 +339,20 @@ def _field_line(field: MetaField, imports: set[str], config: GenConfig) -> tuple
     else:
         assignment = " = None"
 
-    # Pydantic field name = @column when present, else field.name. A cross-port
-    # entity carries the camelCase field.name (the TS property) AND the snake_case
-    # @column (the physical DB column); the Python model field IS the column, so it
-    # binds straight to the row. Backward-compatible: snake-authored models with no
-    # @column emit field.name unchanged.
-    py_name = field.attrs().get(fc.FIELD_ATTR_COLUMN) or field.name
-    return f"    {py_name}: {annotation}{assignment}", uses_field
+    # Pydantic field name = field.name, ALWAYS. `@column` is the physical column name,
+    # a different axis: it is what the persistence layer binds to, never what the model
+    # calls the field. Every other surface in this port already keyed by field.name —
+    # the FR-036 create/patch models, the generated router, and the runtime, whose
+    # ObjectManager maps {_column_of(f): f.name} on every read and RETURNING clause
+    # "for cross-port row-shape parity" — so keying the read model by @column made one
+    # generated module disagree with itself, and its stated reason (that the model field
+    # binds straight to the row) was never true.
+    #
+    # Idiomatic snake_case for a Python consumer is a real goal and this is not the
+    # lever for it: `columnNamingStrategy` applied to field.name is, because @column is
+    # free-form — `callPurpose` + `@column: purpose_code` used to emit a field
+    # `purpose_code`, which is neither the wire name nor derived from the field name.
+    return f"    {field.name}: {annotation}{assignment}", uses_field
 
 
 def _primary_identity_field_names(entity: MetaObject) -> list[str]:

{metaobjects-0.24.4 → metaobjects-0.24.5}/src/metaobjects/codegen/generators/m2m_codegen.py

@@ -26,6 +26,11 @@ from __future__ import annotations
 from dataclasses import dataclass
 
 from metaobjects.meta.core.field import field_constants as fc
+from metaobjects.naming import (
+    DEFAULT_COLUMN_NAMING,
+    apply_column_naming_strategy,
+    resolve_column_name,
+)
 from metaobjects.meta.core.field.meta_field import MetaField
 from metaobjects.meta.meta_data import MetaData
 from metaobjects.meta.core.identity.identity_constants import (
@@ -92,15 +97,18 @@ def _physical_table(entity: MetaObject) -> str:
     return entity.name
 
 
-def _column_of(field: MetaField | None, fallback: str) -> str:
-    """Physical column name for a metadata field name: its ``@column`` override,
-    else the field's own name. Mirrors the runtime ``object_manager._column_of``
-    (no implicit snake_case — the metadata field name IS the column unless
-    ``@column`` overrides)."""
+def _column_of(
+    field: MetaField | None, fallback: str, strategy: str = DEFAULT_COLUMN_NAMING
+) -> str:
+    """Physical column name for a junction FK. Delegates to the shared
+    :func:`metaobjects.naming.resolve_column_name` — the SAME resolver the runtime uses,
+    so generated junction SQL and runtime SQL cannot disagree about a column name.
+
+    *fallback* covers the case where the field could not be resolved at all; it is a
+    bare metadata name, so it goes through the strategy too."""
     if field is None:
-        return fallback
-    col = field.attrs().get(fc.FIELD_ATTR_COLUMN)
-    return col if isinstance(col, str) and col else field.name
+        return apply_column_naming_strategy(fallback, strategy)
+    return resolve_column_name(field, strategy)
 
 
 def _field_named(entity: MetaObject, field_name: str) -> MetaField | None:
@@ -144,7 +152,9 @@ def m2m_relationships(entity: MetaObject) -> list[MetaRelationship]:
 
 
 def resolve_m2m_descriptors(
-    entity: MetaObject, object_index: dict[str, MetaObject]
+    entity: MetaObject,
+    object_index: dict[str, MetaObject],
+    column_naming: str = DEFAULT_COLUMN_NAMING,
 ) -> list[M2mDescriptor]:
     """Resolve every M:N navigation on *entity* into a build-time descriptor.
 
@@ -181,11 +191,12 @@ def resolve_m2m_descriptors(
                 target_plural=plural_lowercase(target.name),
                 junction_table=_physical_table(junction),
                 target_table=_physical_table(target),
-                source_column=_column_of(source_fk, fields.source_field),
-                target_column=_column_of(target_fk, fields.target_field),
+                source_column=_column_of(source_fk, fields.source_field, column_naming),
+                target_column=_column_of(target_fk, fields.target_field, column_naming),
                 target_pk_column=_column_of(
                     _field_named(target, pk_field_name(target)),
                     pk_field_name(target),
+                    column_naming,
                 ),
                 symmetric=rel.symmetric(),
             )

metaobjects-0.24.5/src/metaobjects/naming.py

@@ -0,0 +1,90 @@
+"""Physical naming: how a metadata name becomes a database identifier.
+
+The column-naming strategy is CONFIG, not metadata (ADR-0023 does not apply). The same
+model has to be able to drive a snake_case Postgres schema and a literal-column one —
+which is exactly why it lives beside the persistence layer rather than in the metadata,
+and why the byte-gated registry prose for ``@column`` describes the default as coming
+"via columnNamingStrategy".
+
+Cross-port siblings, sharing this vocabulary and this algorithm:
+  * TypeScript  ``metadata/src/naming.ts``      (``applyColumnNamingStrategy``)
+  * C#          ``MetaObjects.Codegen``         (``ColumnNamingStrategy``)
+  * Kotlin      ``KotlinGenUtil``               (``applyColumnNamingStrategy``)
+
+**This port's default is ``literal``** — ``@column`` or the field name verbatim — which
+is what it has always done. Note that the ports deliberately differ here (TypeScript
+defaults to ``snake_case``, the Postgres convention; C# to ``literal``, EF's
+property=column convention), so a polyglot project either sets the strategy explicitly
+or declares ``@column``.
+"""
+from __future__ import annotations
+
+from metaobjects.meta.core.field import field_constants as fc
+from metaobjects.meta.core.field.meta_field import MetaField
+
+COLUMN_NAMING_SNAKE_CASE = "snake_case"
+COLUMN_NAMING_LITERAL = "literal"
+COLUMN_NAMING_KEBAB_CASE = "kebab-case"
+
+COLUMN_NAMING_STRATEGIES = (
+    COLUMN_NAMING_SNAKE_CASE,
+    COLUMN_NAMING_LITERAL,
+    COLUMN_NAMING_KEBAB_CASE,
+)
+
+#: This port's default. Not the same as TypeScript's — see the module docstring.
+DEFAULT_COLUMN_NAMING = COLUMN_NAMING_LITERAL
+
+
+def to_snake_case(name: str) -> str:
+    """``displayName`` → ``display_name``, ``URLPath`` → ``url_path``.
+
+    Byte-for-byte the algorithm the other ports use: insert ``_`` before an uppercase
+    letter preceded by a lowercase letter or digit, OR before an uppercase letter that
+    both follows another uppercase and precedes a lowercase (so an acronym splits once,
+    ``URLPath`` → ``url_path``, not ``u_r_l_path``). A port-local approximation would put
+    the two halves of one schema out of step.
+    """
+    if not name:
+        return name
+    out: list[str] = []
+    for i, c in enumerate(name):
+        if i > 0 and c.isupper():
+            prev = name[i - 1]
+            nxt = name[i + 1] if i + 1 < len(name) else None
+            if prev.islower() or prev.isdigit() or (
+                prev.isupper() and nxt is not None and nxt.islower()
+            ):
+                out.append("_")
+        out.append(c.lower())
+    return "".join(out)
+
+
+def apply_column_naming_strategy(name: str, strategy: str = DEFAULT_COLUMN_NAMING) -> str:
+    """Apply a strategy to a bare name.
+
+    An unknown strategy RAISES rather than falling back to the default: a typo would
+    otherwise bind a whole schema to the wrong columns and report success.
+    """
+    if strategy == COLUMN_NAMING_LITERAL:
+        return name
+    if strategy == COLUMN_NAMING_SNAKE_CASE:
+        return to_snake_case(name)
+    if strategy == COLUMN_NAMING_KEBAB_CASE:
+        return to_snake_case(name).replace("_", "-")
+    raise ValueError(
+        f"unknown column-naming strategy {strategy!r}; "
+        f"expected one of: {', '.join(COLUMN_NAMING_STRATEGIES)}"
+    )
+
+
+def resolve_column_name(field: MetaField, strategy: str = DEFAULT_COLUMN_NAMING) -> str:
+    """THE physical column name for a field: its explicit ``@column`` when present,
+    else ``field.name`` through the project's strategy.
+
+    ADR-0039: read RESOLVING — ``@column`` may be inherited through ``extends``.
+    """
+    col = field.get_meta_attr(fc.FIELD_ATTR_COLUMN)
+    if isinstance(col, str) and col:
+        return col
+    return apply_column_naming_strategy(field.name, strategy)

{metaobjects-0.24.4 → metaobjects-0.24.5}/src/metaobjects/runtime/object_manager.py

@@ -36,6 +36,7 @@ from ..meta.meta_root import MetaRoot
 from ..meta.core.object.meta_object import MetaObject
 from ..meta.core.field.meta_field import MetaField
 from ..meta.core.field import field_constants as fc
+from ..naming import DEFAULT_COLUMN_NAMING, resolve_column_name
 from ..meta.core.identity import identity_constants as ic
 from ..meta.persistence.db import db_constants as dbc
 from ..meta.persistence.source.meta_source import MetaSource
@@ -176,9 +177,21 @@ class PostgresDriver:
 class ObjectManager:
     """Method-based read API. Translates Filter dicts → parameterized SQL."""
 
-    def __init__(self, root: MetaRoot, driver: PostgresDriver) -> None:
+    def __init__(
+        self,
+        root: MetaRoot,
+        driver: PostgresDriver,
+        column_naming: str = DEFAULT_COLUMN_NAMING,
+    ) -> None:
         self._root = root
         self._driver = driver
+        # How a field with no explicit `@column` becomes a physical column name.
+        # Config, never metadata: the same model must be able to drive a snake_case
+        # schema and a literal-column one. Defaults to `literal`, this port's
+        # historical behaviour — but note `meta migrate`, which owns schema for EVERY
+        # port (ADR-0015), defaults to `snake_case`, so a project whose tables it
+        # created wants `snake_case` here or an explicit `@column` per field.
+        self._column_naming = column_naming
         self._entity_by_name: dict[str, MetaObject] = {}
         # ADR-0039 sanctioned own: top-level entity scan on the loader ROOT
         # (metadata.root is never extended, so own == effective) — mirrors the TS
@@ -278,7 +291,7 @@ class ObjectManager:
             # model, which carries derived fields) must not try to INSERT it; drop it here.
             if f.is_derived():
                 continue
-            insert_cols.append(_column_of(f))
+            insert_cols.append(_column_of(f, self._column_naming))
             params.append(_coerce_write_value(f, raw))
 
         # RETURNING the physical column set so the inserted row — including any
@@ -287,8 +300,8 @@ class ObjectManager:
         # column on the write table (it is computed by the replica view), so it is
         # excluded from RETURNING; the write-through re-read below fetches it via the view.
         returning_fields = [f for f in entity.fields() if not f.is_derived()]
-        all_cols = [_column_of(f) for f in returning_fields]
-        col_to_field = {_column_of(f): f.name for f in returning_fields}
+        all_cols = [_column_of(f, self._column_naming) for f in returning_fields]
+        col_to_field = {_column_of(f, self._column_naming): f.name for f in returning_fields}
 
         if insert_cols:
             col_list = ", ".join(_q(c) for c in insert_cols)
@@ -355,7 +368,7 @@ class ObjectManager:
         entity = self._require_entity(entity_name)
         table = self._table_name(entity)
         pk_field = self._primary_pk_field(entity)
-        pk_col = _column_of(entity.find_field(pk_field))
+        pk_col = _column_of(entity.find_field(pk_field), self._column_naming)
 
         # #203 — @autoSet: bump every onUpdate column to now(), and NEVER rewrite an
         # onCreate column — strip it even if the caller supplied a (stale) value.
@@ -389,7 +402,7 @@ class ObjectManager:
             # UPDATE it; drop it from the SET list.
             if f.is_derived():
                 continue
-            set_cols.append(_column_of(f))
+            set_cols.append(_column_of(f, self._column_naming))
             params.append(_coerce_write_value(f, raw))
         if not set_cols:
             # No columns to set → just read the (scoped) row back by PK (no-op update).
@@ -400,13 +413,13 @@ class ObjectManager:
         # the write table (computed by the replica view); the write-through re-read below
         # fetches them via the view.
         returning_fields = [f for f in entity.fields() if not f.is_derived()]
-        all_cols = [_column_of(f) for f in returning_fields]
-        col_to_field = {_column_of(f): f.name for f in returning_fields}
+        all_cols = [_column_of(f, self._column_naming) for f in returning_fields]
+        col_to_field = {_column_of(f, self._column_naming): f.name for f in returning_fields}
         assignments = ", ".join(f"{_q(c)} = %s" for c in set_cols)
         params.append(_coerce_write_value(entity.find_field(pk_field), id_value))
         where = f"{_q(pk_col)} = %s"
         if tph is not None:
-            where += f" AND {_q(_column_of(entity.find_field(tph.field)))} = %s"
+            where += f" AND {_q(_column_of(entity.find_field(tph.field), self._column_naming))} = %s"
             params.append(tph.value)
         sql = (
             f"UPDATE {_q(table)} SET {assignments} WHERE {where} "
@@ -456,14 +469,14 @@ class ObjectManager:
         entity = self._require_entity(entity_name)
         table = self._table_name(entity)
         pk_field = self._primary_pk_field(entity)
-        pk_col = _column_of(entity.find_field(pk_field))
+        pk_col = _column_of(entity.find_field(pk_field), self._column_naming)
         params: list[Any] = [_coerce_write_value(entity.find_field(pk_field), id_value)]
         where = f"{_q(pk_col)} = %s"
         # FR-017 TPH: a subtype delete is scoped to its discriminator (cross-subtype
         # delete matches no row → False, mirroring the per-subtype route's 404).
         tph = tph_subtype_of(entity)
         if tph is not None:
-            where += f" AND {_q(_column_of(entity.find_field(tph.field)))} = %s"
+            where += f" AND {_q(_column_of(entity.find_field(tph.field), self._column_naming))} = %s"
             params.append(tph.value)
         sql = f"DELETE FROM {_q(table)} WHERE {where}"
         return self._driver.execute_rowcount(sql, tuple(params)) > 0
@@ -482,14 +495,14 @@ class ObjectManager:
         # derived origin.* columns), else the entity's own primary source. All effective
         # fields (incl. derived) are selected — the view exposes them.
         table = self._read_source_name(entity)
-        cols = [_column_of(f) for f in entity.fields()]
+        cols = [_column_of(f, self._column_naming) for f in entity.fields()]
         sql = f'SELECT {", ".join(_q(c) for c in cols)} FROM {_q(table)}'
         params: list[Any] = []
         # FR-017 TPH: a subtype read is scoped to its discriminator value (a row of
         # a different subtype is invisible); the base entity (no @discriminatorValue)
         # reads polymorphically across the single table.
         filter = self._scope_filter(filter, tph_subtype_of(entity))
-        where = _compile_filter(filter, entity) if filter else None
+        where = _compile_filter(filter, entity, self._column_naming) if filter else None
         if where is not None:
             sql += " WHERE " + where[0]
             params.extend(where[1])
@@ -497,7 +510,7 @@ class ObjectManager:
             order_parts = []
             for field_name, direction in sort:
                 f = entity.find_field(field_name)
-                col = _column_of(f) if f is not None else field_name
+                col = _column_of(f, self._column_naming) if f is not None else field_name
                 d = "DESC" if direction.lower() == "desc" else "ASC"
                 order_parts.append(f"{_q(col)} {d}")
             if order_parts:
@@ -509,7 +522,7 @@ class ObjectManager:
         result = self._driver.select(sql, tuple(params))
         # Map raw column → metadata field name for cross-port row-shape parity.
         # Values stay native (ADR-0019); the boundary canonicalizes them.
-        col_to_field = {_column_of(f): f.name for f in entity.fields()}
+        col_to_field = {_column_of(f, self._column_naming): f.name for f in entity.fields()}
         self.last_column_oids = {
             col_to_field.get(c, c): oid for c, oid in result.column_oids.items()
         }
@@ -528,7 +541,7 @@ class ObjectManager:
         sql = f"SELECT COUNT(*) FROM {_q(table)}"
         params: list[Any] = []
         filter = self._scope_filter(filter, tph_subtype_of(entity))  # FR-017 TPH subtype scope
-        where = _compile_filter(filter, entity) if filter else None
+        where = _compile_filter(filter, entity, self._column_naming) if filter else None
         if where is not None:
             sql += " WHERE " + where[0]
             params.extend(where[1])
@@ -670,7 +683,7 @@ class ObjectManager:
             raise ValueError(
                 f"Junction '{junction.name}' has no field '{field_name}'"
             )
-        return _column_of(f)
+        return _column_of(f, self._column_naming)
 
     def primary_key_field(self, entity_name: str) -> str:
         """The single-field primary-key NAME for an entity, from its
@@ -695,7 +708,9 @@ class ObjectManager:
 # ----------------------------------------------------------------------------
 
 
-def _compile_filter(f: Filter | None, entity: MetaObject) -> tuple[str, list[Any]] | None:
+def _compile_filter(
+    f: Filter | None, entity: MetaObject, column_naming: str = DEFAULT_COLUMN_NAMING
+) -> tuple[str, list[Any]] | None:
     if not f:
         return None
     # Top-level `and: [filter, filter, ...]` combinator.
@@ -703,7 +718,7 @@ def _compile_filter(f: Filter | None, entity: MetaObject) -> tuple[str, list[Any
         parts: list[str] = []
         params: list[Any] = []
         for child in f["and"]:
-            compiled = _compile_filter(child, entity)
+            compiled = _compile_filter(child, entity, column_naming)
             if compiled is None:
                 continue
             parts.append("(" + compiled[0] + ")")
@@ -716,7 +731,7 @@ def _compile_filter(f: Filter | None, entity: MetaObject) -> tuple[str, list[Any
     params = []
     for field_name, ops in f.items():
         mf = entity.find_field(field_name)
-        col = _column_of(mf) if mf is not None else field_name
+        col = _column_of(mf, column_naming) if mf is not None else field_name
         if not isinstance(ops, dict):
             # Shortcut: {field: value} → equality. Encoded like any other bound
             # value (see _op_clause) so an int-backed enum reaches SQL as its int.
@@ -992,11 +1007,13 @@ def _parse_datetime(text: str, *, tz_aware: bool) -> _dt.datetime:
     return dt.replace(tzinfo=None)
 
 
-def _column_of(field: MetaField | None) -> str:
+def _column_of(field: MetaField | None, strategy: str = DEFAULT_COLUMN_NAMING) -> str:
+    """Physical column for a field. Module-level shim over the shared
+    :func:`metaobjects.naming.resolve_column_name` so the runtime and codegen cannot
+    drift on what a column is called."""
     if field is None:
         return ""
-    col = field.get_meta_attr(fc.FIELD_ATTR_COLUMN)  # ADR-0039 resolving: @column may be inherited
-    return col if isinstance(col, str) and col else field.name
+    return resolve_column_name(field, strategy)
 
 
 def _q(ident: str) -> str:

{metaobjects-0.24.4 → metaobjects-0.24.5}/tests/codegen/test_entity_model.py

@@ -128,22 +128,34 @@ def test_nested_object_array_imports_ref() -> None:
     assert "posts: list[PostBrief] | None = None" in out
 
 
-def test_column_attr_overrides_python_field_name() -> None:
-    """A field's ``@column`` (the physical DB column) is the READ-model Pydantic field
-    name when present, falling back to ``field.name``. This lets one entity carry the
-    camelCase ``field.name`` the TS port emits as a property AND the snake_case
-    ``@column`` the Python read model emits as the model field (= DB column), so a single
-    cross-port entity feeds both languages idiomatically. The FR-036 create/patch
-    VALIDATION models, by contrast, key by the WIRE name (field.name) — the router
-    validates the raw wire body (see test_create_model_validates_against_wire_name)."""
+def test_column_attr_does_not_rename_the_read_model_field() -> None:
+    """``@column`` is the PHYSICAL column name. It must not become the Pydantic field
+    name — that is a different axis, and conflating them made one generated module
+    disagree with itself.
+
+    The read model used to key by ``@column``. Everything else in this port keys by
+    ``field.name``: the FR-036 create/patch models, the generated router (it stamps
+    ``dto["createdAt"]``), and the runtime — ``ObjectManager`` maps
+    ``{_column_of(f): f.name}`` on every read and RETURNING clause, commented "for
+    cross-port row-shape parity". So the read model's stated reason ("the Python model
+    field IS the column, so it binds straight to the row") was false: the runtime never
+    hands out column-keyed rows.
+
+    It also leaked. ``@column`` is a free-form override, so a field ``callPurpose`` with
+    ``@column: purpose_code`` produced a Pydantic field ``purpose_code`` — neither the
+    wire name nor anything derived from the field name, just the DB column surfacing in
+    the API shape. Idiomatic snake_case for Python is a real goal; the lever for it is
+    ``columnNamingStrategy`` applied to ``field.name``, not the column override.
+    """
     f = _f("callPurpose", fc.FIELD_SUBTYPE_STRING, required=True)
-    f.set_attr(fc.FIELD_ATTR_COLUMN, "call_purpose")
+    # Deliberately NOT the snake_case of the field name — that coincidence is what made
+    # the old behaviour look right.
+    f.set_attr(fc.FIELD_ATTR_COLUMN, "purpose_code")
     e = _entity("LlmCall", [f], package="app::telemetry")
     out = render_entity_model(e)
-    # Scope to the read model (before the first validation model): it binds @column.
     read_model = out.split("class LlmCallCreate")[0]
-    assert "call_purpose: str" in read_model
-    assert "callPurpose" not in read_model
+    assert "callPurpose: str" in read_model
+    assert "purpose_code" not in read_model
 
 
 def test_field_name_used_when_no_column_attr() -> None:
@@ -301,8 +313,9 @@ def test_create_model_validates_against_wire_name_not_column() -> None:
     f.set_attr(fc.FIELD_ATTR_COLUMN, "full_name")
     mod = _load_models(_entity("Person", [f], package="app::p"))
 
-    # Read model keeps the @column name; the create model keys by the wire name.
-    assert "full_name" in mod.Person.model_fields
+    # BOTH key by the wire name now — the read model no longer renames itself to
+    # @column, so one module no longer disagrees with itself about what a field is called.
+    assert "fullName" in mod.Person.model_fields
     assert "fullName" in mod.PersonCreate.model_fields
     # An over-length WIRE value is now actually rejected (was silently dropped before).
     with pytest.raises(ValidationError):

{metaobjects-0.24.4 → metaobjects-0.24.5}/tests/unit/test_agent_context_staleness.py

@@ -62,3 +62,41 @@ def test_installed_version_is_a_string() -> None:
     v = installed_metaobjects_version()
     assert isinstance(v, str)
     assert v  # non-empty
+
+
+# ── the context is AHEAD of the install (publish-what-changed, docs/RELEASING.md) ──
+# A registry publishes only when it has a changed product file, so Python legitimately
+# sits behind npm — and ``meta agent-docs`` (npm, canonical for every port) stamps the
+# NEWER version. Nudging there is #347's shape: the remedy re-stamps the same newer
+# version, so the advisory can never be satisfied and fires forever on a correct setup.
+def test_context_from_a_newer_release_is_silent() -> None:
+    assert agent_context_staleness({"generatedBy": "0.24.7"}, "0.24.4") is None
+
+
+def test_context_newer_only_in_the_patch_is_silent() -> None:
+    assert agent_context_staleness({"generatedBy": "0.24.5"}, "0.24.4") is None
+
+
+def test_context_older_than_the_install_still_nudges() -> None:
+    msg = agent_context_staleness({"generatedBy": "0.24.4"}, "0.24.7")
+    assert msg is not None
+    assert "0.24.4" in msg
+    assert "0.24.7" in msg
+
+
+# The suppression is deliberately narrow: anything not orderable as a plain release
+# still nudges, preserving the documented "ANY drift nudges" property.
+def test_prerelease_context_still_nudges() -> None:
+    assert agent_context_staleness({"generatedBy": "0.24.5-rc.1"}, "0.24.4") is not None
+
+
+def test_build_metadata_still_nudges() -> None:
+    assert agent_context_staleness({"generatedBy": "0.24.5+abc"}, "0.24.4") is not None
+
+
+def test_unresolved_install_never_asserts_in_sync() -> None:
+    assert agent_context_staleness({"generatedBy": "0.24.7"}, "0.0.0") is not None
+
+
+def test_non_numeric_version_still_nudges() -> None:
+    assert agent_context_staleness({"generatedBy": "dev"}, "0.24.4") is not None