diff --git a/CHANGELOG.md b/CHANGELOG.md
index d96803c..40ecb38 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,30 @@ All notable changes to Aperture Image Viewer are documented here. The format fol
 
 ## [Unreleased]
 
+## [0.8.6-beta1] - 2026-08-21
+
+### Fixed
+- **Folder-tree keyboard** — Tab / Shift+Tab cycle only the folder tree and the tile
+  list (ribbon and the Everything button stay out). Tabbing in does not change the
+  destination selection. Clicking or Tabbing to the tree gives it keyboard focus so
+  arrows move folders immediately. Arrowing the tree commits the selected node at
+  once; the tile pane rebuilds in the background and shows the existing Loading…
+  spinner if that rebuild is slow, instead of gating the next arrow on grid render.
+- **First click** on an unfocused window or pane focuses the clicked folder / tile /
+  canvas in that same click (Explorer-style). The activating click is not swallowed.
+  The folder expand arrow and include checkbox do not change the selected folder.
+
+## [0.8.5-beta1] - 2026-08-21
+
+### Fixed
+- **Tile-pane Up/Down** stay in the same *visual* column at every zoom. 0.8.4
+  stepped by a width-based column count that came out one low once the
+  scrollbar (and padding) were already excluded from the wrap viewport — a
+  4-column grid walked as 3, so selection moved diagonally. The picker now
+  uses layout X (and a column count that cannot undercut columns already on
+  screen). PageUp/PageDown still move one viewport in that same column;
+  Left/Right are unchanged. Headers are not stops.
+
 ## [0.8.4-beta1] - 2026-08-21
 
 ### Fixed
diff --git a/src/Aperture.App/Aperture.App.csproj b/src/Aperture.App/Aperture.App.csproj
index 874e3f9..616b907 100644
--- a/src/Aperture.App/Aperture.App.csproj
+++ b/src/Aperture.App/Aperture.App.csproj
@@ -16,7 +16,7 @@
     <UseWPF>true</UseWPF>
     <ApplicationIcon>Assets\aperture.ico</ApplicationIcon>
     <AssemblyName>Aperture</AssemblyName>
-    <Version>0.8.4-beta1</Version>
+    <Version>0.8.6-beta1</Version>
     <AssemblyTitle>Aperture Image Viewer</AssemblyTitle>
     <Product>Aperture Image Viewer</Product>
     <Description>A fast local image &amp; video browser for Windows.</Description>
diff --git a/src/Aperture.App/LibraryPaneFocus.cs b/src/Aperture.App/LibraryPaneFocus.cs
index bbd7ca0..c29b3e2 100644
--- a/src/Aperture.App/LibraryPaneFocus.cs
+++ b/src/Aperture.App/LibraryPaneFocus.cs
@@ -8,9 +8,10 @@
 namespace Aperture.App;
 
 /// <summary>
