diff --git a/ILSpy.Tests/AssemblyList/ReloadAssemblyContextMenuTests.cs b/ILSpy.Tests/AssemblyList/ReloadAssemblyContextMenuTests.cs
index 35b57774c..f3b50c9ca 100644
--- a/ILSpy.Tests/AssemblyList/ReloadAssemblyContextMenuTests.cs
+++ b/ILSpy.Tests/AssemblyList/ReloadAssemblyContextMenuTests.cs
@@ -116,9 +116,7 @@ public class ReloadAssemblyContextMenuTests
 
 		var menu = pane.BuildContextMenuForCurrentState(registry.Entries);
 		menu.Should().NotBeNull();
-		var reloadItem = menu!.Items.OfType<MenuItem>()
-			.Single(i => (string?)i.Header == Resources._Reload);
-		reloadItem.RaiseEvent(new RoutedEventArgs(MenuItem.ClickEvent));
+		menu!.ClickItem(Resources._Reload);
 		window.Capture("reload-clicked");
 
 		// Assert — the LoadedAssembly for that file name is a different instance now.
diff --git a/ILSpy.Tests/AssemblyList/RemoveAssemblyContextMenuTests.cs b/ILSpy.Tests/AssemblyList/RemoveAssemblyContextMenuTests.cs
index f9193e90e..e6b6e3045 100644
--- a/ILSpy.Tests/AssemblyList/RemoveAssemblyContextMenuTests.cs
+++ b/ILSpy.Tests/AssemblyList/RemoveAssemblyContextMenuTests.cs
@@ -121,9 +121,7 @@ public class RemoveAssemblyContextMenuTests
 
 		var menu = pane.BuildContextMenuForCurrentState(registry.Entries);
 		menu.Should().NotBeNull();
-		var removeItem = menu!.Items.OfType<MenuItem>()
-			.Single(i => (string?)i.Header == Resources._Remove);
-		removeItem.RaiseEvent(new RoutedEventArgs(MenuItem.ClickEvent));
+		menu!.ClickItem(Resources._Remove);
 		window.Capture("remove-clicked");
 
 		// Assert — the assembly is gone from the list; the survivor is still there.
diff --git a/ILSpy.Tests/ContextMenus/DecompileInNewViewTests.cs b/ILSpy.Tests/ContextMenus/DecompileInNewViewTests.cs
index 2eebe4374..e4de6a9c4 100644
--- a/ILSpy.Tests/ContextMenus/DecompileInNewViewTests.cs
+++ b/ILSpy.Tests/ContextMenus/DecompileInNewViewTests.cs
@@ -19,9 +19,15 @@
 using System.Linq;
 using System.Threading.Tasks;
 
+using Avalonia;
 using Avalonia.Controls;
+using Avalonia.Controls.DataGridHierarchical;
+using Avalonia.Headless;
 using Avalonia.Headless.NUnit;
+using Avalonia.Input;
 using Avalonia.Interactivity;
+using Avalonia.Threading;
+using Avalonia.VisualTree;
 
 using AwesomeAssertions;
 
@@ -99,13 +105,14 @@ public class DecompileInNewViewTests
 			.Should().NotContain(header);
 	}
 
-	// audit (2026-05-12): converted 📦 → 🧪. Was firing `entry.Execute(synthetic ctx)`
-	// directly; now selects the second method via the model and clicks the
-	// "Decompile in new tab" MenuItem produced by the live menu-build path. The Click
-	// routed event hits the same handler ContextMenuProvider attached during Build —
-	// matching what the user's right-click → menu-item-click triggers.
+	// audit (2026-06-02): rewritten for the Thunderbird-style context target. Previously this
+	// test selected the second method via the model first — encoding the OLD bug where
+	// right-clicking a row moved the selection there before the menu opened, so you ended up
+	// with the right-clicked node twice (the preview reused for it + the new tab) instead of
+	// "keep A, open B". Now A stays the active document and the menu targets B directly, so the
+	// result is A + B: the new tab shows B and A is untouched.
 	[AvaloniaTest]
-	public async Task Clicking_DecompileInNewView_Spawns_A_New_Tab_For_The_Selected_Method()
+	public async Task Clicking_DecompileInNewView_Opens_The_Right_Clicked_Method_While_Keeping_The_Active_One()
 	{
 		var window = AppComposition.Current.GetExport<MainWindow>();
 		window.Show();
@@ -119,41 +126,164 @@ public class DecompileInNewViewTests
 		var secondMethod = typeNode.Children.OfType<MethodTreeNode>()
 			.First(m => m.MethodDefinition.Name == "Empty");
 
-		// Seed an existing decompile in the active tab so we have a "current" tab on screen
-		// before the gesture; that tab will be reused by the right-click's selection move
-		// (production behaviour — right-clicking a row in the DataGrid moves selection there
-		// before the menu opens), so the assertion we care about is "a *new* tab spawned in
-		// addition to the existing one and shows the dispatched method".
+		// A is the active document: select firstMethod and decompile it into the preview tab.
 		vm.AssemblyTreeModel.SelectNode(firstMethod);
 		var firstTab = await vm.DockWorkspace.WaitForDecompiledTextAsync();
-		window.Capture("first-method-decompiled-into-active-tab");
+		firstTab.Text.Should().Contain("AsEnumerable");
+		window.Capture("first-method-active");
 
 		var pane = await window.WaitForComponent<AssemblyListPane>();
 		var registry = AppComposition.Current.GetExport<ContextMenuEntryRegistry>();
 		var documents = ((ILSpyDockFactory)vm.DockWorkspace.Factory).Documents!;
 		var initialCount = documents.VisibleDockables?.Count ?? 0;
 
-		// Select the second method and click the menu entry through the live context-menu path.
-		vm.AssemblyTreeModel.SelectNode(secondMethod);
-		await vm.DockWorkspace.WaitForDecompiledTextAsync();
-		window.Capture("second-method-replaced-active-tab");
-
-		var menu = pane.BuildContextMenuForCurrentState(registry.Entries);
+		// Right-click B (secondMethod) WITHOUT moving the selection, and click "Decompile to
+		// new tab" from the menu the right-click would produce.
+		var menu = pane.BuildContextMenuForCurrentState(registry.Entries, rightClickedNode: secondMethod);
 		menu.Should().NotBeNull();
-		var item = menu!.Items.OfType<MenuItem>()
-			.Single(i => (string?)i.Header == Resources.DecompileToNewPanel);
-		item.RaiseEvent(new RoutedEventArgs(MenuItem.ClickEvent));
+		menu!.ClickItem(Resources.DecompileToNewPanel);
 
 		await Waiters.WaitForAsync(
 			() => (documents.VisibleDockables?.Count ?? 0) > initialCount);
 		var newTab = await vm.DockWorkspace.WaitForDecompiledTextAsync();
+
+		// The new tab shows B...
 		ReferenceEquals(newTab, firstTab).Should().BeFalse(
 			"a fresh decompiler tab must be created instead of reusing the existing one");
 		newTab.Text.Should().Contain("Empty");
-		// Count grew by one — the click added a tab on top of the right-click selection's reuse
-		// of firstTab. (The right-click selection move into secondMethod re-uses firstTab; the
-		// menu-click then creates an additional tab. Net effect: +1 dockable.)
+		// ...the original tab still shows A (it was NOT yanked to B by the right-click — this is
+		// the whole point: you keep A and gain B, instead of ending up with B twice)...
+		firstTab.Text.Should().Contain("AsEnumerable");
+		// ...and exactly one tab was added (A + B), not two copies of B.
 		documents.VisibleDockables!.Count.Should().Be(initialCount + 1);
-		window.Capture("after-click-new-tab-spawned");
+		window.Capture("a-kept-b-opened");
+	}
+
+	[AvaloniaTest]
+	public async Task Right_Clicking_An_Unselected_Row_Does_Not_Move_The_Selection()
+	{
+		// Thunderbird-style context target: right-clicking a row the user has NOT selected must
+		// leave the real selection (and therefore the preview document) untouched. Today
+		// ProDataGrid's default selects the right-clicked row on press, which yanks the preview
+		// to B before the menu opens — so "Decompile to new tab" ends up with B twice instead of
+		// the intended A + B. This probe asserts the selection stays put under a real right-click.
+
+		var window = AppComposition.Current.GetExport<MainWindow>();
+		window.Show();
+		var vm = (MainWindowViewModel)window.DataContext!;
+		await vm.AssemblyTreeModel.WaitForAssembliesAsync(minimumCount: 3);
+		var pane = await window.WaitForComponent<AssemblyListPane>();
+		var grid = await pane.WaitForComponent<DataGrid>();
+
+		var nodeA = vm.AssemblyTreeModel.FindNode<AssemblyTreeNode>("System.Linq");
+		var nodeB = vm.AssemblyTreeModel.FindNode<AssemblyTreeNode>(TreeNavigation.CoreLibName);
+
+		// Make A the active document/selection.
+		vm.AssemblyTreeModel.SelectNode(nodeA);
+
+		// Let the top-level rows realise and layout settle.
+		for (int i = 0; i < 8; i++)
+		{
+			Dispatcher.UIThread.RunJobs();
+			grid.UpdateLayout();
+			await Task.Delay(25);
+		}
+
+		var rowB = grid.GetVisualDescendants().OfType<DataGridRow>()
+			.FirstOrDefault(r => RowNodeEquals(r, nodeB));
+		rowB.Should().NotBeNull("the top-level CoreLib row must be realised");
+
+		// Suppressing the right-press must not also suppress the context menu — it still opens
+		// from ContextRequested (raised on release). Watch for it.
+		var menuRequested = false;
+		grid.AddHandler(Control.ContextRequestedEvent, (_, _) => menuRequested = true,
+			handledEventsToo: true);
+
+		// Right-click the centre of B's row (clear of the far-left expander glyph).
+		var point = rowB!.TranslatePoint(new Point(rowB.Bounds.Width / 2, rowB.Bounds.Height / 2), window);
+		point.Should().NotBeNull();
+		HeadlessWindowExtensions.MouseDown(window, point!.Value, MouseButton.Right);
+		HeadlessWindowExtensions.MouseUp(window, point.Value, MouseButton.Right);
+		for (int i = 0; i < 4; i++)
+		{
+			Dispatcher.UIThread.RunJobs();
+			await Task.Delay(20);
+		}
+
+		ReferenceEquals(vm.AssemblyTreeModel.SelectedItem, nodeA).Should().BeTrue(
+			"right-clicking an unselected row must not change the selection (Thunderbird-style context target)");
+		menuRequested.Should().BeTrue(
+			"the context menu must still be requested after the suppressed right-press");
+		rowB.Classes.Should().Contain("contextTarget",
+			"the right-clicked row must carry the focus-box style class while it is the menu target");
 	}
+
+	[AvaloniaTest]
+	public async Task Right_Clicking_A_Second_Row_Moves_The_Context_Highlight_To_It()
+	{
+		// Regression: the focus box must follow every right-click, not stick after the first one
+		// and then never appear again. Reproduces "right-click B (highlight), dismiss, right-click
+		// C (no highlight)".
+		var window = AppComposition.Current.GetExport<MainWindow>();
+		window.Show();
+		var vm = (MainWindowViewModel)window.DataContext!;
+		await vm.AssemblyTreeModel.WaitForAssembliesAsync(minimumCount: 3);
+		var pane = await window.WaitForComponent<AssemblyListPane>();
+		var grid = await pane.WaitForComponent<DataGrid>();
+
+		var assemblies = vm.AssemblyTreeModel.Root!.Children.OfType<AssemblyTreeNode>().Take(3).ToArray();
+		assemblies.Length.Should().BeGreaterThanOrEqualTo(3, "need three top-level rows to click");
+		var nodeA = assemblies[0];
+		var nodeB = assemblies[1];
+		var nodeC = assemblies[2];
+
+		vm.AssemblyTreeModel.SelectNode(nodeA);
+		for (int i = 0; i < 8; i++)
+		{
+			Dispatcher.UIThread.RunJobs();
+			grid.UpdateLayout();
+			await Task.Delay(25);
+		}
+
+		DataGridRow Row(SharpTreeNode node) => grid.GetVisualDescendants().OfType<DataGridRow>()
+			.First(r => RowNodeEquals(r, node));
+
+		async Task RightClick(SharpTreeNode node)
+		{
+			var row = Row(node);
+			var pt = row.TranslatePoint(new Point(row.Bounds.Width / 2, row.Bounds.Height / 2), window);
+			HeadlessWindowExtensions.MouseDown(window, pt!.Value, MouseButton.Right);
+			HeadlessWindowExtensions.MouseUp(window, pt.Value, MouseButton.Right);
+			for (int i = 0; i < 4; i++)
+			{
+				Dispatcher.UIThread.RunJobs();
+				await Task.Delay(20);
+			}
+		}
+
+		async Task Dismiss()
+		{
+			window.KeyPress(Key.Escape, RawInputModifiers.None, PhysicalKey.Escape, keySymbol: null);
+			for (int i = 0; i < 4; i++)
+			{
+				Dispatcher.UIThread.RunJobs();
+				await Task.Delay(20);
+			}
+		}
+
+		await RightClick(nodeB);
+		Row(nodeB).Classes.Should().Contain("contextTarget", "the first right-click highlights B");
+
+		// Dismiss B's menu, then right-click C — the user's exact sequence.
+		await Dismiss();
+		await RightClick(nodeC);
+		Row(nodeC).Classes.Should().Contain("contextTarget",
+			"a second right-click (after dismissing the first menu) must highlight C");
+		Row(nodeB).Classes.Should().NotContain("contextTarget",
+			"B's highlight must be gone");
+	}
+
+	static bool RowNodeEquals(DataGridRow row, SharpTreeNode node)
+		=> row.DataContext is HierarchicalNode hn && ReferenceEquals(hn.Item, node);
+
 }
