@@ -236,10 +236,13 @@ def topological_sort(
         """
         Sort children topologically — a task always comes after its upstream dependencies.
 
-        See ``TaskGroup.topological_sort`` in task-sdk for the algorithm. Cycles are
-        treated as corrupt input: ``DAG.check_cycle`` rejects cyclic Dags before
-        serialization, so a cycle reaching this code indicates malformed serialized data,
-        and we raise ``ValueError`` rather than silently looping forever.
+        See ``TaskGroup.topological_sort`` in task-sdk for the algorithm. Unlike the task-sdk
+        variant, a cycle between siblings does not raise. ``DAG.check_cycle`` rejects task-level
+        cycles, but a task with no upstream inside its own group counts as a root of that group,
+        so edges routed through tasks outside the group can still make siblings depend on each
+        other. ``partial_subset`` can also create such a cycle by dropping a task's in-group
+        upstream. Grid and Graph must render these Dags, so the siblings on a cycle are ordered
+        as one unit instead (see ``_sort_cyclic_projection``).
         """
         children = self.children
         if not children:
@@ -329,14 +332,21 @@ def _sweep_projection(self, nodes: list[DAGNode], projected: list[tuple[int, ...
                 emitted[i] = 1
                 order_append(nodes[i])
             if len(next_pending) == len(pending):
-                raise ValueError(f"A cyclic dependency occurred in dag: {self.dag_id}")
+                return self._sort_cyclic_projection(nodes, projected)
             pending = next_pending
         return order
 
     def _sort_via_pass_numbering(
         self, nodes: list[DAGNode], projected: list[tuple[int, ...]]
     ) -> list[DAGNode]:
-        n = len(nodes)
+        sorted_indices = self._compute_pass_order(projected)
+        if len(sorted_indices) != len(nodes):
+            return self._sort_cyclic_projection(nodes, projected)
+        return [nodes[i] for i in sorted_indices]
+
+    @staticmethod
+    def _compute_pass_order(projected: list[tuple[int, ...]]) -> list[int]:
+        n = len(projected)
         in_degree = [len(deps) for deps in projected]
         successors: list[list[int]] = [[] for _ in range(n)]
         for i, deps in enumerate(projected):
@@ -345,7 +355,7 @@ def _sort_via_pass_numbering(
 
         pass_of = [0] * n
         queue: deque[int] = deque(i for i in range(n) if in_degree[i] == 0)
-        processed = 0
+        processed: list[int] = []
         while queue:
             i = queue.popleft()
             my_pass = 1
@@ -357,17 +367,74 @@ def _sort_via_pass_numbering(
                 elif d_pass + 1 > my_pass:
                     my_pass = d_pass + 1
             pass_of[i] = my_pass
-            processed += 1
+            processed.append(i)
             for s in successors[i]:
                 in_degree[s] -= 1
                 if in_degree[s] == 0:
                     queue.append(s)
 
-        if processed != n:
-            raise ValueError(f"A cyclic dependency occurred in dag: {self.dag_id}")
+        # Children on or downstream of a cycle never reach in-degree 0 and are left out.
+        return sorted(processed, key=lambda i: (pass_of[i], i))
 
-        sorted_indices = sorted(range(n), key=lambda i: (pass_of[i], i))
-        return [nodes[i] for i in sorted_indices]
+    def _sort_cyclic_projection(
+        self, nodes: list[DAGNode], projected: list[tuple[int, ...]]
+    ) -> list[DAGNode]:
+        # Each component is one unit placed by its first child; units follow the same pass
+        # ordering as the acyclic path, and a unit's children keep insertion order.
+        component_of = self._find_projection_components(projected)
+        count = max(component_of) + 1
+        members: list[list[int]] = [[] for _ in range(count)]
+        component_deps: list[set[int]] = [set() for _ in range(count)]
+        for i, deps in enumerate(projected):
+            c = component_of[i]
+            members[c].append(i)
+            component_deps[c].update(component_of[d] for d in deps if component_of[d] != c)
+        component_order = self._compute_pass_order([tuple(deps) for deps in component_deps])
+        return [nodes[i] for c in component_order for i in members[c]]
+
+    @staticmethod
+    def _find_projection_components(projected: list[tuple[int, ...]]) -> list[int]:
+        """Return each child's strongly connected component, numbered in order of its first child."""
+        n = len(projected)
+        successors: list[list[int]] = [[] for _ in range(n)]
+        for i, deps in enumerate(projected):
+            for d in deps:
+                successors[d].append(i)
+
+        # Kosaraju: finish order along successors, then collect components along dependencies.
+        visited = bytearray(n)
+        finish_order: list[int] = []
+        for start in range(n):
+            if visited[start]:
+                continue
+            visited[start] = 1
+            stack: list[tuple[int, Iterator[int]]] = [(start, iter(successors[start]))]
+            while stack:
+                node, remaining = stack[-1]
+                for s in remaining:
+                    if not visited[s]:
+                        visited[s] = 1
+                        stack.append((s, iter(successors[s])))
+                        break
+                else:
+                    stack.pop()
+                    finish_order.append(node)
+
+        root_of = [-1] * n
+        for start in reversed(finish_order):
+            if root_of[start] != -1:
+                continue
+            root_of[start] = start
+            to_visit = [start]
+            while to_visit:
+                node = to_visit.pop()
+                for d in projected[node]:
+                    if root_of[d] == -1:
+                        root_of[d] = start
+                        to_visit.append(d)
+
+        numbering: dict[int, int] = {}
+        return [numbering.setdefault(root, len(numbering)) for root in root_of]
 
     def add(self, node: DAGNode) -> DAGNode:
         # Set the TG first, as setting it might change the return value of node_id!
 
@@ -1063,6 +1063,32 @@ def test_task_converted_to_task_group_doesnt_crash(self, session, dag_maker, tes
             {"id": "task_b", "label": "task_b"},
         ]
 
+    def test_structure_filter_creating_task_group_cycle(self, dag_maker, test_client, session):
+        """Dropping ``g.guard`` makes ``g.second`` a root of ``g``, so ``g`` and ``bridge`` depend on each other."""
+        with dag_maker(dag_id="filtered_task_group_cycle", serialized=True, session=session):
+            with TaskGroup(group_id="g"):
+                first = EmptyOperator(task_id="first")
+                second = EmptyOperator(task_id="second")
+                guard = EmptyOperator(task_id="guard")
+                guard >> second
+            bridge = EmptyOperator(task_id="bridge")
+            first >> bridge >> second
+        dag_maker.sync_dagbag_to_db()
+
+        response = test_client.get(
+            "/grid/structure/filtered_task_group_cycle?root=g.first&include_downstream=true"
+        )
+
+        assert response.status_code == 200
+        assert response.json() == [
+            {"id": "bridge", "label": "bridge"},
+            {
+                "id": "g",
+                "label": "g",
+                "children": [{"id": "g.first", "label": "first"}, {"id": "g.second", "label": "second"}],
+            },
+        ]
+
     # Tests for root, include_upstream, and include_downstream parameters
     @pytest.mark.parametrize(
         ("params", "expected_task_ids", "description"),
 
@@ -393,6 +393,28 @@ def test_mapped_operator_in_task_group(self, dag_maker, test_client, session):
         assert mapped_in_group["is_mapped"] is True
         assert mapped_in_group["operator"] == "PythonOperator"
 
+    def test_filter_creating_task_group_cycle(self, dag_maker, test_client, session):
+        """Dropping ``g.guard`` makes ``g.second`` a root of ``g``, so ``g`` and ``bridge`` depend on each other."""
+        with dag_maker(dag_id="filtered_task_group_cycle", serialized=True, session=session):
+            with TaskGroup(group_id="g"):
+                first = EmptyOperator(task_id="first")
+                second = EmptyOperator(task_id="second")
+                guard = EmptyOperator(task_id="guard")
+                guard >> second
+            bridge = EmptyOperator(task_id="bridge")
+            first >> bridge >> second
+        dag_maker.sync_dagbag_to_db()
+
+        response = test_client.get(
+            "/structure/structure_data",
+            params={"dag_id": "filtered_task_group_cycle", "root": "g.first", "include_downstream": True},
+        )
+
+        assert response.status_code == 200
+        nodes = response.json()["nodes"]
+        assert [node["id"] for node in nodes] == ["bridge", "g"]
+        assert [child["id"] for child in nodes[1]["children"]] == ["g.first", "g.second"]
+
     def test_ui_colors_passed_through_to_graph(self, dag_maker, test_client, session):
         """Both raw hex colors and Chakra palette tokens reach the graph unchanged, for operators and groups."""
 
 
@@ -1351,6 +1351,88 @@ def spy(self, nodes, projected):
         assert position[f"r{i}"] < position[f"r{i + 1}"]
 
 
+def _make_sibling_groups_cycle():
+    with DAG("sibling_groups_cycle", schedule=None, start_date=DEFAULT_DATE) as dag:
+        start = EmptyOperator(task_id="start")
+        with TaskGroup("group1"):
+            a1 = EmptyOperator(task_id="a1")
+            a2 = EmptyOperator(task_id="a2")
+        with TaskGroup("group2"):
+            b1 = EmptyOperator(task_id="b1")
+            b2 = EmptyOperator(task_id="b2")
+        end = EmptyOperator(task_id="end")
+        start >> [a1, b2]
+        a1 >> b1
+        b2 >> a2
+        [a2, b1] >> end
+    return dag
+
+
+def _make_group_bridged_by_outside_task():
+    with DAG("group_bridged_by_outside_task", schedule=None, start_date=DEFAULT_DATE) as dag:
+        with TaskGroup("group"):
+            a = EmptyOperator(task_id="a")
+            b = EmptyOperator(task_id="b")
+        bridge = EmptyOperator(task_id="bridge")
+        a >> bridge >> b
+    return dag
+
+
+def _make_three_group_ring():
+    with DAG("three_group_ring", schedule=None, start_date=DEFAULT_DATE) as dag:
+        groups = {}
+        for group_id in ("g0", "g1", "g2"):
+            with TaskGroup(group_id):
+                groups[group_id] = (EmptyOperator(task_id="first"), EmptyOperator(task_id="second"))
+        groups["g1"][0] >> groups["g0"][1]
+        groups["g2"][0] >> groups["g1"][1]
+        groups["g0"][0] >> groups["g2"][1]
+    return dag
+
+
+@pytest.mark.parametrize(
+    ("make_dag", "expected"),
+    [
+        pytest.param(
+            _make_sibling_groups_cycle,
+            {
+                None: ["start", "group1", "group2", "end"],
+                "group1": ["group1.a1", "group1.a2"],
+                "group2": ["group2.b1", "group2.b2"],
+            },
+            id="sibling-groups",
+        ),
+        pytest.param(
+            _make_group_bridged_by_outside_task,
+            {None: ["bridge", "group"], "group": ["group.a", "group.b"]},
+            id="group-bridged-by-outside-task",
+        ),
+        # Two of the three siblings depend on a later sibling, which selects pass numbering.
+        pytest.param(
+            _make_three_group_ring,
+            {
+                None: ["g0", "g1", "g2"],
+                "g0": ["g0.first", "g0.second"],
+                "g1": ["g1.first", "g1.second"],
+                "g2": ["g2.first", "g2.second"],
+            },
+            id="three-group-ring",
+        ),
+    ],
+)
+def test_topological_sort_serialized_task_group_cycle(make_dag, expected):
+    """Siblings that depend on each other only at the group level are ordered instead of raising."""
+    dag = make_dag()
+    dag.check_cycle()
+    serialized = create_scheduler_dag(dag)
+    group_dict = serialized.task_group.get_task_group_dict()
+
+    assert {
+        group_id: [node.node_id for node in group.topological_sort(group_dict=group_dict)]
+        for group_id, group in group_dict.items()
+    } == expected
+
+
 def test_task_group_arrow_with_setup_group():
     with DAG(dag_id="setup_group_teardown_group") as dag:
         with TaskGroup("group_1") as g1: