fix(chat): validate queued tail navigation

Capture immutable tail requests, revalidate their index and row identity against the reconciled item count, and coalesce dispatcher work without allowing stale generations to execute.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Author: karkarl

src/OpenClaw.Tray.WinUI/Chat/ReactorChatTimeline.cs

@@ -160,6 +160,7 @@ void SetEntryHovered(string entryId, bool isHovered)
                 .BindVerticalScrollController(
                     annotatedScrollBarRef,
                     rows.Count - 1,
+                    rows.Count,
                     initialTailRequestKey,
                     displayedTailKey)
                 .Grid(column: 0)

src/OpenClaw.Tray.WinUI/Chat/ReactorItemsViewScrollController.cs

@@ -14,6 +14,7 @@ file sealed record ItemsViewVerticalScrollControllerElement(
     Element Child,
     ElementRef<WinUIAnnotatedScrollBar> ScrollBarRef,
     int InitialTailIndex,
+    int ItemCount,
     string InitialTailRequestKey,
     string? DisplayedTailKey) : Element
 {
@@ -41,6 +42,7 @@ public UIElement Mount(MountContext context, ItemsViewVerticalScrollControllerEl
         Positioners.Add(itemsView, positioner);
         positioner.Request(
             element.InitialTailIndex,
+            element.ItemCount,
             element.InitialTailRequestKey,
             element.DisplayedTailKey);
         return itemsView;
@@ -59,11 +61,13 @@ public UIElement Update(
             && Positioners.TryGetValue(itemsView, out var positioner))
             positioner.Request(
                 newElement.InitialTailIndex,
+                newElement.ItemCount,
                 newElement.InitialTailRequestKey,
                 newElement.DisplayedTailKey);
         else if (Positioners.TryGetValue(itemsView, out var existingPositioner))
             existingPositioner.UpdateTail(
                 newElement.InitialTailIndex,
+                newElement.ItemCount,
                 newElement.DisplayedTailKey);
         return itemsView;
     }
@@ -87,13 +91,14 @@ public V1UnmountDisposition Unmount(UnmountContext context, ItemsViewVerticalScr
     private string? _requestKey;
     private string? _displayedTailKey;
     private int _tailIndex;
+    private int _itemCount;
     private int _version;
     private bool _valid;
     private bool _awaitingLayout;
     private WinUIScrollView? _awaitingScrollView;
     private WinUIScrollView? _scrollView;
     private bool _following;
-    private bool _tailRequestQueued;
+    private readonly TailNavigationQueue _tailNavigationQueue = new();
     private bool _disposed;
 
     public InitialTailPositioner(WinUIItemsView itemsView)
@@ -103,33 +108,42 @@ public InitialTailPositioner(WinUIItemsView itemsView)
         itemsView.Unloaded += OnUnloaded;
     }
 
-    public void Request(int tailIndex, string requestKey, string? displayedTailKey)
+    public void Request(int tailIndex, int itemCount, string requestKey, string? displayedTailKey)
     {
         if (_disposed || string.Equals(_requestKey, requestKey, StringComparison.Ordinal))
             return;
 
         _requestKey = requestKey;
         _version++;
         DetachLayout();
-        _valid = tailIndex >= 0;
-        if (!_valid)
-            return;
-
         _tailIndex = tailIndex;
+        _itemCount = itemCount;
         _displayedTailKey = displayedTailKey;
         _following = true;
+        _valid = TailNavigationPolicy.TryCapture(tailIndex, displayedTailKey, itemCount, out _);
+        if (!_valid)
+            return;
+
         if (itemsView.IsLoaded)
             AwaitLayout();
     }
 
-    public void UpdateTail(int tailIndex, string? displayedTailKey)
+    public void UpdateTail(int tailIndex, int itemCount, string? displayedTailKey)
     {
         var changed = !string.Equals(_displayedTailKey, displayedTailKey, StringComparison.Ordinal);
         _tailIndex = tailIndex;
+        _itemCount = itemCount;
         _displayedTailKey = displayedTailKey;
-        if (changed && _following && tailIndex >= 0 && itemsView.IsLoaded && displayedTailKey is not null)
+        _valid = TailNavigationPolicy.TryCapture(tailIndex, displayedTailKey, itemCount, out var request);
+        if (!_valid)
+        {
+            _tailNavigationQueue.Clear();
+            return;
+        }
+
+        if (changed && _following && itemsView.IsLoaded)
         {
-            QueueTailRequest(_version);
+            QueueTailRequest(_version, request);
         }
     }
 
@@ -174,7 +188,9 @@ private void OnLayoutUpdated(object? sender, object args)
         }
 
         var version = _version;
-        var index = _tailIndex;
+        if (!TailNavigationPolicy.TryCapture(_tailIndex, _displayedTailKey, _itemCount, out var request))
+            return;
+
         itemsView.DispatcherQueue.TryEnqueue(() =>
         {
             if (_disposed || !_valid || !itemsView.IsLoaded || version != _version
@@ -186,7 +202,8 @@ private void OnLayoutUpdated(object? sender, object args)
             }
 
             AttachScrollView();
-            StartTailRequest(index);
+            if (!StartTailRequest(request) && !_disposed && _valid)
+                AwaitLayout();
         });
     }
 
@@ -210,38 +227,51 @@ private void OnViewChanged(WinUIScrollView sender, object args)
         _following = IsNearBottom(sender);
     }
 
-    private void QueueTailRequest(int version)
+    private void QueueTailRequest(int version, TailNavigationRequest request)
     {
-        if (_tailRequestQueued)
+        if (!_tailNavigationQueue.Enqueue(version, request))
             return;
 
-        _tailRequestQueued = true;
         if (!itemsView.DispatcherQueue.TryEnqueue(() =>
         {
-            _tailRequestQueued = false;
-            if (_disposed || !_valid || !itemsView.IsLoaded || version != _version || !_following)
+            if (!_tailNavigationQueue.TryDequeue(_version, out var queuedRequest)
+                || _disposed
+                || !_valid
+                || !itemsView.IsLoaded
+                || !_following)
             {
                 return;
             }
 
-            StartTailRequest(_tailIndex);
+            StartTailRequest(queuedRequest);
         }))
         {
-            _tailRequestQueued = false;
+            _tailNavigationQueue.SchedulingFailed();
             _following = false;
         }
     }
 
-    private void StartTailRequest(int index)
+    private bool StartTailRequest(TailNavigationRequest request)
     {
         if (itemsView.ScrollView is not { IsLoaded: true })
-            return;
+            return false;
+
+        if (!TailNavigationPolicy.CanExecute(
+                request,
+                _tailIndex,
+                _displayedTailKey,
+                _itemCount))
+        {
+            return false;
+        }
+
         _following = true;
-        itemsView.StartBringItemIntoView(index, new BringIntoViewOptions
+        itemsView.StartBringItemIntoView(request.Index, new BringIntoViewOptions
         {
             AnimationDesired = false,
             VerticalAlignmentRatio = 1.0,
         });
+        return true;
     }
 
     private static bool IsNearBottom(WinUIScrollView scrollView) =>
@@ -250,6 +280,7 @@ private static bool IsNearBottom(WinUIScrollView scrollView) =>
     private void OnUnloaded(object sender, RoutedEventArgs args)
     {
         _version++;
+        _tailNavigationQueue.Clear();
         DetachLayout();
         DetachScrollView();
     }
@@ -287,6 +318,7 @@ public void Dispose()
 
         _disposed = true;
         _version++;
+        _tailNavigationQueue.Clear();
         DetachLayout();
         DetachScrollView();
         itemsView.Loaded -= OnLoaded;
@@ -300,12 +332,14 @@ public static Element BindVerticalScrollController<T>(
         this ItemsViewElement<T> itemsView,
         ElementRef<WinUIAnnotatedScrollBar> scrollBarRef,
         int initialTailIndex,
+        int itemCount,
         string initialTailRequestKey,
         string? displayedTailKey) =>
         new ItemsViewVerticalScrollControllerElement(
             itemsView,
             scrollBarRef,
             initialTailIndex,
+            itemCount,
             initialTailRequestKey,
             displayedTailKey);
 }

src/OpenClaw.Tray.WinUI/Chat/TailNavigationPolicy.cs

@@ -0,0 +1,75 @@
+namespace OpenClawTray.Chat;
+
+internal readonly record struct TailNavigationRequest(int Index, string DisplayedTailKey);
+
+internal static class TailNavigationPolicy
+{
+    public static bool TryCapture(
+        int tailIndex,
+        string? displayedTailKey,
+        int itemCount,
+        out TailNavigationRequest request)
+    {
+        if (tailIndex < 0 || tailIndex >= itemCount || string.IsNullOrEmpty(displayedTailKey))
+        {
+            request = default;
+            return false;
+        }
+
+        request = new TailNavigationRequest(tailIndex, displayedTailKey);
+        return true;
+    }
+
+    public static bool CanExecute(
+        TailNavigationRequest request,
+        int currentTailIndex,
+        string? currentDisplayedTailKey,
+        int itemCount) =>
+        request.Index >= 0
+        && request.Index < itemCount
+        && request.Index == currentTailIndex
+        && string.Equals(
+            request.DisplayedTailKey,
+            currentDisplayedTailKey,
+            StringComparison.Ordinal);
+}
+
+internal sealed class TailNavigationQueue
+{
+    private (int Version, TailNavigationRequest Request)? _pending;
+
+    public bool Enqueue(int version, TailNavigationRequest request)
+    {
+        _pending = (version, request);
+        if (IsScheduled)
+            return false;
+
+        IsScheduled = true;
+        return true;
+    }
+
+    public bool TryDequeue(int currentVersion, out TailNavigationRequest request)
+    {
+        IsScheduled = false;
+        var pending = _pending;
+        _pending = null;
+        if (pending is not { } value || value.Version != currentVersion)
+        {
+            request = default;
+            return false;
+        }
+
+        request = value.Request;
+        return true;
+    }
+
+    public void Clear() => _pending = null;
+
+    public void SchedulingFailed()
+    {
+        IsScheduled = false;
+        _pending = null;
+    }
+
+    public bool IsScheduled { get; private set; }
+}