fix(threads): avoid nested workspace bleed on reload

Author: Dimillian

src/features/threads/hooks/useThreadActions.test.tsx

@@ -1182,6 +1182,53 @@ describe("useThreadActions", () => {
     });
   });
 
+  it("does not absorb nested child workspace threads when reloading one workspace", async () => {
+    const parentWorkspace: WorkspaceInfo = {
+      ...workspace,
+      id: "ws-parent",
+      path: "/tmp/codex",
+    };
+    const childWorkspace: WorkspaceInfo = {
+      ...workspaceTwo,
+      id: "ws-child",
+      path: "/tmp/codex/subdir",
+    };
+    vi.mocked(listWorkspaces).mockResolvedValue([parentWorkspace, childWorkspace]);
+    vi.mocked(listThreads).mockResolvedValue({
+      result: {
+        data: [
+          {
+            id: "thread-child-only",
+            cwd: "/tmp/codex/subdir/project",
+            preview: "Child workspace thread",
+            updated_at: 5000,
+          },
+        ],
+        nextCursor: null,
+      },
+    });
+    vi.mocked(getThreadTimestamp).mockReturnValue(5000);
+
+    const { result, dispatch } = renderActions();
+
+    await act(async () => {
+      await result.current.listThreadsForWorkspace(parentWorkspace);
+    });
+
+    expect(listWorkspaces).toHaveBeenCalled();
+    const parentSetThreadsAction = dispatch.mock.calls
+      .map(([action]) => action)
+      .find(
+        (action) =>
+          action?.type === "setThreads" &&
+          action?.workspaceId === "ws-parent",
+      ) as
+      | { type: "setThreads"; threads: Array<{ id: string }>; workspaceId: string }
+      | undefined;
+
+    expect(parentSetThreadsAction?.threads.map((thread) => thread.id) ?? []).toEqual([]);
+  });
+
   it("preserves list state when requested", async () => {
     vi.mocked(listThreads).mockResolvedValue({
       result: {

src/features/threads/hooks/useThreadActions.ts

@@ -569,7 +569,18 @@ export function useThreadActions({
       try {
         const requester = targets.find((workspace) => workspace.connected) ?? targets[0];
         const matchingThreadsByWorkspace: Record<string, Record<string, unknown>[]> = {};
-        const workspacePathLookup = buildWorkspacePathLookup(targets);
+        let workspacePathLookup = buildWorkspacePathLookup(targets);
+        try {
+          const knownWorkspaces = await listWorkspacesService();
+          if (knownWorkspaces.length > 0) {
+            workspacePathLookup = buildWorkspacePathLookup([
+              ...knownWorkspaces,
+              ...targets,
+            ]);
+          }
+        } catch {
+          workspacePathLookup = buildWorkspacePathLookup(targets);
+        }
         const uniqueThreadIdsByWorkspace: Record<string, Set<string>> = {};
         const resumeCursorByWorkspace: Record<string, string | null> = {};
         targets.forEach((workspace) => {