diff --git a/ILSpy.Tests/TestHarness.cs b/ILSpy.Tests/TestHarness.cs
index f0728cf8e..39671d189 100644
--- a/ILSpy.Tests/TestHarness.cs
+++ b/ILSpy.Tests/TestHarness.cs
@@ -21,6 +21,9 @@ using System.Linq;
 using System.Threading.Tasks;
 using System.Windows.Input;
 
+using Avalonia.Controls;
+using Avalonia.Interactivity;
+
 using ICSharpCode.ILSpy.Properties;
 using ICSharpCode.ILSpyX;
 
@@ -83,6 +86,23 @@ public static class TestHarness
 			.Value;
 	}
 
+	/// <summary>
+	/// Finds the <see cref="MenuItem"/> whose <c>Header</c> equals <paramref name="header"/> (pass
+	/// the resolved resource string, e.g. <c>Resources._Reload</c>) in a menu built by
+	/// <c>AssemblyListPane.BuildContextMenuForCurrentState</c> and raises its <c>Click</c> — the
+	/// same routed event the production menu fires when the user picks the item. Collapses the
+	/// <c>Items.OfType&lt;MenuItem&gt;().Single(...).RaiseEvent(...)</c> dance every context-menu
+	/// test repeats.
+	/// </summary>
+	public static void ClickItem(this ContextMenu menu, string header)
+	{
+		ArgumentNullException.ThrowIfNull(menu);
+		ArgumentNullException.ThrowIfNull(header);
+		var item = menu.Items.OfType<MenuItem>()
+			.Single(i => string.Equals((string?)i.Header, header, StringComparison.Ordinal));
+		item.RaiseEvent(new RoutedEventArgs(MenuItem.ClickEvent));
+	}
+
 	/// <summary>
 	/// Opens <paramref name="path"/> through the production Open command, waits for it to appear
 	/// in the assembly list, awaits its load result, and returns the resulting
