@@ -465,11 +465,7 @@ def _track_event_in_context(self, event: Event, ctx: Context) -> None:
       ctx.output = event.content
     if event.long_running_tool_ids is not None:
       ctx._interrupt_ids.update(event.long_running_tool_ids)
-    # Only propagate decisions from native events (authored by this node or unspecified).
-    # This prevents structured parent nodes (e.g. SequentialAgent) from intercepting
-    # and bubbling up actions already handled internally by their nested sub-agents.
-    is_native_node_event = not event.author or event.author == self._node.name
-    if event.actions and is_native_node_event:
+    if event.actions and self._is_native_event(event):
       if event.actions.route is not None:
         ctx.route = event.actions.route
         ctx._route_emitted = True
@@ -562,18 +558,34 @@ def _flush_deltas(self, event: Event, ctx: Context) -> None:
       event.actions.artifact_delta.update(artifact_delta)
       artifact_delta.clear()
 
+  def _is_native_event(self, event: Event) -> bool:
+    """Whether this node produced the event itself rather than relaying it.
+
+    A structured agent run as a node (e.g. a SequentialAgent or ParallelAgent)
+    re-yields its sub-agents' events, still authored by those sub-agents. The
+    sub-agents already acted on what such an event carries, so its route,
+    transfer and branch apply to them, not to this node. Read the author before
+    ``_enrich_event`` overwrites it.
+    """
+    return not event.author or event.author == self._node.name
+
   def _enrich_event(self, event: Event, ctx: Context) -> None:
     """Set author, node_info, invocation_id on the event."""
+    is_native_event = self._is_native_event(event)
     event.author = ctx.event_author or self._node.name
     event.invocation_id = ctx._invocation_context.invocation_id
     event.node_info.path = ctx.node_path
     if event.branch is None:
       event.branch = ctx._invocation_context.branch
-    elif event.branch == "":
-      event.branch = None
-      ctx._invocation_context.branch = None
     else:
-      ctx._invocation_context.branch = event.branch
+      if event.branch == "":
+        event.branch = None
+      # An event the node emits on another branch moves the node there. A
+      # relayed event stays on its sub-agent's branch: following it would put
+      # the node's later events and its successors on whichever sub-branch
+      # spoke last, hiding the other branches from them.
+      if is_native_event:
+        ctx._invocation_context.branch = event.branch
     if event.output is not None:
       event.node_info.output_for = [ctx.node_path] + ctx._output_for_ancestors
       # An explicitly claimed output is the claimer's output: publish it on
 
@@ -414,8 +414,15 @@ def get_owner_key(event_path_builder: _NodePathBuilder) -> str | None:
             event.branch, owner_path_builder.node_name, tool_call_ids
         )
     )
+    # Like NodeRunner._is_native_event: only the node's own events move its
+    # branch. A stored native event carries the node's name or one it inherits
+    # from an ancestor; a relayed one keeps its sub-agent's name.
+    is_native = not event.author or event.author in (
+        event_path_builder.static_path.split('/')
+    )
     if (
         is_direct
+        and is_native
         and event.branch
         and not has_claimed_branch
         and not is_tool_branch
@@ -445,7 +452,12 @@ def get_owner_key(event_path_builder: _NodePathBuilder) -> str | None:
     if is_direct or is_delegated:
       if event.output is not None:
         child.output = event.output
-        if is_direct and not has_claimed_branch and not is_tool_branch:
+        if (
+            is_direct
+            and is_native
+            and not has_claimed_branch
+            and not is_tool_branch
+        ):
           child.branch = event.branch
       elif use_message_as_output:
         child.output = event.content
 
@@ -21,6 +21,7 @@
 from google.adk.agents.llm_agent import Agent
 from google.adk.agents.loop_agent import LoopAgent
 from google.adk.agents.loop_agent import LoopAgentState
+from google.adk.agents.parallel_agent import ParallelAgent
 from google.adk.agents.sequential_agent import SequentialAgent
 from google.adk.agents.sequential_agent import SequentialAgentState
 from google.adk.apps.app import App
@@ -323,6 +324,67 @@ def test_auto_to_sequential(is_resumable: bool):
     ]
 
 