-/// Keyboard focus for the library contents/tile pane. Clicking a tile already
-/// focuses that <see cref="ListBoxItem"/>; clicking the empty canvas did not,
-/// so arrow / PageUp / PageDown / scroll keys stayed on the folder tree.
+/// Keyboard focus for the library: folder tree ↔ tile pane. Clicking a tile
+/// already focuses that <see cref="ListBoxItem"/>; clicking the empty canvas
+/// did not, so arrow / PageUp / PageDown / scroll keys stayed on the folder
+/// tree. Tab onto either pane must not change its selection.
 /// </summary>
 internal static class LibraryPaneFocus
 {
@@ -47,6 +48,127 @@ public static bool ShouldFocusContentsPane(DependencyObject? originalSource, IIn
     public static bool ShouldKeepExistingSelection(bool fromOutside, bool newFocusIsItem, bool newFocusIsSelected) =>
         fromOutside && newFocusIsItem && !newFocusIsSelected;
 
+    /// <summary>Win32 <c>WM_MOUSEACTIVATE</c> — the click that activates a window.</summary>
+    internal const int WmMouseActivate = 0x0021;
+
+    /// <summary>Activate and deliver the click to the control (Explorer). Not <c>MA_ACTIVATEANDEAT</c>.</summary>
+    internal const int MaActivate = 1;
+
+    /// <summary>
+    /// True when this is the click that activates the window. Return
+    /// <see cref="MaActivate"/> so the same click focuses the folder / tile /
+    /// canvas — an activation-only first click would swallow it.
+    /// </summary>
+    public static bool TryPassActivatingClick(int msg, out IntPtr result)
+    {
+        if (msg != WmMouseActivate)
+        {
+            result = IntPtr.Zero;
+            return false;
+        }
+        result = new IntPtr(MaActivate);
+        return true;
+    }
+
+    internal enum TreeFocusAction
+    {
+        /// <summary>Leave WPF's focus target alone (arrows inside the tree, or a click).</summary>
+        Leave,
+        /// <summary>Focus the already-selected folder so arrows move from there.</summary>
+        FocusSelectedItem,
+        /// <summary>
+        /// Keep focus on the TreeView — "Everything" is showing; do not select the first folder.
+        /// </summary>
+        FocusTree,
+    }
+
+    /// <summary>What a left-click on the folder tree should do to keyboard focus.</summary>
+    internal enum TreeClickAction
+    {
+        /// <summary>Folder row / name / icon — <c>TreeViewItem.Focus()</c> (which also selects).</summary>
+        FocusItem,
+        /// <summary>
+        /// Expand chevron or include checkbox: do not <c>Focus()</c> the item.
+        /// That call selects the folder; Explorer and 0.8.5 keep those hits off selection.
+        /// Alias text boxes keep the caret.
+        /// </summary>
+        Leave,
+        /// <summary>Empty tree chrome — focus the TreeView without changing selection.</summary>
+        FocusTree,
+    }
+
+    internal enum TreeHit
+    {
+        Row,
+        Expander,
+        IncludeCheckBox,
+        TextInput,
+        Canvas,
+    }
+
+    /// <summary>
+    /// Same-click folder focus applies to the row only. The expander
+    /// (<see cref="ToggleButton"/>, <c>Focusable=False</c>) and the root include
+    /// checkbox must not select the folder.
+    /// </summary>
+    public static TreeClickAction OnTreePreviewClick(TreeHit hit) => hit switch
+    {
+        TreeHit.Row => TreeClickAction.FocusItem,
+        TreeHit.Canvas => TreeClickAction.FocusTree,
+        _ => TreeClickAction.Leave,
+    };
+
+    public static TreeClickAction OnTreePreviewClick(DependencyObject? originalSource) =>
+        OnTreePreviewClick(ClassifyTreeHit(originalSource));
+
+    internal static TreeHit ClassifyTreeHit(DependencyObject? originalSource)
+    {
+        var node = originalSource;
+        while (node is not null)
+        {
+            if (node is TextBox or PasswordBox or ComboBox or RichTextBox)
+                return TreeHit.TextInput;
+            // CheckBox before ToggleButton — CheckBox is a ToggleButton.
+            if (node is CheckBox)
+                return TreeHit.IncludeCheckBox;
+            if (node is ToggleButton)
+                return TreeHit.Expander;
+            if (node is TreeViewItem)
+                return TreeHit.Row;
+            if (node is TreeView or Window)
+                return TreeHit.Canvas;
+            node = Parent(node);
+        }
+        return TreeHit.Canvas;
+    }
+
+    /// <summary>
+    /// Where keyboard focus should land when it arrives on the folder tree.
+    /// Tab must not change the selected folder; click must not yank focus back
+    /// to a previous node while the new item's <c>IsSelected</c> is still catching up.
+    /// </summary>
+    public static TreeFocusAction OnTreeKeyboardArrival(
+        bool fromOutside, bool mousePressed,
+        bool newFocusIsItem, bool newFocusIsSelected,
+        bool hasSelectedItem)
+    {
+        if (!fromOutside)
+            return TreeFocusAction.Leave;
+
+        // Row-click path focuses the item in PreviewMouseDown; IsSelected may still be false.
+        if (mousePressed)
+            return TreeFocusAction.Leave;
+
+        if (newFocusIsItem && newFocusIsSelected)
+            return TreeFocusAction.Leave;
+
+        if (hasSelectedItem)
+            return TreeFocusAction.FocusSelectedItem;
+
+        // Tab onto the tree (or onto the first folder) while Everything is showing.
+        return TreeFocusAction.FocusTree;
+    }
+
     public static Hit Classify(DependencyObject? originalSource, IInputElement? currentFocus)
     {
         // A dialog keeps focus even if the click somehow reached the pane
diff --git a/src/Aperture.App/MainWindow.xaml b/src/Aperture.App/MainWindow.xaml
index c1e8f0a..30ed633 100644
--- a/src/Aperture.App/MainWindow.xaml
+++ b/src/Aperture.App/MainWindow.xaml
@@ -497,12 +497,15 @@
                     <TextBlock Text="Sort" Foreground="{StaticResource Muted}" VerticalAlignment="Center"
                                Margin="0,0,6,0" FontSize="12" />
                     <ComboBox ItemsSource="{Binding SortLabels}" SelectedItem="{Binding SortPreset, Mode=TwoWay}"
-                              Width="120" VerticalAlignment="Center" VerticalContentAlignment="Center" Height="30" />
+                              Width="120" VerticalAlignment="Center" VerticalContentAlignment="Center" Height="30"
+                              IsTabStop="False" />
                     <Rectangle Width="1" Fill="{StaticResource Line}" Margin="8,2,6,2" />
                     <TextBlock Text="Show" Foreground="{StaticResource Muted}" VerticalAlignment="Center"
                                Margin="0,0,6,0" FontSize="12" />
-                    <CheckBox Content="Pictures" IsChecked="{Binding ShowImages}" VerticalAlignment="Center" Margin="0,0,8,0" />
-                    <CheckBox Content="Videos" IsChecked="{Binding ShowVideos}" VerticalAlignment="Center" />
+                    <CheckBox Content="Pictures" IsChecked="{Binding ShowImages}" VerticalAlignment="Center" Margin="0,0,8,0"
+                              IsTabStop="False" />
+                    <CheckBox Content="Videos" IsChecked="{Binding ShowVideos}" VerticalAlignment="Center"
+                              IsTabStop="False" />
                     <Button Content="{Binding PreviewLabel}" Style="{StaticResource ToolButton}" Margin="10,0,0,0"
                             Command="{Binding CyclePreviewCommand}"
                             ToolTip="Preview / inspector pane — click to cycle: right → bottom → off" />
@@ -580,7 +583,8 @@
                     <TextBlock DockPanel.Dock="Top" Text="LIBRARIES" Foreground="{StaticResource CanvasMuted}"
                                FontSize="11" FontWeight="SemiBold" Margin="14,12,14,6" />
                     <Button x:Name="EverythingButton" DockPanel.Dock="Top" Command="{Binding NavigateHomeCommand}"
-                            Margin="8,0,8,2" KeyboardNavigation.TabIndex="0"
+                            Click="OnEverythingClick"
+                            Margin="8,0,8,2" IsTabStop="False" Focusable="False"
                             HorizontalContentAlignment="Stretch" Cursor="Hand" Padding="0" BorderThickness="0"
                             Foreground="{StaticResource CanvasInk}" FontSize="14"
                             ToolTip="Show everything across all folders">
@@ -620,11 +624,14 @@
                               FontSize="14"
                               KeyboardNavigation.TabNavigation="Once"
                               SelectedItemChanged="OnTreeSelectedChanged" PreviewKeyDown="OnTreeKeyDown"
+                              PreviewMouseLeftButtonDown="OnTreePreviewMouseLeftButtonDown"
                               PreviewGotKeyboardFocus="OnTreePreviewGotKeyboardFocus">
                         <TreeView.ItemContainerStyle>
                             <Style TargetType="TreeViewItem">
                                 <Setter Property="IsExpanded" Value="{Binding IsExpanded, Mode=TwoWay}" />
                                 <Setter Property="IsSelected" Value="{Binding IsSelected, Mode=TwoWay}" />
+                                <Setter Property="Focusable" Value="True" />
+                                <Setter Property="KeyboardNavigation.IsTabStop" Value="False" />
                                 <Setter Property="Padding" Value="2,3" />
                                 <Setter Property="HorizontalContentAlignment" Value="Stretch" />
                                 <!-- Custom template: the selection cue is driven by the item's own IsSelected
@@ -697,6 +704,7 @@
                                 <StackPanel Orientation="Horizontal" Margin="0,2">
                                     <CheckBox IsChecked="{Binding Root.IsIncluded, Mode=TwoWay}" VerticalAlignment="Center"
                                               Margin="0,0,6,0" ToolTip="Include this folder"
+                                              Focusable="False" IsTabStop="False"
                                               Visibility="{Binding IsRoot, Converter={StaticResource BoolToVis}}" />
                                     <Path Data="M2,5 L6,5 L7.6,6.8 L14,6.8 L14,13 L2,13 Z" Fill="#3FC2B6"
                                           Stretch="Uniform" Width="15" Height="15" Margin="0,0,6,0" VerticalAlignment="Center"
diff --git a/src/Aperture.App/MainWindow.xaml.cs b/src/Aperture.App/MainWindow.xaml.cs
index 39aa55c..33d474c 100644
--- a/src/Aperture.App/MainWindow.xaml.cs
+++ b/src/Aperture.App/MainWindow.xaml.cs
@@ -28,6 +28,23 @@ private void OnSourceInitialized(object? sender, EventArgs e)
             ApplyWindowPlacement(p);
         if (ViewModel?.GetNavWidth() is { } w && w >= NavColumn.MinWidth)
             NavColumn.Width = new GridLength(w);
+
+        var hwnd = new WindowInteropHelper(this).Handle;
+        if (hwnd != IntPtr.Zero && HwndSource.FromHwnd(hwnd) is { } source)
+            source.AddHook(WndProc);
+    }
+
+    /// <summary>
+    /// Explorer-style: the click that activates Aperture is also delivered to
+    /// the folder / tile / canvas under the cursor. Default Win32/WPF can
+    /// return MA_ACTIVATEANDEAT and eat that first click.
+    /// </summary>
+    private IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
+    {
+        if (!LibraryPaneFocus.TryPassActivatingClick(msg, out var result))
+            return IntPtr.Zero;
+        handled = true;
+        return result;
     }
 
     private void OnLoaded(object sender, RoutedEventArgs e)
@@ -41,9 +58,9 @@ private void OnLoaded(object sender, RoutedEventArgs e)
         ViewModel.PropertyChanged += OnViewModelPropertyChanged;
         ConfigurePreviewLayout(ViewModel.PreviewMode);
 
-        // Land keyboard focus on the "Everything" library so a single Tab drops into the grid
+        // Land keyboard focus on the folder tree so Tab cycles tree ↔ tile list
         // without changing either pane's selection (ribbon is not a Tab stop).
-        Dispatcher.BeginInvoke(new Action(() => EverythingButton.Focus()),
+        Dispatcher.BeginInvoke(new Action(FocusTreeWithoutChangingSelection),
             System.Windows.Threading.DispatcherPriority.Loaded);
     }
 
@@ -250,6 +267,27 @@ private void OnWindowPreviewKeyDown(object sender, KeyEventArgs e)
 
         var focused = Keyboard.FocusedElement;
 
+        // Tab / Shift+Tab: only the folder tree and the tile list. Ribbon stays out.
+        // Two stops — either direction toggles. Do not change the destination selection.
+        if (e.Key == Key.Tab && (Keyboard.Modifiers & ~ModifierKeys.Shift) == 0)
+        {
+            if (ViewModel.ShowFirstRun)
+                return; // first-run overlay owns Tab
+            if (SettingsToggle.IsChecked == true)
+                return; // hamburger menu owns Tab
+            if (focused is System.Windows.Controls.TextBox tb && !ReferenceEquals(tb, SearchBox))
+                return; // alias rename / caption field — leave caret Tab alone
+            if (focused is DependencyObject d && System.Windows.Window.GetWindow(d) is not MainWindow)
+                return;
+
+            e.Handled = true;
+            if (IsInTree(focused as DependencyObject))
+                FocusTileListWithoutChangingSelection();
+            else
+                FocusTreeWithoutChangingSelection();
+            return;
+        }
+
         // "/" focuses search (unless already typing).
         if (e.Key == Key.Oem2 && Keyboard.Modifiers == ModifierKeys.None
             && focused is not System.Windows.Controls.TextBox)
@@ -297,22 +335,68 @@ private void OnTreeKeyDown(object sender, KeyEventArgs e)
         }
     }
 
