From 16655b29f38f3ab41fdc6c0bd32c0e1d60cb3b4f Mon Sep 17 00:00:00 2001
From: wilson-seok <wilson.seok@intel.com>
Date: Wed, 15 Jul 2026 13:44:36 +0900
Subject: [PATCH 1/2] [GPU] Fix fused eltwise rank reduction

Keep per-channel eltwise transformations correct across rank-changing data movement.

Canonicalize provable higher-rank fused peers against the actual reduced layout and preserve producer rank when no exact fold exists.

Add regression coverage for 5D and exhaustive 6D broadcast masks.
---
 .../graph/impls/ocl/kernel_selector_helper.h  |  25 +-
 .../src/graph/include/fused_shape_utils.hpp   |  71 ++
 .../intel_gpu/src/graph/layout_optimizer.cpp  |  43 +-
 ...e_eltwise_up_data_movement_per_channel.cpp | 178 ++++
 ...e_eltwise_up_data_movement_per_channel.hpp |  17 +
 .../src/plugin/transformations_pipeline.cpp   |   3 +-
 .../unit/fusions/permute_fusion_test.cpp      | 764 ++++++++++++++++++
 .../canonicalize_fused_shapes_test.cpp        | 161 ++++
 ...wise_up_data_movement_per_channel_test.cpp | 234 ++++++
 9 files changed, 1491 insertions(+), 5 deletions(-)
 create mode 100644 src/plugins/intel_gpu/src/graph/include/fused_shape_utils.hpp
 create mode 100644 src/plugins/intel_gpu/src/plugin/transformations/move_eltwise_up_data_movement_per_channel.cpp
 create mode 100644 src/plugins/intel_gpu/src/plugin/transformations/move_eltwise_up_data_movement_per_channel.hpp
 create mode 100644 src/plugins/intel_gpu/tests/unit/module_tests/canonicalize_fused_shapes_test.cpp
 create mode 100644 src/plugins/intel_gpu/tests/unit/transformations/move_eltwise_up_data_movement_per_channel_test.cpp

diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/kernel_selector_helper.h b/src/plugins/intel_gpu/src/graph/impls/ocl/kernel_selector_helper.h
index b7c5883fc1c5..5347ca0d6993 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/kernel_selector_helper.h
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/kernel_selector_helper.h
@@ -17,6 +17,10 @@
 #include "intel_gpu/primitives/reorder.hpp"
 #include "intel_gpu/primitives/primitive.hpp"
 
+#include "fused_shape_utils.hpp"
+
+#include "openvino/core/shape.hpp"
+
 #include "kernel_selector_params.h"
 #include "weight_bias_params.h"
 #include "kernel_selector_common.h"
