fix(threads): preserve existing order on timestamp ties

Author: jacobjmc

src/features/threads/hooks/threadReducer/threadItemsSlice.ts

@@ -11,7 +11,6 @@ import {
   looksAutoGeneratedThreadName,
   maybeRenameThreadFromAgent,
   mergeStreamingText,
-  prefersUpdatedSort,
 } from "./common";
 
 export function reduceThreadItems(state: ThreadState, action: ThreadAction): ThreadState {
@@ -105,7 +104,6 @@ export function reduceThreadItems(state: ThreadState, action: ThreadAction): Thr
     case "upsertItem": {
       let list = state.itemsByThread[action.threadId] ?? [];
       const item = normalizeItem(action.item);
-      const hasExistingItem = list.some((entry) => entry.id === item.id);
       const isUserMessage = item.kind === "message" && item.role === "user";
       const hadUserMessage = isUserMessage
         ? list.some((entry) => entry.kind === "message" && entry.role === "user")
@@ -152,19 +150,9 @@ export function reduceThreadItems(state: ThreadState, action: ThreadAction): Thr
                 : thread.name;
           return { ...thread, name: nextName };
         });
-        const bumpedThreads =
-          prefersUpdatedSort(state, action.workspaceId) &&
-          updatedThreads.length &&
-          !hasExistingItem &&
-          !action.isReplay
-            ? [
-                ...updatedThreads.filter((thread) => thread.id === action.threadId),
-                ...updatedThreads.filter((thread) => thread.id !== action.threadId),
-              ]
-            : updatedThreads;
         nextThreadsByWorkspace = {
           ...state.threadsByWorkspace,
-          [action.workspaceId]: bumpedThreads,
+          [action.workspaceId]: updatedThreads,
         };
       }
       return {

src/features/threads/hooks/threadReducer/threadLifecycleSlice.ts

@@ -4,8 +4,11 @@ import { prefersUpdatedSort } from "./common";
 
 type ThreadStatus = ThreadState["threadStatusById"][string];
 
-function sortThreadsByUpdatedAtDesc(threads: ThreadSummary[]): ThreadSummary[] {
-  const originalIndexById = new Map(
+function sortThreadsByUpdatedAtDesc(
+  threads: ThreadSummary[],
+  previousOrderIndex?: ReadonlyMap<string, number>,
+): ThreadSummary[] {
+  const inputIndexById = new Map(
     threads.map((thread, index) => [thread.id, index] as const),
   );
   return [...threads].sort((a, b) => {
@@ -14,10 +17,19 @@ function sortThreadsByUpdatedAtDesc(threads: ThreadSummary[]): ThreadSummary[] {
     if (bUpdated !== aUpdated) {
       return bUpdated - aUpdated;
     }
-    const aIndex = originalIndexById.get(a.id) ?? Number.MAX_SAFE_INTEGER;
-    const bIndex = originalIndexById.get(b.id) ?? Number.MAX_SAFE_INTEGER;
-    if (aIndex !== bIndex) {
-      return aIndex - bIndex;
+    const aPreviousIndex = previousOrderIndex?.get(a.id);
+    const bPreviousIndex = previousOrderIndex?.get(b.id);
+    if (
+      aPreviousIndex !== undefined &&
+      bPreviousIndex !== undefined &&
+      aPreviousIndex !== bPreviousIndex
+    ) {
+      return aPreviousIndex - bPreviousIndex;
+    }
+    const aInputIndex = inputIndexById.get(a.id) ?? Number.MAX_SAFE_INTEGER;
+    const bInputIndex = inputIndexById.get(b.id) ?? Number.MAX_SAFE_INTEGER;
+    if (aInputIndex !== bInputIndex) {
+      return aInputIndex - bInputIndex;
     }
     return a.id.localeCompare(b.id);
   });
@@ -314,8 +326,11 @@ export function reduceThreadLifecycle(
       if (!didChange) {
         return state;
       }
+      const previousOrderIndex = new Map(
+        list.map((thread, index) => [thread.id, index] as const),
+      );
       const sorted = prefersUpdatedSort(state, action.workspaceId)
-        ? sortThreadsByUpdatedAtDesc(next)
+        ? sortThreadsByUpdatedAtDesc(next, previousOrderIndex)
         : next;
       return {
         ...state,
@@ -330,6 +345,9 @@ export function reduceThreadLifecycle(
       const visibleThreads = action.threads.filter((thread) => !hidden[thread.id]);
       const incomingIds = new Set(visibleThreads.map((thread) => thread.id));
       const existingList = state.threadsByWorkspace[action.workspaceId] ?? [];
+      const previousOrderIndex = new Map(
+        existingList.map((thread, index) => [thread.id, index] as const),
+      );
       const existingById = new Map(existingList.map((thread) => [thread.id, thread]));
 
       const activeThreadId =
@@ -396,7 +414,7 @@ export function reduceThreadLifecycle(
 
       const merged = [...freshenedThreads, ...preservedThreads];
       const sorted = prefersUpdatedSort(state, action.workspaceId)
-        ? sortThreadsByUpdatedAtDesc(merged)
+        ? sortThreadsByUpdatedAtDesc(merged, previousOrderIndex)
         : merged;
 
       return {

src/features/threads/hooks/useThreadsReducer.test.ts

@@ -133,6 +133,41 @@ describe("threadReducer", () => {
     ]);
   });
 
+  it("does not reorder threads on non-replay user upsert without timestamp update", () => {
+    const next = threadReducer(
+      {
+        ...initialState,
+        threadsByWorkspace: {
+          "ws-1": [
+            { id: "thread-1", name: "Agent 1", updatedAt: 2000 },
+            { id: "thread-2", name: "Agent 2", updatedAt: 1000 },
+          ],
+        },
+        threadSortKeyByWorkspace: { "ws-1": "updated_at" },
+        itemsByThread: {
+          "thread-2": [],
+        },
+      },
+      {
+        type: "upsertItem",
+        workspaceId: "ws-1",
+        threadId: "thread-2",
+        item: {
+          id: "user-2",
+          kind: "message",
+          role: "user",
+          text: "New message",
+        },
+        hasCustomName: true,
+      },
+    );
+
+    expect(next.threadsByWorkspace["ws-1"]?.map((thread) => thread.id)).toEqual([
+      "thread-1",
+      "thread-2",
+    ]);
+  });
+
   it("renames auto-generated thread from assistant output when no user message", () => {
     const threads: ThreadSummary[] = [
       { id: "thread-1", name: "New Agent", updatedAt: 1 },
@@ -224,6 +259,30 @@ describe("threadReducer", () => {
     ]);
   });
 
+  it("preserves existing order when a timestamp update creates an updated_at tie", () => {
+    const threads: ThreadSummary[] = [
+      { id: "thread-2", name: "Agent 2", updatedAt: 1000 },
+      { id: "thread-1", name: "Agent 1", updatedAt: 900 },
+    ];
+    const next = threadReducer(
+      {
+        ...initialState,
+        threadsByWorkspace: { "ws-1": threads },
+        threadSortKeyByWorkspace: { "ws-1": "updated_at" },
+      },
+      {
+        type: "setThreadTimestamp",
+        workspaceId: "ws-1",
+        threadId: "thread-1",
+        timestamp: 1000,
+      },
+    );
+    expect(next.threadsByWorkspace["ws-1"]?.map((thread) => thread.id)).toEqual([
+      "thread-2",
+      "thread-1",
+    ]);
+  });
+
   it("keeps ordering stable on timestamp updates when sorted by created_at", () => {
     const threads: ThreadSummary[] = [
       { id: "thread-1", name: "Agent 1", updatedAt: 1000 },
@@ -682,4 +741,35 @@ describe("threadReducer", () => {
     expect(ids).toContain("thread-visible");
     expect(ids).not.toContain("thread-bg");
   });
+
+  it("preserves existing equal-timestamp order across setThreads syncs", () => {
+    const base: ThreadState = {
+      ...initialState,
+      threadsByWorkspace: {
+        "ws-1": [
+          { id: "thread-a", name: "Agent A", updatedAt: 1000 },
+          { id: "thread-b", name: "Agent B", updatedAt: 1000 },
+          { id: "thread-c", name: "Agent C", updatedAt: 1000 },
+        ],
+      },
+      threadSortKeyByWorkspace: { "ws-1": "updated_at" },
+    };
+
+    const next = threadReducer(base, {
+      type: "setThreads",
+      workspaceId: "ws-1",
+      sortKey: "updated_at",
+      threads: [
+        { id: "thread-c", name: "Agent C", updatedAt: 1000 },
+        { id: "thread-a", name: "Agent A", updatedAt: 1000 },
+        { id: "thread-b", name: "Agent B", updatedAt: 1000 },
+      ],
+    });
+
+    expect(next.threadsByWorkspace["ws-1"]?.map((thread) => thread.id)).toEqual([
+      "thread-a",
+      "thread-b",
+      "thread-c",
+    ]);
+  });
 });