+    /// <summary>
+    /// Same-click focus onto a folder row so Up/Down move folders immediately
+    /// when the tree was not the keyboard pane. Do not handle the event —
+    /// selection still happens. Focusing a TreeViewItem selects the node —
+    /// skip that for the expand chevron and the include checkbox so those
+    /// hits stay off selection (Explorer).
+    /// </summary>
+    private void OnTreePreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
+    {
+        var action = LibraryPaneFocus.OnTreePreviewClick(e.OriginalSource as DependencyObject);
+        if (action == LibraryPaneFocus.TreeClickAction.Leave)
+            return;
+        if (action == LibraryPaneFocus.TreeClickAction.FocusItem)
+        {
+            var src = e.OriginalSource as DependencyObject;
+            while (src is not null && !ReferenceEquals(src, FolderTreeView))
+            {
+                if (src is System.Windows.Controls.TreeViewItem item)
+                {
+                    item.Focus();
+                    return;
+                }
+                src = src is System.Windows.Media.Visual or System.Windows.Media.Media3D.Visual3D
+                    ? VisualTreeHelper.GetParent(src)
+                    : LogicalTreeHelper.GetParent(src);
+            }
+        }
+        FolderTreeView.Focus();
+    }
+
+    /// <summary>Everything is click-only (not a Tab stop). After Home, park keyboard on the tree.</summary>
+    private void OnEverythingClick(object sender, RoutedEventArgs e) =>
+        FolderTreeView.Focus();
+
     /// <summary>
     /// Tabbing into the tree must not change its selection. WPF TreeView focuses
     /// (and selects) the first node when nothing is selected — keep Everything /
-    /// the current folder.
+    /// the current folder. A row click already focused the item in PreviewMouseDown.
     /// </summary>
     private void OnTreePreviewGotKeyboardFocus(object sender, KeyboardFocusChangedEventArgs e)
     {
-        if (e.NewFocus is not System.Windows.Controls.TreeViewItem item)
-            return;
-        if (!LibraryPaneFocus.ShouldKeepExistingSelection(
-                fromOutside: !IsInTree(e.OldFocus as DependencyObject),
-                newFocusIsItem: true,
-                newFocusIsSelected: item.IsSelected))
+        // WPF TreeView.Focus() hops onto the first item with OldFocus=TreeView
+        // (which IsInTree). Treat that hop as outside so Tab onto Everything does
+        // not select the first folder.
+        var action = LibraryPaneFocus.OnTreeKeyboardArrival(
+            fromOutside: !IsInTree(e.OldFocus as DependencyObject)
+                || ReferenceEquals(e.OldFocus, FolderTreeView),
+            mousePressed: Mouse.LeftButton == MouseButtonState.Pressed,
+            newFocusIsItem: e.NewFocus is System.Windows.Controls.TreeViewItem,
+            newFocusIsSelected: e.NewFocus is System.Windows.Controls.TreeViewItem { IsSelected: true },
+            hasSelectedItem: FolderTreeView.SelectedItem is FolderNodeVm);
+        if (action == LibraryPaneFocus.TreeFocusAction.Leave)
             return;
 
         e.Handled = true;
+        if (action == LibraryPaneFocus.TreeFocusAction.FocusSelectedItem)
+            FocusTreeWithoutChangingSelection();
+        // FocusTree: swallow the hop onto the first folder; the TreeView keeps focus.
+    }
+
+    private void FocusTreeWithoutChangingSelection()
+    {
         if (FolderTreeView.SelectedItem is FolderNodeVm selected
             && FindTreeViewItem(FolderTreeView, selected) is { } keep)
             keep.Focus();
@@ -320,6 +404,15 @@ private void OnTreePreviewGotKeyboardFocus(object sender, KeyboardFocusChangedEv
             FolderTreeView.Focus();
     }
 
+    private void FocusTileListWithoutChangingSelection()
+    {
+        if (ItemsList.SelectedItem is { } selected
+            && ItemsList.ItemContainerGenerator.ContainerFromItem(selected) is System.Windows.Controls.ListBoxItem keep)
+            keep.Focus();
+        else
+            ItemsList.Focus();
+    }
+
     private static System.Windows.Controls.TreeViewItem? FindTreeViewItem(
         System.Windows.Controls.ItemsControl parent, FolderNodeVm node)
     {
@@ -739,6 +832,10 @@ private void OnGridPreviewLeftDown(object sender, MouseButtonEventArgs e)
             || IsWithinButton(e.OriginalSource as DependencyObject))
             return;
 
+        // Same-click focus when the grid was not the keyboard pane (tree had focus,
+        // or the window just activated). Do not handle — selection and drag still run.
+        container.Focus();
+
         // Capture the drag set BEFORE WPF collapses the selection on mouse-down: pressing an
         // already-selected tile drags the whole selection (Explorer-style); otherwise just this one.
         var selected = ItemsList.SelectedItems.OfType<TileVm>().ToList();
@@ -1089,13 +1186,50 @@ private bool TryBuildCells(
         if (items.Count == 0)
             return false;
 
-        var columns = VisualColumnCount();
-        var (tileW, tileH) = MeasureTileSize();
+        var realized = CollectRealizedByItem();
+        var (tileW, tileH, slotW, _) = MeasureTileSlot(realized.Values);
+        var viewportW = WrapViewportWidth();
+        var observedXs = TileSpatialNavigation.DistinctColumnXs(
+            realized.Values.Select(c => c.X).ToList(), slop: Math.Max(tileW * 0.5, 1));
+        var fitted = TileSpatialNavigation.FitColumns(viewportW, slotW);
+        var columns = TileSpatialNavigation.ResolveColumnCount(observedXs.Count, fitted);
+
+        IReadOnlyList<double>? columnXs = observedXs.Count == columns
+            ? observedXs
+            : TileSpatialNavigation.UniformColumnXs(viewportW, slotW, tileW);
+
         var headerH = layout.HasHeaders ? MeasureSectionHeaderHeight() : 0;
-        cells = TileSpatialNavigation.LayoutWrap(layout.SectionCounts, columns, tileW, tileH, headerH);
+        cells = TileSpatialNavigation.LayoutWrap(
+            layout.SectionCounts, columns, tileW, tileH, headerH, columnXs);
+
+        if (realized.Count > 0)
+        {
+            var byIndex = new Dictionary<int, TileSpatialNavigation.Cell>();
+            foreach (var (item, measured) in realized)
+            {
+                var idx = IndexOfItem(items, item);
+                if (idx < 0)
+                    continue;
+                // Overlay X/size only. Realized Y is viewport-relative; mixing it
+                // with the document-space wrap model skips rows. Column is X.
+                byIndex[idx] = cells[idx] with { X = measured.X, Width = measured.Width, Height = measured.Height };
+            }
+            cells = TileSpatialNavigation.OverlayMeasured(cells, byIndex);
+        }
+
         return cells.Count > 0;
     }
 
+    private static int IndexOfItem(IReadOnlyList<IGridItem> items, IGridItem item)
+    {
+        for (var i = 0; i < items.Count; i++)
+        {
+            if (ReferenceEquals(items[i], item))
+                return i;
+        }
+        return -1;
+    }
+
     private int? CurrentCellIndex(IReadOnlyList<IGridItem> items)
     {
         if (ViewModel?.SelectedItem is not IGridItem sel)
@@ -1125,9 +1259,13 @@ private static void CollectRealizedTileRects(
         if (node is System.Windows.Controls.ListBoxItem { IsVisible: true, DataContext: IGridItem item } li)
         {
             // Origin is the ListBox: coordinates are viewport-relative (scroll already applied).
+            // Use the wrap slot (margin included) so X matches TryBuildCells / Uniform columns.
             var tl = li.TranslatePoint(new Point(0, 0), origin);
+            var slotW = li.ActualWidth + li.Margin.Left + li.Margin.Right;
+            var slotH = li.ActualHeight + li.Margin.Top + li.Margin.Bottom;
             cells.Add(new TileSpatialNavigation.Cell(
-                cells.Count, Row: 0, Col: 0, tl.X, tl.Y, li.ActualWidth, li.ActualHeight));
+                cells.Count, Row: 0, Col: 0,
+                tl.X - li.Margin.Left, tl.Y - li.Margin.Top, slotW, slotH));
             items.Add(item);
             return;
         }
@@ -1137,32 +1275,87 @@ private static void CollectRealizedTileRects(
             CollectRealizedTileRects(VisualTreeHelper.GetChild(node, i), origin, cells, items);
     }
 
-    private int VisualColumnCount()
+    /// <summary>
+    /// Width the wrap panel actually laid out against. ScrollViewer.ViewportWidth
+    /// already excludes the vertical scrollbar — do not subtract padding/12 again
+    /// (that was the 0.8.4 off-by-one: 4 visual columns, nav used 3).
+    /// </summary>
+    private double WrapViewportWidth()
     {
-        var realized = new List<Rect>();
-        CollectRealizedItemRects(ItemsList, ItemsList, realized);
-        if (realized.Count > 0)
+        if (FindDescendant<WpfToolkit.Controls.VirtualizingWrapPanel>(ItemsList)
+            is { ActualWidth: > 1 } panel)
+            return panel.ActualWidth;
+
+        var sv = GridScroll();
+        if (sv is { ViewportWidth: > 1 })
+            return sv.ViewportWidth;
+
+        var w = ItemsList.ActualWidth - ItemsList.Padding.Left - ItemsList.Padding.Right;
+        if (sv?.ComputedVerticalScrollBarVisibility == System.Windows.Visibility.Visible)
+            w -= SystemParameters.VerticalScrollBarWidth;
+        return Math.Max(1, w);
+    }
+
+    private (double Width, double Height, double SlotWidth, double SlotHeight) MeasureTileSlot(
+        IEnumerable<TileSpatialNavigation.Cell>? realized = null)
+    {
+        if (realized is not null)
         {
-            var itemW = realized.Max(r => r.Width);
-            var fitted = (int)((ItemsList.ActualWidth - 12) / Math.Max(1, itemW));
-            var fullestRow = realized
-                .GroupBy(r => Math.Round(r.Y / 8.0) * 8.0)
-                .Select(g => g.Count())
-                .DefaultIfEmpty(1)
-                .Max();
-            return Math.Max(1, Math.Max(fullestRow, fitted));
+            foreach (var c in realized)
+                return (c.Width, c.Height, c.Width, c.Height);
         }
-        return ColumnsPerRow();
+
+        if (FindFirstTileItem(ItemsList) is { } li && li.ActualWidth > 0)
+        {
+            var w = li.ActualWidth;
+            var h = li.ActualHeight;
+            return (w, h, w + li.Margin.Left + li.Margin.Right, h + li.Margin.Top + li.Margin.Bottom);
+        }
+
+        var outer = (ViewModel?.TileSize ?? 200) + 20;
+        return (outer, outer + 18, outer, outer + 18);
     }
 
-    private (double Width, double Height) MeasureTileSize()
+    private static System.Windows.Controls.ListBoxItem? FindFirstTileItem(DependencyObject node)
     {
-        var realized = new List<Rect>();
-        CollectRealizedItemRects(ItemsList, ItemsList, realized);
-        if (realized.Count > 0)
-            return (realized[0].Width, realized[0].Height);
-        var outer = (ViewModel?.TileSize ?? 200) + 20;
-        return (outer, outer + 18);
+        if (node is System.Windows.Controls.ListBoxItem { IsVisible: true, DataContext: IGridItem } li)
+            return li;
+
+        var count = VisualTreeHelper.GetChildrenCount(node);
+        for (var i = 0; i < count; i++)
+        {
+            if (FindFirstTileItem(VisualTreeHelper.GetChild(node, i)) is { } found)
+                return found;
+        }
+        return null;
+    }
+
+    private Dictionary<IGridItem, TileSpatialNavigation.Cell> CollectRealizedByItem()
+    {
+        var map = new Dictionary<IGridItem, TileSpatialNavigation.Cell>();
+        CollectRealizedByItem(ItemsList, ItemsList, map);
+        return map;
+    }
+
+    private static void CollectRealizedByItem(
+        DependencyObject node,
+        UIElement origin,
+        Dictionary<IGridItem, TileSpatialNavigation.Cell> map)
+    {
+        if (node is System.Windows.Controls.ListBoxItem { IsVisible: true, DataContext: IGridItem item } li)
+        {
+            var tl = li.TranslatePoint(new Point(0, 0), origin);
+            // Slot the wrap used: arranged width includes margin.
+            var slotW = li.ActualWidth + li.Margin.Left + li.Margin.Right;
+            var slotH = li.ActualHeight + li.Margin.Top + li.Margin.Bottom;
+            map[item] = new TileSpatialNavigation.Cell(
+                map.Count, Row: 0, Col: 0, tl.X - li.Margin.Left, tl.Y - li.Margin.Top, slotW, slotH);
+            return;
+        }
+
+        var count = VisualTreeHelper.GetChildrenCount(node);
+        for (var i = 0; i < count; i++)
+            CollectRealizedByItem(VisualTreeHelper.GetChild(node, i), origin, map);
     }
 
     private double MeasureSectionHeaderHeight()
@@ -1188,19 +1381,6 @@ private double MeasureSectionHeaderHeight()
         return null;
     }
 