@@ -269,13 +273,30 @@ inline kernel_impl_params canonicalize_fused_shapes(const kernel_impl_params& im
     for (auto& fd : updated_impl_params.fused_desc) {
         if (fd.is_type<eltwise>() && fd.total_num_deps == 2 && fd.has_outer_dep()) {
             if (updated_impl_params.input_layouts.size() > size_t(fd.outer_dep_start_idx)) {
-                const auto& out_pshape = updated_impl_params.output_layouts[0].get_partial_shape();
+                const auto& out_layout = updated_impl_params.output_layouts[0];
+                const auto& out_pshape = out_layout.get_partial_shape();
 
                 auto& dep_layout = updated_impl_params.input_layouts[fd.outer_dep_start_idx];
                 const auto& dep_shape = dep_layout.get_partial_shape();
 
                 if (!broadcastable(dep_shape, out_pshape, use_new_shape_infer)) {
-                    dep_layout.set_partial_shape(extend_shape_to_rank_from_begin(dep_shape, out_pshape.size()));
+                    if (dep_shape.size() > out_pshape.size()) {
+                        // extend_shape_to_rank_from_begin() can only prepend unit dims; it leaves a
+                        // higher-rank peer unchanged, so the fused-op kernel would read the peer with a
+                        // rank/format inconsistent with the host iteration space (df1 output-0 defect).
+                        // Fold the peer onto the host rank when it is a provably order-preserving reshape
+                        // (equal-total planar reshape or a legal planar broadcast); otherwise leave it to
+                        // the pre-existing rank-extension path. Optimization inapplicability is not an
+                        // error, so no assertion is raised and valid models always compile.
+                        if (auto folded = fold_higher_rank_fused_peer(dep_layout, out_layout)) {
+                            dep_layout.set_partial_shape(*folded);
+                            dep_layout.format = format::adjust_to_rank(dep_layout.format, out_pshape.size());
+                        } else {
+                            dep_layout.set_partial_shape(extend_shape_to_rank_from_begin(dep_shape, out_pshape.size()));
+                        }
+                    } else {
+                        dep_layout.set_partial_shape(extend_shape_to_rank_from_begin(dep_shape, out_pshape.size()));
+                    }
                 }
             }
         }
diff --git a/src/plugins/intel_gpu/src/graph/include/fused_shape_utils.hpp b/src/plugins/intel_gpu/src/graph/include/fused_shape_utils.hpp
new file mode 100644
index 000000000000..a78736fa980f
--- /dev/null
+++ b/src/plugins/intel_gpu/src/graph/include/fused_shape_utils.hpp
@@ -0,0 +1,71 @@
+// Copyright (C) 2018-2026 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include <optional>
+
+#include "intel_gpu/runtime/layout.hpp"
+#include "openvino/core/shape_util.hpp"
+
+namespace cldnn {
+
+// Computes a lower-rank representation of a fused eltwise peer when collapsing its leading spatial
+// axes is an order-preserving reshape and the result broadcasts directly to the host layout.
+inline std::optional<ov::PartialShape> fold_higher_rank_fused_peer(const layout& peer_layout, const layout& host_layout) {
+    const auto& peer_shape = peer_layout.get_partial_shape();
+    const auto& host_shape = host_layout.get_partial_shape();
+
+    const size_t peer_rank = peer_shape.size();
+    const size_t host_rank = host_shape.size();
+    if (peer_rank <= host_rank || host_rank < 3)
+        return std::nullopt;
+    if (peer_shape.is_dynamic() || host_shape.is_dynamic())
+        return std::nullopt;
+    if (peer_layout.data_padding || host_layout.data_padding)
+        return std::nullopt;
+
+    const auto& peer_format = peer_layout.format;
+    const auto& host_format = host_layout.format;
+    if (!format::is_simple_data_format(peer_format) || !format::is_simple_data_format(host_format))
+        return std::nullopt;
+    if (!format::is_default_format(peer_format) || !format::is_default_format(host_format))
+        return std::nullopt;
+    if (format::adjust_to_rank(peer_format, host_rank) != host_format)
+        return std::nullopt;
+
+    const auto peer_dims = peer_shape.to_shape();
+    const auto host_dims = host_shape.to_shape();
+    const size_t fold_count = peer_rank - host_rank + 1;
+    ov::Shape folded_dims;
+    folded_dims.reserve(host_rank);
+    folded_dims.push_back(peer_dims[0]);
+    folded_dims.push_back(peer_dims[1]);
+
+    size_t grouped = 1;
+    for (size_t i = 2; i < 2 + fold_count; ++i) {
+        const auto grouped_size = ov::util::shape_size_safe({grouped, peer_dims[i]});
+        if (!grouped_size.has_value())
+            return std::nullopt;
+        grouped = grouped_size.value();
+    }
+    folded_dims.push_back(grouped);
+    folded_dims.insert(folded_dims.end(), peer_dims.begin() + 2 + fold_count, peer_dims.end());
+
+    const auto peer_total = ov::util::shape_size_safe(peer_dims);
+    const auto folded_total = ov::util::shape_size_safe(folded_dims);
+    if (!peer_total.has_value() || !folded_total.has_value() || peer_total.value() != folded_total.value())
+        return std::nullopt;
+    if (folded_dims.size() != host_dims.size())
+        return std::nullopt;
+
+    for (size_t i = 0; i < folded_dims.size(); ++i) {
+        if (folded_dims[i] != 1 && folded_dims[i] != host_dims[i])
+            return std::nullopt;
+    }
+
+    return ov::PartialShape(folded_dims);
+}
+
+}  // namespace cldnn
\ No newline at end of file
diff --git a/src/plugins/intel_gpu/src/graph/layout_optimizer.cpp b/src/plugins/intel_gpu/src/graph/layout_optimizer.cpp
index 766fad3be4b8..364e65d3bc02 100644
--- a/src/plugins/intel_gpu/src/graph/layout_optimizer.cpp
+++ b/src/plugins/intel_gpu/src/graph/layout_optimizer.cpp
@@ -47,6 +47,7 @@
 #include "lstm_seq_inst.h"
 #include "group_normalization_inst.h"
 #include "to_string_utils.h"
+#include "fused_shape_utils.hpp"
 #include <vector>
 #include <memory>
 #include <utility>
@@ -69,6 +70,37 @@ static size_t get_post_ops_count(const program_node& node) {
     return onednn_post_ops_count;
 }
 
+// A rank-reducing reorder may be fused into a producer only when every higher-rank external eltwise
+// peer has the same provable lower-rank representation that OCL fused-op canonicalization will use.
+static bool fused_peers_can_fold_to_layout(const program_node& prev, const layout& reduced_layout) {
+    if (!prev.has_fused_primitives())
+        return true;
+
+    const size_t reduced_rank = reduced_layout.get_rank();
+    if (prev.get_output_layout().get_rank() <= reduced_rank)
+        return true;
+
+    for (const auto& fd : prev.get_fused_primitives()) {
+        if (!fd.is_type<eltwise>() || !fd.has_outer_dep())
+            continue;
+
+        const auto outer_idx = static_cast<size_t>(fd.outer_dep_start_idx);
+        const size_t outer_count = fd.deps.size();
+        if (outer_idx >= prev.get_dependencies().size() || outer_count == 0 || outer_count > prev.get_dependencies().size() - outer_idx) {
+            return false;
+        }
+
+        for (size_t i = 0; i < outer_count; ++i) {
+            const auto peer_layout = prev.get_dependency(outer_idx + i).get_output_layout();
+            if (peer_layout.get_rank() > reduced_rank && !fold_higher_rank_fused_peer(peer_layout, reduced_layout).has_value()) {
+                return false;
+            }
+        }
+    }
+
+    return true;
+}
+
 std::pair<std::shared_ptr<reorder>, bool> reorder_factory::get_reorder(primitive_id src_id,
                                                                        int32_t src_port,
                                                                        const layout& in_layout,
@@ -391,6 +423,14 @@ bool layout_optimizer::can_fuse_reorder(program_node& prev, program_node& next,
 
 bool layout_optimizer::can_fuse_reorder_to_prev(program_node& prev, reorder_node& node, format fmt_prev, format fmt_next) {
     bool allow_new_shape_infer = node.get_program().is_new_shape_infer();
+
+    // Do not fuse a rank-reducing reorder into a producer whose fused higher-rank
+    // eltwise peer cannot be indexed correctly at the reduced rank (inner-spatial
+    // broadcast over the collapsed axes). Keeping the producer at its higher rank
+    // keeps the fused peer rank-consistent so the fused-op kernel reads it right.
+    if (!node.get_output_layout().is_dynamic() && !fused_peers_can_fold_to_layout(prev, node.get_output_layout())) {
+        return false;
+    }
     // Because kernels can work cross-layout, if reorder only performs type conversion,
     // fusing reorder to the previous node can be done even if it is a dynamic shape case
     if ((format::is_simple_data_format(fmt_prev) && format::is_simple_data_format(fmt_next)) &&
@@ -398,8 +438,7 @@ bool layout_optimizer::can_fuse_reorder_to_prev(program_node& prev, reorder_node
         // We can void only that case if we can check whether the current node is backedge of the network.
         // However no such handle is existing yet. (To be done in the future when we need to optimize out the type converting
         // reorders in the body network)
-        !node.get_program().is_body_program() && !prev.is_in_shape_of_subgraph() &&
-        prev.get_preferred_impl_type() != cldnn::impl_types::cpu) {
+        !node.get_program().is_body_program() && !prev.is_in_shape_of_subgraph() && prev.get_preferred_impl_type() != cldnn::impl_types::cpu) {
         // case for truncate mode
         if ((prev.is_type<mvn>() || prev.is_type<concatenation>() || prev.is_type<gather>() || prev.is_type<broadcast>() ||
             prev.is_type<select>() || prev.is_type<eltwise>() || prev.is_type<rms>()) &&
diff --git a/src/plugins/intel_gpu/src/plugin/transformations/move_eltwise_up_data_movement_per_channel.cpp b/src/plugins/intel_gpu/src/plugin/transformations/move_eltwise_up_data_movement_per_channel.cpp
new file mode 100644
index 000000000000..c3b44d58aa18
--- /dev/null
+++ b/src/plugins/intel_gpu/src/plugin/transformations/move_eltwise_up_data_movement_per_channel.cpp
@@ -0,0 +1,178 @@
+// Copyright (C) 2018-2026 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include "move_eltwise_up_data_movement_per_channel.hpp"
+
+#include <algorithm>
+#include <cstdint>
+#include <limits>
+#include <memory>
+
+#include "openvino/core/graph_util.hpp"
+#include "openvino/core/rt_info.hpp"
+#include "openvino/op/constant.hpp"
+#include "openvino/op/reshape.hpp"
+#include "openvino/op/squeeze.hpp"
+#include "openvino/op/unsqueeze.hpp"
+#include "openvino/op/util/binary_elementwise_arithmetic.hpp"
+#include "openvino/pass/pattern/op/wrap_type.hpp"
+
+namespace {
+
+using ov::pass::pattern::Matcher;
+using ov::pass::pattern::wrap_type;
+
+namespace v0 = ov::op::v0;
+namespace v1 = ov::op::v1;
+namespace op_util = ov::op::util;
+
+}  // namespace
+
+ov::intel_gpu::MoveEltwiseUpThroughDataMovPerChannel::MoveEltwiseUpThroughDataMovPerChannel() {
+    auto const_predicate = [](const ov::Output<ov::Node>& output) {
+        auto constant_op = ov::as_type_ptr<v0::Constant>(output.get_node_shared_ptr());
+        if (!constant_op)
+            return false;
+
+        if (output.get_target_inputs().size() != 1)
+            return false;
+
+        const auto& shape = constant_op->get_shape();
+        return std::count_if(shape.begin(), shape.end(), [](size_t value) {
+                   return value > 1;
+               }) == 1;
+    };
+
+    auto eltw_predicate = [](const ov::Output<ov::Node>& output) {
+        if (output.get_target_inputs().size() != 1)
+            return false;
+
+        auto node = output.get_node();
+        if (node->get_output_partial_shape(0).rank().is_dynamic())
+            return false;
+
+        const size_t const_idx = ov::is_type<v0::Constant>(node->get_input_node_ptr(0)) ? 0 : 1;
+        const size_t data_flow_idx = (const_idx + 1) % 2;
+
+        return node->get_input_partial_shape(data_flow_idx).size() >= node->get_input_partial_shape(const_idx).size();
+    };
+
+    auto eltw_data_flow_in = wrap_type<v1::Reshape, v0::Squeeze, v0::Unsqueeze>(ov::pass::pattern::consumers_count(1));
+    auto eltw_const_in = wrap_type<v0::Constant>(const_predicate);
+    auto eltwise_pattern = wrap_type<op_util::BinaryElementwiseArithmetic>({eltw_data_flow_in, eltw_const_in}, eltw_predicate);
+
+    ov::matcher_pass_callback callback = [this, eltwise_pattern](Matcher& matcher) {
+        const auto& pattern_map = matcher.get_pattern_value_map();
+
+        auto eltwise = pattern_map.at(eltwise_pattern).get_node_shared_ptr();
+        if (transformation_callback(eltwise))
+            return false;
+
+        auto binary_eltwise = std::dynamic_pointer_cast<op_util::BinaryElementwiseArithmetic>(eltwise);
+        if (!binary_eltwise || binary_eltwise->get_autob().m_type != ov::op::AutoBroadcastType::NUMPY)
+            return false;
+
+        const size_t const_idx = ov::is_type<v0::Constant>(eltwise->get_input_node_ptr(0)) ? 0 : 1;
+        const size_t data_flow_idx = (const_idx + 1) % 2;
+
+        const auto const_shape = eltwise->get_input_shape(const_idx);
+        size_t channel_idx = 0;
+        size_t channel_val = 0;
+        for (size_t index = 0; index < const_shape.size(); ++index) {
+            if (const_shape[index] > 1) {
+                channel_idx = index;
+                channel_val = const_shape[index];
+            }
+        }
+
+        auto parent = eltwise->get_input_node_shared_ptr(data_flow_idx);
+        const auto& parent_in_pshape = parent->get_input_partial_shape(0);
+        const auto& parent_out_pshape = parent->get_output_partial_shape(0);
+
+        if (parent_in_pshape.rank().is_dynamic() || parent_out_pshape.rank().is_dynamic())
+            return false;
+
+        const size_t in_rank = parent_in_pshape.size();
+        const size_t out_rank = parent_out_pshape.size();
+
+        for (const auto& dimension : parent_in_pshape) {
+            if (dimension.is_dynamic())
+                return false;
+        }
+        for (const auto& dimension : parent_out_pshape) {
+            if (dimension.is_dynamic())
+                return false;
+        }
+
+        const size_t const_rank = const_shape.size();
+        if (const_rank > out_rank)
+            return false;
+
+        const size_t output_channel_idx = out_rank - const_rank + channel_idx;
+        if (output_channel_idx >= out_rank || static_cast<size_t>(parent_out_pshape[output_channel_idx].get_length()) != channel_val) {
+            return false;
+        }
+
+        int64_t output_stride = 1;
+        for (size_t index = output_channel_idx + 1; index < out_rank; ++index) {
+            const int64_t dimension = parent_out_pshape[index].get_length();
+            if (dimension > 0 && output_stride > std::numeric_limits<int64_t>::max() / dimension)
+                return false;
+            output_stride *= dimension;
+        }
+
+        size_t input_channel_idx = in_rank;
+        for (size_t index = 0; index < in_rank; ++index) {
+            if (static_cast<size_t>(parent_in_pshape[index].get_length()) != channel_val)
+                continue;
+
+            int64_t input_stride = 1;
+            bool overflow = false;
+            for (size_t trailing_index = index + 1; trailing_index < in_rank; ++trailing_index) {
+                const int64_t dimension = parent_in_pshape[trailing_index].get_length();
+                if (dimension > 0 && input_stride > std::numeric_limits<int64_t>::max() / dimension) {
+                    overflow = true;
+                    break;
+                }
+                input_stride *= dimension;
+            }
+
+            if (overflow)
+                continue;
+
+            if (input_stride == output_stride) {
+                if (input_channel_idx != in_rank)
+                    return false;
+                input_channel_idx = index;
+            }
+        }
+
+        if (input_channel_idx == in_rank)
+            return false;
+
+        auto new_shape = ov::Shape(in_rank, 1);
+        new_shape[input_channel_idx] = channel_val;
+        auto old_constant = ov::as_type_ptr<v0::Constant>(eltwise->get_input_node_shared_ptr(const_idx));
+        auto new_constant = std::make_shared<v0::Constant>(*old_constant, new_shape);
+        ov::replace_node_update_name(old_constant, new_constant);
+        ov::replace_output_update_name(eltwise->output(0), eltwise->input_value(data_flow_idx));
+
+        ov::OutputVector eltwise_inputs = eltwise->input_values();
+        eltwise_inputs[data_flow_idx] = parent->input_value(0);
+        auto new_eltwise = eltwise->clone_with_new_inputs(eltwise_inputs);
+        ov::copy_runtime_info(eltwise, new_eltwise);
+
+        ov::OutputVector parent_inputs = parent->input_values();
+        parent_inputs[0] = new_eltwise;
+        auto new_parent = parent->clone_with_new_inputs(parent_inputs);
+        ov::copy_runtime_info(parent, new_parent);
+        new_parent->set_friendly_name(parent->get_friendly_name());
+
+        ov::replace_node(parent, new_parent);
+        return true;
+    };
+
+    auto matcher = std::make_shared<Matcher>(eltwise_pattern, "MoveEltwiseUpThroughDataMovPerChannelGPU");
+    register_matcher(matcher, callback);
+}
diff --git a/src/plugins/intel_gpu/src/plugin/transformations/move_eltwise_up_data_movement_per_channel.hpp b/src/plugins/intel_gpu/src/plugin/transformations/move_eltwise_up_data_movement_per_channel.hpp
new file mode 100644
index 000000000000..b7bd64a50766
--- /dev/null
+++ b/src/plugins/intel_gpu/src/plugin/transformations/move_eltwise_up_data_movement_per_channel.hpp
@@ -0,0 +1,17 @@
+// Copyright (C) 2018-2026 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include "openvino/pass/graph_rewrite.hpp"
+
+namespace ov::intel_gpu {
+
+class MoveEltwiseUpThroughDataMovPerChannel : public ov::pass::MatcherPass {
+public:
+    OPENVINO_MATCHER_PASS_RTTI("MoveEltwiseUpThroughDataMovPerChannelGPU");
+    MoveEltwiseUpThroughDataMovPerChannel();
+};
+
+}  // namespace ov::intel_gpu
diff --git a/src/plugins/intel_gpu/src/plugin/transformations_pipeline.cpp b/src/plugins/intel_gpu/src/plugin/transformations_pipeline.cpp
index 79b317d4bd1a..420b1c77561a 100644
--- a/src/plugins/intel_gpu/src/plugin/transformations_pipeline.cpp
+++ b/src/plugins/intel_gpu/src/plugin/transformations_pipeline.cpp
@@ -106,6 +106,7 @@
 #include "plugin/transformations/kv_cache_fusion.hpp"
 #include "plugin/transformations/lora_horizontal_fusion.hpp"
 #include "plugin/transformations/lora_subgraph_horizontal_fusion.hpp"
+#include "plugin/transformations/move_eltwise_up_data_movement_per_channel.hpp"
 #include "intel_gpu/op/fully_connected.hpp"
 #include "transformations/common_optimizations/move_fc_reshape_to_weights.hpp"
 #include "plugin/transformations/optimize_subsequent_reshapes.hpp"
@@ -1662,7 +1663,7 @@ void TransformationsPipeline::apply(std::shared_ptr<ov::Model> func) {
         manager.register_pass<ov::intel_gpu::ConvertConvolutionToInternal>();
 
         // This pass should be done after asymmetric quantization matching as it can move zp subtraction upper in the graph
-        manager.register_pass<ov::pass::MoveEltwiseUpThroughDataMovPerChannel>();
+        manager.register_pass<ov::intel_gpu::MoveEltwiseUpThroughDataMovPerChannel>();
 
         manager.register_pass<ov::intel_gpu::ConvertStridedSlicesToVariadicSplit>();
 
diff --git a/src/plugins/intel_gpu/tests/unit/fusions/permute_fusion_test.cpp b/src/plugins/intel_gpu/tests/unit/fusions/permute_fusion_test.cpp
index 18940f0af1cb..4ec9e8246504 100644
--- a/src/plugins/intel_gpu/tests/unit/fusions/permute_fusion_test.cpp
+++ b/src/plugins/intel_gpu/tests/unit/fusions/permute_fusion_test.cpp
@@ -745,3 +745,767 @@ INSTANTIATE_TEST_SUITE_P(fusings_gpu, permute_eltwise_reorder, ::testing::Values
     permute_reorder_params{ CASE_PERMUTE_REORDER_TILED_F16_11, 3, 5 },
     permute_reorder_params{ CASE_PERMUTE_REORDER_TILED_F16_12, 3, 5 },
 }));
+
+// -----------------------------------------------------------------------------
+// Regression coverage for the fused-eltwise higher-rank-peer canonicalization fix
+// in canonicalize_fused_shapes() (kernel_selector_helper.h).
+//
+// Reproduces the df1 output-0 defect: in legacy shape-inference mode (the
+// default), a permute whose 5D output is flattened to 4D bfyx by the layout
+// optimizer (because a downstream Reshape consumes it) has an eltwise Add fused
+// in as a post-op, while the fused Add's peer dependency stays 5D bfzyx.
+// Before the fix, canonicalize_fused_shapes() could not down-rank the higher-rank
+// 5D peer to the 4D host output (extend_shape_to_rank_from_begin() only *extends*),
+// so the fused eltwise kernel read the 5D peer with 4D indexing and scrambled data
+// (MSE ~= 12-20 vs CPU). The fix folds the contiguous planar peer onto the host
+// shape, keeping the Add fused and producing the correct result.
+//
+// This mirrors the accepted reproducer_v3.xml built in-memory with its exact
+// f16 weights, so it exercises the real GPU compile/layout/fusion path rather
+// than a hand-forced cldnn topology (the 5D->4D flattening is IR-layout-optimizer
+// driven and cannot be reproduced with raw cldnn primitives). The reference is the
+// same model compiled on the reference device (CPU); GPU must match it. The
+// fusion, impl, and 4D-host / 5D-peer layout state are asserted explicitly so a
+// silently-unfused or re-laid-out graph cannot make the test pass for the wrong
+// reason. A companion NSI variant asserts the rank-consistent (both-5D) path stays
+// correct as well. A broadcast variant asserts that a legal higher-rank NumPy
+// broadcast peer (fewer elements than the host) compiles by default and matches
+// CPU, proving the fold is not restricted to the equal-total reshape case and that
+// no valid model fails compilation. Because ov::Core loads the installed GPU
+// plugin, validating a source change with these tests requires building AND
+// installing the plugin.
+
+#include <cstdlib>
+
+#include <openvino/runtime/core.hpp>
+#include <openvino/core/model.hpp>
+#include <openvino/runtime/exec_model_info.hpp>
+#include "openvino/op/parameter.hpp"
+#include "openvino/op/constant.hpp"
+#include "openvino/op/matmul.hpp"
+#include "openvino/op/transpose.hpp"
+#include "openvino/op/reshape.hpp"
+#include "openvino/op/add.hpp"
+
+namespace {
+// Exact f16 weights of reproducer_v3.bin (branch-1 and branch-2 MatMul, [12,8]).
+const std::vector<float> kReproV3Weights1 = {
+    -1.085938f, 0.997559f, 0.282959f, -1.505859f, -0.578613f, 1.651367f, -2.425781f, -0.428955f,
+    1.265625f, -0.866699f, -0.678711f, -0.094727f, 1.491211f, -0.638672f, -0.444092f, -0.434326f,
+    2.205078f, 2.187500f, 1.003906f, 0.386230f, 0.737305f, 1.491211f, -0.936035f, 1.175781f,
+    -1.253906f, -0.637695f, 0.907227f, -1.428711f, -0.140015f, -0.861816f, -0.255615f, -2.798828f,
+    -1.771484f, -0.699707f, 0.927246f, -0.173584f, 0.002846f, 0.687988f, -0.879395f, 0.283691f,
+    -0.805176f, -1.727539f, -0.390869f, 0.573730f, 0.338623f, -0.011833f, 2.392578f, 0.412842f,
+    0.978516f, 2.238281f, -1.293945f, -1.039062f, 1.744141f, -0.797852f, 0.029678f, 1.069336f,
+    0.890625f, 1.754883f, 1.496094f, 1.069336f, -0.772949f, 0.794922f, 0.314209f, -1.326172f,
+    1.416992f, 0.807129f, 0.045502f, -0.233032f, -1.198242f, 0.199585f, 0.468506f, -0.831055f,
+    1.162109f, -1.097656f, -2.123047f, 1.040039f, -0.403320f, -0.125977f, -0.837402f, -1.606445f,
+    1.254883f, -0.688965f, 1.661133f, 0.807129f, -0.314697f, -1.085938f, -0.732422f, -1.212891f,
+    2.087891f, 0.164429f, 1.150391f, -1.267578f, 0.181030f, 1.177734f, -0.334961f, 1.031250f};
+
+const std::vector<float> kReproV3Weights2 = {
+    -1.084961f, -1.363281f, 0.379395f, -0.379150f, 0.642090f, -1.977539f, 0.712402f, 2.597656f,
+    -0.024628f, 0.034149f, 0.179565f, -1.862305f, 0.426025f, -1.605469f, -0.427734f, 1.243164f,
+    -0.735352f, 0.501465f, 1.012695f, 0.278809f, -1.371094f, -0.332520f, 1.958984f, -2.025391f,
+    -0.275879f, -0.552246f, 0.120728f, 0.748047f, 1.608398f, -0.270264f, 0.812500f, 0.499756f,
+    0.474365f, -0.563965f, -0.997559f, -1.099609f, -0.756348f, 0.321777f, 0.760742f, 0.323486f,
+    -0.548828f, 1.805664f, 1.518555f, -0.354004f, -0.823242f, 0.130249f, 1.267578f, 0.332764f,
+    0.556641f, -0.212036f, 0.456299f, 1.544922f, -0.239624f, 0.143311f, 0.253906f, 0.283691f,
+    -1.412109f, -1.876953f, -1.019531f, 0.167969f, 0.553711f, -0.530762f, 1.376953f, -0.143188f,
+    0.020309f, -0.193970f, 0.134033f, 0.704590f, 0.665527f, -0.898438f, 1.523438f, -1.094727f,
+    0.079224f, -0.274414f, -1.048828f, -0.075134f, -0.740723f, 0.072937f, 0.403076f, 1.471680f,
+    0.307373f, -0.611328f, -0.391602f, 0.140015f, 0.093445f, 1.459961f, 1.395508f, -0.358887f,
+    -0.548828f, -2.556641f, -0.548828f, -0.978027f, -0.354736f, 0.391602f, 0.177246f, -0.029968f};
+
+// Builds the reproducer_v3 model:
+//   in[1,2,60,12] -> Reshape[1,2,6,10,12] -> MatMul(*W) -> [1,2,6,10,8]
+//     -> Transpose[0,1,4,2,3] -> [1,2,8,6,10]     (two such branches)
+//   Add(branch1, branch2) -> Reshape[2,8,6,10] -> Result
+std::shared_ptr<ov::Model> build_repro_v3_model() {
+    using namespace ov;
+    auto make_branch = [](const std::shared_ptr<op::v0::Parameter>& param,
+                          const std::vector<float>& w) {
+        auto to5d = op::v0::Constant::create(element::i64, Shape{5}, {1, 2, 6, 10, 12});
+        auto reshape5d = std::make_shared<op::v1::Reshape>(param, to5d, false);
+        auto weights = std::make_shared<op::v0::Constant>(element::f16, Shape{12, 8},
+                                                          std::vector<ov::float16>(w.begin(), w.end()));
+        auto matmul = std::make_shared<op::v0::MatMul>(reshape5d, weights, false, false);
+        auto order = op::v0::Constant::create(element::i64, Shape{5}, {0, 1, 4, 2, 3});
+        return std::make_shared<op::v1::Transpose>(matmul, order);
+    };
+
+    auto in1 = std::make_shared<op::v0::Parameter>(element::f16, PartialShape{1, 2, 60, 12});
+    auto in2 = std::make_shared<op::v0::Parameter>(element::f16, PartialShape{1, 2, 60, 12});
+    in1->set_friendly_name("input1");
+    in2->set_friendly_name("input2");
+
+    auto t1 = make_branch(in1, kReproV3Weights1);
+    t1->set_friendly_name("Transpose_target");
+    auto t2 = make_branch(in2, kReproV3Weights2);
+    t2->set_friendly_name("Transpose_peer");
+
+    auto add = std::make_shared<op::v1::Add>(t1, t2);
+    add->set_friendly_name("Add_target");
+
+    auto to4d = op::v0::Constant::create(element::i64, Shape{4}, {2, 8, 6, 10});
+    auto reshape4d = std::make_shared<op::v1::Reshape>(add, to4d, false);
+    reshape4d->set_friendly_name("Reshape_to4D");
+
+    auto result = std::make_shared<op::v0::Result>(reshape4d);
+    return std::make_shared<ov::Model>(ResultVector{result}, ParameterVector{in1, in2}, "reproducer_v3");
+}
+
+// Compiles build_repro_v3_model() on the given device and returns the f16 output flattened to float.
+std::pair<std::vector<float>, ov::CompiledModel> run_repro_v3(ov::Core& core,
+                                                              const std::string& device,
+                                                              const ov::AnyMap& cfg,
+                                                              const ov::Tensor& in1,
+                                                              const ov::Tensor& in2) {
+    auto model = build_repro_v3_model();
+    auto compiled = core.compile_model(model, device, cfg);
+    auto req = compiled.create_infer_request();
+    req.set_input_tensor(0, in1);
+    req.set_input_tensor(1, in2);
+    req.infer();
+    auto out = req.get_output_tensor(0);
+    std::vector<float> vals(out.get_size());
+    const auto* p = out.data<ov::float16>();
+    for (size_t i = 0; i < out.get_size(); ++i)
+        vals[i] = static_cast<float>(p[i]);
+    return std::make_pair(vals, compiled);
+}
+
+double repro_v3_mse(const std::vector<float>& a, const std::vector<float>& b, double& max_ae) {
+    double se = 0.0;
+    max_ae = 0.0;
+    for (size_t i = 0; i < a.size(); ++i) {
+        double d = static_cast<double>(a[i]) - static_cast<double>(b[i]);
+        se += d * d;
+        max_ae = std::max(max_ae, std::abs(d));
+    }
+    return se / static_cast<double>(a.size());
+}
+
+bool discover_gpu_and_cpu(ov::Core& core) {
+    std::vector<std::string> devices;
+    try {
+        devices = core.get_available_devices();
+    } catch (...) {}
+    const bool has_gpu = std::any_of(devices.begin(), devices.end(),
+                                     [](const std::string& d) { return d.rfind("GPU", 0) == 0; });
+    const bool has_cpu = std::any_of(devices.begin(), devices.end(),
+                                     [](const std::string& d) { return d == "CPU"; });
+    return has_gpu && has_cpu;
+}
+
+void fill_repro_v3_inputs(ov::Tensor& in1, ov::Tensor& in2) {
+    tests::random_generator rg;
+    rg.set_seed(GET_SUITE_NAME);
+    auto rnd = rg.generate_random_1d<ov::float16>(1 * 2 * 60 * 12, -2, 2);
+    std::copy(rnd.begin(), rnd.end(), in1.data<ov::float16>());
+    auto rnd2 = rg.generate_random_1d<ov::float16>(1 * 2 * 60 * 12, -2, 2);
+    std::copy(rnd2.begin(), rnd2.end(), in2.data<ov::float16>());
+}
+
+// Cross-platform, exception-safe scoped environment-variable override. On construction it records the
+// previous value (if any) and sets the new one; on destruction it restores the previous value or unsets
+// the variable, so every exit path (including a thrown/failed assertion) leaves the environment as it
+// was found. Uses _putenv_s on Windows and setenv/unsetenv elsewhere.
+class ScopedEnvVar {
+public:
+    ScopedEnvVar(const char* name, const char* value) : m_name(name) {
+        const char* prev = std::getenv(name);
+        if (prev != nullptr) {
+            m_had_prev = true;
+            m_prev = prev;
+        }
+        set(name, value);
+    }
+    ~ScopedEnvVar() {
+        if (m_had_prev) {
+            set(m_name.c_str(), m_prev.c_str());
+        } else {
+            unset(m_name.c_str());
+        }
+    }
+    ScopedEnvVar(const ScopedEnvVar&) = delete;
+    ScopedEnvVar& operator=(const ScopedEnvVar&) = delete;
+
+private:
+    static void set(const char* name, const char* value) {
+#ifdef _WIN32
+        _putenv_s(name, value);
+#else
+        ::setenv(name, value, 1);
+#endif
+    }
+    static void unset(const char* name) {
+#ifdef _WIN32
+        _putenv_s(name, "");
+#else
+        ::unsetenv(name);
+#endif
+    }
+    std::string m_name;
+    std::string m_prev;
+    bool m_had_prev = false;
+};
+
+// Builds a higher-rank *broadcast* variant of the reproducer_v3 model: the host branch produces
+// [1,2,8,6,10] (flattened to 4D bfyx [1,2,48,10]) while the peer branch produces [1,1,8,6,10] (5D
+// bfzyx), which broadcasts against the host over the feature dim. Element counts differ (960 vs 480),
+// so this is a legal NumPy broadcast, NOT the equal-total reshape of reproducer_v3. Before the Worker
+// 08R fix this aborted GPU compilation at the Worker 08 fold assertion; the fix must compile it and
+// match CPU with the Add kept fused.
+std::shared_ptr<ov::Model> build_broadcast_repro_model() {
+    using namespace ov;
+    auto make_branch = [](const std::shared_ptr<op::v0::Parameter>& param, int64_t f,
+                          const std::vector<float>& w) {
+        auto to5d = op::v0::Constant::create(element::i64, Shape{5},
+                                             std::vector<int64_t>{1, f, 6, 10, 12});
+        auto reshape5d = std::make_shared<op::v1::Reshape>(param, to5d, false);
+        auto weights = std::make_shared<op::v0::Constant>(element::f16, Shape{12, 8},
+                                                          std::vector<ov::float16>(w.begin(), w.end()));
+        auto matmul = std::make_shared<op::v0::MatMul>(reshape5d, weights, false, false);
+        auto order = op::v0::Constant::create(element::i64, Shape{5}, {0, 1, 4, 2, 3});
+        return std::make_shared<op::v1::Transpose>(matmul, order);
+    };
+
+    auto in1 = std::make_shared<op::v0::Parameter>(element::f16, PartialShape{1, 2, 60, 12});
+    auto in2 = std::make_shared<op::v0::Parameter>(element::f16, PartialShape{1, 1, 60, 12});
+    in1->set_friendly_name("input1");
+    in2->set_friendly_name("input2");
+
+    auto t1 = make_branch(in1, 2, kReproV3Weights1);  // host: [1,2,8,6,10]
+    t1->set_friendly_name("Transpose_target");
+    auto t2 = make_branch(in2, 1, kReproV3Weights2);  // peer: [1,1,8,6,10] (broadcasts over F)
+    t2->set_friendly_name("Transpose_peer");
+
+    auto add = std::make_shared<op::v1::Add>(t1, t2);
+    add->set_friendly_name("Add_target");
+
+    auto to4d = op::v0::Constant::create(element::i64, Shape{4}, {2, 8, 6, 10});
+    auto reshape4d = std::make_shared<op::v1::Reshape>(add, to4d, false);
+    reshape4d->set_friendly_name("Reshape_to4D");
+
+    auto result = std::make_shared<op::v0::Result>(reshape4d);
+    return std::make_shared<ov::Model>(ResultVector{result}, ParameterVector{in1, in2}, "broadcast_repro");
+}
+
+std::pair<std::vector<float>, ov::CompiledModel> run_broadcast_repro(ov::Core& core,
+                                                                     const std::string& device,
+                                                                     const ov::Tensor& in1,
+                                                                     const ov::Tensor& in2) {
+    auto model = build_broadcast_repro_model();
+    auto compiled = core.compile_model(model, device);
+    auto req = compiled.create_infer_request();
+    req.set_input_tensor(0, in1);
+    req.set_input_tensor(1, in2);
+    req.infer();
+    auto out = req.get_output_tensor(0);
+    std::vector<float> vals(out.get_size());
+    const auto* p = out.data<ov::float16>();
+    for (size_t i = 0; i < out.get_size(); ++i)
+        vals[i] = static_cast<float>(p[i]);
+    return std::make_pair(vals, compiled);
+}
+}  // namespace
+
+// Default (legacy) path: the target permute host output is flattened to 4D bfyx while the fused Add's
+// peer dependency stays 5D bfzyx. The fix must keep the Add fused, keep permute_ref, and produce a
+// result that matches the CPU reference (the higher-rank peer is folded onto the 4D host shape).
+TEST(permute_fused_eltwise_rank_mismatch, legacy_5d_peer_into_4d_host) {
+    ov::Core core;
+    if (!discover_gpu_and_cpu(core)) {
+        GTEST_SKIP() << "Requires both GPU and CPU plugins discoverable via ov::Core.";
+    }
+
+    ov::Tensor in1(ov::element::f16, ov::Shape{1, 2, 60, 12});
+    ov::Tensor in2(ov::element::f16, ov::Shape{1, 2, 60, 12});
+    fill_repro_v3_inputs(in1, in2);
+
+    auto [cpu_vals, cpu_compiled] = run_repro_v3(core, "CPU", {}, in1, in2);
+    auto [gpu_vals, gpu_compiled] = run_repro_v3(core, "GPU", {}, in1, in2);
+
+    // --- Prove the buggy graph state is actually present on GPU (4D fused host + 5D peer). ---
+    auto rt = gpu_compiled.get_runtime_model();
+    bool found_fused_target = false;
+    bool target_is_4d = false;
+    bool target_is_permute_ref = false;
+    bool peer_is_5d = false;
+    for (const auto& node : rt->get_ordered_ops()) {
+        const auto& info = node->get_rt_info();
+        auto it = info.find(ov::exec_model_info::ORIGINAL_NAMES);
+        if (it == info.end())
+            continue;
+        const auto orig = it->second.as<std::string>();
+        std::string impl;
+        if (auto i2 = info.find(ov::exec_model_info::IMPL_TYPE); i2 != info.end())
+            impl = i2->second.as<std::string>();
+
+        // Target permute: Add fused in, permute_ref, 4D output.
+        if (orig.find("Transpose_target") != std::string::npos &&
+            orig.find("Add_target") != std::string::npos) {
+            found_fused_target = true;
+            target_is_permute_ref = impl.find("permute_ref") != std::string::npos;
+            target_is_4d = node->get_output_partial_shape(0).rank().get_length() == 4;
+        }
+        // Peer permute: still 5D.
+        if (orig.find("Transpose_peer") != std::string::npos &&
+            orig.find("Add_target") == std::string::npos) {
+            peer_is_5d = node->get_output_partial_shape(0).rank().get_length() == 5;
+        }
+    }
+    ASSERT_TRUE(found_fused_target) << "Add_target was not fused into Transpose_target on GPU; "
+                                       "the fusion mechanism under test is absent.";
+    ASSERT_TRUE(target_is_permute_ref) << "Target permute did not select permute_ref.";
+    ASSERT_TRUE(target_is_4d) << "Target permute host output was not flattened to 4D.";
+    ASSERT_TRUE(peer_is_5d) << "Fused peer dependency was not 5D; rank-mismatch condition absent.";
+
+    // --- Numerical gate: GPU must match the CPU reference. ---
+    ASSERT_EQ(gpu_vals.size(), cpu_vals.size());
+    double max_ae = 0.0;
+    double mse = repro_v3_mse(gpu_vals, cpu_vals, max_ae);
+    // FP16 tolerance: correct path agrees with CPU to ~1e-3 MSE; the bug produced MSE ~12.
+    EXPECT_LT(mse, 1e-2) << "GPU fused-permute output diverges from CPU reference. "
+                            "MSE=" << mse << " MaxAbsErr=" << max_ae
+                         << " (rank-mismatched fused eltwise reads 5D peer with 4D indexing).";
+}
+
+// New-shape-infer (NSI) path: the host output stays 5D bfzyx so the fused peer is already
+// rank-consistent (both 5D). This path never entered the broken repair branch and must remain correct;
+// it guards against a fix that only works because it changed the default flattening behavior.
+// NSI is a RELEASE_INTERNAL option, so it is selected through its OV_GPU environment variable (the same
+// mechanism used by the standalone reproducer controls), not via a public compile_model property.
+TEST(permute_fused_eltwise_rank_mismatch, nsi_5d_peer_and_5d_host) {
+    ov::Core core;
+    if (!discover_gpu_and_cpu(core)) {
+        GTEST_SKIP() << "Requires both GPU and CPU plugins discoverable via ov::Core.";
+    }
+
+    ov::Tensor in1(ov::element::f16, ov::Shape{1, 2, 60, 12});
+    ov::Tensor in2(ov::element::f16, ov::Shape{1, 2, 60, 12});
+    fill_repro_v3_inputs(in1, in2);
+
+    auto [cpu_vals, cpu_compiled] = run_repro_v3(core, "CPU", {}, in1, in2);
+
+    // Use a fresh Core so the NSI env option is picked up for the GPU compile. The scoped guard restores
+    // any pre-existing value on every exit path, including a failed assertion below.
+    std::pair<std::vector<float>, ov::CompiledModel> gpu_result;
+    {
+        ScopedEnvVar nsi_env("OV_GPU_ALLOW_NEW_SHAPE_INFER", "1");
+        ov::Core nsi_core;
+        gpu_result = run_repro_v3(nsi_core, "GPU", {}, in1, in2);
+    }
+    auto& gpu_vals = gpu_result.first;
+    auto& gpu_compiled = gpu_result.second;
+
+    // Under NSI the fused target permute output stays 5D (rank-consistent with the peer).
+    auto rt = gpu_compiled.get_runtime_model();
+    bool found_fused_target = false;
+    bool target_is_5d = false;
+    for (const auto& node : rt->get_ordered_ops()) {
+        const auto& info = node->get_rt_info();
+        auto it = info.find(ov::exec_model_info::ORIGINAL_NAMES);
+        if (it == info.end())
+            continue;
+        const auto orig = it->second.as<std::string>();
+        if (orig.find("Transpose_target") != std::string::npos &&
+            orig.find("Add_target") != std::string::npos) {
+            found_fused_target = true;
+            target_is_5d = node->get_output_partial_shape(0).rank().get_length() == 5;
+        }
+    }
+    ASSERT_TRUE(found_fused_target) << "Add_target was not fused into Transpose_target under NSI.";
+    ASSERT_TRUE(target_is_5d) << "Under NSI the fused permute host output should remain 5D.";
+
+    ASSERT_EQ(gpu_vals.size(), cpu_vals.size());
+    double max_ae = 0.0;
+    double mse = repro_v3_mse(gpu_vals, cpu_vals, max_ae);
+    EXPECT_LT(mse, 1e-2) << "GPU (NSI) fused-permute output diverges from CPU reference. "
+                            "MSE=" << mse << " MaxAbsErr=" << max_ae;
+}
+
+// Legal higher-rank NumPy broadcast peer: the host branch produces a 4D-flattened bfyx [1,2,48,10]
+// host while the fused peer stays 5D bfzyx [1,1,8,6,10] and broadcasts over the feature dim. The peer
+// holds FEWER elements than the host (480 vs 960), so it is not the equal-total reshape case; Worker
+// 08's equal-total predicate rejected it and its OPENVINO_ASSERT aborted compilation of this valid
+// model. The Worker 08R fix must compile it by default (no override), keep the Add fused, and match the
+// CPU reference. This is the primary regression guard for the rejected-broadcast defect.
+TEST(permute_fused_eltwise_rank_mismatch, legacy_higher_rank_broadcast_peer_compiles_and_matches_cpu) {
+    ov::Core core;
+    if (!discover_gpu_and_cpu(core)) {
+        GTEST_SKIP() << "Requires both GPU and CPU plugins discoverable via ov::Core.";
+    }
+
+    tests::random_generator rg;
+    rg.set_seed(GET_SUITE_NAME);
+    ov::Tensor in1(ov::element::f16, ov::Shape{1, 2, 60, 12});
+    ov::Tensor in2(ov::element::f16, ov::Shape{1, 1, 60, 12});
+    auto rnd1 = rg.generate_random_1d<ov::float16>(1 * 2 * 60 * 12, -2, 2);
+    std::copy(rnd1.begin(), rnd1.end(), in1.data<ov::float16>());
+    auto rnd2 = rg.generate_random_1d<ov::float16>(1 * 1 * 60 * 12, -2, 2);
+    std::copy(rnd2.begin(), rnd2.end(), in2.data<ov::float16>());
+
+    auto [cpu_vals, cpu_compiled] = run_broadcast_repro(core, "CPU", in1, in2);
+
+    // Default GPU compilation must SUCCEED (the Worker 08 assertion is removed) and keep the Add fused.
+    std::vector<float> gpu_vals;
+    ov::CompiledModel gpu_compiled;
+    ASSERT_NO_THROW({
+        auto res = run_broadcast_repro(core, "GPU", in1, in2);
+        gpu_vals = res.first;
+        gpu_compiled = res.second;
+    }) << "Default GPU compilation of the valid higher-rank broadcast model must not fail.";
+
+    // The legal Add fusion must be retained (the fold represents the peer at the host rank).
+    auto rt = gpu_compiled.get_runtime_model();
+    bool found_fused_target = false;
+    bool target_is_permute_ref = false;
+    for (const auto& node : rt->get_ordered_ops()) {
+        const auto& info = node->get_rt_info();
+        auto it = info.find(ov::exec_model_info::ORIGINAL_NAMES);
+        if (it == info.end())
+            continue;
+        const auto orig = it->second.as<std::string>();
+        std::string impl;
+        if (auto i2 = info.find(ov::exec_model_info::IMPL_TYPE); i2 != info.end())
+            impl = i2->second.as<std::string>();
+        if (orig.find("Transpose_target") != std::string::npos &&
+            orig.find("Add_target") != std::string::npos) {
+            found_fused_target = true;
+            target_is_permute_ref = impl.find("permute_ref") != std::string::npos;
+        }
+    }
+    ASSERT_TRUE(found_fused_target) << "Add_target was not fused into Transpose_target on GPU; the "
+                                       "broadcast fold must retain the legal fusion.";
+    EXPECT_TRUE(target_is_permute_ref) << "Target permute did not select permute_ref.";
+
+    // Numerical gate: GPU broadcast result must match the CPU reference.
+    ASSERT_EQ(gpu_vals.size(), cpu_vals.size());
+    double max_ae = 0.0;
+    double mse = repro_v3_mse(gpu_vals, cpu_vals, max_ae);
+    for (float v : gpu_vals)
+        ASSERT_TRUE(std::isfinite(v)) << "GPU broadcast output has non-finite values.";
+    EXPECT_LT(mse, 1e-2) << "GPU higher-rank-broadcast fused-permute output diverges from CPU. "
+                            "MSE=" << mse << " MaxAbsErr=" << max_ae;
+}
+
+// -----------------------------------------------------------------------------
+// Worker 08S: behavior-level collapsed-axis broadcast matrix.
+//
+// Host permute output is 5D bfzyx [1,2,8,6,10], flattened by the layout optimizer
+// to 4D bfyx [1,2,48,10] (collapsing z=8,y=6 -> 48) because a downstream Reshape
+// consumes it. The fused Add peer keeps its 5D rank with a per-axis broadcast mask
+// over {f,z,y,x}. The direct fix retains rank reduction only when the shared
+// fold_higher_rank_fused_peer() proof can represent that peer at the actual 4D
+// output layout. Every other mask conservatively keeps the permute at 5D, avoiding
+// the mismatched indexing that made inner-spatial broadcasts silently wrong. Every
+// mask below must compile by default on GPU.1, be finite, and match the CPU
+// reference; the intended fused/rank-preserved runtime state is asserted so a
+// silently-unfused or mis-laid-out graph cannot pass for the wrong reason.
+namespace {
+
+struct collapse_mask_case {
+    // peer extents on f,z,y,x (1 => broadcast). Host is always [1,2,8,6,10].
+    int64_t pf, pz, py, px;
+    // Expected: does the host permute stay higher-rank because no exact 4D peer
+    // representation can be proven?
+    bool expect_rank_preserved;
+    const char* label;
+};
+
+// Builds host [1,2,8,6,10] + peer [1,pf,pz,py,px], Add (numpy broadcast), Reshape to 4D.
+std::shared_ptr<ov::Model> build_collapse_mask_model(const collapse_mask_case& c) {
+    using namespace ov;
+    auto make_branch = [](const std::shared_ptr<op::v0::Parameter>& param, int64_t f, int64_t z, int64_t y, int64_t x, const std::vector<float>& w) {
+        // pre-transpose logical [1,f,y,x,K] -> matmul(K,z) -> [1,f,y,x,z] -> transpose[0,1,4,2,3]
+        const int64_t K = 12;
+        auto to5d = op::v0::Constant::create(element::i64, Shape{5}, std::vector<int64_t>{1, f, y, x, K});
+        auto reshape5d = std::make_shared<op::v1::Reshape>(param, to5d, false);
+        std::vector<ov::float16> wz(static_cast<size_t>(K * z));
+        for (size_t i = 0; i < wz.size(); ++i)
+            wz[i] = static_cast<ov::float16>(w[i % w.size()]);
+        auto weights = std::make_shared<op::v0::Constant>(element::f16, Shape{static_cast<size_t>(K), static_cast<size_t>(z)}, wz);
+        auto matmul = std::make_shared<op::v0::MatMul>(reshape5d, weights, false, false);
+        auto order = op::v0::Constant::create(element::i64, Shape{5}, {0, 1, 4, 2, 3});
+        return std::make_shared<op::v1::Transpose>(matmul, order);  // [1,f,z,y,x]
+    };
+
+    auto in1 = std::make_shared<op::v0::Parameter>(element::f16, PartialShape{1, 2, 60, 12});
+    auto in2 = std::make_shared<op::v0::Parameter>(element::f16, PartialShape{1, c.pf, c.py * c.px, 12});
+    in1->set_friendly_name("input1");
+    in2->set_friendly_name("input2");
+
+    auto t1 = make_branch(in1, 2, 8, 6, 10, kReproV3Weights1);  // host [1,2,8,6,10]
+    t1->set_friendly_name("Transpose_target");
+    auto t2 = make_branch(in2, c.pf, c.pz, c.py, c.px, kReproV3Weights2);  // peer [1,pf,pz,py,px]
+    t2->set_friendly_name("Transpose_peer");
+
+    auto add = std::make_shared<op::v1::Add>(t1, t2);
+    add->set_friendly_name("Add_target");
+
+    auto to4d = op::v0::Constant::create(element::i64, Shape{4}, {2, 8, 6, 10});
+    auto reshape4d = std::make_shared<op::v1::Reshape>(add, to4d, false);
+    reshape4d->set_friendly_name("Reshape_to4D");
+
+    auto result = std::make_shared<op::v0::Result>(reshape4d);
+    return std::make_shared<ov::Model>(ResultVector{result}, ParameterVector{in1, in2}, "collapse_mask");
+}
+
+std::pair<std::vector<float>, ov::CompiledModel> run_collapse_mask(ov::Core& core,
+                                                                   const std::string& device,
+                                                                   const collapse_mask_case& c,
+                                                                   const ov::Tensor& in1,
+                                                                   const ov::Tensor& in2) {
+    auto model = build_collapse_mask_model(c);
+    auto compiled = core.compile_model(model, device);
+    auto req = compiled.create_infer_request();
+    req.set_input_tensor(0, in1);
+    req.set_input_tensor(1, in2);
+    req.infer();
+    auto out = req.get_output_tensor(0);
+    std::vector<float> vals(out.get_size());
+    const auto* p = out.data<ov::float16>();
+    for (size_t i = 0; i < out.get_size(); ++i)
+        vals[i] = static_cast<float>(p[i]);
+    return std::make_pair(vals, compiled);
+}
+
+class permute_fused_collapse_broadcast_matrix : public ::testing::TestWithParam<collapse_mask_case> {};
+
+}  // namespace
+
+TEST_P(permute_fused_collapse_broadcast_matrix, compiles_finite_and_matches_cpu) {
+    const auto c = GetParam();
+    ov::Core core;
+    if (!discover_gpu_and_cpu(core)) {
+        GTEST_SKIP() << "Requires both GPU and CPU plugins discoverable via ov::Core.";
+    }
+
+    tests::random_generator rg;
+    rg.set_seed(GET_SUITE_NAME);
+    ov::Tensor in1(ov::element::f16, ov::Shape{1, 2, 60, 12});
+    ov::Tensor in2(ov::element::f16, ov::Shape{1, static_cast<size_t>(c.pf), static_cast<size_t>(c.py * c.px), 12});
+    auto rnd1 = rg.generate_random_1d<ov::float16>(in1.get_size(), -2, 2);
+    std::copy(rnd1.begin(), rnd1.end(), in1.data<ov::float16>());
+    auto rnd2 = rg.generate_random_1d<ov::float16>(in2.get_size(), -2, 2);
+    std::copy(rnd2.begin(), rnd2.end(), in2.data<ov::float16>());
+
+    auto [cpu_vals, cpu_compiled] = run_collapse_mask(core, "CPU", c, in1, in2);
+
+    std::vector<float> gpu_vals;
+    ov::CompiledModel gpu_compiled;
+    ASSERT_NO_THROW({
+        auto res = run_collapse_mask(core, "GPU", c, in1, in2);
+        gpu_vals = res.first;
+        gpu_compiled = res.second;
+    }) << "Default GPU compilation must not fail for mask "
+       << c.label;
+
+    // Assert the intended runtime state: Add fused into Transpose_target, and the host permute rank
+    // matches the fix's decision (5D preserved for the inner-spatial masks, 4D flattened otherwise).
+    auto rt = gpu_compiled.get_runtime_model();
+    bool found_fused_target = false;
+    int64_t target_rank = 0;
+    for (const auto& node : rt->get_ordered_ops()) {
+        const auto& info = node->get_rt_info();
+        auto it = info.find(ov::exec_model_info::ORIGINAL_NAMES);
+        if (it == info.end())
+            continue;
+        const auto orig = it->second.as<std::string>();
+        if (orig.find("Transpose_target") != std::string::npos && orig.find("Add_target") != std::string::npos) {
+            found_fused_target = true;
+            target_rank = node->get_output_partial_shape(0).rank().get_length();
+        }
+    }
+    ASSERT_TRUE(found_fused_target) << "Add_target not fused into Transpose_target for mask " << c.label;
+    if (c.expect_rank_preserved) {
+        EXPECT_EQ(target_rank, 5) << "Inner-spatial mask " << c.label << " must keep the fused permute host at 5D (rank preserved).";
+    } else {
+        EXPECT_EQ(target_rank, 4) << "Representable mask " << c.label << " should keep the flattened 4D fused host.";
+    }
+
+    ASSERT_EQ(gpu_vals.size(), cpu_vals.size());
+    for (float v : gpu_vals)
+        ASSERT_TRUE(std::isfinite(v)) << "Non-finite GPU output for mask " << c.label;
+    double max_ae = 0.0;
+    double mse = repro_v3_mse(gpu_vals, cpu_vals, max_ae);
+    EXPECT_LT(mse, 1e-2) << "GPU vs CPU mismatch for mask " << c.label << " MSE=" << mse << " MaxAbsErr=" << max_ae;
+}
+
+INSTANTIATE_TEST_SUITE_P(collapse_broadcast_matrix,
+                         permute_fused_collapse_broadcast_matrix,
+                         ::testing::Values(
+                             // host [1,2,8,6,10]; peer f,z,y,x extents (1 == broadcast).
+                             collapse_mask_case{2, 8, 6, 10, false, "equal_total"},            // [1,2,8,6,10]
+                             collapse_mask_case{1, 8, 6, 10, false, "feature_broadcast"},      // [1,1,8,6,10] (W08R)
+                             collapse_mask_case{2, 1, 6, 10, true, "outer_z_broadcast"},       // [1,2,1,6,10]
+                             collapse_mask_case{2, 8, 1, 10, true, "inner_y_broadcast"},       // [1,2,8,1,10] REGRESSION
+                             collapse_mask_case{2, 1, 1, 10, false, "all_spatial_broadcast"},  // [1,2,1,1,10]
+                             collapse_mask_case{2, 8, 6, 1, false, "trailing_x_broadcast"},    // [1,2,8,6,1]
+                             collapse_mask_case{2, 8, 1, 1, true, "inner_y_and_x_broadcast"}   // [1,2,8,1,1] REGRESSION
+                             ),
+                         [](const ::testing::TestParamInfo<collapse_mask_case>& info) {
+                             return std::string(info.param.label);
+                         });
+
+// -----------------------------------------------------------------------------
+// Direct-fix 6D-to-4D matrix. Host permute output is 6D bfwzyx
+// [1,2,X=2,W=4,Z=3,Y=5], and a downstream Reshape introduces the actual reduced
+// bfyx layout selected by the optimizer. All 16 spatial broadcast masks are
+// covered. Rank reduction is retained only when fold_higher_rank_fused_peer()
+// proves that the peer can be represented at that exact reduced layout; every
+// other mask conservatively keeps the producer at 6D. Each case must remain
+// fused, compile by default, be finite, match CPU, and use the expected rank.
+namespace {
+
+struct collapse6d_case {
+    int64_t pf, px, pw, pz, py;  // peer extents on x,w,z,y (1 => broadcast); host [1,2,2,4,3,5]
+    bool expect_rank_preserved;
+    const char* label;
+};
+
+std::shared_ptr<ov::Model> build_collapse6d_model(const collapse6d_case& c) {
+    using namespace ov;
+    const int64_t X = 2, K = 12;
+    auto make_branch =
+        [&](const std::shared_ptr<op::v0::Parameter>& param, int64_t f, int64_t x, int64_t w, int64_t z, int64_t y, const std::vector<float>& wsrc) {
+            // pre [1,f,w,z,y,K] -> matmul(K,x) -> [1,f,w,z,y,x] -> transpose[0,1,5,2,3,4] -> [1,f,x,w,z,y]
+            auto to6d = op::v0::Constant::create(element::i64, Shape{6}, std::vector<int64_t>{1, f, w, z, y, K});
+            auto reshape6d = std::make_shared<op::v1::Reshape>(param, to6d, false);
+            std::vector<ov::float16> wx(static_cast<size_t>(K * x));
+            for (size_t i = 0; i < wx.size(); ++i)
+                wx[i] = static_cast<ov::float16>(wsrc[i % wsrc.size()]);
+            auto weights = std::make_shared<op::v0::Constant>(element::f16, Shape{static_cast<size_t>(K), static_cast<size_t>(x)}, wx);
+            auto matmul = std::make_shared<op::v0::MatMul>(reshape6d, weights, false, false);
+            auto order = op::v0::Constant::create(element::i64, Shape{6}, {0, 1, 5, 2, 3, 4});
+            return std::make_shared<op::v1::Transpose>(matmul, order);  // [1,f,x,w,z,y]
+        };
+
+    auto in1 = std::make_shared<op::v0::Parameter>(element::f16, PartialShape{1, 2, 4 * 3 * 5, K});
+    auto in2 = std::make_shared<op::v0::Parameter>(element::f16, PartialShape{1, c.pf, c.pw * c.pz * c.py, K});
+    in1->set_friendly_name("input1");
+    in2->set_friendly_name("input2");
+
+    auto t1 = make_branch(in1, 2, X, 4, 3, 5, kReproV3Weights1);  // host [1,2,X,4,3,5]
+    t1->set_friendly_name("Transpose_target");
+    auto t2 = make_branch(in2, c.pf, c.px, c.pw, c.pz, c.py, kReproV3Weights2);
+    t2->set_friendly_name("Transpose_peer");
+
+    auto add = std::make_shared<op::v1::Add>(t1, t2);
+    add->set_friendly_name("Add_target");
+
+    // Flatten to 4D [2, X, W, Z*Y].
+    auto to4d = op::v0::Constant::create(element::i64, Shape{4}, std::vector<int64_t>{2, X, 4, 15});
+    auto reshape4d = std::make_shared<op::v1::Reshape>(add, to4d, false);
+    reshape4d->set_friendly_name("Reshape_to4D");
+
+    auto result = std::make_shared<op::v0::Result>(reshape4d);
+    return std::make_shared<ov::Model>(ResultVector{result}, ParameterVector{in1, in2}, "collapse6d");
+}
+
+std::pair<std::vector<float>, ov::CompiledModel> run_collapse6d(ov::Core& core,
+                                                                const std::string& device,
+                                                                const collapse6d_case& c,
+                                                                const ov::Tensor& in1,
+                                                                const ov::Tensor& in2) {
+    auto model = build_collapse6d_model(c);
+    auto compiled = core.compile_model(model, device);
+    auto req = compiled.create_infer_request();
+    req.set_input_tensor(0, in1);
+    req.set_input_tensor(1, in2);
+    req.infer();
+    auto out = req.get_output_tensor(0);
+    std::vector<float> vals(out.get_size());
+    const auto* p = out.data<ov::float16>();
+    for (size_t i = 0; i < out.get_size(); ++i)
+        vals[i] = static_cast<float>(p[i]);
+    return std::make_pair(vals, compiled);
+}
+
+class permute_fused_collapse6d_matrix : public ::testing::TestWithParam<collapse6d_case> {};
+
+}  // namespace
+
+TEST_P(permute_fused_collapse6d_matrix, compiles_finite_and_matches_cpu) {
+    const auto c = GetParam();
+    ov::Core core;
+    if (!discover_gpu_and_cpu(core)) {
+        GTEST_SKIP() << "Requires both GPU and CPU plugins discoverable via ov::Core.";
+    }
+
+    tests::random_generator rg;
+    rg.set_seed(GET_SUITE_NAME);
+    ov::Tensor in1(ov::element::f16, ov::Shape{1, 2, 4 * 3 * 5, 12});
+    ov::Tensor in2(ov::element::f16, ov::Shape{1, static_cast<size_t>(c.pf), static_cast<size_t>(c.pw * c.pz * c.py), 12});
+    auto rnd1 = rg.generate_random_1d<ov::float16>(in1.get_size(), -2, 2);
+    std::copy(rnd1.begin(), rnd1.end(), in1.data<ov::float16>());
+    auto rnd2 = rg.generate_random_1d<ov::float16>(in2.get_size(), -2, 2);
+    std::copy(rnd2.begin(), rnd2.end(), in2.data<ov::float16>());
+
+    auto [cpu_vals, cpu_compiled] = run_collapse6d(core, "CPU", c, in1, in2);
+
+    std::vector<float> gpu_vals;
+    ov::CompiledModel gpu_compiled;
+    ASSERT_NO_THROW({
+        auto res = run_collapse6d(core, "GPU", c, in1, in2);
+        gpu_vals = res.first;
+        gpu_compiled = res.second;
+    }) << "Default GPU compilation must not fail for 6D mask "
+       << c.label;
+
+    auto rt = gpu_compiled.get_runtime_model();
+    bool found_fused_target = false;
+    int64_t target_rank = 0;
+    for (const auto& node : rt->get_ordered_ops()) {
+        const auto& info = node->get_rt_info();
+        auto it = info.find(ov::exec_model_info::ORIGINAL_NAMES);
+        if (it == info.end())
+            continue;
+        const auto orig = it->second.as<std::string>();
+        if (orig.find("Transpose_target") != std::string::npos && orig.find("Add_target") != std::string::npos) {
+            found_fused_target = true;
+            target_rank = node->get_output_partial_shape(0).rank().get_length();
+        }
+    }
+    ASSERT_TRUE(found_fused_target) << "Add_target not fused into Transpose_target for 6D mask " << c.label;
+    if (c.expect_rank_preserved) {
+        EXPECT_EQ(target_rank, 6) << "Inner-spatial 6D mask " << c.label << " must preserve 6D host rank.";
+    } else {
+        EXPECT_EQ(target_rank, 4) << "Representable 6D mask " << c.label << " should keep the 4D host.";
+    }
+
+    ASSERT_EQ(gpu_vals.size(), cpu_vals.size());
+    for (float v : gpu_vals)
+        ASSERT_TRUE(std::isfinite(v)) << "Non-finite GPU output for 6D mask " << c.label;
+    double max_ae = 0.0;
+    double mse = repro_v3_mse(gpu_vals, cpu_vals, max_ae);
+    EXPECT_LT(mse, 1e-2) << "GPU vs CPU mismatch for 6D mask " << c.label << " MSE=" << mse << " MaxAbsErr=" << max_ae;
+}
+
+INSTANTIATE_TEST_SUITE_P(collapse6d_matrix,
+                         permute_fused_collapse6d_matrix,
+                         ::testing::Values(
+                             // host [1,2,X=2,W=4,Z=3,Y=5]. Peer f,x,w,z,y (1 == broadcast).
+                             // A 4D metadata fold is retained only when the peer can be proven broadcast-compatible with
+                             // the actual reduced layout. Every other mask conservatively preserves the 6D host rank.
+                             collapse6d_case{2, 2, 4, 3, 5, false, "equal_total_6d"},
+                             collapse6d_case{2, 2, 4, 3, 1, false, "y_broadcast_6d"},
+                             collapse6d_case{2, 2, 4, 1, 5, true, "z_broadcast_6d"},
+                             collapse6d_case{2, 2, 4, 1, 1, true, "zy_broadcast_6d"},
+                             collapse6d_case{2, 2, 1, 3, 5, true, "w_broadcast_6d"},
+                             collapse6d_case{2, 2, 1, 3, 1, true, "wy_broadcast_6d"},
+                             collapse6d_case{2, 2, 1, 1, 5, true, "wz_broadcast_6d"},
+                             collapse6d_case{2, 2, 1, 1, 1, true, "wzy_broadcast_6d"},
+                             collapse6d_case{2, 1, 4, 3, 5, true, "x_broadcast_6d"},
+                             collapse6d_case{2, 1, 4, 3, 1, true, "xy_broadcast_6d"},
+                             collapse6d_case{2, 1, 4, 1, 5, true, "xz_broadcast_6d"},
+                             collapse6d_case{2, 1, 4, 1, 1, true, "xzy_broadcast_6d"},
+                             collapse6d_case{2, 1, 1, 3, 5, true, "xw_broadcast_6d"},
+                             collapse6d_case{2, 1, 1, 3, 1, true, "xwy_broadcast_6d"},
+                             collapse6d_case{2, 1, 1, 1, 5, false, "xwz_broadcast_6d"},
+                             collapse6d_case{2, 1, 1, 1, 1, false, "xwzy_broadcast_6d"}),
+                         [](const ::testing::TestParamInfo<collapse6d_case>& info) {
+                             return std::string(info.param.label);
+                         });
diff --git a/src/plugins/intel_gpu/tests/unit/module_tests/canonicalize_fused_shapes_test.cpp b/src/plugins/intel_gpu/tests/unit/module_tests/canonicalize_fused_shapes_test.cpp
new file mode 100644
index 000000000000..70888f50ce0f
--- /dev/null
+++ b/src/plugins/intel_gpu/tests/unit/module_tests/canonicalize_fused_shapes_test.cpp
@@ -0,0 +1,161 @@
+// Copyright (C) 2018-2026 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include <limits>
+
+#include "impls/ocl/kernel_selector_helper.h"
+#include "intel_gpu/runtime/layout.hpp"
+#include "test_utils.h"
+
+using namespace cldnn;
+using namespace ::tests;
+
+// Unit coverage for fold_higher_rank_fused_peer(), the function that guards and computes the higher-rank
+// fused-eltwise-peer fold in canonicalize_fused_shapes(). The fold is only valid when the peer is an
+// order-preserving reshape of its own axes down to the host rank (contiguous, unpadded, planar, default
+// format) whose result is broadcast-compatible with the host output. It returns the folded host-rank
+// shape on success and std::nullopt otherwise, in which case canonicalize_fused_shapes() falls back to
+// the pre-existing rank-extension path (never an assertion). These cases prove that:
+//   * the proven equal-total planar reshape (df1) folds to exactly the host shape (kept fused);
+//   * a legal higher-rank broadcast peer folds to its broadcast shape (kept fused, distinct from the
+//     equal-total case);
+//   * every unsafe/unprovable higher-rank shape is rejected (returns nullopt -> safe fallback);
+//   * overflowing element counts cannot authorize a fold.
+
+namespace {
+
+layout make_layout(const ov::PartialShape& shape, format fmt, const padding& pad = padding()) {
+    return layout(shape, data_types::f16, fmt, pad);
+}
+
+}  // namespace
+
+// The proven df1 / reproducer_v3 case: a 5D bfzyx peer folds onto a 4D bfyx host of equal element count.
+// The folded shape equals the host shape exactly (equal-total reshape).
+TEST(canonicalize_fused_peer_fold, planar_5d_peer_equal_total_folds_to_host) {
+    auto peer = make_layout({1, 2, 8, 6, 10}, format::bfzyx);  // 960 elements
+    auto host = make_layout({1, 2, 48, 10}, format::bfyx);     // 960 elements (48 = 8 * 6)
+    auto folded = fold_higher_rank_fused_peer(peer, host);
+    ASSERT_TRUE(folded.has_value());
+    EXPECT_EQ(folded->to_shape(), (ov::Shape{1, 2, 48, 10}));
+
+    // The df1 shapes as well.
+    auto peer_df1 = make_layout({1, 2, 96, 270, 270}, format::bfzyx);
+    auto host_df1 = make_layout({1, 2, 25920, 270}, format::bfyx);  // 25920 = 96 * 270
+    auto folded_df1 = fold_higher_rank_fused_peer(peer_df1, host_df1);
+    ASSERT_TRUE(folded_df1.has_value());
+    EXPECT_EQ(folded_df1->to_shape(), (ov::Shape{1, 2, 25920, 270}));
+}
+
+// A 6D peer folding onto a 4D host (still contiguous planar, equal total) is valid; the outermost three
+// spatial axes (w,z,y) fold into the host's single first spatial axis.
+TEST(canonicalize_fused_peer_fold, planar_6d_peer_equal_total_folds_to_host) {
+    auto peer = make_layout({1, 2, 3, 4, 5, 6}, format::bfwzyx);  // 720 elements
+    auto host = make_layout({1, 2, 60, 6}, format::bfyx);         // 720 elements (60 = 3 * 4 * 5)
+    auto folded = fold_higher_rank_fused_peer(peer, host);
+    ASSERT_TRUE(folded.has_value());
+    EXPECT_EQ(folded->to_shape(), (ov::Shape{1, 2, 60, 6}));
+}
+
+// A legal NumPy broadcast peer (coordinator's case): the peer has FEWER elements than the host and
+// broadcasts over the feature dim. It must fold to its own regrouped shape [1,1,48,10] (480 elements),
+// which is broadcast-compatible with host [1,2,48,10] (960 elements) -- NOT to the host shape, and it
+// must remain distinct from the equal-total reshape case.
+TEST(canonicalize_fused_peer_fold, planar_5d_broadcast_peer_folds_to_broadcast_shape) {
+    auto peer = make_layout({1, 1, 8, 6, 10}, format::bfzyx);  // 480 elements
+    auto host = make_layout({1, 2, 48, 10}, format::bfyx);     // 960 elements
+    auto folded = fold_higher_rank_fused_peer(peer, host);
+    ASSERT_TRUE(folded.has_value());
+    EXPECT_EQ(folded->to_shape(), (ov::Shape{1, 1, 48, 10}));
+}
+
+// A peer of the SAME rank as the host is not a higher-rank case; the existing extend path owns it.
+TEST(canonicalize_fused_peer_fold, equal_rank_rejected) {
+    auto peer = make_layout({1, 2, 48, 10}, format::bfyx);
+    auto host = make_layout({1, 2, 48, 10}, format::bfyx);
+    ASSERT_FALSE(fold_higher_rank_fused_peer(peer, host).has_value());
+}
+
+// A peer of LOWER rank than the host must not fold (right-aligned extension owns it).
+TEST(canonicalize_fused_peer_fold, lower_rank_rejected) {
+    auto peer = make_layout({48, 10}, format::bfyx);
+    auto host = make_layout({1, 2, 48, 10}, format::bfyx);
+    ASSERT_FALSE(fold_higher_rank_fused_peer(peer, host).has_value());
+}
+
+// Higher rank, unequal total, and NOT a legal broadcast (folded first spatial 48 != host 48 is fine but
+// the folded feature dim 2 vs host 3 differs and is not 1): must be rejected.
+TEST(canonicalize_fused_peer_fold, higher_rank_incompatible_broadcast_rejected) {
+    auto peer = make_layout({1, 2, 8, 6, 10}, format::bfzyx);  // folds to [1,2,48,10]
+    auto host = make_layout({1, 3, 48, 10}, format::bfyx);     // feature 2 vs 3, neither is 1
+    ASSERT_FALSE(fold_higher_rank_fused_peer(peer, host).has_value());
+}
+
+// Higher rank whose folded first spatial axis mismatches the host and is not 1: rejected.
+TEST(canonicalize_fused_peer_fold, higher_rank_spatial_mismatch_rejected) {
+    auto peer = make_layout({1, 2, 8, 6, 10}, format::bfzyx);  // folds to [1,2,48,10]
+    auto host = make_layout({1, 2, 50, 10}, format::bfyx);     // 48 vs 50, neither is 1
+    ASSERT_FALSE(fold_higher_rank_fused_peer(peer, host).has_value());
+}
+
+// Padding on either layout makes the physical layout non-contiguous, so folding is unsafe.
+TEST(canonicalize_fused_peer_fold, padded_peer_rejected) {
+    auto peer = make_layout({1, 2, 8, 6, 10}, format::bfzyx, padding({0, 0, 0, 1, 0}, {0, 0, 0, 1, 0}));
+    auto host = make_layout({1, 2, 48, 10}, format::bfyx);
+    ASSERT_FALSE(fold_higher_rank_fused_peer(peer, host).has_value());
+}
+
+TEST(canonicalize_fused_peer_fold, padded_host_rejected) {
+    auto peer = make_layout({1, 2, 8, 6, 10}, format::bfzyx);
+    auto host = make_layout({1, 2, 48, 10}, format::bfyx, padding({0, 0, 1, 0}, {0, 0, 1, 0}));
+    ASSERT_FALSE(fold_higher_rank_fused_peer(peer, host).has_value());
+}
+
+// A blocked peer format is not a plain row-major layout, so regrouping axes would change offsets.
+TEST(canonicalize_fused_peer_fold, blocked_peer_rejected) {
+    auto peer = make_layout({1, 32, 8, 6, 10}, format::b_fs_zyx_fsv16);
+    auto host = make_layout({1, 32, 48, 10}, format::bfyx);
+    ASSERT_FALSE(fold_higher_rank_fused_peer(peer, host).has_value());
+}
+
+// A blocked host format is likewise rejected.
+TEST(canonicalize_fused_peer_fold, blocked_host_rejected) {
+    auto peer = make_layout({1, 32, 8, 6, 10}, format::bfzyx);
+    auto host = make_layout({1, 32, 48, 10}, format::b_fs_yx_fsv16);
+    ASSERT_FALSE(fold_higher_rank_fused_peer(peer, host).has_value());
+}
+
+// A higher-rank peer whose host is a non-default planar format (byxf) does not describe the same
+// physical order after adjust_to_rank, so the fold is rejected.
+TEST(canonicalize_fused_peer_fold, non_default_host_rejected) {
+    auto peer = make_layout({1, 2, 8, 6, 10}, format::bfzyx);  // 5D default
+    auto host = make_layout({1, 2, 48, 10}, format::byxf);     // 4D non-default, equal total
+    ASSERT_FALSE(fold_higher_rank_fused_peer(peer, host).has_value());
+}
+
+// Dynamic shapes cannot be proven equal-total and must be rejected.
+TEST(canonicalize_fused_peer_fold, dynamic_peer_rejected) {
+    auto peer = make_layout(ov::PartialShape{1, 2, 8, 6, ov::Dimension::dynamic()}, format::bfzyx);
+    auto host = make_layout({1, 2, 48, 10}, format::bfyx);
+    ASSERT_FALSE(fold_higher_rank_fused_peer(peer, host).has_value());
+}
+
+// A host rank below 3 (no batch+feature+spatial to fold into) is rejected.
+TEST(canonicalize_fused_peer_fold, host_rank_below_three_rejected) {
+    auto peer = make_layout({2, 8, 6}, format::bfyx);
+    auto host = make_layout({16, 6}, format::bfyx);
+    ASSERT_FALSE(fold_higher_rank_fused_peer(peer, host).has_value());
+}
+
+// Overflow guard: a static peer whose folded spatial product overflows size_t must NOT authorize a fold
+// through wrapped equality. Using near-2^64 spatial extents makes the true product overflow; the
+// overflow-safe computation must reject the fold rather than fold on a wrapped value.
+TEST(canonicalize_fused_peer_fold, overflow_rejected) {
+    const int64_t big = static_cast<int64_t>(3037000500LL);  // ~2^31.5; big*big*big overflows size_t
+    auto peer = make_layout({1, 1, big, big, big}, format::bfzyx);
+    // Host chosen so that adjust_to_rank/format checks pass; equality never reached because overflow
+    // rejects first. The folded first spatial would be big*big*big (overflow).
+    auto host = make_layout({1, 1, big, big}, format::bfyx);
+    ASSERT_FALSE(fold_higher_rank_fused_peer(peer, host).has_value());
+}
diff --git a/src/plugins/intel_gpu/tests/unit/transformations/move_eltwise_up_data_movement_per_channel_test.cpp b/src/plugins/intel_gpu/tests/unit/transformations/move_eltwise_up_data_movement_per_channel_test.cpp
new file mode 100644
index 000000000000..d3c1f08fe1a8
--- /dev/null
+++ b/src/plugins/intel_gpu/tests/unit/transformations/move_eltwise_up_data_movement_per_channel_test.cpp
@@ -0,0 +1,234 @@
+// Copyright (C) 2018-2026 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include "plugin/transformations/move_eltwise_up_data_movement_per_channel.hpp"
+
+#include <gtest/gtest.h>
+
+#include <memory>
+#include <vector>
+
+#include "common_test_utils/ov_test_utils.hpp"
+#include "openvino/op/add.hpp"
+#include "openvino/op/constant.hpp"
+#include "openvino/op/multiply.hpp"
+#include "openvino/op/parameter.hpp"
+#include "openvino/op/reshape.hpp"
+#include "openvino/op/squeeze.hpp"
+#include "openvino/op/unsqueeze.hpp"
+
+namespace {
+
+namespace v0 = ov::op::v0;
+namespace v1 = ov::op::v1;
+
+class MoveEltwiseUpThroughDataMovPerChannelGPUTest : public TransformationTestsF {
+protected:
+    void register_pass() {
+        manager.register_pass<ov::intel_gpu::MoveEltwiseUpThroughDataMovPerChannel>();
+    }
+};
+
+TEST_F(MoveEltwiseUpThroughDataMovPerChannelGPUTest, SqueezeMiddleAxisSquareDims) {
+    const ov::Shape shape{1, 1, 5, 5};
+    {
+        auto input = std::make_shared<v0::Parameter>(ov::element::f32, shape);
+        auto squeeze_axis = v0::Constant::create(ov::element::i64, ov::Shape{}, {1});
+        auto squeeze = std::make_shared<v0::Squeeze>(input, squeeze_axis);
+        auto constant = v0::Constant::create(ov::element::f32, {1, 1, 5}, {0.f, 1.f, 2.f, 3.f, 4.f});
+        auto add = std::make_shared<v1::Add>(squeeze, constant);
+
+        model = std::make_shared<ov::Model>(ov::OutputVector{add}, ov::ParameterVector{input});
+        register_pass();
+    }
+    {
+        auto input = std::make_shared<v0::Parameter>(ov::element::f32, shape);
+        auto constant = v0::Constant::create(ov::element::f32, {1, 1, 1, 5}, {0.f, 1.f, 2.f, 3.f, 4.f});
+        auto add = std::make_shared<v1::Add>(input, constant);
+        auto squeeze_axis = v0::Constant::create(ov::element::i64, ov::Shape{}, {1});
+        auto squeeze = std::make_shared<v0::Squeeze>(add, squeeze_axis);
+
+        model_ref = std::make_shared<ov::Model>(ov::OutputVector{squeeze}, ov::ParameterVector{input});
+    }
+    comparator.enable(FunctionsComparator::CmpValues::CONST_VALUES);
+}
+
+TEST_F(MoveEltwiseUpThroughDataMovPerChannelGPUTest, ReshapeReduceRankSquareDims) {
+    const ov::Shape shape{1, 1, 5, 5};
+    const std::vector<int64_t> target_shape{1, 5, 5};
+    {
+        auto input = std::make_shared<v0::Parameter>(ov::element::f32, shape);
+        auto reshape_pattern = std::make_shared<v0::Constant>(ov::element::i64, ov::Shape{target_shape.size()}, target_shape);
+        auto reshape = std::make_shared<v1::Reshape>(input, reshape_pattern, false);
+        auto constant = v0::Constant::create(ov::element::f32, {1, 1, 5}, {0.f, 1.f, 2.f, 3.f, 4.f});
+        auto add = std::make_shared<v1::Add>(reshape, constant);
+
+        model = std::make_shared<ov::Model>(ov::OutputVector{add}, ov::ParameterVector{input});
+        register_pass();
+    }
+    {
+        auto input = std::make_shared<v0::Parameter>(ov::element::f32, shape);
+        auto constant = v0::Constant::create(ov::element::f32, {1, 1, 1, 5}, {0.f, 1.f, 2.f, 3.f, 4.f});
+        auto add = std::make_shared<v1::Add>(input, constant);
+        auto reshape_pattern = std::make_shared<v0::Constant>(ov::element::i64, ov::Shape{target_shape.size()}, target_shape);
+        auto reshape = std::make_shared<v1::Reshape>(add, reshape_pattern, false);
+
+        model_ref = std::make_shared<ov::Model>(ov::OutputVector{reshape}, ov::ParameterVector{input});
+    }
+    comparator.enable(FunctionsComparator::CmpValues::CONST_VALUES);
+}
+
+TEST_F(MoveEltwiseUpThroughDataMovPerChannelGPUTest, SqueezeLowerRankConstant) {
+    const ov::Shape shape{1, 1, 5, 5};
+    {
+        auto input = std::make_shared<v0::Parameter>(ov::element::f32, shape);
+        auto squeeze_axis = v0::Constant::create(ov::element::i64, ov::Shape{}, {1});
+        auto squeeze = std::make_shared<v0::Squeeze>(input, squeeze_axis);
+        auto constant = v0::Constant::create(ov::element::f32, {5}, {0.f, 1.f, 2.f, 3.f, 4.f});
+        auto add = std::make_shared<v1::Add>(squeeze, constant);
+
+        model = std::make_shared<ov::Model>(ov::OutputVector{add}, ov::ParameterVector{input});
+        register_pass();
+    }
+    {
+        auto input = std::make_shared<v0::Parameter>(ov::element::f32, shape);
+        auto constant = v0::Constant::create(ov::element::f32, {1, 1, 1, 5}, {0.f, 1.f, 2.f, 3.f, 4.f});
+        auto add = std::make_shared<v1::Add>(input, constant);
+        auto squeeze_axis = v0::Constant::create(ov::element::i64, ov::Shape{}, {1});
+        auto squeeze = std::make_shared<v0::Squeeze>(add, squeeze_axis);
+
+        model_ref = std::make_shared<ov::Model>(ov::OutputVector{squeeze}, ov::ParameterVector{input});
+    }
+    comparator.enable(FunctionsComparator::CmpValues::CONST_VALUES);
+}
+
+TEST_F(MoveEltwiseUpThroughDataMovPerChannelGPUTest, SqueezeTrailingAxisLegal) {
+    const ov::Shape shape{10, 20, 1, 1};
+    {
+        auto input = std::make_shared<v0::Parameter>(ov::element::f32, shape);
+        auto squeeze_axis = v0::Constant::create(ov::element::i64, ov::Shape{}, {2});
+        auto squeeze = std::make_shared<v0::Squeeze>(input, squeeze_axis);
+        auto constant = v0::Constant::create(ov::element::f32, {10, 1, 1}, {0.5f});
+        auto add = std::make_shared<v1::Add>(squeeze, constant);
+
+        model = std::make_shared<ov::Model>(ov::OutputVector{add}, ov::ParameterVector{input});
+        register_pass();
+    }
+    {
+        auto input = std::make_shared<v0::Parameter>(ov::element::f32, shape);
+        auto constant = v0::Constant::create(ov::element::f32, {10, 1, 1, 1}, {0.5f});
+        auto add = std::make_shared<v1::Add>(input, constant);
+        auto squeeze_axis = v0::Constant::create(ov::element::i64, ov::Shape{}, {2});
+        auto squeeze = std::make_shared<v0::Squeeze>(add, squeeze_axis);
+
+        model_ref = std::make_shared<ov::Model>(ov::OutputVector{squeeze}, ov::ParameterVector{input});
+    }
+}
+
+TEST_F(MoveEltwiseUpThroughDataMovPerChannelGPUTest, UnsqueezeMultipleAxes) {
+    const ov::Shape shape{10, 20};
+    {
+        auto input = std::make_shared<v0::Parameter>(ov::element::f32, shape);
+        auto unsqueeze_axes = v0::Constant::create(ov::element::i64, ov::Shape{2}, {2, 3});
+        auto unsqueeze = std::make_shared<v0::Unsqueeze>(input, unsqueeze_axes);
+        auto constant = v0::Constant::create(ov::element::f32, {1, 20, 1, 1}, {0.5f});
+        auto add = std::make_shared<v1::Add>(unsqueeze, constant);
+
+        model = std::make_shared<ov::Model>(ov::OutputVector{add}, ov::ParameterVector{input});
+        register_pass();
+    }
+    {
+        auto input = std::make_shared<v0::Parameter>(ov::element::f32, shape);
+        auto constant = v0::Constant::create(ov::element::f32, {1, 20}, {0.5f});
+        auto add = std::make_shared<v1::Add>(input, constant);
+        auto unsqueeze_axes = v0::Constant::create(ov::element::i64, ov::Shape{2}, {2, 3});
+        auto unsqueeze = std::make_shared<v0::Unsqueeze>(add, unsqueeze_axes);
+
+        model_ref = std::make_shared<ov::Model>(ov::OutputVector{unsqueeze}, ov::ParameterVector{input});
+    }
+}
+
+TEST_F(MoveEltwiseUpThroughDataMovPerChannelGPUTest, ReshapeLegalExpand) {
+    const ov::Shape shape{1, 3, 20};
+    const std::vector<int64_t> target_shape{1, 3, 4, 5};
+    {
+        auto input = std::make_shared<v0::Parameter>(ov::element::f32, shape);
+        auto reshape_pattern = std::make_shared<v0::Constant>(ov::element::i64, ov::Shape{target_shape.size()}, target_shape);
+        auto reshape = std::make_shared<v1::Reshape>(input, reshape_pattern, false);
+        auto constant = v0::Constant::create(ov::element::f32, {1, 3, 1, 1}, {0.5f});
+        auto multiply = std::make_shared<v1::Multiply>(reshape, constant);
+
+        model = std::make_shared<ov::Model>(ov::OutputVector{multiply}, ov::ParameterVector{input});
+        register_pass();
+    }
+    {
+        auto input = std::make_shared<v0::Parameter>(ov::element::f32, shape);
+        auto constant = v0::Constant::create(ov::element::f32, {1, 3, 1}, {0.5f});
+        auto multiply = std::make_shared<v1::Multiply>(input, constant);
+        auto reshape_pattern = std::make_shared<v0::Constant>(ov::element::i64, ov::Shape{target_shape.size()}, target_shape);
+        auto reshape = std::make_shared<v1::Reshape>(multiply, reshape_pattern, false);
+
+        model_ref = std::make_shared<ov::Model>(ov::OutputVector{reshape}, ov::ParameterVector{input});
+    }
+}
+
+TEST_F(MoveEltwiseUpThroughDataMovPerChannelGPUTest, SqueezeNoAxesInput) {
+    const ov::Shape shape{10, 1, 20};
+    {
+        auto input = std::make_shared<v0::Parameter>(ov::element::f32, shape);
+        auto squeeze = std::make_shared<v0::Squeeze>(input);
+        auto constant = v0::Constant::create(ov::element::f32, {1, 20}, {0.5f});
+        auto add = std::make_shared<v1::Add>(squeeze, constant);
+
+        model = std::make_shared<ov::Model>(ov::OutputVector{add}, ov::ParameterVector{input});
+        register_pass();
+    }
+    {
+        auto input = std::make_shared<v0::Parameter>(ov::element::f32, shape);
+        auto constant = v0::Constant::create(ov::element::f32, {1, 1, 20}, {0.5f});
+        auto add = std::make_shared<v1::Add>(input, constant);
+        auto squeeze = std::make_shared<v0::Squeeze>(add);
+
+        model_ref = std::make_shared<ov::Model>(ov::OutputVector{squeeze}, ov::ParameterVector{input});
+    }
+}
+
+TEST_F(MoveEltwiseUpThroughDataMovPerChannelGPUTest, DynamicInputReject) {
+    auto input = std::make_shared<v0::Parameter>(ov::element::f32, ov::PartialShape{1, -1, 5, 5});
+    auto squeeze_axis = v0::Constant::create(ov::element::i64, ov::Shape{}, {1});
+    auto squeeze = std::make_shared<v0::Squeeze>(input, squeeze_axis);
+    auto constant = v0::Constant::create(ov::element::f32, {1, 1, 5}, {0.5f});
+    auto add = std::make_shared<v1::Add>(squeeze, constant);
+
+    model = std::make_shared<ov::Model>(ov::OutputVector{add}, ov::ParameterVector{input});
+    register_pass();
+}
+
+TEST_F(MoveEltwiseUpThroughDataMovPerChannelGPUTest, ReshapePDPDAxisZeroReject) {
+    auto input = std::make_shared<v0::Parameter>(ov::element::f32, ov::Shape{5, 2, 5});
+    auto reshape_pattern = std::make_shared<v0::Constant>(ov::element::i64, ov::Shape{3}, std::vector<int64_t>{5, 2, 5});
+    auto reshape = std::make_shared<v1::Reshape>(input, reshape_pattern, false);
+    auto constant = v0::Constant::create(ov::element::f32, {5}, {0.f, 1.f, 2.f, 3.f, 4.f});
+    auto add = std::make_shared<v1::Add>(reshape, constant, ov::op::AutoBroadcastSpec(ov::op::AutoBroadcastType::PDPD, 0));
+
+    model = std::make_shared<ov::Model>(ov::OutputVector{add}, ov::ParameterVector{input});
+    register_pass();
+    comparator.enable(FunctionsComparator::CmpValues::ATTRIBUTES);
+    comparator.enable(FunctionsComparator::CmpValues::CONST_VALUES);
+}
+
+TEST_F(MoveEltwiseUpThroughDataMovPerChannelGPUTest, SqueezePDPDAxisOneReject) {
+    auto input = std::make_shared<v0::Parameter>(ov::element::f32, ov::Shape{2, 1, 5, 5});
+    auto squeeze_axis = v0::Constant::create(ov::element::i64, ov::Shape{}, {1});
+    auto squeeze = std::make_shared<v0::Squeeze>(input, squeeze_axis);
+    auto constant = v0::Constant::create(ov::element::f32, {5}, {0.f, 1.f, 2.f, 3.f, 4.f});
+    auto add = std::make_shared<v1::Add>(squeeze, constant, ov::op::AutoBroadcastSpec(ov::op::AutoBroadcastType::PDPD, 1));
+
+    model = std::make_shared<ov::Model>(ov::OutputVector{add}, ov::ParameterVector{input});
+    register_pass();
+    comparator.enable(FunctionsComparator::CmpValues::ATTRIBUTES);
+    comparator.enable(FunctionsComparator::CmpValues::CONST_VALUES);
+}
+
+}  // namespace

From d9222c62d539e2810b032ca61f8ca0975aaf2cfb Mon Sep 17 00:00:00 2001
From: wilson-seok <wilson.seok@intel.com>
Date: Thu, 16 Jul 2026 12:20:10 +0900
Subject: [PATCH 2/2] [GPU] Move reproducer includes to top of
 permute_fusion_test.cpp

Address Copilot review comment on PR #36889: consolidate the new
reproducer's #include statements into the file's top include block
instead of mid-file, matching the file's convention.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .../unit/fusions/permute_fusion_test.cpp      | 23 +++++++++----------
 1 file changed, 11 insertions(+), 12 deletions(-)

diff --git a/src/plugins/intel_gpu/tests/unit/fusions/permute_fusion_test.cpp b/src/plugins/intel_gpu/tests/unit/fusions/permute_fusion_test.cpp
index 4ec9e8246504..918a11dff0a7 100644
--- a/src/plugins/intel_gpu/tests/unit/fusions/permute_fusion_test.cpp
+++ b/src/plugins/intel_gpu/tests/unit/fusions/permute_fusion_test.cpp
@@ -12,6 +12,17 @@
 #include <intel_gpu/primitives/permute.hpp>
 
 #include <cmath>
+#include <cstdlib>
+
+#include <openvino/runtime/core.hpp>
+#include <openvino/core/model.hpp>
+#include <openvino/runtime/exec_model_info.hpp>
+#include "openvino/op/parameter.hpp"
+#include "openvino/op/constant.hpp"
+#include "openvino/op/matmul.hpp"
+#include "openvino/op/transpose.hpp"
+#include "openvino/op/reshape.hpp"
+#include "openvino/op/add.hpp"
 
 using namespace cldnn;
 using namespace ::tests;
@@ -775,18 +786,6 @@ INSTANTIATE_TEST_SUITE_P(fusings_gpu, permute_eltwise_reorder, ::testing::Values
 // plugin, validating a source change with these tests requires building AND
 // installing the plugin.
 
-#include <cstdlib>
-
-#include <openvino/runtime/core.hpp>
-#include <openvino/core/model.hpp>
-#include <openvino/runtime/exec_model_info.hpp>
-#include "openvino/op/parameter.hpp"
-#include "openvino/op/constant.hpp"
-#include "openvino/op/matmul.hpp"
-#include "openvino/op/transpose.hpp"
-#include "openvino/op/reshape.hpp"
-#include "openvino/op/add.hpp"
-
 namespace {
 // Exact f16 weights of reproducer_v3.bin (branch-1 and branch-2 MatMul, [12,8]).
 const std::vector<float> kReproV3Weights1 = {