feat(#195): Python per-capability origin validation + native typing (cross-port parity)

Mirrors the committed TS reference (63943d0 validation, aff49ce typing) into the
Python port: the four #195 capabilities are now validated + typed identically.

- validation_passes.py: ports the closed expression grammar (validate_expr_node +
  infer_expr_type, mirroring meta-attr-expression.ts) + the shared _validate_order_by_keys
  helper, and the per-@agg branches — any/all (boolean non-array; @filter required; @Of
  forbidden; @via required + to-many), collect (isArray; @Of required + element-type
  preservation; @distinct/@orderby collect-only + mutually exclusive; @orderby resolves on
  the @Of entity), the inverse rule (non-collect ⇒ isArray:false), origin.computed
  (structural grammar → ERR_UNKNOWN_EXPR_NODE; inference vs base effective fields; type
  mismatch → ERR_COMPUTED_TYPE_MISMATCH), origin.first (@Of required + type-preserving;
  not @required; @via inference; @orderby resolution).
- errors.py: ERR_UNKNOWN_EXPR_NODE + ERR_COMPUTED_TYPE_MISMATCH.
- entity_model.py: origin_guaranteed_non_null — any/all/collect projection DTO fields
  non-null; first Optional; computed conservative-nullable.
- origin_constants.py: AGG_ANY/AGG_ALL/AGG_COLLECT.
- test_validation_origin_195.py: 20 tests mirroring the TS suite.

Verified: conformance 336 + the 20 validation tests = 356 passed; error CODES identical to
TS (message text keeps Python phrasing — conformance compares codes). Tier-3: the expression
grammar lives in validation_passes.py (beside ops_for_subtype) to avoid an import cycle.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NGQ7oSuNcjhsMHWwZzhBwr

Author: dmealing

server/python/src/metaobjects/codegen/generators/entity_model.py

@@ -14,7 +14,14 @@
     IDENTITY_ATTR_GENERATION,
 )
 from metaobjects.meta.core.validator import validator_constants as vc
-from metaobjects.shared.base_types import TYPE_VALIDATOR
+from metaobjects.meta.persistence.origin.origin_constants import (
+    AGG_ALL,
+    AGG_ANY,
+    AGG_COLLECT,
+    ORIGIN_ATTR_AGG,
+    ORIGIN_SUBTYPE_AGGREGATE,
+)
+from metaobjects.shared.base_types import TYPE_ORIGIN, TYPE_VALIDATOR
 from metaobjects.shared.separators import PACKAGE_SEP
 from metaobjects.codegen.config import GenConfig
 from metaobjects.codegen.constants import generated_header
@@ -221,6 +228,22 @@ def _type_expr_for_field(
     return type_expr, enum_type_name
 
 
+def origin_guaranteed_non_null(field: MetaField) -> bool:
+    """#195 — a field derived by an origin.aggregate ``@agg:any|all|collect`` is
+    COALESCE-guaranteed non-null in the synthesized view (any→false, all→true,
+    collect→[]), so its read type is non-null even when the field is not ``@required``.
+    origin.first is deliberately NOT here — an empty related set selects no row (→ null);
+    origin.computed nullability is expression-dependent, so it stays the conservative
+    nullable default. Mirrors the TS originGuaranteedNonNull."""
+    # ADR-0039 sanctioned own — origin.* never inherits (ADR-0029), so own is correct.
+    for child in field.own_children():
+        if child.type == TYPE_ORIGIN and child.sub_type == ORIGIN_SUBTYPE_AGGREGATE:
+            agg = child.attr(ORIGIN_ATTR_AGG)  # ADR-0039 own — origin attr
+            if agg in (AGG_ANY, AGG_ALL, AGG_COLLECT):
+                return True
+    return False
+
+
 def _field_line(field: MetaField, imports: set[str], config: GenConfig) -> tuple[str, bool]:
     """Return (source line, uses_field). Collects required imports into *imports*."""
     type_expr, enum_type_name = _type_expr_for_field(field, imports, config)
@@ -243,15 +266,20 @@ def _field_line(field: MetaField, imports: set[str], config: GenConfig) -> tuple
     else:
         default_expr = None
 
-    # A field is Optional only when it is neither required nor carries a @default.
-    annotation = type_expr if (required or has_default) else f"{type_expr} | None"
+    # #195 — a field derived by an origin.aggregate any|all|collect always COALESCEs
+    # to a value (any→false, all→true, collect→[]), so its read type is mandatory
+    # non-null exactly like a @required field (no `| None`, no default). origin.first /
+    # origin.computed stay the conservative nullable default.
+    mandatory = required or origin_guaranteed_non_null(field)
+    # A field is Optional only when it is neither mandatory nor carries a @default.
+    annotation = type_expr if (mandatory or has_default) else f"{type_expr} | None"
     if has_default and uses_field:
         assignment = f" = Field(default={default_expr}, {', '.join(parts)})"
     elif has_default:
         assignment = f" = {default_expr}"
-    elif required and uses_field:
+    elif mandatory and uses_field:
         assignment = f" = Field({', '.join(parts)})"
-    elif required:
+    elif mandatory:
         assignment = ""
     elif uses_field:
         assignment = f" = Field(default=None, {', '.join(parts)})"

server/python/src/metaobjects/errors.py

@@ -60,6 +60,13 @@ class ErrorCode(str, Enum):
     # is to-one at every hop (you meant passthrough).
     ERR_AMBIGUOUS_PATH = "ERR_AMBIGUOUS_PATH"
     ERR_ORIGIN_CARDINALITY = "ERR_ORIGIN_CARDINALITY"
+    # #195 — origin.computed @expr validation. ERR_UNKNOWN_EXPR_NODE: the expression
+    # tree contains a node whose kind/op/fn is not in the closed grammar (fail-closed
+    # per ADR-0023). ERR_COMPUTED_TYPE_MISMATCH: the @expr tree's inferred root type
+    # does not equal the carrying field's declared field.<subType> (a computed column's
+    # type is DERIVED from its expression, never asserted — no @convert escape).
+    ERR_UNKNOWN_EXPR_NODE = "ERR_UNKNOWN_EXPR_NODE"
+    ERR_COMPUTED_TYPE_MISMATCH = "ERR_COMPUTED_TYPE_MISMATCH"
     # FR-024 B6 — extends/origin agreement + derived-field providability. Vocabulary-
     # only here until FR-024 Phase E (the Python loader does not run these checks yet):
     # ERR_EXTENDS_ORIGIN_MISMATCH — a field's entity-nested extends (shape lineage)