+@pytest.mark.parametrize('is_resumable', [True, False])
+def test_auto_to_sequential_with_parallel_keeps_merger_branch(
+    is_resumable: bool,
+):
+  """A merger after a parallel step stays on its sequence's branch.
+
+  After the transfer the pipeline runs as one node that relays the events of
+  every agent inside it. The merger's reply belongs on the pipeline's branch,
+  as when the same pipeline is the root agent, not on whichever parallel
+  sub-branch spoke last; otherwise only that one worker sees the merger's
+  reply on later turns.
+  """
+  # root (auto) - pipeline (seq) - fan_out (parallel) - worker_a (single)
+  #                                                    \ worker_b (single)
+  #                             \ merger (single)
+  worker_a = Agent(
+      name='worker_a',
+      model=testing_utils.MockModel.create(responses=['from a']),
+  )
+  worker_b = Agent(
+      name='worker_b',
+      model=testing_utils.MockModel.create(responses=['from b']),
+  )
+  merger = Agent(
+      name='merger',
+      model=testing_utils.MockModel.create(responses=['merged']),
+  )
+  pipeline = SequentialAgent(
+      name='pipeline',
+      sub_agents=[
+          ParallelAgent(name='fan_out', sub_agents=[worker_a, worker_b]),
+          merger,
+      ],
+  )
+  root_agent = Agent(
+      name='root_agent',
+      model=testing_utils.MockModel.create(
+          responses=[transfer_call_part('pipeline')]
+      ),
+      sub_agents=[pipeline],
+  )
+  app = App(
+      name='test_app',
+      root_agent=root_agent,
+      resumability_config=ResumabilityConfig(is_resumable=is_resumable),
+  )
+  runner = testing_utils.InMemoryRunner(app=app)
+
+  events = runner.run('test1')
+
+  assert {
+      event.author: event.branch
+      for event in events
+      if event.content and event.author != 'root_agent'
+  } == {
+      'worker_a': 'fan_out.worker_a',
+      'worker_b': 'fan_out.worker_b',
+      'merger': None,
+  }
+
+
 @pytest.mark.parametrize('is_resumable', [True, False])
 def test_auto_to_sequential_to_auto(is_resumable: bool):
   response = [
 
@@ -968,6 +968,56 @@ async def _run_impl(self, *, ctx, node_input):
   assert parent_ctx._invocation_context.branch == 'parent_branch'
 
 
+@pytest.mark.asyncio
+async def test_own_event_branch_moves_node_branch():
+  """An event the node authors on another branch moves the node there."""
+
+  class _Node(BaseNode):
+
+    async def _run_impl(self, *, ctx, node_input):
+      yield Event(branch='other_branch')
+      yield Event(output='result')
+
+  parent_ctx, events = _make_ctx()
+  parent_ctx._invocation_context.branch = 'parent_branch'
+  child_ctx = await NodeRunner(
+      node=_Node(name='n'), parent_ctx=parent_ctx
+  ).run()
+
+  assert [e.branch for e in events] == ['other_branch', 'other_branch']
+  assert child_ctx._invocation_context.branch == 'other_branch'
+
+
+@pytest.mark.asyncio
+async def test_relayed_event_branch_does_not_move_node_branch():
+  """A sub-agent's event relayed by the node does not move the node's branch.
+
+  A structured agent run as a node, such as a ParallelAgent, re-yields events
+  its sub-agents emitted on their own sub-branches. Each relayed event keeps
+  its sub-branch, but the node stays on its own branch, so its later events
+  and the branch its successors inherit do not depend on which sub-agent
+  spoke last.
+  """
+
+  class _Node(BaseNode):
+
+    async def _run_impl(self, *, ctx, node_input):
+      yield Event(author='sub_agent', branch='parent_branch.n.sub_agent')
+      yield Event(output='result')
+
+  parent_ctx, events = _make_ctx()
+  parent_ctx._invocation_context.branch = 'parent_branch'
+  child_ctx = await NodeRunner(
+      node=_Node(name='n'), parent_ctx=parent_ctx
+  ).run()
+
+  assert [e.branch for e in events] == [
+      'parent_branch.n.sub_agent',
+      'parent_branch',
+  ]
+  assert child_ctx._invocation_context.branch == 'parent_branch'
+
+
 @pytest.mark.asyncio
 async def test_override_isolation_scope_used_in_node_runner():
   """NodeRunner sets isolation_scope on child context and enriches emitted events."""
 
@@ -19,6 +19,9 @@
 from google.adk.agents.base_agent import BaseAgent
 from google.adk.agents.context import Context
 from google.adk.agents.invocation_context import InvocationContext as BaseInvocationContext
+from google.adk.agents.llm_agent import LlmAgent
+from google.adk.agents.parallel_agent import ParallelAgent
+from google.adk.agents.sequential_agent import SequentialAgent
 from google.adk.events.event import Event
 from google.adk.sessions.in_memory_session_service import InMemorySessionService
 from google.adk.sessions.session import Session
@@ -27,6 +30,8 @@
 from google.genai import types
 import pytest
 
+from tests.unittests import testing_utils
+
 from .workflow_testing_utils import create_runner
 from .workflow_testing_utils import InputCapturingNode
 from .workflow_testing_utils import simplify_events_with_node
@@ -165,3 +170,116 @@ async def test_run_async_with_agent_node_piping_data(
   # AgentNode does not record content as node output, so the next node
   # receives None as input.
   assert node_b.received_inputs == [None]
+
+
+async def _run_workflow(wf: Workflow) -> list[Event]:
+  ss = InMemorySessionService()
+  runner = create_runner(app_name='test', node=wf, session_service=ss)
+  session = await ss.create_session(app_name='test', user_id='u')
+  msg = types.Content(parts=[types.Part(text='start')], role='user')
+  return [
+      event
+      async for event in runner.run_async(
+          user_id='u', session_id=session.id, new_message=msg
+      )
+  ]
+
+
+@pytest.mark.asyncio
+async def test_node_after_parallel_agent_node_sees_every_branch():
+  """A node after a ParallelAgent node runs on the workflow's own branch.
+
+  The ParallelAgent relays each sub-agent's events on that sub-agent's
+  branch. Its successor must not inherit whichever of those branches spoke
+  last: an agent there reads history filtered by branch, so it would see only
+  that one sub-agent's answer, and its own replies would land on that
+  sub-agent's branch.
+  """
+  researcher_a = LlmAgent(
+      name='researcher_a',
+      model=testing_utils.MockModel.create(responses=['finding from a']),
+  )
+  researcher_b = LlmAgent(
+      name='researcher_b',
+      model=testing_utils.MockModel.create(responses=['finding from b']),
+  )
+  research = ParallelAgent(
+      name='research', sub_agents=[researcher_a, researcher_b]
+  )
+  summarizer_model = testing_utils.MockModel.create(responses=['summary'])
+  report = SequentialAgent(
+      name='report',
+      sub_agents=[LlmAgent(name='summarizer', model=summarizer_model)],
+  )
+
+  events = await _run_workflow(
+      Workflow(name='wf', edges=[(START, research, report)])
+  )
+
+  summarizer_request = ' '.join(
+      part.text
+      for content in summarizer_model.requests[0].contents
+      for part in content.parts or []
+      if part.text
+  )
+  assert 'finding from a' in summarizer_request
+  assert 'finding from b' in summarizer_request
+  assert {event.author: event.branch for event in events if event.content} == {
+      'researcher_a': 'research.researcher_a',
+      'researcher_b': 'research.researcher_b',
+      'summarizer': None,
+  }
+
+
+class _Dispatcher(BaseAgent):
+  """Runs its sub-agent on a sub-branch and hands back the final answer."""
+
+  async def _run_async_impl(
+      self, ctx: BaseInvocationContext
+  ) -> AsyncGenerator[Event, None]:
+    target = self.sub_agents[0]
+    parent_branch = ctx.branch
+    ctx.branch = f'{self.name}.{target.name}'
+    async for event in target.run_async(ctx):
+      if event.is_final_response():
+        event.branch = parent_branch
+      yield event
+
+
+@pytest.mark.asyncio
+async def test_answer_relayed_onto_parent_branch_stays_there():
+  """A relayed answer re-stamped onto the parent branch is not pulled back.
+
+  The dispatcher keeps its sub-agent's tool traffic on a sub-branch and hands
+  the final answer back on its own branch, so later agents see the answer
+  but not the tool calls. The tool events must not move the dispatcher node
+  onto the sub-branch, or the branch-less answer gets stamped with it.
+  """
+
+  def lookup_arrival() -> dict[str, str]:
+    """Looks up the arrival time."""
+    return {'arrival': 'Tuesday 14:05'}
+
+  bookings = LlmAgent(
+      name='bookings',
+      model=testing_utils.MockModel.create(
+          responses=[
+              types.Part.from_function_call(name='lookup_arrival', args={}),
+              'You land on Tuesday at 14:05.',
+          ]
+      ),
+      tools=[lookup_arrival],
+  )
+  dispatcher = _Dispatcher(name='dispatcher', sub_agents=[bookings])
+
+  events = await _run_workflow(Workflow(name='wf', edges=[(START, dispatcher)]))
+
+  bookings_events = [e for e in events if e.author == 'bookings' and e.content]
+  assert [e.branch for e in bookings_events] == [
+      'dispatcher.bookings',
+      'dispatcher.bookings',
+      None,
+  ]
+  assert bookings_events[-1].content.parts[0].text == (
+      'You land on Tuesday at 14:05.'
+  )