Backtestspydanticrun-20260929-204949#13507

Issue #13507 Merged fix PR #13516 Run 29 Sep 2026 · run-20260929-204949 pydantic/pydantic

Experimental pipeline: every constraint chained after ge/lt/le is dropped from the JSON schema

Worse

The merged fix was judged better than our patch.

In this judgment, Patch A = our agent, Patch B = the merged fix.

Both patches fix the reported root cause (the unconditional fallback function wrapper on Ge/Lt/Le that buries later constraints inside an opaque function-after schema invisible to JSON schema generation), and both add regression tests for the exact table cases in the issue. The decision comes down to completeness, tests, and alignment with the issue's own analysis.

Patch A is the surgical, low-risk fix: it introduces the `native_constraint_applied` flag on Ge/Lt/Le, mirroring the established convention, and gates the fallback so validation is provably unchanged (native path when the field is set, function path on type mismatch). It cleanly handles the Interval decomposition and the trailing multiple_of case. Its weakness is that it only touches three branches and its tests, while adequate, are narrower.

Patch B implements the single symmetric change across all five branches (Gt/Ge/Lt/Le/MultipleOf) that the issue explicitly argues is the right shape ('one symmetric change across all five branches rather than three separate patches'). It removes the redundant isinstance type-narrowing and lets the fallback live in an `else:` (the same structure Gt used correctly), relying on pydantic-core to cast the bound when building the validator. This is a broader behavioral change (mismatched-type bounds now go native instead of a Python function), which is the one real risk, but Patch B deliberately validates exactly those cases: it adds parametrized validation tests for float bounds on int schemas, int bounds on float/Decimal schemas, and multiple_of type mismatches, plus a `transform()` case demonstrating the fallback still fires for non-numeric core schemas, plus JSON-schema tests for both ge/le and gt/lt chains. That test coverage is markedly more thorough and directly exercises the assumption the fix rests on.

Weighing correctness (both correct; A is risk-free on validation, B's casting assumption is sound for pydantic-core and is explicitly tested), tests (B clearly stronger and non-tautological), scope (A tighter, B broader but matching the issue's stated architectural preference rather than gratuitous churn), and craft (B cleaner and more symmetric, with honest pyright-ignore annotations for the type mismatch), Patch B is the better overall fix. The scope expansion is the kind the issue itself recommends and its risk is mitigated by targeted tests, so it edges out A's safer but less complete approach.

The judge saw only the two patches, labelled A and B in random order, with issue links and version numbers removed. The reasoning above is shown verbatim.

Solve

5m 35s14 turns

Wall-clock time in the container

Full test suite

No new failures

12,279 passed · 501 skipped · 12,780 total

Contamination audit

Clean

No sign the agent saw the real fix

Patch size

66vs 112 merged

Changed lines, ours vs merged

Initial Checks

  • I confirm that I'm using Pydantic V2

Description

In the experimental pipeline API, chaining constraints silently drops every bound after the first from the generated JSON schema. Validation stays correct - only the published schema is wrong, which makes it easy to miss.

All bounds below are non-zero, so this is not #13450 (falsy zero bounds in Interval). Observed identically on released 2.13.4 and on main (2.14.0a1).

expressionJSON schemavalidation
validate_as(int).ge(1).le(100){"minimum": 1, "type": "integer"}0 reject, 50 accept, 200 reject
validate_as(int).le(100).ge(1){"maximum": 100, "type": "integer"}0 reject, 50 accept, 200 reject
validate_as(int).constrain(Interval(ge=1, le=100)){"minimum": 1, "type": "integer"}0 reject, 50 accept, 200 reject
validate_as(int).ge(1).le(100).multiple_of(5){"minimum": 1, "type": "integer"}correct
validate_as(int).gt(1).lt(100) (control){"exclusiveMinimum": 1, "exclusiveMaximum": 100, ...}correct
Annotated[int, Ge(1), Le(100)] (control){"minimum": 1, "maximum": 100, ...}correct

So .ge(1).le(100).multiple_of(5) publishes a schema advertising any integer >= 1, while the validator rejects 200 and 52. For FastAPI that means the OpenAPI component and every generated client disagree with the server.

Cause

In _apply_constraint(), the Ge, Lt and Le branches apply their fallback function validator unconditionally - including when the native core-schema field was just set:

elif isinstance(constraint, annotated_types.Ge):
    ge = constraint.ge
    if s and s['type'] in {'int', 'float', 'decimal'}:
        s = s.copy()
        if s['type'] == 'int' and isinstance(ge, int):
            s['ge'] = ge          # native constraint applied...
        ...

    def check_ge(v: Any) -> bool:
        return v >= ge

    s = _check_func(check_ge, f'>= {ge}', s)   # ...and then wrapped anyway

_check_func wraps the schema in function-after. The next constraint in the chain sees s['type'] == 'function-after', which is not in {'int', 'float', 'decimal'}, so it cannot set its own native field and survives only inside an opaque callable that JSON-schema generation cannot read. Core schema for .ge(1).le(100):

{'type': 'function-after',
 'function': ...,                       # <- le(100) lives in here, invisible to the schema
 'schema': {'type': 'function-after',
            'function': ...,            # <- redundant ge check
            'schema': {'type': 'int', 'ge': 1}}}

Gt is the control that works, and only by accident: its fallback sits in an else:, so nothing is wrapped when the native constraint applies.

Relationship to the open PRs in this function

Two in-flight PRs each fix one branch of this, for unrelated reasons, and between them they leave Ge, Lt and Le untouched:

  • #13473 adds a native_constraint_applied flag to MultipleOf to avoid a float parity problem. Same shape as the fix needed here.
  • #13446 restructures Gt so the fallback lands inside the numeric branch.

Worth flagging on the second one: #13446's description argues that Gt is uniquely broken and holds up Ge/Lt/Le/MultipleOf as the correct model, because they "always apply" the check and so enforce the bound on a type mismatch. That is true of validation, but always applying it is exactly what destroys the schema. Gt is uniquely broken for validation; the other four are broken for schema. Whichever way this is fixed, it probably wants to be one symmetric change across all five branches rather than three separate patches.

Example Code

from typing import Annotated

from pydantic import TypeAdapter
from pydantic.experimental.pipeline import validate_as

ta = TypeAdapter(Annotated[int, validate_as(int).ge(1).le(100)])

print(ta.json_schema())      # {'minimum': 1, 'type': 'integer'}   <- no maximum
ta.validate_python(200)      # ValidationError, as it should be

# control: the same constraints without the pipeline
import annotated_types
print(TypeAdapter(Annotated[int, annotated_types.Ge(1), annotated_types.Le(100)]).json_schema())
# {'maximum': 100, 'minimum': 1, 'type': 'integer'}

Python, Pydantic & OS Version

             pydantic version: 2.13.4
        pydantic-core version: 2.46.4
          pydantic-core build: profile=release pgo=false
               python version: 3.11.15 (main, Mar  3 2026, 09:26:23) [GCC 13.3.0]
                     platform: Linux-6.18.5-x86_64-with-glibc2.39
             related packages: typing_extensions-4.16.0
                       commit: unknown

I have a PR ready that applies the native_constraint_applied shape from #13473 to Ge/Lt/Le, with regression tests that fail without it. Happy to open it, or to fold it into one of the existing PRs if you'd rather land a single change.

The two patches

Our patch+57 −9
pydantic/experimental/pipeline.pyindex b9668517..a1d53f10 100644@@ -502,49 +502,67 @@ def _apply_constraint(  # noqa: C901             s = _check_func(check_gt, f'> {gt}', s)     elif isinstance(constraint, annotated_types.Ge):         ge = constraint.ge+        native_constraint_applied = False         if s and s['type'] in {'int', 'float', 'decimal'}:             s = s.copy()             if s['type'] == 'int' and isinstance(ge, int):                 s['ge'] = ge+                native_constraint_applied = True             elif s['type'] == 'float' and isinstance(ge, float):                 s['ge'] = ge+                native_constraint_applied = True             elif s['type'] == 'decimal' and isinstance(ge, Decimal):                 s['ge'] = ge+                native_constraint_applied = True -        def check_ge(v: Any) -> bool:-            return v >= ge+        if not native_constraint_applied: -        s = _check_func(check_ge, f'>= {ge}', s)+            def check_ge(v: Any) -> bool:+                return v >= ge++            s = _check_func(check_ge, f'>= {ge}', s)     elif isinstance(constraint, annotated_types.Lt):         lt = constraint.lt+        native_constraint_applied = False         if s and s['type'] in {'int', 'float', 'decimal'}:             s = s.copy()             if s['type'] == 'int' and isinstance(lt, int):                 s['lt'] = lt+                native_constraint_applied = True             elif s['type'] == 'float' and isinstance(lt, float):                 s['lt'] = lt+                native_constraint_applied = True             elif s['type'] == 'decimal' and isinstance(lt, Decimal):                 s['lt'] = lt+                native_constraint_applied = True++        if not native_constraint_applied: -        def check_lt(v: Any) -> bool:-            return v < lt+            def check_lt(v: Any) -> bool:+                return v < lt -        s = _check_func(check_lt, f'< {lt}', s)+            s = _check_func(check_lt, f'< {lt}', s)     elif isinstance(constraint, annotated_types.Le):         le = constraint.le+        native_constraint_applied = False         if s and s['type'] in {'int', 'float', 'decimal'}:             s = s.copy()             if s['type'] == 'int' and isinstance(le, int):                 s['le'] = le+                native_constraint_applied = True             elif s['type'] == 'float' and isinstance(le, float):                 s['le'] = le+                native_constraint_applied = True             elif s['type'] == 'decimal' and isinstance(le, Decimal):                 s['le'] = le+                native_constraint_applied = True++        if not native_constraint_applied: -        def check_le(v: Any) -> bool:-            return v <= le+            def check_le(v: Any) -> bool:+                return v <= le -        s = _check_func(check_le, f'<= {le}', s)+            s = _check_func(check_le, f'<= {le}', s)     elif isinstance(constraint, annotated_types.Len):         min_len = constraint.min_length         max_len = constraint.max_lengthtests/test_pipeline.pyindex 00e42101..a30296f4 100644@@ -7,6 +7,7 @@ from collections.abc import Callable from decimal import Decimal from typing import Annotated, Any +import annotated_types import pytest import pytz from annotated_types import Interval@@ -338,6 +339,26 @@ def test_predicates() -> None:             {'type': 'integer', 'exclusiveMinimum': 0, 'exclusiveMaximum': 100},             {'type': 'integer', 'exclusiveMinimum': 0, 'exclusiveMaximum': 100},         ),+        (+            Annotated[int, validate_as(int).ge(1).le(100)],+            {'type': 'integer', 'minimum': 1, 'maximum': 100},+            {'type': 'integer', 'minimum': 1, 'maximum': 100},+        ),+        (+            Annotated[int, validate_as(int).le(100).ge(1)],+            {'type': 'integer', 'minimum': 1, 'maximum': 100},+            {'type': 'integer', 'minimum': 1, 'maximum': 100},+        ),+        (+            Annotated[int, validate_as(int).constrain(annotated_types.Interval(ge=1, le=100))],+            {'type': 'integer', 'minimum': 1, 'maximum': 100},+            {'type': 'integer', 'minimum': 1, 'maximum': 100},+        ),+        (+            Annotated[int, validate_as(int).ge(1).le(100).multiple_of(5)],+            {'type': 'integer', 'minimum': 1, 'maximum': 100, 'multipleOf': 5},+            {'type': 'integer', 'minimum': 1, 'maximum': 100, 'multipleOf': 5},+        ),         (             Annotated[int, validate_as(int).gt(0) | validate_as(int).lt(100)],             {'anyOf': [{'type': 'integer', 'exclusiveMinimum': 0}, {'type': 'integer', 'exclusiveMaximum': 100}]},@@ -376,6 +397,15 @@ def test_json_schema(     assert schema == expected_ser_schema  +def test_ge_le_validation() -> None:+    ta = TypeAdapter[int](Annotated[int, validate_as(int).ge(1).le(100)])+    assert ta.validate_python(50) == 50+    with pytest.raises(ValidationError):+        ta.validate_python(0)+    with pytest.raises(ValidationError):+        ta.validate_python(200)++ def test_transform_first_step() -> None:     """Check that when transform() is used as the first step in a pipeline it run after parsing."""     ta = TypeAdapter[int](Annotated[int, transform(lambda x: x + 1)]) 
Merged fix · PR #13516+69 −43
pydantic/experimental/pipeline.pyindex b96685172..806156842 100644@@ -8,7 +8,6 @@ import re from collections import deque from collections.abc import Callable, Container from dataclasses import dataclass-from decimal import Decimal from functools import cached_property, partial from re import Pattern from types import EllipsisType@@ -484,16 +483,13 @@ def _apply_constraint(  # noqa: C901     s: cs.CoreSchema | None, constraint: _ConstraintAnnotation ) -> cs.CoreSchema:     """Apply a single constraint to a schema."""+    # No casting of the constraints is necessary, as pydantic-core does it+    # when building the validator from the core schema:     if isinstance(constraint, annotated_types.Gt):         gt = constraint.gt         if s and s['type'] in {'int', 'float', 'decimal'}:             s = s.copy()-            if s['type'] == 'int' and isinstance(gt, int):-                s['gt'] = gt-            elif s['type'] == 'float' and isinstance(gt, float):-                s['gt'] = gt-            elif s['type'] == 'decimal' and isinstance(gt, Decimal):-                s['gt'] = gt+            s['gt'] = gt  # pyright: ignore[reportGeneralTypeIssues]         else:              def check_gt(v: Any) -> bool:@@ -504,47 +500,35 @@ def _apply_constraint(  # noqa: C901         ge = constraint.ge         if s and s['type'] in {'int', 'float', 'decimal'}:             s = s.copy()-            if s['type'] == 'int' and isinstance(ge, int):-                s['ge'] = ge-            elif s['type'] == 'float' and isinstance(ge, float):-                s['ge'] = ge-            elif s['type'] == 'decimal' and isinstance(ge, Decimal):-                s['ge'] = ge+            s['ge'] = ge  # pyright: ignore[reportGeneralTypeIssues]+        else: -        def check_ge(v: Any) -> bool:-            return v >= ge+            def check_ge(v: Any) -> bool:+                return v >= ge -        s = _check_func(check_ge, f'>= {ge}', s)+            s = _check_func(check_ge, f'>= {ge}', s)     elif isinstance(constraint, annotated_types.Lt):         lt = constraint.lt         if s and s['type'] in {'int', 'float', 'decimal'}:             s = s.copy()-            if s['type'] == 'int' and isinstance(lt, int):-                s['lt'] = lt-            elif s['type'] == 'float' and isinstance(lt, float):-                s['lt'] = lt-            elif s['type'] == 'decimal' and isinstance(lt, Decimal):-                s['lt'] = lt+            s['lt'] = lt  # pyright: ignore[reportGeneralTypeIssues]+        else: -        def check_lt(v: Any) -> bool:-            return v < lt+            def check_lt(v: Any) -> bool:+                return v < lt -        s = _check_func(check_lt, f'< {lt}', s)+            s = _check_func(check_lt, f'< {lt}', s)     elif isinstance(constraint, annotated_types.Le):         le = constraint.le         if s and s['type'] in {'int', 'float', 'decimal'}:             s = s.copy()-            if s['type'] == 'int' and isinstance(le, int):-                s['le'] = le-            elif s['type'] == 'float' and isinstance(le, float):-                s['le'] = le-            elif s['type'] == 'decimal' and isinstance(le, Decimal):-                s['le'] = le+            s['le'] = le  # pyright: ignore[reportGeneralTypeIssues]+        else: -        def check_le(v: Any) -> bool:-            return v <= le+            def check_le(v: Any) -> bool:+                return v <= le -        s = _check_func(check_le, f'<= {le}', s)+            s = _check_func(check_le, f'<= {le}', s)     elif isinstance(constraint, annotated_types.Len):         min_len = constraint.min_length         max_len = constraint.max_length@@ -574,17 +558,13 @@ def _apply_constraint(  # noqa: C901         multiple_of = constraint.multiple_of         if s and s['type'] in {'int', 'float', 'decimal'}:             s = s.copy()-            if s['type'] == 'int' and isinstance(multiple_of, int):-                s['multiple_of'] = multiple_of-            elif s['type'] == 'float' and isinstance(multiple_of, float):-                s['multiple_of'] = multiple_of-            elif s['type'] == 'decimal' and isinstance(multiple_of, Decimal):-                s['multiple_of'] = multiple_of+            s['multiple_of'] = multiple_of  # pyright: ignore[reportGeneralTypeIssues]+        else: -        def check_multiple_of(v: Any) -> bool:-            return v % multiple_of == 0+            def check_multiple_of(v: Any) -> bool:+                return v % multiple_of == 0 -        s = _check_func(check_multiple_of, f'% {multiple_of} == 0', s)+            s = _check_func(check_multiple_of, f'% {multiple_of} == 0', s)     elif isinstance(constraint, annotated_types.Timezone):         tz = constraint.tz tests/test_pipeline.pyindex 00e421012..7198d4302 100644@@ -34,15 +34,30 @@ def test_parse_str_with_pattern() -> None:         (int, validate_as(...).ge(0), [0, 1, 100], [-1, -100]),         (float, validate_as(...).ge(0.0), [1.8, 0.0], [-1.0]),         (Decimal, validate_as(...).ge(Decimal(0.0)), [Decimal(1), Decimal(0.0)], [Decimal(-1.0)]),+        (float, validate_as(float).ge(0), [1.8, 0.0], [-1.0]),+        (Decimal, validate_as(Decimal).ge(0), [Decimal(1), Decimal(0)], [Decimal(-1)]),  # pyright: ignore[reportArgumentType]+        (int, validate_as(int).ge(0.0), [0, 1, 100], [-1, -100]),  # pyright: ignore[reportArgumentType]+        # The `transform()` step results in a non-numeric core schema, meaning the constraint+        # is applied as a function check:+        (int, validate_as(int).transform(lambda x: x).ge(0), [0, 1, 100], [-1, -100]),         (int, validate_as(...).le(5), [2, 4], [6, 100]),         (float, validate_as(...).le(1.0), [0.5, 0.0], [100.0]),         (Decimal, validate_as(...).le(Decimal(1.0)), [Decimal(1)], [Decimal(5.0)]),+        (float, validate_as(float).le(1), [0.5, 0.0], [100.0]),+        (Decimal, validate_as(Decimal).le(1), [Decimal(1)], [Decimal(5)]),  # pyright: ignore[reportArgumentType]+        (int, validate_as(int).le(5.0), [2, 4], [6, 100]),  # pyright: ignore[reportArgumentType]         (int, validate_as(...).gt(0), [1, 2, 100], [0, -1]),         (float, validate_as(...).gt(0.0), [0.1, 1.8], [0.0, -1.0]),         (Decimal, validate_as(...).gt(Decimal(0.0)), [Decimal(1)], [Decimal(0.0), Decimal(-1.0)]),+        (float, validate_as(float).gt(0), [1.0, 2.5], [0.0, -1.0]),+        (Decimal, validate_as(Decimal).gt(0), [Decimal(1)], [Decimal(0), Decimal(-1)]),  # pyright: ignore[reportArgumentType]+        (int, validate_as(int).gt(0.0), [1, 2], [0, -3]),  # pyright: ignore[reportArgumentType]         (int, validate_as(...).lt(5), [2, 4], [5, 6, 100]),         (float, validate_as(...).lt(1.0), [0.5, 0.0], [1.0, 100.0]),         (Decimal, validate_as(...).lt(Decimal(1.0)), [Decimal(0.5)], [Decimal(1.0), Decimal(5.0)]),+        (float, validate_as(float).lt(1), [0.5, 0.0], [1.0, 100.0]),+        (Decimal, validate_as(Decimal).lt(1), [Decimal('0.5')], [Decimal(1), Decimal(5)]),  # pyright: ignore[reportArgumentType]+        (int, validate_as(int).lt(5.0), [2, 4], [5, 6, 100]),  # pyright: ignore[reportArgumentType]     ], ) def test_ge_le_gt_lt(@@ -61,6 +76,12 @@ def test_ge_le_gt_lt(     [         (int, validate_as(int).multiple_of(5), [5, 20, 0], [18, 7]),         (float, validate_as(float).multiple_of(2.5), [2.5, 5.0, 7.5], [3.0, 1.1]),+        (float, validate_as(float).multiple_of(2), [2.0, 4.0, 6.0], [3.0, 1.1]),+        (Decimal, validate_as(Decimal).multiple_of(2), [Decimal(2), Decimal(4)], [Decimal(3), Decimal('1.1')]),  # pyright: ignore[reportArgumentType]+        (int, validate_as(int).multiple_of(5.0), [5, 20, 0], [18, 7]),  # pyright: ignore[reportArgumentType]+        # The `transform()` step results in a non-numeric core schema, meaning the constraint+        # is applied as a function check:+        (int, validate_as(int).transform(lambda x: x).multiple_of(5), [5, 20, 0], [18, 7]),         (             Decimal,             validate_as(Decimal).multiple_of(Decimal('1.5')),@@ -338,6 +359,31 @@ def test_predicates() -> None:             {'type': 'integer', 'exclusiveMinimum': 0, 'exclusiveMaximum': 100},             {'type': 'integer', 'exclusiveMinimum': 0, 'exclusiveMaximum': 100},         ),+        (+            Annotated[int, validate_as(int).ge(1).le(100)],+            {'type': 'integer', 'minimum': 1, 'maximum': 100},+            {'type': 'integer', 'minimum': 1, 'maximum': 100},+        ),+        (+            Annotated[int, validate_as(int).le(100).ge(1)],+            {'type': 'integer', 'minimum': 1, 'maximum': 100},+            {'type': 'integer', 'minimum': 1, 'maximum': 100},+        ),+        (+            Annotated[int, validate_as(int).constrain(Interval(ge=1, le=100))],+            {'type': 'integer', 'minimum': 1, 'maximum': 100},+            {'type': 'integer', 'minimum': 1, 'maximum': 100},+        ),+        (+            Annotated[int, validate_as(int).ge(1).le(100).multiple_of(5)],+            {'type': 'integer', 'minimum': 1, 'maximum': 100, 'multipleOf': 5},+            {'type': 'integer', 'minimum': 1, 'maximum': 100, 'multipleOf': 5},+        ),+        (+            Annotated[int, validate_as(int).lt(100).gt(1)],+            {'type': 'integer', 'exclusiveMinimum': 1, 'exclusiveMaximum': 100},+            {'type': 'integer', 'exclusiveMinimum': 1, 'exclusiveMaximum': 100},+        ),         (             Annotated[int, validate_as(int).gt(0) | validate_as(int).lt(100)],             {'anyOf': [{'type': 'integer', 'exclusiveMinimum': 0}, {'type': 'integer', 'exclusiveMaximum': 100}]}, 

What the agent reported

Done. Here is the final report.

What was wrong

In pydantic/experimental/pipeline.py, _apply_constraint() handled the Ge, Lt, and Le constraints by setting the native core-schema field (s['ge']/s['lt']/s['le']) and then unconditionally wrapping the schema in a fallback function-after validator via _check_func. That function-after node hid the underlying numeric schema from the next constraint in a chain: when the following constraint checked s['type'] in {'int','float','decimal'} it saw 'function-after' instead, so it couldn't set its own native field and its bound survived only inside an opaque callable that JSON-schema generation can't read.

Result: .ge(1).le(100) published {"minimum": 1} (no maximum), even though validation still rejected 200. Gt happened to work only because its fallback sat in an else:.

What I changed

Applied the native_constraint_applied flag pattern (the shape from #13473) to the Ge, Lt, and Le branches: the fallback _check_func validator is now added only when the native field could not be set (non-numeric schema, or a bound whose type doesn't match the schema). On the matched numeric path the native field alone enforces the bound and the schema stays intact for downstream constraints. Gt and MultipleOf were left untouched (out of scope; not part of the reported broken scenarios).

Files: pydantic/experimental/pipeline.py (fix), tests/test_pipeline.py (regression tests).

Test evidence

  • Before the fix, the 4 new test_json_schema cases failed (schema dropped the second/later bound); test_ge_le_validation passed (validation was already correct).
  • After the fix: ./bt-test tests/test_pipeline.py → 74 passed.
  • Reproduction against repo source now yields both bounds for every reported expression:
  • .ge(1).le(100) → {'minimum': 1, 'maximum': 100, 'type': 'integer'}
  • .le(100).ge(1) → same
  • .constrain(Interval(ge=1, le=100)) → same
  • .ge(1).le(100).multiple_of(5) → {'minimum': 1, 'maximum': 100, 'multipleOf': 5, ...}
  • controls .gt(1).lt(100) and Annotated[int, Ge(1), Le(100)] unchanged.
  • Reviewer confirmed validation is preserved on all type-mismatch/non-numeric paths (no bound becomes silently unenforced), no existing tests weakened, no unrelated changes.

Requirements disposition

  1. Fix Ge/Lt/Le dropping chained bounds from JSON schema — ✅ Implemented.
  2. Use the native_constraint_applied shape from #13473 — ✅ Implemented for Ge/Lt/Le.
  3. Regression test failing before / passing after — ✅ Added 4 schema cases + 1 validation test; observed failing pre-fix, passing post-fix.
  4. Scenarios .ge().le(), .le().ge(), constrain(Interval), .ge().le().multiple_of() publish both bounds and validate — ✅ Verified.
  5. Controls .gt().lt() and Annotated[int, Ge, Le] stay correct — ✅ Verified unchanged; Gt/MultipleOf branches deliberately not modified.
  6. Offer to fold into an existing PR (#13446/#13473) — Skipped: the report offered this as an alternative to a standalone change. I delivered the standalone working-tree fix as the defensible default; the diff is minimal and mirrors #13473's shape, so it can be folded in later if the maintainers prefer.

Changes are left uncommitted in the working tree.