fix: ignore replayed items in thread activity and ordering

Author: jacobjmc

src-tauri/src/shared/codex_core.rs

@@ -418,8 +418,14 @@ pub(crate) async fn list_threads_core(
                 .unwrap_or_default();
             let updated_at = s
                 .get("updatedAt")
-                .and_then(|v| v.as_str())
-                .unwrap_or_default();
+                .or_else(|| s.get("updated_at"))
+                .cloned()
+                .unwrap_or(Value::Null);
+            let created_at = s
+                .get("createdAt")
+                .or_else(|| s.get("created_at"))
+                .cloned()
+                .unwrap_or_else(|| updated_at.clone());
             let directory = s
                 .get("directory")
                 .and_then(|v| v.as_str())
@@ -436,7 +442,7 @@ pub(crate) async fn list_threads_core(
                 "name": title,
                 "preview": title,
                 "updatedAt": updated_at,
-                "createdAt": updated_at
+                "createdAt": created_at
             });
             if let Some(pid) = parent_id {
                 entry["parentId"] = json!(pid);

src/features/app/hooks/useAppServerEvents.test.tsx

@@ -245,6 +245,27 @@ describe("useAppServerEvents", () => {
       threadId: "thread-1",
       itemId: "item-2",
       text: "Done",
+      isReplay: false,
+    });
+
+    act(() => {
+      listener?.({
+        workspace_id: "ws-1",
+        message: {
+          method: "item/completed",
+          params: {
+            threadId: "thread-1",
+            item: { type: "agentMessage", id: "replay_item_1", text: "Old" },
+          },
+        },
+      });
+    });
+    expect(handlers.onAgentMessageCompleted).toHaveBeenCalledWith({
+      workspaceId: "ws-1",
+      threadId: "thread-1",
+      itemId: "replay_item_1",
+      text: "Old",
+      isReplay: true,
     });
 
     act(() => {

src/features/app/hooks/useAppServerEvents.ts

@@ -26,6 +26,7 @@ type AgentCompleted = {
   threadId: string;
   itemId: string;
   text: string;
+  isReplay: boolean;
 };
 
 type AppServerEventHandlers = {
@@ -388,12 +389,17 @@ export function useAppServerEvents(handlers: AppServerEventHandlers) {
         if (threadId && item?.type === "agentMessage") {
           const itemId = String(item.id ?? "");
           const text = String(item.text ?? "");
+          const isReplay =
+            item.replay === true ||
+            item.replayed === true ||
+            itemId.startsWith("replay_item_");
           if (itemId) {
             currentHandlers.onAgentMessageCompleted?.({
               workspaceId: workspace_id,
               threadId,
               itemId,
               text,
+              isReplay,
             });
           }
         }

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

@@ -105,6 +105,7 @@ 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")
@@ -141,7 +142,8 @@ export function reduceThreadItems(state: ThreadState, action: ThreadAction): Thr
             !hadUserMessage &&
             textValue.length > 0 &&
             looksAutoGenerated &&
-            !action.hasCustomName;
+            !action.hasCustomName &&
+            !action.isReplay;
           const nextName =
             shouldRename && textValue.length > 38
               ? `${textValue.slice(0, 38)}…`
@@ -151,7 +153,10 @@ export function reduceThreadItems(state: ThreadState, action: ThreadAction): Thr
           return { ...thread, name: nextName };
         });
         const bumpedThreads =
-          prefersUpdatedSort(state, action.workspaceId) && updatedThreads.length
+          prefersUpdatedSort(state, action.workspaceId) &&
+          updatedThreads.length &&
+          !hasExistingItem &&
+          !action.isReplay
             ? [
                 ...updatedThreads.filter((thread) => thread.id === action.threadId),
                 ...updatedThreads.filter((thread) => thread.id !== action.threadId),

src/features/threads/hooks/useThreadActions.ts

@@ -495,15 +495,15 @@ export function useThreadActions({
           threadActivityRef.current = next;
           saveThreadActivity(next);
         }
+        const getEffectiveTimestamp = (thread: Record<string, unknown>) => {
+          const threadId = String(thread?.id ?? "");
+          const baseTimestamp = getThreadTimestamp(thread);
+          const activityTimestamp = nextActivityByThread[threadId] ?? 0;
+          return Math.max(baseTimestamp, activityTimestamp);
+        };
         if (requestedSortKey === "updated_at") {
           uniqueThreads.sort((a, b) => {
-            const aId = String(a?.id ?? "");
-            const bId = String(b?.id ?? "");
-            const aCreated = getThreadTimestamp(a);
-            const bCreated = getThreadTimestamp(b);
-            const aActivity = Math.max(nextActivityByThread[aId] ?? 0, aCreated);
-            const bActivity = Math.max(nextActivityByThread[bId] ?? 0, bCreated);
-            return bActivity - aActivity;
+            return getEffectiveTimestamp(b) - getEffectiveTimestamp(a);
           });
         } else {
           uniqueThreads.sort((a, b) => {
@@ -535,7 +535,7 @@ export function useThreadActions({
             return {
               id,
               name,
-              updatedAt: getThreadTimestamp(thread),
+              updatedAt: getEffectiveTimestamp(thread),
             };
           })
           .filter((entry) => entry.id);
@@ -558,11 +558,12 @@ export function useThreadActions({
           if (!threadId || !message) {
             return;
           }
+          const timestamp = getEffectiveTimestamp(thread);
           dispatch({
             type: "setLastAgentMessage",
             threadId,
             text: message,
-            timestamp: getThreadTimestamp(thread),
+            timestamp,
           });
         });
       } catch (error) {
@@ -615,6 +616,9 @@ export function useThreadActions({
         payload: { workspaceId: workspace.id, cursor: nextCursor },
       });
       try {
+        const activityByThread = threadActivityRef.current[workspace.id] ?? {};
+        const nextActivityByThread = { ...activityByThread };
+        let didChangeActivity = false;
         const matchingThreads: Record<string, unknown>[] = [];
         const maxPagesWithoutMatch = THREAD_LIST_MAX_PAGES_OLDER;
         let pagesFetched = 0;
@@ -663,6 +667,11 @@ export function useThreadActions({
           if (!id || existingIds.has(id)) {
             return;
           }
+          const timestamp = getThreadTimestamp(thread);
+          if (timestamp > (nextActivityByThread[id] ?? 0)) {
+            nextActivityByThread[id] = timestamp;
+            didChangeActivity = true;
+          }
           const sourceParentId = getParentThreadIdFromSource(thread.source);
           const directParentId = asString(thread.parentId ?? thread.parent_id ?? "").trim() || null;
           const resolvedParentId = sourceParentId ?? directParentId;
@@ -681,10 +690,23 @@ export function useThreadActions({
                 ? `${nameSeed.slice(0, 38)}…`
                 : nameSeed
               : fallbackName;
-          additions.push({ id, name, updatedAt: getThreadTimestamp(thread) });
+          additions.push({
+            id,
+            name,
+            updatedAt: Math.max(timestamp, nextActivityByThread[id] ?? 0),
+          });
           existingIds.add(id);
         });
 
+        if (didChangeActivity) {
+          const next = {
+            ...threadActivityRef.current,
+            [workspace.id]: nextActivityByThread,
+          };
+          threadActivityRef.current = next;
+          saveThreadActivity(next);
+        }
+
         if (additions.length > 0) {
           dispatch({
             type: "setThreads",
@@ -706,11 +728,15 @@ export function useThreadActions({
           if (!threadId || !message) {
             return;
           }
+          const timestamp = Math.max(
+            getThreadTimestamp(thread),
+            nextActivityByThread[threadId] ?? 0,
+          );
           dispatch({
             type: "setLastAgentMessage",
             threadId,
             text: message,
-            timestamp: getThreadTimestamp(thread),
+            timestamp,
           });
         });
       } catch (error) {

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

@@ -192,6 +192,39 @@ describe("useThreadItemEvents", () => {
     );
   });
 
+  it("does not treat replayed user messages as new activity", () => {
+    const onUserMessageCreated = vi.fn();
+    vi.mocked(buildConversationItem).mockReturnValue({
+      id: "item-2",
+      kind: "message",
+      role: "user",
+      text: "Hello from history",
+    });
+    const { result, dispatch } = makeOptions({ onUserMessageCreated });
+
+    act(() => {
+      result.current.onItemCompleted("ws-1", "thread-1", {
+        type: "userMessage",
+        id: "replay_item_2",
+      });
+    });
+
+    expect(dispatch).toHaveBeenCalledWith({
+      type: "upsertItem",
+      workspaceId: "ws-1",
+      threadId: "thread-1",
+      item: {
+        id: "item-2",
+        kind: "message",
+        role: "user",
+        text: "Hello from history",
+      },
+      hasCustomName: false,
+      isReplay: true,
+    });
+    expect(onUserMessageCreated).not.toHaveBeenCalled();
+  });
+
   it("marks processing and appends agent deltas", () => {
     const { result, dispatch, markProcessing } = makeOptions();
 
@@ -232,6 +265,7 @@ describe("useThreadItemEvents", () => {
         threadId: "thread-1",
         itemId: "assistant-1",
         text: "Done",
+        isReplay: false,
       });
     });
 
@@ -271,6 +305,41 @@ describe("useThreadItemEvents", () => {
     nowSpy.mockRestore();
   });
 
+  it("does not update thread timestamp for non-active empty completions", () => {
+    const nowSpy = vi.spyOn(Date, "now").mockReturnValue(9999);
+    const { result, dispatch, recordThreadActivity } = makeOptions({
+      hasActiveTurn: () => false,
+    });
+
+    act(() => {
+      result.current.onAgentMessageCompleted({
+        workspaceId: "ws-1",
+        threadId: "thread-1",
+        itemId: "assistant-1",
+        text: "",
+        isReplay: true,
+      });
+    });
+
+    expect(dispatch).toHaveBeenCalledWith({
+      type: "completeAgentMessage",
+      workspaceId: "ws-1",
+      threadId: "thread-1",
+      itemId: "assistant-1",
+      text: "",
+      hasCustomName: false,
+    });
+    expect(dispatch).not.toHaveBeenCalledWith(
+      expect.objectContaining({ type: "setThreadTimestamp" }),
+    );
+    expect(dispatch).not.toHaveBeenCalledWith(
+      expect.objectContaining({ type: "setLastAgentMessage" }),
+    );
+    expect(recordThreadActivity).not.toHaveBeenCalled();
+
+    nowSpy.mockRestore();
+  });
+
   it("dispatches reasoning summary boundaries", () => {
     const { result, dispatch } = makeOptions();