fix: preserve parent thread anchors on partial list refresh (#494)

amanthanvi · web-flow · commit c0f144bb066a · 2026-02-23T20:32:13.000+01:00
diff --git a/AGENTS.md b/AGENTS.md
@@ -76,6 +76,12 @@ Use project aliases for frontend imports:
 
 For broader path maps, use `docs/codebase-map.md`.
 
+## Thread Hierarchy Invariants
+
+- `setThreads` reconciliation must preserve incoming order while retaining required local anchors (active/processing/ancestor summaries) when payloads are partial.
+- Never resurrect hidden threads during reconciliation (`hiddenThreadIdsByWorkspace` still wins).
+- `useThreadRows` renders children under parents only when parent summaries are present in the visible list; missing parent summaries will promote children to roots.
+
 ## Follow-up Behavior Map
 
 For Queue vs Steer follow-up behavior, start here:
diff --git a/src/features/threads/hooks/threadReducer/threadLifecycleSlice.ts b/src/features/threads/hooks/threadReducer/threadLifecycleSlice.ts
@@ -312,11 +312,66 @@ export function reduceThreadLifecycle(
     case "setThreads": {
       const hidden = state.hiddenThreadIdsByWorkspace[action.workspaceId] ?? {};
       const visibleThreads = action.threads.filter((thread) => !hidden[thread.id]);
+      const existingThreads = state.threadsByWorkspace[action.workspaceId] ?? [];
+      const existingById = new Map(
+        existingThreads.map((thread) => [thread.id, thread] as const),
+      );
+      const reconciled = [...visibleThreads];
+      const includedIds = new Set(reconciled.map((thread) => thread.id));
+      const freshenAnchorSummary = (summary: ThreadSummary) => {
+        const lastMessageTimestamp =
+          state.lastAgentMessageByThread[summary.id]?.timestamp ?? 0;
+        const processingStartedAt =
+          state.threadStatusById[summary.id]?.processingStartedAt ?? 0;
+        const nextUpdatedAt = Math.max(
+          summary.updatedAt ?? 0,
+          lastMessageTimestamp,
+          processingStartedAt,
+        );
+        if (nextUpdatedAt <= (summary.updatedAt ?? 0)) {
+          return summary;
+        }
+        return {
+          ...summary,
+          updatedAt: nextUpdatedAt,
+        };
+      };
+      const appendExistingAnchor = (threadId: string | null | undefined) => {
+        if (!threadId || hidden[threadId] || includedIds.has(threadId)) {
+          return;
+        }
+        const summary = existingById.get(threadId);
+        if (!summary) {
+          return;
+        }
+        reconciled.push(freshenAnchorSummary(summary));
+        includedIds.add(threadId);
+      };
+
+      const activeThreadId = state.activeThreadIdByWorkspace[action.workspaceId];
+      appendExistingAnchor(activeThreadId);
+      existingThreads.forEach((thread) => {
+        if (state.threadStatusById[thread.id]?.isProcessing) {
+          appendExistingAnchor(thread.id);
+        }
+      });
+
+      const seedThreadIds = [...includedIds];
+      seedThreadIds.forEach((threadId) => {
+        const visited = new Set<string>([threadId]);
+        let parentId = state.threadParentById[threadId];
+        while (parentId && !visited.has(parentId)) {
+          visited.add(parentId);
+          appendExistingAnchor(parentId);
+          parentId = state.threadParentById[parentId];
+        }
+      });
+
       return {
         ...state,
         threadsByWorkspace: {
           ...state.threadsByWorkspace,
-          [action.workspaceId]: visibleThreads,
+          [action.workspaceId]: reconciled,
         },
         threadSortKeyByWorkspace: {
           ...state.threadSortKeyByWorkspace,
diff --git a/src/features/threads/hooks/useThreadActions.test.tsx b/src/features/threads/hooks/useThreadActions.test.tsx
@@ -81,6 +81,7 @@ describe("useThreadActions", () => {
       threadsByWorkspace: {},
       activeThreadIdByWorkspace: {},
       activeTurnIdByThread: {},
+      threadParentById: {},
       threadListCursorByWorkspace: {},
       threadStatusById: {},
       threadSortKey: "updated_at",
@@ -755,6 +756,50 @@ describe("useThreadActions", () => {
     });
   });
 
+  it("uses fresh fetched data for active anchors outside top thread target", async () => {
+    const data = Array.from({ length: 21 }, (_, index) => ({
+      id: `thread-${index + 1}`,
+      cwd: workspace.path,
+      preview: `Thread ${index + 1} fresh`,
+      updated_at: 5000 - index,
+    }));
+    vi.mocked(listThreads).mockResolvedValue({
+      result: {
+        data,
+        nextCursor: null,
+      },
+    });
+    vi.mocked(getThreadTimestamp).mockImplementation((thread) => {
+      const value = (thread as Record<string, unknown>).updated_at as number;
+      return value ?? 0;
+    });
+
+    const { result, dispatch } = renderActions({
+      threadsByWorkspace: {
+        "ws-1": [{ id: "thread-21", name: "Thread 21 stale", updatedAt: 10 }],
+      },
+      activeThreadIdByWorkspace: { "ws-1": "thread-21" },
+    });
+
+    await act(async () => {
+      await result.current.listThreadsForWorkspace(workspace);
+    });
+
+    const setThreadsAction = dispatch.mock.calls
+      .map(([action]) => action)
+      .find(
+        (action) => action.type === "setThreads" && action.workspaceId === "ws-1",
+      );
+    expect(setThreadsAction).toBeTruthy();
+    if (!setThreadsAction || setThreadsAction.type !== "setThreads") {
+      return;
+    }
+    expect(setThreadsAction.threads).toHaveLength(21);
+    expect(setThreadsAction.threads[20]?.id).toBe("thread-21");
+    expect(setThreadsAction.threads[20]?.name).toBe("Thread 21 fresh");
+    expect(setThreadsAction.threads[20]?.updatedAt).toBe(4980);
+  });
+
   it("lists threads once and distributes results across workspaces", async () => {
     vi.mocked(listThreads).mockResolvedValue({
       result: {
diff --git a/src/features/threads/hooks/useThreadActions.ts b/src/features/threads/hooks/useThreadActions.ts
@@ -56,6 +56,7 @@ type UseThreadActionsOptions = {
   threadsByWorkspace: ThreadState["threadsByWorkspace"];
   activeThreadIdByWorkspace: ThreadState["activeThreadIdByWorkspace"];
   activeTurnIdByThread: ThreadState["activeTurnIdByThread"];
+  threadParentById: ThreadState["threadParentById"];
   threadListCursorByWorkspace: ThreadState["threadListCursorByWorkspace"];
   threadStatusById: ThreadState["threadStatusById"];
   threadSortKey: ThreadListSortKey;
@@ -84,6 +85,7 @@ export function useThreadActions({
   threadsByWorkspace,
   activeThreadIdByWorkspace,
   activeTurnIdByThread,
+  threadParentById,
   threadListCursorByWorkspace,
   threadStatusById,
   threadSortKey,
@@ -644,10 +646,54 @@ export function useThreadActions({
               return aId.localeCompare(bId);
             });
           }
+          const summaryById = new Map<string, ThreadSummary>();
+          uniqueThreads.forEach((thread, index) => {
+            const summary = buildThreadSummary(workspace.id, thread, index);
+            if (!summary) {
+              return;
+            }
+            summaryById.set(summary.id, summary);
+          });
           const summaries = uniqueThreads
             .slice(0, THREAD_LIST_TARGET_COUNT)
-            .map((thread, index) => buildThreadSummary(workspace.id, thread, index))
+            .map((thread) => summaryById.get(String(thread?.id ?? "")) ?? null)
             .filter((entry): entry is ThreadSummary => Boolean(entry));
+          const includedIds = new Set(summaries.map((thread) => thread.id));
+          const appendFreshAnchor = (threadId: string | null | undefined) => {
+            if (!threadId || includedIds.has(threadId)) {
+              return;
+            }
+            const summary = summaryById.get(threadId);
+            if (!summary) {
+              return;
+            }
+            summaries.push(summary);
+            includedIds.add(threadId);
+          };
+          appendFreshAnchor(activeThreadIdByWorkspace[workspace.id]);
+          const workspaceThreadIds = new Set<string>([
+            ...Array.from(summaryById.keys()),
+            ...(threadsByWorkspace[workspace.id] ?? []).map((thread) => thread.id),
+          ]);
+          const activeThreadId = activeThreadIdByWorkspace[workspace.id];
+          if (activeThreadId) {
+            workspaceThreadIds.add(activeThreadId);
+          }
+          workspaceThreadIds.forEach((threadId) => {
+            if (threadStatusById[threadId]?.isProcessing) {
+              appendFreshAnchor(threadId);
+            }
+          });
+          const seedThreadIds = [...includedIds];
+          seedThreadIds.forEach((threadId) => {
+            const visited = new Set<string>([threadId]);
+            let parentId = threadParentById[threadId];
+            while (parentId && !visited.has(parentId)) {
+              visited.add(parentId);
+              appendFreshAnchor(parentId);
+              parentId = threadParentById[parentId];
+            }
+          });
           dispatch({
             type: "setThreads",
             workspaceId: workspace.id,
@@ -703,8 +749,12 @@ export function useThreadActions({
       onDebug,
       onSubagentThreadDetected,
       onThreadCodexMetadataDetected,
+      activeThreadIdByWorkspace,
+      threadParentById,
       threadActivityRef,
+      threadStatusById,
       threadSortKey,
+      threadsByWorkspace,
       updateThreadParent,
     ],
   );
diff --git a/src/features/threads/hooks/useThreads.integration.test.tsx b/src/features/threads/hooks/useThreads.integration.test.tsx
@@ -1683,4 +1683,96 @@ describe("useThreads UX integration", () => {
     ]);
     expect(unpinnedRows.map((row) => row.thread.id)).toEqual(["thread-b"]);
   });
+
+  it("keeps parent rows anchored when refresh only returns subagent children", async () => {
+    vi.mocked(listThreads)
+      .mockResolvedValueOnce({
+        result: {
+          data: [
+            {
+              id: "thread-parent-anchor",
+              preview: "Parent",
+              updated_at: 2000,
+              cwd: workspace.path,
+            },
+            {
+              id: "thread-child-anchor",
+              preview: "Child",
+              updated_at: 3000,
+              cwd: workspace.path,
+              source: {
+                subAgent: {
+                  thread_spawn: {
+                    parent_thread_id: "thread-parent-anchor",
+                    depth: 1,
+                  },
+                },
+              },
+            },
+          ],
+          nextCursor: null,
+        },
+      })
+      .mockResolvedValueOnce({
+        result: {
+          data: [
+            {
+              id: "thread-child-anchor",
+              preview: "Child",
+              updated_at: 3500,
+              cwd: workspace.path,
+              source: {
+                subAgent: {
+                  thread_spawn: {
+                    parent_thread_id: "thread-parent-anchor",
+                    depth: 1,
+                  },
+                },
+              },
+            },
+          ],
+          nextCursor: null,
+        },
+      });
+
+    const { result } = renderHook(() =>
+      useThreads({
+        activeWorkspace: workspace,
+        onWorkspaceConnected: vi.fn(),
+      }),
+    );
+
+    await act(async () => {
+      await result.current.listThreadsForWorkspace(workspace);
+    });
+
+    await waitFor(() => {
+      expect(result.current.threadParentById["thread-child-anchor"]).toBe(
+        "thread-parent-anchor",
+      );
+    });
+
+    await act(async () => {
+      await result.current.listThreadsForWorkspace(workspace);
+    });
+
+    expect(vi.mocked(listThreads)).toHaveBeenCalledTimes(2);
+    expect(result.current.threadsByWorkspace["ws-1"]?.map((thread) => thread.id)).toEqual(
+      ["thread-child-anchor", "thread-parent-anchor"],
+    );
+
+    const { result: threadRowsResult } = renderHook(() =>
+      useThreadRows(result.current.threadParentById),
+    );
+    const rows = threadRowsResult.current.getThreadRows(
+      result.current.threadsByWorkspace["ws-1"] ?? [],
+      true,
+      "ws-1",
+      () => null,
+    );
+    expect(rows.unpinnedRows.map((row) => [row.thread.id, row.depth])).toEqual([
+      ["thread-parent-anchor", 0],
+      ["thread-child-anchor", 1],
+    ]);
+  });
 });
diff --git a/src/features/threads/hooks/useThreads.ts b/src/features/threads/hooks/useThreads.ts
@@ -548,6 +548,7 @@ export function useThreads({
     threadsByWorkspace: state.threadsByWorkspace,
     activeThreadIdByWorkspace: state.activeThreadIdByWorkspace,
     activeTurnIdByThread: state.activeTurnIdByThread,
+    threadParentById: state.threadParentById,
     threadListCursorByWorkspace: state.threadListCursorByWorkspace,
     threadStatusById: state.threadStatusById,
     threadSortKey,
diff --git a/src/features/threads/hooks/useThreadsReducer.test.ts b/src/features/threads/hooks/useThreadsReducer.test.ts