diff --git a/ILSpy/App.axaml b/ILSpy/App.axaml
index 0241d76c4..1bef450a4 100644
--- a/ILSpy/App.axaml
+++ b/ILSpy/App.axaml
@@ -55,6 +55,7 @@
                     <SolidColorBrush x:Key="ILSpy.PaneBackground" Color="White" />
                     <SolidColorBrush x:Key="ILSpy.TreeAutoloadedForeground" Color="SteelBlue" />
                     <SolidColorBrush x:Key="ILSpy.TreeNonPublicForeground" Color="Gray" />
+                    <SolidColorBrush x:Key="ILSpy.ContextTargetRowBackground" Color="#2E007ACC" />
                     <SolidColorBrush x:Key="ILSpy.ChromeBorder" Color="#FFC8CDD3" />
                     <SolidColorBrush x:Key="ILSpy.SecondaryForeground" Color="Gray" />
                     <SolidColorBrush x:Key="ILSpy.MenuBackground" Color="White" />
@@ -92,6 +93,7 @@
                     <SolidColorBrush x:Key="ILSpy.PaneBackground" Color="#1E1E1E" />
                     <SolidColorBrush x:Key="ILSpy.TreeAutoloadedForeground" Color="#6FA8DC" />
                     <SolidColorBrush x:Key="ILSpy.TreeNonPublicForeground" Color="#9AA0A6" />
+                    <SolidColorBrush x:Key="ILSpy.ContextTargetRowBackground" Color="#33007ACC" />
                     <SolidColorBrush x:Key="ILSpy.ChromeBorder" Color="#3F3F46" />
                     <SolidColorBrush x:Key="ILSpy.SecondaryForeground" Color="#A0A0A0" />
                     <SolidColorBrush x:Key="ILSpy.MenuBackground" Color="#2D2D30" />
diff --git a/ILSpy/AssemblyTree/AssemblyListPane.axaml b/ILSpy/AssemblyTree/AssemblyListPane.axaml
index 7a839a8d2..56aff2cea 100644
--- a/ILSpy/AssemblyTree/AssemblyListPane.axaml
+++ b/ILSpy/AssemblyTree/AssemblyListPane.axaml
@@ -16,6 +16,15 @@
 		<Style Selector="TextBlock.nonPublicAPI">
 			<Setter Property="Foreground" Value="{DynamicResource ILSpy.TreeNonPublicForeground}" />
 		</Style>
+		<!-- Thunderbird-style context-menu target highlight. A right-click marks its target row
+		     with this class WITHOUT moving the selection, so the menu's target is visible while
+		     the real selection (and the decompiled document) stays put. Deliberately distinct
+		     from the solid-accent selection highlight: a faint accent fill. No border on purpose:
+		     BorderThickness adds to the row's layout box and makes the row grow by 2px when
+		     targeted. Applied/cleared from SetContextTargetRow in the code-behind. -->
+		<Style Selector="DataGridRow.contextTarget">
+			<Setter Property="Background" Value="{DynamicResource ILSpy.ContextTargetRowBackground}" />
+		</Style>
 	</UserControl.Styles>
 
 	<DataGrid Name="TreeGrid"
diff --git a/ILSpy/AssemblyTree/AssemblyListPane.axaml.cs b/ILSpy/AssemblyTree/AssemblyListPane.axaml.cs
index a0727869b..ff6da7618 100644
--- a/ILSpy/AssemblyTree/AssemblyListPane.axaml.cs
+++ b/ILSpy/AssemblyTree/AssemblyListPane.axaml.cs
@@ -54,6 +54,33 @@ namespace ILSpy.AssemblyTree
 		SharpTreeNode? pendingClickCollapseNode;
 		Point pendingClickCollapsePos;
 