-    private static void CollectRealizedItemRects(DependencyObject node, UIElement origin, List<Rect> rects)
-    {
-        if (node is System.Windows.Controls.ListBoxItem { IsVisible: true, DataContext: IGridItem } li)
-        {
-            rects.Add(new Rect(li.TranslatePoint(new Point(0, 0), origin), li.RenderSize));
-            return;
-        }
-
-        var count = VisualTreeHelper.GetChildrenCount(node);
-        for (var i = 0; i < count; i++)
-            CollectRealizedItemRects(VisualTreeHelper.GetChild(node, i), origin, rects);
-    }
-
     /// <summary>Home/End: move the cursor to the first/last stop and scroll the grid to that extreme.</summary>
     private void JumpCursor(bool toEnd)
     {
@@ -1278,8 +1458,7 @@ private static void CollectRealizedItems(DependencyObject root, System.Collectio
 
     private int ColumnsPerRow()
     {
-        var tileOuter = (ViewModel?.TileSize ?? 200) + 20; // tile + margin/padding/spacing
-        var columns = (int)((ItemsList.ActualWidth - 12) / Math.Max(1, tileOuter));
-        return Math.Max(1, columns);
+        var (_, _, slotW, _) = MeasureTileSlot();
+        return TileSpatialNavigation.FitColumns(WrapViewportWidth(), slotW);
     }
 }
diff --git a/src/Aperture.App/TileSpatialNavigation.cs b/src/Aperture.App/TileSpatialNavigation.cs
index a3f0477..12bc727 100644
--- a/src/Aperture.App/TileSpatialNavigation.cs
+++ b/src/Aperture.App/TileSpatialNavigation.cs
@@ -3,7 +3,8 @@ namespace Aperture.App;
 /// <summary>
 /// Explorer-style 2D pick over a wrapping, date-sectioned tile grid.
 /// Operates on layout rectangles so Up/Down / PageUp/PageDown follow
-/// visual columns rather than ListBox item index.
+/// visual X (the column on screen) rather than ListBox item index or a
+/// stale <c>index % columns</c> guess.
 /// </summary>
 internal static class TileSpatialNavigation
 {
@@ -20,20 +21,141 @@ internal readonly record struct Cell(
         public double CenterY => Y + Height / 2;
     }
 
+    /// <summary>
+    /// How many tiles a wrap panel actually fits:
+    /// <c>floor(availableWidth / slotWidth)</c>.
+    /// <paramref name="availableWidth"/> is the panel/viewport width the wrap
+    /// used (scrollbar already excluded). Do not subtract padding again.
+    /// <paramref name="slotWidth"/> is the arranged child size including margin.
+    /// </summary>
+    public static int FitColumns(double availableWidth, double slotWidth)
+    {
+        slotWidth = Math.Max(1, slotWidth);
+        availableWidth = Math.Max(slotWidth, availableWidth);
+        return Math.Max(1, (int)Math.Floor(availableWidth / slotWidth));
+    }
+
+    /// <summary>
+    /// Visual column count. A stale width-based estimate (scrollbar subtracted
+    /// twice, padding fudge, leftover tile-size guess) can come in one low;
+    /// never prefer that over columns already seen on screen.
+    /// </summary>
+    public static int ResolveColumnCount(int columnsFromLayoutX, int fittedFromWidth) =>
+        Math.Max(1, Math.Max(columnsFromLayoutX, fittedFromWidth));
+
+    /// <summary>
+    /// Cluster left edges into visual columns. Tiles in the same wrap column
+    /// share an X; a short last row just contributes fewer clusters.
+    /// </summary>
+    public static IReadOnlyList<double> DistinctColumnXs(IReadOnlyList<double> xs, double slop)
+    {
+        if (xs is null || xs.Count == 0)
+            return Array.Empty<double>();
+
+        slop = Math.Max(1, slop);
+        var sorted = xs.OrderBy(x => x).ToList();
+        var groups = new List<List<double>>();
+        var first = new List<double>();
+        first.Add(sorted[0]);
+        groups.Add(first);
+        for (var i = 1; i < sorted.Count; i++)
+        {
+            var last = groups[groups.Count - 1];
+            if (Math.Abs(sorted[i] - last[0]) > slop)
+            {
+                var next = new List<double>();
+                next.Add(sorted[i]);
+                groups.Add(next);
+            }
+            else
+            {
+                last.Add(sorted[i]);
+            }
+        }
+
+        return groups.Select(g => g.Average()).ToList();
+    }
+
+    /// <summary>
+    /// Uniform wrap origins (start + between + end leftover), matching
+    /// VirtualizingWrapPanel <c>SpacingMode.Uniform</c>.
+    /// </summary>
+    public static IReadOnlyList<double> UniformColumnXs(
+        double availableWidth, double slotWidth, double tileWidth)
+    {
+        var columns = FitColumns(availableWidth, slotWidth);
+        slotWidth = Math.Max(1, slotWidth);
+        tileWidth = Math.Max(1, tileWidth);
+        var unused = Math.Max(0, availableWidth - columns * slotWidth);
+        var outer = unused / (columns + 1);
+        var xs = new double[columns];
+        for (var i = 0; i < columns; i++)
+            xs[i] = outer + i * (slotWidth + outer);
+        return xs;
+    }
+
+    /// <summary>
+    /// Relabel Row/Col as <c>index % staleColumns</c> while keeping visual X/Y.
+    /// That is the 0.8.4 path when the window under-counted columns (scrollbar /
+    /// padding). Pickers that still use Col/Row walk diagonally; X-based pick
+    /// must not.
+    /// </summary>
+    public static IReadOnlyList<Cell> WithIndexColumns(IReadOnlyList<Cell> cells, int staleColumns)
+    {
+        ArgumentNullException.ThrowIfNull(cells);
+        staleColumns = Math.Max(1, staleColumns);
+        var relabeled = new Cell[cells.Count];
+        for (var i = 0; i < cells.Count; i++)
+        {
+            var c = cells[i];
+            relabeled[i] = c with { Col = c.Index % staleColumns, Row = c.Index / staleColumns };
+        }
+        return relabeled;
+    }
+
+    /// <summary>
+    /// Copy measured X/Y/size onto the matching model cells. Unrealized tiles
+    /// keep the wrap model so virtualization cannot invent a wrong column.
+    /// </summary>
+    public static IReadOnlyList<Cell> OverlayMeasured(
+        IReadOnlyList<Cell> model, IReadOnlyDictionary<int, Cell> measured)
+    {
+        ArgumentNullException.ThrowIfNull(model);
+        if (measured is null || measured.Count == 0)
+            return model;
+
+        var next = new Cell[model.Count];
+        for (var i = 0; i < model.Count; i++)
+        {
+            var c = model[i];
+            next[i] = measured.TryGetValue(c.Index, out var m)
+                ? c with { X = m.X, Y = m.Y, Width = m.Width, Height = m.Height }
+                : c;
+        }
+        return next;
+    }
+
     /// <summary>
     /// Wrap tiles into a column grid. Each section starts on a new row after an
     /// optional header gap (headers are not cells — crossing them is fine).
     /// A zero-count section still consumes <paramref name="headerHeight"/> so
     /// Page distance matches a collapsed date bucket.
+    /// <para>
+    /// When <paramref name="columnXs"/> is set, X comes from those origins
+    /// (actual wrap / Uniform spacing) instead of <c>col * tileWidth</c>.
+    /// </para>
     /// </summary>
     public static IReadOnlyList<Cell> LayoutWrap(
         IReadOnlyList<int> sectionCounts,
         int columns,
         double tileWidth,
         double tileHeight,
-        double headerHeight)
+        double headerHeight,
+        IReadOnlyList<double>? columnXs = null)
     {
         ArgumentNullException.ThrowIfNull(sectionCounts);
+        if (columnXs is { Count: > 0 })
+            columns = columnXs.Count;
         columns = Math.Max(1, columns);
         tileWidth = Math.Max(1, tileWidth);
         tileHeight = Math.Max(1, tileHeight);
@@ -59,7 +181,8 @@ public static IReadOnlyList<Cell> LayoutWrap(
                     y += tileHeight;
                 }
 
-                cells.Add(new Cell(index, row, col, col * tileWidth, y, tileWidth, tileHeight));
+                var x = columnXs is { Count: > 0 } ? columnXs[col] : col * tileWidth;
+                cells.Add(new Cell(index, row, col, x, y, tileWidth, tileHeight));
                 index++;
             }
 
@@ -72,8 +195,9 @@ public static IReadOnlyList<Cell> LayoutWrap(
 
     /// <summary>
     /// One visual row up (<paramref name="sign"/> = -1) or down (+1) in the same
-    /// column. Empty cell (short last row, end of a section): nearest tile in
-    /// that column, then nearest in the adjacent row.
+    /// <em>screen</em> column (layout X), not <c>index % columns</c>. Empty cell
+    /// (short last row, end of a section): nearest tile in that column, then
+    /// nearest in the adjacent row.
     /// </summary>
     public static int? PickVertical(IReadOnlyList<Cell> cells, int currentIndex, int sign)
     {
@@ -81,30 +205,28 @@ public static IReadOnlyList<Cell> LayoutWrap(
             return null;
 
         sign = Math.Sign(sign);
-        var targetRow = cur.Row + sign;
-        var adjacent = cells.Where(c => c.Row == targetRow).ToList();
-
-        if (CellInColumn(adjacent, cur.Col) is { } sameColOnRow)
-            return sameColOnRow.Index;
-
-        var further = cells
-            .Where(c => c.Col == cur.Col && c.Row * sign > cur.Row * sign)
-            .OrderBy(c => Math.Abs(c.Row - cur.Row))
-            .ThenBy(c => c.Index)
-            .FirstOrDefault();
-        if (further.Width > 0)
-            return further.Index;
+        var inColumn = cells
+            .Where(c => c.Index != cur.Index && SameColumnX(c, cur) && FurtherY(c, cur, sign))
+            .ToList();
+        if (inColumn.Count > 0)
+            return inColumn.MinBy(c => (Math.Abs(c.CenterY - cur.CenterY), c.Index)).Index;
 
-        if (adjacent.Count > 0)
-            return adjacent.MinBy(c => (Math.Abs(c.Col - cur.Col), c.Index)).Index;
+        var others = cells
+            .Where(c => c.Index != cur.Index && FurtherY(c, cur, sign))
+            .ToList();
+        if (others.Count == 0)
+            return null;
 
-        return null;
+        var nextY = others.MinBy(c => Math.Abs(c.CenterY - cur.CenterY)).CenterY;
+        var rowSlop = Math.Max(cur.Height * 0.5, 1);
+        var adjacent = others.Where(c => Math.Abs(c.CenterY - nextY) <= rowSlop).ToList();
+        return adjacent.MinBy(c => (Math.Abs(c.CenterX - cur.CenterX), c.Index)).Index;
     }
 
     /// <summary>
-    /// After moving the viewport by one page, pick the tile in the same column
-    /// closest to the same vertical position within the viewport. Not "skip N
-    /// items" and not a jump onto a section header.
+    /// After moving the viewport by one page, pick the tile in the same visual
+    /// column closest to the same vertical position within the viewport. Not
+    /// "skip N items" and not a jump onto a section header.
     /// </summary>
     public static int? PickPage(
         IReadOnlyList<Cell> cells,
@@ -123,15 +245,13 @@ public static IReadOnlyList<Cell> LayoutWrap(
         var targetY = newViewportTop + yInViewport;
 
         var sameCol = cells
-            .Where(c => c.Col == cur.Col && c.Index != cur.Index)
-            .Where(c => sign > 0 ? c.CenterY > cur.CenterY : c.CenterY < cur.CenterY)
+            .Where(c => c.Index != cur.Index && SameColumnX(c, cur) && FurtherY(c, cur, sign))
             .ToList();
         if (sameCol.Count > 0)
             return ClosestToY(sameCol, targetY, sign).Index;
 
         var others = cells
-            .Where(c => c.Index != cur.Index)
-            .Where(c => sign > 0 ? c.CenterY > cur.CenterY : c.CenterY < cur.CenterY)
+            .Where(c => c.Index != cur.Index && FurtherY(c, cur, sign))
             .ToList();
         if (others.Count == 0)
             return null;
@@ -139,7 +259,7 @@ public static IReadOnlyList<Cell> LayoutWrap(
         var rowY = others.MinBy(c => Math.Abs(c.CenterY - targetY)).CenterY;
         var slop = Math.Max(cur.Height * 0.5, 1);
         var row = others.Where(c => Math.Abs(c.CenterY - rowY) <= slop).ToList();
-        return row.MinBy(c => (Math.Abs(c.Col - cur.Col), c.Index)).Index;
+        return row.MinBy(c => (Math.Abs(c.CenterX - cur.CenterX), c.Index)).Index;
     }
 
     /// <summary>
@@ -176,17 +296,17 @@ private static bool TryCurrent(IReadOnlyList<Cell> cells, int currentIndex, out
         return true;
     }
 
-    private static Cell? CellInColumn(List<Cell> row, int col)
+    private static bool SameColumnX(Cell a, Cell b)
     {
-        foreach (var c in row)
-        {
-            if (c.Col == col)
-                return c;
-        }
-
-        return null;
+        var slop = Math.Max(Math.Max(a.Width, b.Width) * 0.5, 1);
+        return Math.Abs(a.CenterX - b.CenterX) <= slop;
     }
 
+    private static bool FurtherY(Cell candidate, Cell current, int sign) =>
+        sign > 0
+            ? candidate.CenterY > current.CenterY + 1
+            : candidate.CenterY < current.CenterY - 1;
+
     private static Cell ClosestToY(List<Cell> cells, double targetY, int sign) =>
         cells.MinBy(c =>
         {
diff --git a/src/Aperture.App/ViewModels/MainViewModel.cs b/src/Aperture.App/ViewModels/MainViewModel.cs
index 0d73261..071d06e 100644
--- a/src/Aperture.App/ViewModels/MainViewModel.cs
+++ b/src/Aperture.App/ViewModels/MainViewModel.cs
@@ -5,6 +5,7 @@
 using System.Reflection;
 using System.Windows.Data;
 using System.Windows.Input;
+using System.Windows.Threading;
 using Microsoft.Win32;
 using Aperture.App.Mvvm;
 using Aperture.App.Services;
@@ -1304,7 +1305,7 @@ private static void Notify(string message, bool warn = false) =>
 
     private bool _navigating;
 
-    private void NavigateTo(long? rootId, string relDir, bool pushBack = true)
+    private void NavigateTo(long? rootId, string relDir, bool pushBack = true, bool syncTree = true)
     {
         if (_navigating)
             return;
@@ -1321,13 +1322,18 @@ private void NavigateTo(long? rootId, string relDir, bool pushBack = true)
             _searchInput = "";
             _searchText = "";
             OnPropertyChanged(nameof(SearchInput));
-            SelectedItem = null;
-            RequestBuildView(); // debounced + async so rapid tree navigation doesn't queue
+            // Do not clear SelectedItem or rebuild the grid here: that invalidates
+            // tile layout and the dispatcher would Render before the next tree
+            // keydown. ApplyView drops the stale selection when the tiles land.
+            RequestBuildView();
             OnPropertyChanged(nameof(IsHome));
-            if (rootId is null)
-                ClearTreeSelection(FolderTree); // "Everything" — no folder node should stay highlighted
-            else
-                SelectPath(rootId, relDir); // keep the tree's selection in sync
+            if (syncTree)
+            {
+                if (rootId is null)
+                    ClearTreeSelection(FolderTree); // "Everything" — no folder node should stay highlighted
+                else
+                    SelectPath(rootId, relDir); // keep the tree's selection in sync
+            }
         }
         finally
         {
@@ -1973,7 +1979,11 @@ private void LoadRows()
     /// <summary>
     /// Debounced, last-one-wins async rebuild. Rapid triggers — arrowing the folder
     /// tree, typing in search — coalesce, and the heavy filter/sort/tile work runs off
-    /// the UI thread so keystrokes never queue behind it. A brief spinner covers the gap.
+    /// the UI thread. Generation is stamped at request time (not after debounce) so an
+    /// in-flight compute from folder A cannot ApplyView after the user has moved to B.
+    /// ApplyView is posted at Background (below Input) so queued tree arrows drain
+    /// first. The existing Loading… spinner covers a slow rebuild after the tree node
+    /// has already moved.
     /// </summary>
     private async void RequestBuildView()
     {
@@ -1981,18 +1991,35 @@ private async void RequestBuildView()
         var cts = new CancellationTokenSource();
         _buildDebounce = cts;
         var token = cts.Token;
+        var generation = ++_buildGeneration;
         try { await Task.Delay(BuildDebounceMs, token); }
         catch (OperationCanceledException) { return; }
 
-        var generation = ++_buildGeneration;
+        if (generation != _buildGeneration)
+            return;
+
         IsLoadingView = true;
         var inputs = CaptureBuildInputs();
 
         try
         {
             var build = await Task.Run(() => ComputeView(inputs), token);
-            if (generation == _buildGeneration) // a newer request may have superseded this one
+            if (generation != _buildGeneration)
+                return;
+
+            var dispatcher = System.Windows.Application.Current?.Dispatcher;
+            if (dispatcher is not null && !dispatcher.HasShutdownStarted)
+            {
+                await dispatcher.InvokeAsync(() =>
+                {
+                    if (generation == _buildGeneration)
+                        ApplyView(build);
+                }, DispatcherPriority.Background);
+            }
+            else if (generation == _buildGeneration)
+            {
                 ApplyView(build);
+            }
         }
         catch (OperationCanceledException)
         {
@@ -2088,6 +2115,11 @@ private void ApplyView(ViewBuild build)
         ClearCursorHighlight();
         _cursorSection = null;
         _selectedTiles = []; // stale references across a view rebuild would act on the wrong tiles
+        // Folder change drops the old tile; a streaming/sort rebuild that reuses the
+        // same TileVm must not. Clearing here (not in NavigateTo) keeps tree keydown
+        // off the grid's layout pass.
+        if (_selectedItem is not TileVm stay || !build.MediaTiles.Contains(stay))
+            SelectedItem = null;
 
         _sections.Clear();
         foreach (var (key, section) in build.Sections)
@@ -2236,11 +2268,15 @@ private List<FolderNodeVm> LoadChildNodes(long rootId, string relDir) =>
             .ToList();
     }
 
-    /// <summary>Called from the tree when the user selects a node.</summary>
+    /// <summary>
+    /// Called from the tree when the user selects a node. The TreeView has
+    /// already committed the highlight; do not SelectPath (that would walk /
+    /// lazy-load children on the keydown) and do not wait for the tile rebuild.
+    /// </summary>
     public void NavigateToNode(FolderNodeVm? node)
     {
         if (node is not null)
-            NavigateTo(node.RootId, node.RelDir);
+            NavigateTo(node.RootId, node.RelDir, pushBack: true, syncTree: false);
     }
 
     /// <summary>Clears selection on every loaded tree node — used when navigating to "Everything".</summary>
diff --git a/tests/Aperture.Core.Tests/LibraryPaneFocusTests.cs b/tests/Aperture.Core.Tests/LibraryPaneFocusTests.cs
index 90082cc..1f9a638 100644
--- a/tests/Aperture.Core.Tests/LibraryPaneFocusTests.cs
+++ b/tests/Aperture.Core.Tests/LibraryPaneFocusTests.cs
@@ -10,10 +10,12 @@ namespace Aperture.Core.Tests;
 /// PageDown / scroll keys move the grid, not the tree. Clicking a folder,
 /// a tile, a section header, the search box, or a dialog must stay as today.
 ///
-/// Tab / Shift+Tab (manual): tree arrows keep the folder; Tab to the grid
-/// keeps the selected tile; Up/Down stay in column; Page is ~one screen
-/// same column; Tab back to the tree keeps the folder; ribbon is never a
-/// Tab stop. Search stays on / and Ctrl+F.
+/// Tab / Shift+Tab (manual): only tree ↔ tile list; ribbon and Everything
+/// are not stops. Tab to the tree keeps the folder (or Everything) and
+/// arrows move folders immediately; Tab to the grid keeps the selected tile.
+/// Click in the tree focuses it. First click on an unfocused window or pane
+/// focuses the clicked folder / tile / canvas in that same click. Tree Up/Down
+/// commit the node at once; the tile pane may spinner. Search stays on / and Ctrl+F.
 /// </summary>
 public class LibraryPaneFocusTests
 {
@@ -55,4 +57,96 @@ public void TabIntoPane_AllowsFocusOnAlreadySelectedItem() =>
     public void ArrowsInsidePane_DoNotRedirect() =>
         Assert.False(LibraryPaneFocus.ShouldKeepExistingSelection(
             fromOutside: false, newFocusIsItem: true, newFocusIsSelected: false));
+
+    [Fact]
+    public void TabIntoTree_RedirectsToSelectedFolder() =>
+        Assert.Equal(LibraryPaneFocus.TreeFocusAction.FocusSelectedItem,
+            LibraryPaneFocus.OnTreeKeyboardArrival(
+                fromOutside: true, mousePressed: false,
+                newFocusIsItem: true, newFocusIsSelected: false, hasSelectedItem: true));
+
+    [Fact]
+    public void TabOntoTree_WithSelection_FocusesSelectedItem() =>
+        Assert.Equal(LibraryPaneFocus.TreeFocusAction.FocusSelectedItem,
+            LibraryPaneFocus.OnTreeKeyboardArrival(
+                fromOutside: true, mousePressed: false,
+                newFocusIsItem: false, newFocusIsSelected: false, hasSelectedItem: true));
+
+    [Fact]
+    public void TabOntoTree_Everything_FocusesTreeNotFirstFolder() =>
+        Assert.Equal(LibraryPaneFocus.TreeFocusAction.FocusTree,
+            LibraryPaneFocus.OnTreeKeyboardArrival(
+                fromOutside: true, mousePressed: false,
+                newFocusIsItem: false, newFocusIsSelected: false, hasSelectedItem: false));
+
+    [Fact]
+    public void TabOntoFirstFolder_WhenEverything_DoesNotSelectIt() =>
+        Assert.Equal(LibraryPaneFocus.TreeFocusAction.FocusTree,
+            LibraryPaneFocus.OnTreeKeyboardArrival(
+                fromOutside: true, mousePressed: false,
+                newFocusIsItem: true, newFocusIsSelected: false, hasSelectedItem: false));
+
+    [Fact]
+    public void TabOntoAlreadySelectedFolder_LeavesIt() =>
+        Assert.Equal(LibraryPaneFocus.TreeFocusAction.Leave,
+            LibraryPaneFocus.OnTreeKeyboardArrival(
+                fromOutside: true, mousePressed: false,
+                newFocusIsItem: true, newFocusIsSelected: true, hasSelectedItem: true));
+
+    [Fact]
+    public void ClickTreeRow_LeavesFocusOnClickedItem() =>
+        Assert.Equal(LibraryPaneFocus.TreeFocusAction.Leave,
+            LibraryPaneFocus.OnTreeKeyboardArrival(
+                fromOutside: true, mousePressed: true,
+                newFocusIsItem: true, newFocusIsSelected: false, hasSelectedItem: true));
+
+    [Fact]
+    public void ArrowsInsideTree_DoNotRedirect() =>
+        Assert.Equal(LibraryPaneFocus.TreeFocusAction.Leave,
+            LibraryPaneFocus.OnTreeKeyboardArrival(
+                fromOutside: false, mousePressed: false,
+                newFocusIsItem: true, newFocusIsSelected: false, hasSelectedItem: true));
+
+    [Fact]
+    public void TreeClick_Row_FocusesItem() =>
+        Assert.Equal(LibraryPaneFocus.TreeClickAction.FocusItem,
+            LibraryPaneFocus.OnTreePreviewClick(LibraryPaneFocus.TreeHit.Row));
+
+    [Fact]
+    public void TreeClick_Expander_DoesNotSelectFolder() =>
+        Assert.Equal(LibraryPaneFocus.TreeClickAction.Leave,
+            LibraryPaneFocus.OnTreePreviewClick(LibraryPaneFocus.TreeHit.Expander));
+
+    [Fact]
+    public void TreeClick_IncludeCheckBox_DoesNotSelectFolder() =>
+        Assert.Equal(LibraryPaneFocus.TreeClickAction.Leave,
+            LibraryPaneFocus.OnTreePreviewClick(LibraryPaneFocus.TreeHit.IncludeCheckBox));
+
+    [Fact]
+    public void TreeClick_AliasEdit_LeavesCaret() =>
+        Assert.Equal(LibraryPaneFocus.TreeClickAction.Leave,
+            LibraryPaneFocus.OnTreePreviewClick(LibraryPaneFocus.TreeHit.TextInput));
+
+    [Fact]
+    public void TreeClick_EmptyChrome_FocusesTree() =>
+        Assert.Equal(LibraryPaneFocus.TreeClickAction.FocusTree,
+            LibraryPaneFocus.OnTreePreviewClick(LibraryPaneFocus.TreeHit.Canvas));
+
+    [Fact]
+    public void ClassifyTreeHit_NullIsCanvas() =>
+        Assert.Equal(LibraryPaneFocus.TreeHit.Canvas, LibraryPaneFocus.ClassifyTreeHit(null));
+
+    [Fact]
+    public void ActivatingClick_IsPassedThrough_NotEaten()
+    {
+        Assert.True(LibraryPaneFocus.TryPassActivatingClick(LibraryPaneFocus.WmMouseActivate, out var result));
+        Assert.Equal(LibraryPaneFocus.MaActivate, result.ToInt32());
+    }
+
+    [Fact]
+    public void NonActivateMessage_IsNotHandled()
+    {
+        Assert.False(LibraryPaneFocus.TryPassActivatingClick(0x0201, out var result)); // WM_LBUTTONDOWN
+        Assert.Equal(IntPtr.Zero, result);
+    }
 }
diff --git a/tests/Aperture.Core.Tests/TileSpatialNavigationTests.cs b/tests/Aperture.Core.Tests/TileSpatialNavigationTests.cs
index 70535bd..1f81962 100644
--- a/tests/Aperture.Core.Tests/TileSpatialNavigationTests.cs
+++ b/tests/Aperture.Core.Tests/TileSpatialNavigationTests.cs
@@ -162,4 +162,114 @@ public void CollapsedSection_ConsumesHeaderGap_ButNoCells()
         // Down from last tile of section 0 (index 1, col 1) crosses the collapsed bucket to col 1 of section 2.
         Assert.Equal(5, TileSpatialNavigation.PickVertical(cells, 1, +1));
     }
+
+    // --- 0.8.5: visual X, not a stale column count (Paul's recording) ---
+
+    [Theory]
+    [InlineData(3)]
+    [InlineData(4)]
+    [InlineData(5)]
+    [InlineData(6)]
+    public void Down_FromColumn0_StaysInColumn0_NotColumn1(int columns)
+    {
+        var cells = TileSpatialNavigation.LayoutWrap([columns * 3], columns, tileWidth: 100, tileHeight: 100, headerHeight: 0);
+        var pick = TileSpatialNavigation.PickVertical(cells, 0, +1);
+        Assert.Equal(columns, pick);                 // next row, same visual column
+        Assert.NotEqual(columns + 1, pick);          // must not slide into column 1
+        Assert.Equal(cells[0].X, cells[pick!.Value].X);
+    }
+
+    [Fact]
+    public void Up_FourColumnWrap_DoesNotUseStaleThree()
+    {
+        // Paul's 4-column zoom: Need a Hint at visual row 3, col 3 (1-based)
+        // is index 10. Up must stay in that column (index 6), not land on
+        // index 7 — Bar Chart, one tile right. 0.8.4 subtracted 3 because
+        // (ActualWidth-12)/slot ignored that the viewport already excluded
+        // the scrollbar, so calculatedColumns = 3.
+        const int visualColumns = 4;
+        const int wrongColumns = 3;
+        var visual = TileSpatialNavigation.LayoutWrap(
+            [visualColumns * 5], visualColumns, tileWidth: 100, tileHeight: 100, headerHeight: 0);
+        var staleLabels = TileSpatialNavigation.WithIndexColumns(visual, wrongColumns);
+
+        const int needAHint = 10; // row 2, col 2 (0-based) on a 4-col wrap
+        const int barChartDiagonal = needAHint - wrongColumns; // 7 — today's math
+        const int sameColumnUp = needAHint - visualColumns;    // 6
+
+        Assert.Equal(200, visual[needAHint].X);
+        Assert.Equal(visual[needAHint].X, visual[sameColumnUp].X);
+        Assert.NotEqual(visual[needAHint].X, visual[barChartDiagonal].X);
+
+        // Col/Row look like a 3-column wrap (the 0.8.4 picker). X is still 4-col.
+        Assert.Equal(1, staleLabels[needAHint].Col);
+        Assert.Equal(7, StepByColumnCount(needAHint, -wrongColumns));
+
+        var pick = TileSpatialNavigation.PickVertical(staleLabels, needAHint, -1);
+        Assert.Equal(sameColumnUp, pick);
+        Assert.NotEqual(barChartDiagonal, pick);
+        Assert.Equal(visual[needAHint].CenterX, visual[pick!.Value].CenterX);
+    }
+
+    [Fact]
+    public void Up_SixColumnWrap_DoesNotSkipARow()
+    {
+        // 6-column zoom: green Wordle at row 6, col 3 (1-based) is index 32.
+        // One Up must be the tile immediately above (index 26), not a 12-item
+        // jump that skips the in-between row.
+        var cells = TileSpatialNavigation.LayoutWrap([42], columns: 6, tileWidth: 100, tileHeight: 100, headerHeight: 0);
+        const int green = 5 * 6 + 2; // row 5, col 2
+        Assert.Equal(26, TileSpatialNavigation.PickVertical(cells, green, -1));
+        Assert.Equal(20, TileSpatialNavigation.PickVertical(cells, 26, -1));
+        Assert.NotEqual(20, TileSpatialNavigation.PickVertical(cells, green, -1));
+        Assert.Equal(cells[green].X, cells[26].X);
+    }
+
+    [Fact]
+    public void Up_SixColumnWrap_StaleFiveStillUsesVisualX()
+    {
+        var visual = TileSpatialNavigation.LayoutWrap([42], columns: 6, tileWidth: 100, tileHeight: 100, headerHeight: 0);
+        var stale = TileSpatialNavigation.WithIndexColumns(visual, staleColumns: 5);
+        const int green = 32;
+        var pick = TileSpatialNavigation.PickVertical(stale, green, -1);
+        Assert.Equal(26, pick);
+        Assert.NotEqual(green - 5, pick);
+        Assert.Equal(visual[green].X, visual[pick!.Value].X);
+    }
+
+    [Fact]
+    public void ResolveColumnCount_PrefersVisualFour_OverStaleFittedThree()
+    {
+        // Viewport already excludes the scrollbar; subtracting padding again
+        // (or using TileSize+20) yields 3. The wrap fitted 4.
+        Assert.Equal(4, TileSpatialNavigation.FitColumns(availableWidth: 860, slotWidth: 215));
+        Assert.Equal(3, TileSpatialNavigation.FitColumns(availableWidth: 860 - 12, slotWidth: 215 + 20));
+        Assert.Equal(4, TileSpatialNavigation.ResolveColumnCount(columnsFromLayoutX: 4, fittedFromWidth: 3));
+        Assert.Equal(6, TileSpatialNavigation.ResolveColumnCount(columnsFromLayoutX: 5, fittedFromWidth: 6));
+    }
+
+    [Fact]
+    public void DistinctColumnXs_CountsVisualColumns_NotFlatIndex()
+    {
+        var visual = TileSpatialNavigation.LayoutWrap([12], columns: 4, tileWidth: 100, tileHeight: 100, headerHeight: 0);
+        var xs = TileSpatialNavigation.DistinctColumnXs(visual.Select(c => c.X).ToList(), slop: 50);
+        Assert.Equal(4, xs.Count);
+        Assert.Equal(4, TileSpatialNavigation.ResolveColumnCount(xs.Count, fittedFromWidth: 3));
+    }
+
+    [Fact]
+    public void Down_DateSectioned_SameVisualX_AtTwoColumnCounts()
+    {
+        foreach (var columns in new[] { 4, 6 })
+        {
+            var cells = TileSpatialNavigation.LayoutWrap(
+                [columns + 2, columns * 2], columns, tileWidth: 100, tileHeight: 100, headerHeight: 50);
+            var pick = TileSpatialNavigation.PickVertical(cells, 0, +1);
+            Assert.Equal(columns, pick);
+            Assert.Equal(cells[0].X, cells[pick!.Value].X);
+            Assert.NotEqual(columns + 1, pick);
+        }
+    }
+
+    private static int StepByColumnCount(int index, int delta) => index + delta;
 }