@@ -681,6 +681,24 @@ steps:
       cd "$GITHUB_WORKSPACE" && UNIT_TESTS_ALLOW_TEARDOWN_CRASH=1
       python .github/scripts/run_unit_tests.py --timeout 300
 
+  # #644: the Iluvatar non-inner reduction workaround wraps flag_gems entry
+  # points in Python, so its contract -- which calls take the path at all, which
+  # axis moves, `keepdim` round-trip, and that `*_out` bindings are left alone --
+  # is checked with torch alone: no device, no FlagGems build, no weights. That
+  # is why it runs on every platform rather than only where the wrapper is
+  # installed; a drift in it would be silent everywhere.
+  #
+  # Not in .github/workflows/agnostic-checks.yml: that job installs no torch by
+  # design, so a torch-backed file listed there is collected and skipped, which
+  # is not evidence. Not in `unit_tests_per_file` either: that group now names
+  # only dcu, and running the whole of tests/unit on Iluvatar still has
+  # unrelated failures (test_profiler_privateuse1 crashes, the ascend/gcu
+  # qwenimage rope files fail), so widening it belongs to the PR that triages
+  # those, not to this one.
+  - id: iluvatar_reduction_contract
+    name: Iluvatar reduction workaround contract
+    command: python -m pytest tests/unit/test_iluvatar_masked_reductions.py -v --tb=short
+
   - id: runtime_conformance
     name: Runtime conformance (hardware-agnostic)
     command: python -m pytest tests/integration/runtime -v -s --tb=short
 
@@ -52,6 +52,30 @@
 CUDA_ABI_PLATFORMS = ("cuda", "dcu", "metax", "ppu")
 
 
+def _build_platform() -> str:
+    """The accelerator this wheel was built for ("" when unrecorded)."""
+    return torch_fl._build_accelerator()
+
+
+# Builds with no on-device dtype cast at all: copy_ops.cc puts them in the
+# same-device flagos->flagos branch's "Fallback: CPU round-trip when no
+# on-device cast is available". The CUDA-ABI platforms reach the native
+# TensorIterator cast through the boxed arm, and Ascend / GCU / Kunlunxin /
+# MUSA each compile a vendor cast (`aclnnCast`, `topsatenToCopy`, `cast`,
+# `MudnnCopy`); these four do not, so a host round trip is the design there and
+# the transfer count below cannot be zero.
+_NO_ON_DEVICE_CAST = ("bpu", "iluvatar", "mps", "tsingmicro")
+
+
+def _has_on_device_cast() -> bool:
+    """Whether `.to(dtype)` can stay on the device on this build.
+
+    See `csrc/aten/copy_ops.cc`, the same-device flagos->flagos dtype branch;
+    the USE_ILUVATAR group there has no `DtypeCast` implementation.
+    """
+    return _build_platform() not in _NO_ON_DEVICE_CAST
+
+
 def _flagos_available():
     try:
         return (
@@ -179,6 +203,14 @@ def test_cuda_abi_cast_does_not_route_through_host(platform):
     )
 
 
