Fix inverted EXTENDS direction in _TransformationData.to_subgraph

The previous to_subgraph emitted

    Relationship.type("EXTENDS")(etask_node, task_node, ...)

which creates ``(etask)-[:EXTENDS]->(task)``, i.e. "extended_task
extends task" -- the opposite of what the source graph encoded:

    OPTIONAL MATCH (task)-[:EXTENDS]->(extended_task:Task)

and what every other place in the store writes
(``Neo4jStore.create_tasks`` at line 3424:
``Relationship.type("EXTENDS")(task_node, extends_task_node, ...)``)
and reads (lines 2392, 3152, 3547, 3634, 4219, all traversing
``(task)-[:EXTENDS]->(other_task)``).

No existing test exercised the cloned EXTENDS direction (the store-
level test_merge_networks only counted PDRRs, and my own client tests
used independent Tasks with no EXTENDS chain), so the bug shipped
silently as part of the original PR's inline to_subgraph. Swap the
argument order and add a focused regression test:

- test_copy_network_preserves_extends_direction stages a base
  complete Task plus an extending complete Task on the same
  Transformation (using ``create_tasks(transformation_sks,
  extends=base_task_sks)``), copies the source network into a
  different scope, then asserts via raw Cypher that exactly one
  EXTENDS edge exists in the target scope with
  ``extender == extending_task.gufe_key`` and
  ``extended == base_task.gufe_key`` -- i.e. the direction matches
  the source.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: dotsdl

alchemiscale/interface/client.py

@@ -293,13 +293,11 @@ def copy_network(
         existing Task (regardless of status) and its associated
         ProtocolDAGResultRefs.
 
-        Cloned Tasks are wired to their Transformations via ``PERFORMS`` and
-        are reachable through standard network traversals
-        (``get_network_tasks``, ``get_network_results``, etc.). They are
-        intentionally **not** actioned to the new network's TaskHub; to
-        pick up errored or waiting Tasks for execution on the merged
-        network, call :meth:`action_tasks` with the new network's
-        ``ScopedKey`` after the copy completes.
+        Cloned Tasks are intentionally **not** actioned; to pick up errored or
+        waiting Tasks for execution on the merged network, call
+        :meth:`action_tasks` with the new network's ``ScopedKey`` after the
+        copy completes, and set the Tasks' status to back to `waiting` with
+        :meth:`set_tasks_status`.
 
         Parameters
         ----------
@@ -377,7 +375,7 @@ def merge_scopes(
 
         Each source AlchemicalNetwork is copied via :meth:`copy_network`,
         preserving its name, Tasks, and ProtocolDAGResultRefs. Cloned
-        Tasks are not actioned to the target network's TaskHub.
+        Tasks are not actioned.
 
         Parameters
         ----------

alchemiscale/storage/statestore.py

@@ -238,15 +238,21 @@ def record_to_node(record):
             # this edge the Task is unreachable from get_network_tasks
             # and every other PERFORMS-based traversal
             subgraph |= Relationship.type("PERFORMS")(task_node, tf_node, **scope_props)
-            # create the task node this task extends if it exists
+            # create the task node this task extends if it exists. The
+            # source query returns ``record["extended_task"]`` as the Task
+            # that ``record["task"]`` extends -- i.e. in the source graph,
+            # ``(task)-[:EXTENDS]->(extended_task)``. The relationship's
+            # direction must be preserved on the clone so the standard
+            # downstream traversals (e.g. lines 2392, 3152, 3547, 3634:
+            # ``(task)-[:EXTENDS]->(other_task)``) keep working.
             etask_node = (
                 None
                 if not record["extended_task"]
                 else record_to_node(record["extended_task"])
             )
             if etask_node:
                 subgraph |= Relationship.type("EXTENDS")(
-                    etask_node, task_node, **scope_props
+                    task_node, etask_node, **scope_props
                 )
             # clone all result refs for the task
             for pdrr_record in record["pdrrs"]:

alchemiscale/tests/integration/interface/client/test_client.py

@@ -536,6 +536,66 @@ def test_copy_network_with_rename(
         copied_an = user_client.get_network(copied_sk)
         assert copied_an.name == new_name
 
+    def test_copy_network_preserves_extends_direction(
+        self,
+        scope_test,
+        multiple_scopes,
+        n4js_preloaded,
+        user_client: client.AlchemiscaleClient,
+    ):
+        """The cloned EXTENDS edge must match the source direction:
+        ``(task)-[:EXTENDS]->(extended_task)``. Regressing this direction
+        would silently invert every EXTENDS chain on copied networks and
+        break the downstream traversals that read it forward (e.g.
+        ``get_task_extends``, ``get_task_results``)."""
+        source_sks = user_client.query_networks(scope=scope_test, state=None)
+        source_sk = source_sks[0]
+
+        transformation_sks = n4js_preloaded.get_network_transformations(source_sk)
+        assert transformation_sks
+
+        # base Task: complete with ok PDRR
+        base_task_sks = n4js_preloaded.create_tasks(transformation_sks[:1])
+        n4js_preloaded.set_task_running(base_task_sks)
+        n4js_preloaded.set_task_complete(base_task_sks)
+        base_pdrr = ProtocolDAGResultRef(
+            obj_key=f"ProtocolDAGResult-{uuid.uuid4()}",
+            scope=base_task_sks[0].scope,
+            ok=True,
+        )
+        n4js_preloaded.set_task_result(base_task_sks[0], base_pdrr)
+
+        # extending Task: extends the base, also complete; the EXTENDS edge
+        # in the source graph is ``(extending)-[:EXTENDS]->(base)``
+        extending_task_sks = n4js_preloaded.create_tasks(
+            transformation_sks[:1], extends=base_task_sks
+        )
+        n4js_preloaded.set_task_running(extending_task_sks)
+        n4js_preloaded.set_task_complete(extending_task_sks)
+        ext_pdrr = ProtocolDAGResultRef(
+            obj_key=f"ProtocolDAGResult-{uuid.uuid4()}",
+            scope=extending_task_sks[0].scope,
+            ok=True,
+        )
+        n4js_preloaded.set_task_result(extending_task_sks[0], ext_pdrr)
+
+        target_scope = multiple_scopes[2]
+        user_client.copy_network(network=source_sk, scope=target_scope, visualize=False)
+
+        # exactly one EXTENDS edge between the two cloned Tasks must exist
+        # in the target scope, with the same direction as the source:
+        # extending -> EXTENDS -> base
+        edges = n4js_preloaded.execute_query(
+            """
+            MATCH (a:Task {`_project`: $project})-[:EXTENDS]->(b:Task {`_project`: $project})
+            RETURN a._gufe_key AS extender, b._gufe_key AS extended
+            """,
+            project=target_scope.project,
+        ).records
+        assert len(edges) == 1
+        assert edges[0]["extender"] == str(extending_task_sks[0].gufe_key)
+        assert edges[0]["extended"] == str(base_task_sks[0].gufe_key)
+
     def test_copy_network_rejects_wildcard_scope(
         self,
         n4js_preloaded,