+		// The row a right-click is targeting for the context menu, recorded in the tunnel phase
+		// (see OnTreeGridPointerPressedPreview). Thunderbird-style: the menu acts on this row
+		// without it becoming the real selection. Null = no pending right-click target, so the
+		// menu falls back to the actual selection (keyboard-invoked menus, or right-click inside
+		// the existing selection). Cleared on any non-right press and when the menu closes.
+		SharpTreeNode? contextMenuTargetNode;
+
+		// The realised DataGridRow for contextMenuTargetNode, carrying the ".contextTarget" style
+		// class that draws the Thunderbird-style focus box. Tracked separately so we can strip the
+		// class off again when the target changes or the menu closes.
+		DataGridRow? contextTargetRow;
+
+		// The row the currently-open menu was opened for, captured at Opening. Its Closed handler
+		// clears the highlight only if contextTargetRow still points at this same row; if a newer
+		// right-click has already moved the target elsewhere, this (now stale) menu's close must
+		// leave that fresh highlight alone.
+		DataGridRow? contextMenuOpenRow;
+
+		void SetContextTargetRow(DataGridRow? row)
+		{
+			if (ReferenceEquals(contextTargetRow, row))
+				return;
+			contextTargetRow?.Classes.Remove("contextTarget");
+			contextTargetRow = row;
+			contextTargetRow?.Classes.Add("contextTarget");
+		}
+
 		LanguageSettings? languageSettings;
 
 		public AssemblyListPane()
@@ -83,6 +110,17 @@ namespace ILSpy.AssemblyTree
 			TreeGrid.AddHandler(PointerPressedEvent, OnTreeGridPointerPressed,
 				global::Avalonia.Interactivity.RoutingStrategies.Bubble,
 				handledEventsToo: true);
+			// Tunnel (preview) phase so we run BEFORE ProDataGrid's row-level pointer handler,
+			// which would otherwise select the right-clicked row on press and drag the preview
+			// document to it before the context menu opens. We capture the row as the menu target
+			// and swallow the right press so the selection never moves.
+			TreeGrid.AddHandler(PointerPressedEvent, OnTreeGridPointerPressedPreview,
+				global::Avalonia.Interactivity.RoutingStrategies.Tunnel);
+			// Capture the right-click's target row when the menu is requested (not at press): a
+			// press over an already-open menu is swallowed by that menu's light-dismiss popup and
+			// never reaches the press handler, but ContextRequested still fires for the reopen.
+			TreeGrid.AddHandler(ContextRequestedEvent, OnTreeGridContextRequested,
+				global::Avalonia.Interactivity.RoutingStrategies.Tunnel, handledEventsToo: true);
 			// Same handledEventsToo opt-in for release: the press that preserves a multi-selection
 			// for a potential row-drag marks itself handled, so we'd miss the release otherwise.
 			TreeGrid.AddHandler(PointerReleasedEvent, OnTreeGridPointerReleased,
@@ -165,6 +203,18 @@ namespace ILSpy.AssemblyTree
 			contextMenuEntries = entries;
 			var menu = new ContextMenu();
 			menu.Opening += OnContextMenuOpening;
+			// Drop the right-click target once the menu is gone so a later keyboard-invoked menu
+			// (Shift+F10 / Menu key, no pointer target) acts on the real selection instead, and
+			// remove the focus box from the targeted row -- but only if this menu's target is
+			// still the current one. A right-press on another row light-dismisses this menu AND
+			// sets a new target+highlight first; without the generation guard this Closed would
+			// then wipe that newer highlight, breaking every right-click after the first.
+			menu.Closed += (_, _) => {
+				if (!ReferenceEquals(contextTargetRow, contextMenuOpenRow))
+					return;
+				contextMenuTargetNode = null;
+				SetContextTargetRow(null);
+			};
 			TreeGrid.ContextMenu = menu;
 		}
 
@@ -172,6 +222,9 @@ namespace ILSpy.AssemblyTree
 		{
 			if (sender is not ContextMenu menu)
 				return;
+			// Remember which row this menu belongs to, so its later Closed only clears the
+			// highlight if no newer right-click has moved the target to a different row.
+			contextMenuOpenRow = contextTargetRow;
 			var built = BuildContextMenuForCurrentState(contextMenuEntries);
 			if (built == null)
 			{
@@ -196,10 +249,38 @@ namespace ILSpy.AssemblyTree
 		internal ContextMenu? BuildContextMenuForCurrentState(IReadOnlyList<IContextMenuEntryExport> entries)
 			=> ContextMenuProvider.Build(entries, CreateContextMenuContext());
 
+		/// <summary>
+		/// Test seam: builds the menu as if <paramref name="rightClickedNode"/> had been
+		/// right-clicked (the Thunderbird-style context target), without simulating a pointer
+		/// gesture on a possibly-unrealised deep row. Production sets the same target from the
+		/// tunnel right-press handler. The built menu captures the resulting context, so the
+		/// target is cleared again before returning.
+		/// </summary>
+		internal ContextMenu? BuildContextMenuForCurrentState(
+			IReadOnlyList<IContextMenuEntryExport> entries, SharpTreeNode? rightClickedNode)
+		{
+			contextMenuTargetNode = rightClickedNode;
+			try
+			{
+				return ContextMenuProvider.Build(entries, CreateContextMenuContext());
+			}
+			finally
+			{
+				contextMenuTargetNode = null;
+			}
+		}
+
 		TextViewContext CreateContextMenuContext()
 		{
-			var nodes = (DataContext as AssemblyTreeModel)?.SelectedItems.ToArray()
+			var selection = (DataContext as AssemblyTreeModel)?.SelectedItems.ToArray()
 				?? System.Array.Empty<SharpTreeNode>();
+			// A right-click outside the current selection targets just the clicked row, leaving
+			// the real selection (and preview document) untouched. A right-click inside the
+			// selection, or a keyboard-invoked menu (no target), acts on the whole selection.
+			var target = contextMenuTargetNode;
+			var nodes = target != null && !System.Array.Exists(selection, n => ReferenceEquals(n, target))
+				? new SharpTreeNode[] { target }
+				: selection;
 			return new TextViewContext {
 				TreeGrid = TreeGrid,
 				SelectedTreeNodes = nodes,
@@ -403,6 +484,43 @@ namespace ILSpy.AssemblyTree
 			}
 		}
 
+		void OnTreeGridContextRequested(object? sender, ContextRequestedEventArgs e)
+		{
+			// Resolve the row under the pointer (mouse / touch context gesture). A keyboard-invoked
+			// menu (Shift+F10 / Menu key) carries no position -> no target -> the menu acts on the
+			// real selection. Each request is a new generation so a stale menu's Closed can't wipe
+			// this fresh highlight.
+			SharpTreeNode? node = null;
+			DataGridRow? row = null;
+			if (e.TryGetPosition(TreeGrid, out var pos) && TreeGrid.InputHitTest(pos) is Visual hit)
+			{
+				node = HitTestRowNode(hit);
+				row = hit.GetVisualAncestors().OfType<DataGridRow>().FirstOrDefault();
+			}
+			contextMenuTargetNode = node;
+			SetContextTargetRow(node != null ? row : null);
+		}
+
+		void OnTreeGridPointerPressedPreview(object? sender, PointerPressedEventArgs e)
+		{
+			if (e.Source is not Visual hit)
+				return;
+			if (!e.GetCurrentPoint(hit).Properties.IsRightButtonPressed)
+			{
+				// Any non-right press (left navigation, middle new-tab) starts a fresh gesture —
+				// drop a stale right-click target and its focus box.
+				contextMenuTargetNode = null;
+				SetContextTargetRow(null);
+				return;
+			}
+			// Right press over a row: swallow it so ProDataGrid doesn't move the selection there.
+			// We do NOT capture the menu target here — when a previous menu is open this press is
+			// eaten by that menu's light-dismiss popup and never reaches us, so capture happens in
+			// OnTreeGridContextRequested instead (it fires on every menu open, including reopens).
+			if (HitTestRowNode(hit) != null)
+				e.Handled = true;
+		}
+
 		void OnTreeGridPointerPressed(object? sender, PointerPressedEventArgs e)
 		{
 			// MMB single-click is the only "open the row's node in a new tab" pointer gesture —