+@pytest.mark.skipif(
+    not _has_on_device_cast(),
+    reason=(
+        "this build has no on-device dtype cast: copy_ops.cc takes the documented "
+        "'Fallback: CPU round-trip when no on-device cast is available' branch, "
+        "so the transfer count below is the design and not a regression"
+    ),
+)
 @pytest.mark.parametrize(
     "src_dtype,dst_dtype",
     [(torch.bfloat16, torch.float32), (torch.float32, torch.bfloat16)],
 
@@ -23,27 +23,48 @@
 
 The module is loaded by path rather than imported: importing ``torch_fl``
 executes the package ``__init__`` and needs a built accelerator, and the module
-under test itself only needs ``torch``.
+under test itself only needs ``torch``. The path resolves through the installed
+``torch_fl`` first so the same file runs in a wheel-only workspace and in a
+source checkout.
 """
 
 import importlib.util
+import sys
 from pathlib import Path
 
 import pytest
 
 torch = pytest.importorskip("torch")
 
-_MODULE_PATH = (
-    Path(__file__).resolve().parents[2]
-    / "torch_fl"
-    / "compile"
-    / "iluvatar_masked_reductions.py"
-)
+
+def _module_path() -> Path:
+    """Locate torch_fl/compile/iluvatar_masked_reductions.py without importing the package.
+
+    From wherever torch_fl resolves: the installed wheel in CI's wheel-only test
+    workspace (which has no source tree), or the repo copy in a source checkout.
+    Same arrangement as tests/integration/ops/conftest.py's `_platform_path`,
+    because this file runs in both.
+    """
+    spec = importlib.util.find_spec("torch_fl")
+    if spec is not None and spec.origin:
+        candidate = (
+            Path(spec.origin).resolve().parent
+            / "compile"
+            / "iluvatar_masked_reductions.py"
+        )
+        if candidate.is_file():
+            return candidate
+    return (
+        Path(__file__).resolve().parents[2]
+        / "torch_fl"
+        / "compile"
+        / "iluvatar_masked_reductions.py"
+    )
 
 
 def _load():
     spec = importlib.util.spec_from_file_location(
-        "iluvatar_masked_reductions", _MODULE_PATH
+        "iluvatar_masked_reductions", _module_path()
     )
     module = importlib.util.module_from_spec(spec)
     spec.loader.exec_module(module)
@@ -162,9 +183,83 @@ def fake_std(x, dim=None, *, correction=None, keepdim=False):
     assert shape == (2, 4, 3) and dim == -1 and correction == 1 and keepdim is False
 
 
-def test_patch_is_idempotent_and_tolerates_missing_flag_gems(monkeypatch):
-    import sys
+def test_out_entry_points_are_never_rewired(monkeypatch):
+    """`out=` entry points keep their own argument behaviour.
+
+    flag_gems' `sum_dim_out` is not `sum_dim`: with no `dtype` it passes the
+    caller's `keepdim` through and reads the result dtype off the input, which
+    is how `torch.sum(bool_input, dim=1, out=int64_out)` lands in an int64
+    buffer. The wrapper forces `keepdim=False` and returns a fresh tensor, so
+    wrapping that binding would silently change both. Alias sweeps keyed on
+    object identity are exactly where that mistake hides: a build that binds
+    `sum_dim_out` to the same function as `sum_dim` would be rewired with it.
+    """
+
+    class FakeGems:
+        pass
 
+    def sum_dim(inp, dim=None, keepdim=False, **kw):
+        return inp
+
+    def sum_dim_out(inp, dim=None, keepdim=False, **kw):
+        return inp
+
+    fake = FakeGems()
+    fake.sum_dim = sum_dim
+    fake.sum_dim_out = sum_dim_out
+    monkeypatch.setitem(sys.modules, "flag_gems", fake)
+
+    assert mr.patch_iluvatar_masked_reductions() is True
+    assert fake.sum_dim.__code__.co_name == "patched"
+    assert fake.sum_dim_out is sum_dim_out
+
+    # The identity sweep is what makes this worth pinning: a build that aliases
+    # the two entry points must still leave the `out=` name alone.
+    del sys.modules["flag_gems"]
+    aliased = FakeGems()
+    aliased.sum_dim = aliased.sum_dim_out = sum_dim
+    monkeypatch.setitem(sys.modules, "flag_gems", aliased)
+    assert mr.patch_iluvatar_masked_reductions() is True
+    assert aliased.sum_dim.__code__.co_name == "patched"
+    assert aliased.sum_dim_out is sum_dim
+
+
+def test_bool_sum_out_dtype_survives_the_patch(monkeypatch, tmp_path):
+    """`torch.sum(bool, dim=1, out=...)` still writes the int64 the op promises.
+
+    Mirrors flag_gems' `sum_dim_comm` dtype rule: an unspecified dtype is read
+    off the input, and a bool input becomes int64. The patched binding is the
+    one `sum.IntList_out` resolves, so if the sweep had wrapped it the caller
+    would get a bool result back and the `out=` buffer would stay untouched.
+    """
+
+    class FakeGems:
+        pass
+
+    def sum_dim_comm(inp, dim=None, keepdim=False, *, dtype=None, out=None):
+        if dtype is None:
+            dtype = torch.int64 if inp.dtype is torch.bool else inp.dtype
+        result = torch.sum(inp, dim=dim, keepdim=keepdim, dtype=dtype)
+        if out is not None:
+            out.copy_(result)
+            return out
+        return result
+
+    fake = FakeGems()
+    fake.sum_dim = lambda inp, dim=None, keepdim=False, **kw: inp
+    fake.sum_dim_out = sum_dim_comm
+    monkeypatch.setitem(sys.modules, "flag_gems", fake)
+    mr.patch_iluvatar_masked_reductions()
+
+    mask = torch.tensor([[True, False, True], [False, True, True]])
+    out = torch.empty(2, dtype=torch.int64)
+    got = fake.sum_dim_out(mask, 1, out=out)
+    assert got is out
+    assert out.dtype == torch.int64
+    assert out.tolist() == [2, 2]
+
+
+def test_patch_is_idempotent_and_tolerates_missing_flag_gems(monkeypatch):
     class FakeGems:
         pass
 
 
@@ -183,8 +183,19 @@ def patch_iluvatar_masked_reductions() -> bool:
         # kernels resolve the package-level name, flag_gems' own ops call their
         # siblings through the module, and some modules import a sibling by
         # name, so identity is the only reliable way to catch every alias.
+        #
+        # ``*_out`` names are left alone. An ``out=`` entry point is not the
+        # same function: flag_gems' ``sum_dim_out`` keeps the caller's
+        # ``keepdim`` and casts a bool input to int64 regardless of the dtype
+        # argument, so writing through it is how ``torch.sum(bool, dim=1,
+        # out=int64_out)`` gets the result it asked for. The wrapper forces
+        # ``keepdim=False`` and returns a fresh tensor, which would leave the
+        # caller's buffer untouched and the dtype it derived from the input.
+        # Those calls keep the pre-existing behaviour of this workaround --
+        # unmasked, and therefore wrong on this backend -- which is the
+        # documented scope rather than a silent semantics change on top.
         for name, val in list(vars(flag_gems).items()):
-            if val is orig:
+            if val is orig and not name.endswith("_out"):
                 setattr(flag_gems, name, wrapped)
         for mod in list(sys.modules.values()):
             if not getattr(mod, "__name__", "").startswith("flag_gems"):
@@ -194,7 +205,7 @@ def patch_iluvatar_masked_reductions() -> bool:
             except Exception:
                 continue
             for name, val in list(namespace.items()):
-                if val is orig:
+                if val is orig and not name.endswith("_out"):
                     try:
                         setattr(mod, name, wrapped)
                     except Exception: