diff --git a/apps/desktop/src/App.vue b/apps/desktop/src/App.vue
index 36c0c086a4..7589553ca9 100644
--- a/apps/desktop/src/App.vue
+++ b/apps/desktop/src/App.vue
@@ -218,7 +218,19 @@ const connectionStats = computed(() => ({
 }));
 const recentConnections = computed(() => connectionStore.connections.slice(0, 5));
 const savedSqlHistoryItems = computed(() => {
-  const folderById = new Map(savedSqlStore.allFolders.map((folder) => [folder.id, folder.name]));
+  const folderById = new Map(savedSqlStore.allFolders.map((folder) => [folder.id, folder]));
+  const folderPath = (folderId?: string): string | undefined => {
+    if (!folderId) return undefined;
+    const parts: string[] = [];
+    const seen = new Set<string>();
+    let folder = folderById.get(folderId);
+    while (folder && !seen.has(folder.id)) {
+      seen.add(folder.id);
+      parts.unshift(folder.name);
+      folder = folder.parentFolderId ? folderById.get(folder.parentFolderId) : undefined;
+    }
+    return parts.join("/");
+  };
   return rankSavedSqlHistory(savedSqlStore.allFiles, { limit: 6 }).map((file) => {
     const connection = connectionStore.getConfig(file.connectionId);
     return {
@@ -226,13 +238,25 @@ const savedSqlHistoryItems = computed(() => {
       name: file.name,
       connectionName: connection ? connectionRedactedNameLabel(connection) : t("welcome.unknownConnection"),
       database: file.database,
-      folderName: file.folderId ? folderById.get(file.folderId) : undefined,
+      folderName: folderPath(file.folderId),
       openCount: file.openCount ?? 0,
     };
   });
 });
 const saveSqlFolders = computed(() => {
-  return savedSqlStore.allFolders;
+  const folderById = new Map(savedSqlStore.allFolders.map((folder) => [folder.id, folder]));
+  const pathForFolder = (folderId: string) => {
+    const parts: string[] = [];
+    const seen = new Set<string>();
+    let folder = folderById.get(folderId);
+    while (folder && !seen.has(folder.id)) {
+      seen.add(folder.id);
+      parts.unshift(folder.name);
+      folder = folder.parentFolderId ? folderById.get(folder.parentFolderId) : undefined;
+    }
+    return parts.join(" / ");
+  };
+  return savedSqlStore.allFoldersTreeOrder.map((folder) => ({ ...folder, displayName: pathForFolder(folder.id) || folder.name }));
 });
 
 async function applyUiScale(scale: number) {
@@ -1209,7 +1233,7 @@ onUnmounted(() => {
                 <SelectContent position="popper">
                   <SelectItem :value="ROOT_SAVED_SQL_FOLDER">{{ t("savedSql.rootFolder") }}</SelectItem>
                   <SelectItem v-for="folder in saveSqlFolders" :key="folder.id" :value="folder.id">
-                    {{ folder.name }}
+                    {{ folder.displayName }}
                   </SelectItem>
                 </SelectContent>
               </Select>
diff --git a/apps/desktop/src/components/layout/SqlLibraryPanel.vue b/apps/desktop/src/components/layout/SqlLibraryPanel.vue
index 8392ef5599..3055dd35b3 100644
--- a/apps/desktop/src/components/layout/SqlLibraryPanel.vue
+++ b/apps/desktop/src/components/layout/SqlLibraryPanel.vue
@@ -147,19 +147,25 @@ async function exportFolderContents(folder?: SavedSqlFolder) {
     const rootDir = await join(targetDir, rootDirName);
     await mkdir(rootDir, { recursive: true });
 
-    if (folder) {
-      for (const file of savedSqlStore.filesInFolder(folder.id)) {
-        const filePath = await join(rootDir, sanitizeFileSystemSegment(ensureSqlExtension(file.name)));
+    const writeFolder = async (libraryFolder: SavedSqlFolder, dir: string): Promise<void> => {
+      for (const child of savedSqlStore.allFolders.filter((item) => item.parentFolderId === libraryFolder.id)) {
+        const childDir = await join(dir, sanitizeFileSystemSegment(child.name));
+        await mkdir(childDir, { recursive: true });
+        await writeFolder(child, childDir);
+      }
+      for (const file of savedSqlStore.filesInFolder(libraryFolder.id)) {
+        const filePath = await join(dir, sanitizeFileSystemSegment(ensureSqlExtension(file.name)));
         await writeTextFile(filePath, file.sql);
       }
+    };
+
+    if (folder) {
+      await writeFolder(folder, rootDir);
     } else {
-      for (const libraryFolder of savedSqlStore.allFolders.filter((item) => isConnectionVisible(item.connectionId))) {
+      for (const libraryFolder of savedSqlStore.allFolders.filter((item) => isConnectionVisible(item.connectionId) && !item.parentFolderId)) {
         const folderDir = await join(rootDir, sanitizeFileSystemSegment(libraryFolder.name));
         await mkdir(folderDir, { recursive: true });
-        for (const file of savedSqlStore.filesInFolder(libraryFolder.id)) {
-          const filePath = await join(folderDir, sanitizeFileSystemSegment(ensureSqlExtension(file.name)));
-          await writeTextFile(filePath, file.sql);
-        }
+        await writeFolder(libraryFolder, folderDir);
       }
 
       const unfiled = savedSqlStore.filesWithoutFolder().filter((file) => !orphanedIds.value.has(file.id));
@@ -310,6 +316,20 @@ function folderMatchesQuery(folder: SavedSqlFolder) {
   return savedSqlStore.filesInFolder(folder.id).some((file) => !orphanedIds.value.has(file.id) && fileMatchesQuery(file));
 }
 
+function childFolders(parentFolderId?: string) {
+  return savedSqlStore.allFolders.filter((folder) => isConnectionVisible(folder.connectionId) && (folder.parentFolderId || "") === (parentFolderId || ""));
+}
+
+function descendantFolders(parentFolderId: string): SavedSqlFolder[] {
+  const direct = childFolders(parentFolderId);
+  return direct.flatMap((folder) => [folder, ...descendantFolders(folder.id)]);
+}
+
+function folderBranchMatchesQuery(folder: SavedSqlFolder) {
+  if (folderMatchesQuery(folder)) return true;
+  return descendantFolders(folder.id).some((child) => folderMatchesQuery(child));
+}
+
 function filesInFolder(folderId: string) {
   const folder = savedSqlStore.allFolders.find((item) => item.id === folderId);
   const includeAllFilesForMatchedFolder = !!folder && !!searchQuery.value && folder.name.toLowerCase().includes(searchQuery.value);
@@ -319,7 +339,26 @@ function filesInFolder(folderId: string) {
     .filter((file) => includeAllFilesForMatchedFolder || fileMatchesQuery(file));
 }
 
-const visibleFolders = computed(() => savedSqlStore.allFolders.filter((folder) => isConnectionVisible(folder.connectionId) && folderMatchesQuery(folder)));
+type SqlLibraryRow = { type: "folder"; folder: SavedSqlFolder; depth: number } | { type: "file"; file: SavedSqlFile; depth: number };
+
+const visibleFolderRows = computed<SqlLibraryRow[]>(() => {
+  const rows: SqlLibraryRow[] = [];
+  const appendFolder = (folder: SavedSqlFolder, depth: number) => {
+    if (!folderBranchMatchesQuery(folder)) return;
+    rows.push({ type: "folder", folder, depth });
+    if (!isFolderExpanded(folder.id)) return;
+    for (const child of childFolders(folder.id)) {
+      appendFolder(child, depth + 1);
+    }
+    for (const file of filesInFolder(folder.id)) {
+      rows.push({ type: "file", file, depth: depth + 1 });
+    }
+  };
+  for (const folder of childFolders()) {
+    appendFolder(folder, 0);
+  }
+  return rows;
+});
 
 const visibleFiles = computed(() =>
   savedSqlStore
@@ -328,7 +367,7 @@ const visibleFiles = computed(() =>
     .filter((file) => fileMatchesQuery(file)),
 );
 
-const hasAnyVisibleItem = computed(() => visibleFolders.value.length > 0 || visibleFiles.value.length > 0);
+const hasAnyVisibleItem = computed(() => visibleFolderRows.value.length > 0 || visibleFiles.value.length > 0);
 
 const collapsedFolders = ref<Set<string>>(new Set());
 
@@ -344,31 +383,15 @@ function isFolderExpanded(folderId: string) {
   return !collapsedFolders.value.has(folderId);
 }
 
-const showNewFolderInput = ref(false);
-const newFolderName = ref("");
-const newFolderInputRef = ref<HTMLInputElement | null>(null);
-
-function openNewFolderInput() {
-  newFolderName.value = "";
-  showNewFolderInput.value = true;
-  nextTick(() => newFolderInputRef.value?.focus());
-}
-
-async function confirmNewFolder() {
-  const name = newFolderName.value.trim();
-  if (!name) {
-    cancelNewFolder();
-    return;
-  }
-  showNewFolderInput.value = false;
-  const connectionId = connectionStore.connections[0]?.id;
+async function openNewFolderInput(parentFolderId?: string) {
+  const parent = parentFolderId ? savedSqlStore.allFolders.find((folder) => folder.id === parentFolderId) : undefined;
+  const connectionId = parent?.connectionId || connectionStore.connections[0]?.id;
   if (!connectionId) return;
-  await savedSqlStore.createFolder(connectionId, name);
-}
-
-function cancelNewFolder() {
-  showNewFolderInput.value = false;
-  newFolderName.value = "";
+  if (parent?.id) {
+    collapsedFolders.value = new Set([...collapsedFolders.value].filter((id) => id !== parent.id));
+  }
+  const folder = await savedSqlStore.createFolder(connectionId, t("savedSql.newFolderDefault"), parent?.id);
+  startRenameFolder(folder);
 }
 
 const renamingTarget = ref<{ type: "folder" | "file"; id: string } | null>(null);
@@ -479,6 +502,7 @@ const contextMenuItems = computed<CtxMenuItem[]>(() => {
     ];
   }
   return [
+    { label: t("savedSql.newFolder"), action: () => openNewFolderInput(target.id), icon: FolderPlus },
     { label: t("sqlLibrary.importIntoFolder"), action: () => importDirectoryIntoLibrary(target), icon: Upload },
     { label: t("sqlLibrary.exportFolder"), action: () => exportFolderContents(target), icon: Download },
     { label: "", separator: true },
@@ -619,6 +643,11 @@ async function performDrop() {
     return;
   }
 
+  if (draggedType === "folder" && targetType === "folder" && dropPosition === "inside") {
+    await savedSqlStore.moveFolderToFolder(draggedId, targetId);
+    return;
+  }
+
   if (draggedType !== "file") return;
 
   if (targetType === "folder") {
@@ -677,7 +706,9 @@ function updateDropTarget(event: MouseEvent, targetId: string, targetType: DragI
   let nextPosition: DropPosition | null = null;
   if (dragState.draggedType === "folder" && targetType === "folder") {
     const rect = (event.currentTarget as HTMLElement).getBoundingClientRect();
-    nextPosition = event.clientY - rect.top < rect.height / 2 ? "before" : "after";
+    const y = event.clientY - rect.top;
+    const third = rect.height / 3;
+    nextPosition = y > third && y < rect.height - third ? "inside" : y < rect.height / 2 ? "before" : "after";
   } else if (dragState.draggedType === "file" && targetType === "file") {
     const rect = (event.currentTarget as HTMLElement).getBoundingClientRect();
     nextPosition = event.clientY - rect.top < rect.height / 2 ? "before" : "after";
@@ -744,19 +775,6 @@ function showDropInside(targetId: string) {
     </div>
 
     <div class="min-h-0 flex-1 overflow-y-auto p-1">
-      <div v-if="showNewFolderInput" class="flex items-center gap-1 px-2 py-1.5">
-        <FolderOpen class="h-4 w-4 text-amber-500 shrink-0" />
-        <input
-          ref="newFolderInputRef"
-          v-model="newFolderName"
-          class="h-6 min-w-0 flex-1 rounded border border-border bg-background px-2 text-xs outline-none focus:ring-1 focus:ring-ring"
-          :placeholder="t('savedSql.newFolderDefault')"
-          @keydown.enter.prevent="confirmNewFolder"
-          @keydown.escape.prevent="cancelNewFolder"
-          @blur="confirmNewFolder"
-        />
-      </div>
-
       <CustomContextMenu :items="contextMenuItems" @close="clearContextTarget">
         <template #default="{ onContextMenu }">
           <div
@@ -766,23 +784,25 @@ function showDropInside(targetId: string) {
               onContextMenu($event);
             "
           >
-            <div v-for="folder in visibleFolders" :key="folder.id" class="mb-0.5">
+            <div v-for="row in visibleFolderRows" :key="row.type === 'folder' ? row.folder.id : row.file.id" class="mb-0.5">
               <div
-                class="relative flex items-center gap-1 rounded px-2 py-1.5 text-xs cursor-pointer transition-colors group"
-                :class="[showDropInside(folder.id) ? 'ring-1 ring-primary/50 bg-primary/5' : 'hover:bg-accent', isDraggingItem(folder.id) ? 'opacity-50' : '']"
-                @mousedown="handleDragMouseDown($event, folder.id, 'folder')"
-                @mousemove="updateDropTarget($event, folder.id, 'folder')"
-                @mouseleave="clearDropTarget(folder.id)"
-                @click="toggleFolder(folder.id)"
+                v-if="row.type === 'folder'"
+                class="relative flex items-center gap-1 rounded py-1.5 pr-2 text-xs cursor-pointer transition-colors group"
+                :style="{ paddingLeft: `${8 + row.depth * 16}px` }"
+                :class="[showDropInside(row.folder.id) ? 'ring-1 ring-primary/50 bg-primary/5' : 'hover:bg-accent', isDraggingItem(row.folder.id) ? 'opacity-50' : '']"
+                @mousedown="handleDragMouseDown($event, row.folder.id, 'folder')"
+                @mousemove="updateDropTarget($event, row.folder.id, 'folder')"
+                @mouseleave="clearDropTarget(row.folder.id)"
+                @click="toggleFolder(row.folder.id)"
                 @contextmenu.prevent="
-                  contextTarget = folder;
+                  contextTarget = row.folder;
                   onContextMenu($event);
                 "
               >
-                <div v-if="showDropBefore(folder.id)" class="absolute left-2 right-2 top-0 border-t-2 border-primary" />
-                <div v-if="showDropAfter(folder.id)" class="absolute left-2 right-2 bottom-0 border-b-2 border-primary" />
-                <component :is="isFolderExpanded(folder.id) ? FolderOpen : FolderClosed" class="h-4 w-4 text-amber-500 shrink-0" />
-                <template v-if="renamingTarget?.type === 'folder' && renamingTarget.id === folder.id">
+                <div v-if="showDropBefore(row.folder.id)" class="absolute left-2 right-2 top-0 border-t-2 border-primary" />
+                <div v-if="showDropAfter(row.folder.id)" class="absolute left-2 right-2 bottom-0 border-b-2 border-primary" />
+                <component :is="isFolderExpanded(row.folder.id) ? FolderOpen : FolderClosed" class="h-4 w-4 text-amber-500 shrink-0" />
+                <template v-if="renamingTarget?.type === 'folder' && renamingTarget.id === row.folder.id">
                   <input
                     :ref="setRenameInputRef"
                     v-model="renameValue"
@@ -795,48 +815,42 @@ function showDropInside(targetId: string) {
                   />
                 </template>
                 <span v-else class="dbx-sql-library-drag-label min-w-0 flex-1 truncate">
-                  {{ folder.name }}
-                  <span class="ml-1 text-muted-foreground">({{ filesInFolder(folder.id).length }})</span>
+                  {{ row.folder.name }}
+                  <span class="ml-1 text-muted-foreground">({{ filesInFolder(row.folder.id).length }})</span>
                 </span>
               </div>
 
-              <div v-if="isFolderExpanded(folder.id)" class="ml-4">
-                <div
-                  v-for="file in filesInFolder(folder.id)"
-                  :key="file.id"
-                  class="relative flex items-center gap-1 rounded px-2 py-1.5 text-xs cursor-pointer transition-colors group"
-                  :class="[isDraggingItem(file.id) ? 'opacity-50' : 'hover:bg-accent']"
-                  @mousedown="handleDragMouseDown($event, file.id, 'file')"
-                  @mousemove="updateDropTarget($event, file.id, 'file')"
-                  @mouseleave="clearDropTarget(file.id)"
-                  @click="openFile(file)"
-                  @contextmenu.prevent="
-                    contextTarget = file;
-                    onContextMenu($event);
-                  "
-                >
-                  <div v-if="showDropBefore(file.id)" class="absolute left-2 right-2 top-0 border-t-2 border-primary" />
-                  <div v-if="showDropAfter(file.id)" class="absolute left-2 right-2 bottom-0 border-b-2 border-primary" />
-                  <FileText class="h-3.5 w-3.5 text-blue-400 shrink-0" />
-                  <template v-if="renamingTarget?.type === 'file' && renamingTarget.id === file.id">
-                    <input
-                      :ref="setRenameInputRef"
-                      v-model="renameValue"
-                      data-no-drag="true"
-                      class="min-w-0 flex-1 rounded border border-primary/50 bg-transparent px-1 text-xs outline-none"
-                      @keydown.enter.prevent="confirmRename"
-                      @keydown.escape.prevent="cancelRename"
-                      @blur="confirmRename"
-                      @click.stop
-                    />
-                  </template>
-                  <span v-else class="dbx-sql-library-drag-label min-w-0 flex-1 truncate">{{ file.name }}</span>
-                  <span class="shrink-0 text-xs text-muted-foreground"> [{{ getConnectionLabel(file.connectionId) }}] </span>
-                </div>
-
-                <div v-if="filesInFolder(folder.id).length === 0" class="px-2 py-1 text-xs text-muted-foreground">
-                  {{ t("sqlLibrary.emptyFolder") }}
-                </div>
+              <div
+                v-else
+                class="relative flex items-center gap-1 rounded py-1.5 pr-2 text-xs cursor-pointer transition-colors group"
+                :style="{ paddingLeft: `${8 + row.depth * 16}px` }"
+                :class="[isDraggingItem(row.file.id) ? 'opacity-50' : 'hover:bg-accent']"
+                @mousedown="handleDragMouseDown($event, row.file.id, 'file')"
+                @mousemove="updateDropTarget($event, row.file.id, 'file')"
+                @mouseleave="clearDropTarget(row.file.id)"
+                @click="openFile(row.file)"
+                @contextmenu.prevent="
+                  contextTarget = row.file;
+                  onContextMenu($event);
+                "
+              >
+                <div v-if="showDropBefore(row.file.id)" class="absolute left-2 right-2 top-0 border-t-2 border-primary" />
+                <div v-if="showDropAfter(row.file.id)" class="absolute left-2 right-2 bottom-0 border-b-2 border-primary" />
+                <FileText class="h-3.5 w-3.5 text-blue-400 shrink-0" />
+                <template v-if="renamingTarget?.type === 'file' && renamingTarget.id === row.file.id">
+                  <input
+                    :ref="setRenameInputRef"
+                    v-model="renameValue"
+                    data-no-drag="true"
+                    class="min-w-0 flex-1 rounded border border-primary/50 bg-transparent px-1 text-xs outline-none"
+                    @keydown.enter.prevent="confirmRename"
+                    @keydown.escape.prevent="cancelRename"
+                    @blur="confirmRename"
+                    @click.stop
+                  />
+                </template>
+                <span v-else class="dbx-sql-library-drag-label min-w-0 flex-1 truncate">{{ row.file.name }}</span>
+                <span class="shrink-0 text-xs text-muted-foreground"> [{{ getConnectionLabel(row.file.connectionId) }}] </span>
               </div>
             </div>
 
@@ -883,7 +897,7 @@ function showDropInside(targetId: string) {
               </div>
             </div>
 
-            <div v-if="!hasAnyVisibleItem && !showNewFolderInput" class="flex h-full flex-col items-center justify-center gap-2 text-muted-foreground">
+            <div v-if="!hasAnyVisibleItem" class="flex h-full flex-col items-center justify-center gap-2 text-muted-foreground">
               <Library class="h-8 w-8 opacity-30" />
               <p class="text-xs">{{ t("sqlLibrary.empty") }}</p>
             </div>
diff --git a/apps/desktop/src/components/sidebar/TreeItem.vue b/apps/desktop/src/components/sidebar/TreeItem.vue
index 7f5dd2156c..122a4bbefd 100644
--- a/apps/desktop/src/components/sidebar/TreeItem.vue
+++ b/apps/desktop/src/components/sidebar/TreeItem.vue
@@ -2358,6 +2358,11 @@ function newConnectionInGroup() {
   connectionStore.startCreatingConnectionInGroup(props.node.id);
 }
 
+function newSubgroup() {
+  const groupId = connectionStore.createConnectionGroup(t("connectionGroup.newGroupDefault"), props.node.id);
+  connectionStore.selectedTreeNodeId = groupId;
+}
+
 function confirmDeleteGroup() {
   connectionStore.deleteConnectionGroup(props.node.id);
   showDeleteGroupConfirm.value = false;
@@ -2393,12 +2398,18 @@ const availableGroups = computed(() => connectionStore.sidebarLayout.groups);
 
 const currentGroupId = computed(() => {
   if (props.node.type !== "connection" || !props.node.connectionId) return null;
-  for (const entry of connectionStore.sidebarLayout.order) {
-    if (entry.type === "group" && entry.connectionIds.includes(props.node.connectionId)) {
-      return entry.id;
+  const find = (entries: typeof connectionStore.sidebarLayout.order): string | null => {
+    for (const entry of entries) {
+      if (entry.type !== "group") continue;
+      if ((entry.children ?? entry.connectionIds?.map((id) => ({ type: "connection" as const, id })) ?? []).some((child) => child.type === "connection" && child.id === props.node.connectionId)) {
+        return entry.id;
+      }
+      const found = find(entry.children ?? []);
+      if (found) return found;
     }
-  }
-  return null;
+    return null;
+  };
+  return find(connectionStore.sidebarLayout.order);
 });
 
 // --- Drag and Drop ---
@@ -2700,6 +2711,7 @@ function treeItemMenuItems(): ContextMenuItem[] {
     items.push({ label: t("contextMenu.copyName"), action: copyName, icon: Copy, shortcut: shortcutCopyName.value });
     items.push({ label: "", separator: true });
     items.push({ label: t("toolbar.newConnection"), action: newConnectionInGroup, icon: Plus });
+    items.push({ label: t("connectionGroup.newGroup"), action: newSubgroup, icon: FolderPlus });
     items.push({ label: "", separator: true });
     items.push({
       label: t("connectionGroup.renameGroup"),
diff --git a/apps/desktop/src/lib/sidebarLayout.ts b/apps/desktop/src/lib/sidebarLayout.ts
index 2b66dd4da2..819d75f446 100644
--- a/apps/desktop/src/lib/sidebarLayout.ts
+++ b/apps/desktop/src/lib/sidebarLayout.ts
@@ -5,6 +5,26 @@ export function emptyLayout(): SidebarLayout {
   return { groups: [], order: [] };
 }
 
+function entryChildren(entry: Extract<SidebarOrderEntry, { type: "group" }>): SidebarOrderEntry[] {
+  return entry.children ?? entry.connectionIds?.map((id) => ({ type: "connection" as const, id })) ?? [];
+}
+
+function normalizeEntry(entry: SidebarOrderEntry, validIds: Set<string>, validGroups: Set<string>, seenConnections: Set<string>, seenGroups: Set<string>): SidebarOrderEntry | null {
+  if (entry.type === "connection") {
+    if (!validIds.has(entry.id) || seenConnections.has(entry.id)) return null;
+    seenConnections.add(entry.id);
+    return { type: "connection", id: entry.id };
+  }
+
+  if (!validGroups.has(entry.id) || seenGroups.has(entry.id)) return null;
+  seenGroups.add(entry.id);
+
+  const children = entryChildren(entry)
+    .map((child) => normalizeEntry(child, validIds, validGroups, seenConnections, seenGroups))
+    .filter(Boolean) as SidebarOrderEntry[];
+  return { type: "group", id: entry.id, children };
+}
+
 export function reconcileLayout(connectionIds: string[], layout: SidebarLayout | null): SidebarLayout {
   if (!layout) {
     return {
@@ -14,34 +34,28 @@ export function reconcileLayout(connectionIds: string[], layout: SidebarLayout |
   }
 
   const validIds = new Set(connectionIds);
-  const seen = new Set<string>();
-
-  const order: SidebarOrderEntry[] = [];
-  for (const entry of layout.order) {
-    if (entry.type === "group") {
-      const filtered = entry.connectionIds.filter((id) => {
-        if (!validIds.has(id) || seen.has(id)) return false;
-        seen.add(id);
-        return true;
-      });
-      order.push({ type: "group", id: entry.id, connectionIds: filtered });
-    } else {
-      if (validIds.has(entry.id) && !seen.has(entry.id)) {
-        seen.add(entry.id);
-        order.push(entry);
-      }
-    }
-  }
+  const validGroups = new Set(layout.groups.map((group) => group.id));
+  const seenConnections = new Set<string>();
+  const seenGroups = new Set<string>();
+  const order = layout.order.map((entry) => normalizeEntry(entry, validIds, validGroups, seenConnections, seenGroups)).filter(Boolean) as SidebarOrderEntry[];
 
   for (const id of connectionIds) {
-    if (!seen.has(id)) {
+    if (!seenConnections.has(id)) {
       order.push({ type: "connection", id });
     }
   }
 
-  const usedGroupIds = new Set(order.filter((e) => e.type === "group").map((e) => e.id));
-  const groups = layout.groups.filter((g) => usedGroupIds.has(g.id));
+  const usedGroupIds = new Set<string>();
+  const collectGroups = (entries: SidebarOrderEntry[]) => {
+    for (const entry of entries) {
+      if (entry.type !== "group") continue;
+      usedGroupIds.add(entry.id);
+      collectGroups(entry.children ?? []);
+    }
+  };
+  collectGroups(order);
 
+  const groups = layout.groups.filter((group) => usedGroupIds.has(group.id));
   return { groups, order };
 }
 
@@ -68,75 +82,103 @@ function orderPinnedFirst(nodes: TreeNode[]): TreeNode[] {
 }
 
 export function buildTreeNodesFromLayout(layout: SidebarLayout, connections: ConnectionConfig[], pinnedIds: Set<string>): TreeNode[] {
-  const configMap = new Map(connections.map((c) => [c.id, c]));
-  const groupMap = new Map(layout.groups.map((g) => [g.id, g]));
+  const configMap = new Map(connections.map((connection) => [connection.id, connection]));
+  const groupMap = new Map(layout.groups.map((group) => [group.id, group]));
+
+  const build = (entries: SidebarOrderEntry[]): TreeNode[] => {
+    const nodes: TreeNode[] = [];
+    for (const entry of entries) {
+      if (entry.type === "connection") {
+        const config = configMap.get(entry.id);
+        if (config) nodes.push(makeConnectionNode(config, pinnedIds.has(entry.id)));
+        continue;
+      }
 
-  const nodes: TreeNode[] = [];
-  for (const entry of layout.order) {
-    if (entry.type === "group") {
       const group = groupMap.get(entry.id);
       if (!group) continue;
-      const children: TreeNode[] = [];
-      for (const connId of entry.connectionIds) {
-        const config = configMap.get(connId);
-        if (config) children.push(makeConnectionNode(config, pinnedIds.has(connId)));
-      }
       nodes.push({
         id: group.id,
         label: group.name,
         type: "connection-group",
         isExpanded: !group.collapsed,
-        children: orderPinnedFirst(children),
+        children: orderPinnedFirst(build(entry.children ?? [])),
       });
-    } else {
-      const config = configMap.get(entry.id);
-      if (config) nodes.push(makeConnectionNode(config, pinnedIds.has(entry.id)));
     }
-  }
+    return nodes;
+  };
 
-  return orderPinnedFirst(nodes);
+  return orderPinnedFirst(build(layout.order));
 }
 
-export function findConnectionLocation(layout: SidebarLayout, connectionId: string): { entryIndex: number; groupId?: string; innerIndex?: number } | null {
-  for (let i = 0; i < layout.order.length; i++) {
-    const entry = layout.order[i];
-    if (entry.type === "connection" && entry.id === connectionId) {
-      return { entryIndex: i };
+export function findConnectionLocation(layout: SidebarLayout, connectionId: string): { entries: SidebarOrderEntry[]; entryIndex: number; groupId?: string } | null {
+  const visit = (entries: SidebarOrderEntry[], groupId?: string): { entries: SidebarOrderEntry[]; entryIndex: number; groupId?: string } | null => {
+    for (let i = 0; i < entries.length; i++) {
+      const entry = entries[i];
+      if (entry.type === "connection" && entry.id === connectionId) return { entries, entryIndex: i, groupId };
+      if (entry.type === "group") {
+        const found = visit(entry.children ?? [], entry.id);
+        if (found) return found;
+      }
+    }
+    return null;
+  };
+  return visit(layout.order);
+}
+
+function findGroupEntry(entries: SidebarOrderEntry[], groupId: string): Extract<SidebarOrderEntry, { type: "group" }> | null {
+  for (const entry of entries) {
+    if (entry.type !== "group") continue;
+    if (entry.id === groupId) return entry;
+    const found = findGroupEntry(entry.children ?? [], groupId);
+    if (found) return found;
+  }
+  return null;
+}
+
+function cloneEntries(entries: SidebarOrderEntry[]): SidebarOrderEntry[] {
+  return entries.map((entry) => (entry.type === "group" ? { type: "group", id: entry.id, children: cloneEntries(entry.children ?? []) } : { ...entry }));
+}
+
+function removeEntry(entries: SidebarOrderEntry[], id: string): SidebarOrderEntry | null {
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i];
+    if ((entry.type === "connection" && entry.id === id) || (entry.type === "group" && entry.id === id)) {
+      entries.splice(i, 1);
+      return entry;
     }
     if (entry.type === "group") {
-      const innerIndex = entry.connectionIds.indexOf(connectionId);
-      if (innerIndex >= 0) {
-        return { entryIndex: i, groupId: entry.id, innerIndex };
-      }
+      const removed = removeEntry(entry.children ?? [], id);
+      if (removed) return removed;
     }
   }
   return null;
 }
 
-function removeConnectionFromLayout(order: SidebarOrderEntry[], connectionId: string): SidebarOrderEntry[] {
-  return order
-    .map((entry) => {
-      if (entry.type === "connection" && entry.id === connectionId) return null;
-      if (entry.type === "group") {
-        return { ...entry, connectionIds: entry.connectionIds.filter((id) => id !== connectionId) };
-      }
-      return entry;
-    })
-    .filter(Boolean) as SidebarOrderEntry[];
+function removeConnectionFromEntries(entries: SidebarOrderEntry[], connectionId: string): SidebarOrderEntry[] {
+  const next = cloneEntries(entries);
+  removeEntry(next, connectionId);
+  return next;
+}
+
+function containsGroup(entry: SidebarOrderEntry, groupId: string): boolean {
+  if (entry.type !== "group") return false;
+  if (entry.id === groupId) return true;
+  return (entry.children ?? []).some((child) => containsGroup(child, groupId));
 }
 
 export function moveConnectionToGroup(layout: SidebarLayout, connectionId: string, targetGroupId: string | null): SidebarLayout {
-  const order = removeConnectionFromLayout([...layout.order], connectionId);
+  const order = removeConnectionFromEntries(layout.order, connectionId);
+  const entry: SidebarOrderEntry = { type: "connection", id: connectionId };
 
   if (targetGroupId) {
-    const groupEntry = order.find((e) => e.type === "group" && e.id === targetGroupId);
-    if (groupEntry && groupEntry.type === "group") {
-      groupEntry.connectionIds.push(connectionId);
+    const group = findGroupEntry(order, targetGroupId);
+    if (group) {
+      group.children = [...(group.children ?? []), entry];
+      return { ...layout, order };
     }
-  } else {
-    order.push({ type: "connection", id: connectionId });
   }
 
+  order.push(entry);
   return { ...layout, order };
 }
 
@@ -145,75 +187,58 @@ export type DropPosition = "before" | "after" | "inside";
 export function reorderEntry(layout: SidebarLayout, draggedId: string, targetId: string, position: DropPosition): SidebarLayout {
   if (draggedId === targetId) return layout;
 
-  const isDraggedGroup = layout.order.some((e) => e.type === "group" && e.id === draggedId);
-  const isTargetGroup = layout.order.some((e) => e.type === "group" && e.id === targetId);
+  const order = cloneEntries(layout.order);
+  const dragged = removeEntry(order, draggedId);
+  if (!dragged) return layout;
 
-  if (isDraggedGroup) {
-    return reorderGroup(layout, draggedId, targetId, position);
-  }
+  if (dragged.type === "group" && containsGroup(dragged, targetId)) return layout;
 
-  if (position === "inside" && isTargetGroup) {
-    return moveConnectionToGroup(layout, draggedId, targetId);
-  }
-
-  return reorderConnection(layout, draggedId, targetId, position);
-}
-
-function reorderGroup(layout: SidebarLayout, draggedId: string, targetId: string, position: DropPosition): SidebarLayout {
-  const order = [...layout.order];
-  const draggedIndex = order.findIndex((e) => e.type === "group" && e.id === draggedId);
-  if (draggedIndex < 0) return layout;
-
-  const [dragged] = order.splice(draggedIndex, 1);
-
-  let targetIndex = order.findIndex((e) => (e.type === "group" && e.id === targetId) || (e.type === "connection" && e.id === targetId));
-  if (targetIndex < 0) {
-    order.push(dragged);
-  } else {
-    if (position === "after") targetIndex++;
-    order.splice(targetIndex, 0, dragged);
-  }
-
-  return { ...layout, order };
-}
-
-function reorderConnection(layout: SidebarLayout, draggedId: string, targetId: string, position: DropPosition): SidebarLayout {
-  const order = removeConnectionFromLayout([...layout.order], draggedId);
-
-  const targetLoc = findConnectionLocation({ ...layout, order }, targetId);
-  if (!targetLoc) {
-    order.push({ type: "connection", id: draggedId });
-    return { ...layout, order };
-  }
-
-  if (targetLoc.groupId) {
-    const groupEntry = order[targetLoc.entryIndex];
-    if (groupEntry.type === "group") {
-      const insertAt = position === "after" ? targetLoc.innerIndex! + 1 : targetLoc.innerIndex!;
-      groupEntry.connectionIds.splice(insertAt, 0, draggedId);
-    }
-  } else {
-    const isTargetGroup = order[targetLoc.entryIndex]?.type === "group";
-    if (isTargetGroup && position === "inside") {
-      const entry = order[targetLoc.entryIndex];
-      if (entry.type === "group") entry.connectionIds.push(draggedId);
-    } else {
-      const insertAt = position === "after" ? targetLoc.entryIndex + 1 : targetLoc.entryIndex;
-      order.splice(insertAt, 0, { type: "connection", id: draggedId });
+  if (position === "inside") {
+    const targetGroup = findGroupEntry(order, targetId);
+    if (targetGroup) {
+      targetGroup.children = [...(targetGroup.children ?? []), dragged];
+      return { ...layout, order };
     }
   }
 
+  const insertNear = (entries: SidebarOrderEntry[]): boolean => {
+    for (let i = 0; i < entries.length; i++) {
+      const entry = entries[i];
+      if ((entry.type === "connection" && entry.id === targetId) || (entry.type === "group" && entry.id === targetId)) {
+        entries.splice(position === "after" ? i + 1 : i, 0, dragged);
+        return true;
+      }
+      if (entry.type === "group" && insertNear(entry.children ?? [])) return true;
+    }
+    return false;
+  };
+
+  if (!insertNear(order)) order.push(dragged);
   return { ...layout, order };
 }
 
-export function createGroup(layout: SidebarLayout, name: string): { layout: SidebarLayout; groupId: string } {
+export function createGroup(layout: SidebarLayout, name: string, parentGroupId?: string | null): { layout: SidebarLayout; groupId: string } {
   const groupId = uuid();
   const group: ConnectionGroup = { id: groupId, name, collapsed: false };
+  const order = cloneEntries(layout.order);
+  const entry: SidebarOrderEntry = { type: "group", id: groupId, children: [] };
+
+  if (parentGroupId) {
+    const parent = findGroupEntry(order, parentGroupId);
+    if (parent) {
+      parent.children = [...(parent.children ?? []), entry];
+    } else {
+      order.push(entry);
+    }
+  } else {
+    order.push(entry);
+  }
+
   return {
     groupId,
     layout: {
       groups: [...layout.groups, group],
-      order: [...layout.order, { type: "group" as const, id: groupId, connectionIds: [] }],
+      order,
     },
   };
 }
@@ -221,23 +246,30 @@ export function createGroup(layout: SidebarLayout, name: string): { layout: Side
 export function renameGroup(layout: SidebarLayout, groupId: string, name: string): SidebarLayout {
   return {
     ...layout,
-    groups: layout.groups.map((g) => (g.id === groupId ? { ...g, name } : g)),
+    groups: layout.groups.map((group) => (group.id === groupId ? { ...group, name } : group)),
   };
 }
 
 export function deleteGroup(layout: SidebarLayout, groupId: string): SidebarLayout {
-  const order: SidebarOrderEntry[] = [];
-  for (const entry of layout.order) {
-    if (entry.type === "group" && entry.id === groupId) {
-      for (const connId of entry.connectionIds) {
-        order.push({ type: "connection", id: connId });
+  const order = cloneEntries(layout.order);
+  const removeGroup = (entries: SidebarOrderEntry[]): boolean => {
+    for (let i = 0; i < entries.length; i++) {
+      const entry = entries[i];
+      if (entry.type === "group" && entry.id === groupId) {
+        entries.splice(i, 1, ...(entry.children ?? []));
+        return true;
+      }
+      if (entry.type === "group") {
+        const removed = removeGroup(entry.children ?? []);
+        if (removed) return true;
       }
-    } else {
-      order.push(entry);
     }
-  }
+    return false;
+  };
+
+  const removed = removeGroup(order);
   return {
-    groups: layout.groups.filter((g) => g.id !== groupId),
+    groups: removed ? layout.groups.filter((group) => group.id !== groupId) : layout.groups,
     order,
   };
 }
@@ -245,21 +277,14 @@ export function deleteGroup(layout: SidebarLayout, groupId: string): SidebarLayo
 export function toggleGroupCollapsed(layout: SidebarLayout, groupId: string): SidebarLayout {
   return {
     ...layout,
-    groups: layout.groups.map((g) => (g.id === groupId ? { ...g, collapsed: !g.collapsed } : g)),
+    groups: layout.groups.map((group) => (group.id === groupId ? { ...group, collapsed: !group.collapsed } : group)),
   };
 }
 
 export function removeConnectionFromSidebarLayout(layout: SidebarLayout, connectionId: string): SidebarLayout {
-  return { ...layout, order: removeConnectionFromLayout(layout.order, connectionId) };
+  return { ...layout, order: removeConnectionFromEntries(layout.order, connectionId) };
 }
 
 export function appendConnectionToLayout(layout: SidebarLayout, connectionId: string, groupId?: string | null): SidebarLayout {
-  if (groupId && layout.groups.some((group) => group.id === groupId)) {
-    return {
-      ...layout,
-      groups: layout.groups.map((group) => (group.id === groupId ? { ...group, collapsed: false } : group)),
-      order: layout.order.map((entry) => (entry.type === "group" && entry.id === groupId ? { ...entry, connectionIds: [...entry.connectionIds, connectionId] } : entry)),
-    };
-  }
-  return { ...layout, order: [...layout.order, { type: "connection" as const, id: connectionId }] };
+  return moveConnectionToGroup(layout, connectionId, groupId ?? null);
 }
diff --git a/apps/desktop/src/stores/connectionStore.ts b/apps/desktop/src/stores/connectionStore.ts
index 6ca7e21796..5837b8093f 100644
--- a/apps/desktop/src/stores/connectionStore.ts
+++ b/apps/desktop/src/stores/connectionStore.ts
@@ -476,7 +476,7 @@ export const useConnectionStore = defineStore("connection", () => {
     const node = findNode(treeNodes.value, id);
     if (node) node.pinned = next.has(id);
 
-    const isConnectionOrGroup = treeNodes.value.some((n) => n.id === id) || treeNodes.value.some((n) => n.type === "connection-group" && n.children?.some((c) => c.id === id));
+    const isConnectionOrGroup = !!findNode(treeNodes.value, id);
     if (isConnectionOrGroup) {
       rebuildTreeNodes();
     } else {
@@ -2512,8 +2512,8 @@ export const useConnectionStore = defineStore("connection", () => {
     fieldLineageSource,
     databaseSearchSource,
     databaseExportSource,
-    createConnectionGroup(name: string) {
-      const result = createGroupOp(sidebarLayout.value, name);
+    createConnectionGroup(name: string, parentGroupId?: string | null) {
+      const result = createGroupOp(sidebarLayout.value, name, parentGroupId);
       updateLayoutAndRebuild(result.layout);
       return result.groupId;
     },
diff --git a/apps/desktop/src/stores/savedSqlStore.ts b/apps/desktop/src/stores/savedSqlStore.ts
index c90e25f317..d6c5721fea 100644
--- a/apps/desktop/src/stores/savedSqlStore.ts
+++ b/apps/desktop/src/stores/savedSqlStore.ts
@@ -49,6 +49,19 @@ function maxOrderIndex(values: Array<{ orderIndex?: number }>) {
   return values.reduce((max, item) => Math.max(max, item.orderIndex ?? -1), -1);
 }
 
+function folderDepth(items: SavedSqlFolder[], folderId: string) {
+  const byId = new Map(items.map((folder) => [folder.id, folder]));
+  const seen = new Set<string>();
+  let depth = 0;
+  let current = byId.get(folderId);
+  while (current?.parentFolderId && !seen.has(current.parentFolderId)) {
+    seen.add(current.parentFolderId);
+    depth++;
+    current = byId.get(current.parentFolderId);
+  }
+  return depth;
+}
+
 function loadLegacyState(): SavedSqlState {
   try {
     const raw = localStorage.getItem(LEGACY_STORAGE_KEY);
@@ -101,7 +114,11 @@ export const useSavedSqlStore = defineStore("savedSql", () => {
   }
 
   function listFolders(connectionId: string) {
-    return sortFoldersByOrder(folders.value.filter((folder) => folder.connectionId === connectionId));
+    return listChildFolders(connectionId);
+  }
+
+  function listChildFolders(connectionId: string, parentFolderId?: string) {
+    return sortFoldersByOrder(folders.value.filter((folder) => folder.connectionId === connectionId && (folder.parentFolderId || "") === (parentFolderId || "")));
   }
 
   function listFiles(connectionId: string, folderId?: string) {
@@ -112,13 +129,14 @@ export const useSavedSqlStore = defineStore("savedSql", () => {
     return files.value.find((file) => file.id === id);
   }
 
-  async function createFolder(connectionId: string, name: string) {
+  async function createFolder(connectionId: string, name: string, parentFolderId?: string) {
     const timestamp = nowIso();
     const folder: SavedSqlFolder = {
       id: uuid(),
       connectionId,
+      parentFolderId: parentFolderId || undefined,
       name,
-      orderIndex: maxOrderIndex(folders.value) + 1,
+      orderIndex: maxOrderIndex(folders.value.filter((item) => item.connectionId === connectionId && (item.parentFolderId || "") === (parentFolderId || ""))) + 1,
       createdAt: timestamp,
       updatedAt: timestamp,
     };
@@ -139,9 +157,10 @@ export const useSavedSqlStore = defineStore("savedSql", () => {
   }
 
   async function deleteFolder(id: string) {
+    const removedIds = descendantFolderIds(id);
     await api.deleteSavedSqlFolder(id);
-    folders.value = folders.value.filter((folder) => folder.id !== id);
-    files.value = files.value.filter((file) => file.folderId !== id);
+    folders.value = folders.value.filter((folder) => !removedIds.has(folder.id));
+    files.value = files.value.filter((file) => !file.folderId || !removedIds.has(file.folderId));
     bumpVersion();
     await syncToLocalDirectory();
   }
@@ -213,7 +232,7 @@ export const useSavedSqlStore = defineStore("savedSql", () => {
   }
 
   async function persistFolders(nextFolders: SavedSqlFolder[]) {
-    const reindexed = reindexFolders(nextFolders).map((folder) => ({ ...folder, updatedAt: nowIso() }));
+    const reindexed = nextFolders.map((folder) => ({ ...folder, updatedAt: folder.updatedAt || nowIso() }));
     await Promise.all(reindexed.map((folder) => api.saveSavedSqlFolder(folder)));
     folders.value = reindexed;
     bumpVersion();
@@ -229,8 +248,20 @@ export const useSavedSqlStore = defineStore("savedSql", () => {
 
   function syncEntries() {
     const folderById = new Map(folders.value.map((folder) => [folder.id, folder]));
+    const folderPath = (folderId?: string): string | undefined => {
+      if (!folderId) return undefined;
+      const parts: string[] = [];
+      const seen = new Set<string>();
+      let current = folderById.get(folderId);
+      while (current && !seen.has(current.id)) {
+        seen.add(current.id);
+        parts.unshift(current.name);
+        current = current.parentFolderId ? folderById.get(current.parentFolderId) : undefined;
+      }
+      return parts.join("/");
+    };
     return sortFilesByOrder(files.value).map((file) => ({
-      folderName: file.folderId ? folderById.get(file.folderId)?.name : undefined,
+      folderName: folderPath(file.folderId),
       fileName: file.name,
       sql: file.sql,
     }));
@@ -256,16 +287,68 @@ export const useSavedSqlStore = defineStore("savedSql", () => {
   }
 
   async function reorderFolders(draggedId: string, targetId: string, position: "before" | "after") {
-    const ordered = sortFoldersByOrder(folders.value);
-    const dragged = ordered.find((folder) => folder.id === draggedId);
-    const target = ordered.find((folder) => folder.id === targetId);
+    const dragged = folders.value.find((folder) => folder.id === draggedId);
+    const target = folders.value.find((folder) => folder.id === targetId);
     if (!dragged || !target || dragged.id === target.id) return;
+    if (descendantFolderIds(draggedId).has(targetId)) return;
 
+    const timestamp = nowIso();
+    const targetParentFolderId = target.parentFolderId || undefined;
+    const previousParentFolderId = dragged.parentFolderId || undefined;
+    const ordered = sortFoldersByOrder(folders.value.filter((folder) => (folder.parentFolderId || "") === (targetParentFolderId || "")));
     const remaining = ordered.filter((folder) => folder.id !== draggedId);
     const targetIndex = remaining.findIndex((folder) => folder.id === targetId);
     const insertIndex = position === "before" ? targetIndex : targetIndex + 1;
-    remaining.splice(insertIndex, 0, dragged);
-    await persistFolders(remaining);
+    remaining.splice(insertIndex, 0, { ...dragged, parentFolderId: targetParentFolderId, updatedAt: timestamp });
+
+    const updatedTargetGroup = reindexFolders(remaining).map((folder) => ({
+      ...folder,
+      parentFolderId: targetParentFolderId,
+      updatedAt: timestamp,
+    }));
+    const updatedSourceGroup =
+      previousParentFolderId === targetParentFolderId
+        ? []
+        : reindexFolders(sortFoldersByOrder(folders.value.filter((folder) => folder.id !== draggedId && (folder.parentFolderId || "") === (previousParentFolderId || "")))).map((folder) => ({
+            ...folder,
+            updatedAt: timestamp,
+          }));
+    const untouched = folders.value.filter((folder) => folder.id !== draggedId && (folder.parentFolderId || "") !== (targetParentFolderId || "") && (folder.parentFolderId || "") !== (previousParentFolderId || ""));
+    await persistFolders([...untouched, ...updatedSourceGroup, ...updatedTargetGroup]);
+  }
+
+  function descendantFolderIds(folderId: string) {
+    const ids = new Set<string>([folderId]);
+    let changed = true;
+    while (changed) {
+      changed = false;
+      for (const folder of folders.value) {
+        if (folder.parentFolderId && ids.has(folder.parentFolderId) && !ids.has(folder.id)) {
+          ids.add(folder.id);
+          changed = true;
+        }
+      }
+    }
+    return ids;
+  }
+
+  async function moveFolderToFolder(folderId: string, parentFolderId?: string) {
+    const target = folders.value.find((folder) => folder.id === folderId);
+    if (!target) return;
+    const nextParentFolderId = parentFolderId || undefined;
+    if ((target.parentFolderId || undefined) === nextParentFolderId) return;
+    if (nextParentFolderId && descendantFolderIds(folderId).has(nextParentFolderId)) return;
+
+    const timestamp = nowIso();
+    const previousParentFolderId = target.parentFolderId || undefined;
+    const sourceGroup = reindexFolders(sortFoldersByOrder(folders.value.filter((folder) => folder.id !== folderId && (folder.parentFolderId || "") === (previousParentFolderId || "")))).map((folder) => ({ ...folder, updatedAt: timestamp }));
+    const destinationGroup = reindexFolders([...sortFoldersByOrder(folders.value.filter((folder) => folder.id !== folderId && (folder.parentFolderId || "") === (nextParentFolderId || ""))), { ...target, parentFolderId: nextParentFolderId, updatedAt: timestamp }]).map((folder) => ({
+      ...folder,
+      parentFolderId: nextParentFolderId,
+      updatedAt: timestamp,
+    }));
+    const untouched = folders.value.filter((folder) => folder.id !== folderId && (folder.parentFolderId || "") !== (previousParentFolderId || "") && (folder.parentFolderId || "") !== (nextParentFolderId || ""));
+    await persistFolders([...untouched, ...sourceGroup, ...destinationGroup]);
   }
 
   async function moveFileToFolder(fileId: string, folderId?: string) {
@@ -330,6 +413,16 @@ export const useSavedSqlStore = defineStore("savedSql", () => {
 
   const allFolders = computed(() => sortFoldersByOrder(folders.value));
 
+  const allFoldersTreeOrder = computed(() =>
+    [...folders.value].sort((a, b) => {
+      const depthDiff = folderDepth(folders.value, a.id) - folderDepth(folders.value, b.id);
+      if (depthDiff !== 0) return depthDiff;
+      const orderDiff = (a.orderIndex ?? 0) - (b.orderIndex ?? 0);
+      if (orderDiff !== 0) return orderDiff;
+      return a.name.localeCompare(b.name, undefined, { numeric: true, sensitivity: "base" });
+    }),
+  );
+
   const allFiles = computed(() => sortFilesByOrder(files.value));
 
   function filesInFolder(folderId: string) {
@@ -351,6 +444,7 @@ export const useSavedSqlStore = defineStore("savedSql", () => {
     version,
     initFromStorage,
     listFolders,
+    listChildFolders,
     listFiles,
     getFile,
     createFolder,
@@ -361,10 +455,12 @@ export const useSavedSqlStore = defineStore("savedSql", () => {
     recordFileUsage,
     deleteFile,
     reorderFolders,
+    moveFolderToFolder,
     reorderFiles,
     moveFileToFolder,
     syncToLocalDirectory,
     allFolders,
+    allFoldersTreeOrder,
     allFiles,
     filesInFolder,
     filesWithoutFolder,
diff --git a/apps/desktop/src/types/database.ts b/apps/desktop/src/types/database.ts
index 99ed74586a..e54766a5ac 100644
--- a/apps/desktop/src/types/database.ts
+++ b/apps/desktop/src/types/database.ts
@@ -357,7 +357,7 @@ export interface ConnectionGroup {
   collapsed: boolean;
 }
 
-export type SidebarOrderEntry = { type: "group"; id: string; connectionIds: string[] } | { type: "connection"; id: string };
+export type SidebarOrderEntry = { type: "group"; id: string; children?: SidebarOrderEntry[]; connectionIds?: string[] } | { type: "connection"; id: string };
 
 export interface SidebarLayout {
   groups: ConnectionGroup[];
@@ -475,6 +475,7 @@ export interface QueryTab {
 export interface SavedSqlFolder {
   id: string;
   connectionId: string;
+  parentFolderId?: string;
   name: string;
   orderIndex?: number;
   createdAt: string;
diff --git a/crates/dbx-core/src/saved_sql.rs b/crates/dbx-core/src/saved_sql.rs
index f8385d29a4..5fbd63724a 100644
--- a/crates/dbx-core/src/saved_sql.rs
+++ b/crates/dbx-core/src/saved_sql.rs
@@ -5,6 +5,7 @@ use serde::{Deserialize, Serialize};
 pub struct SavedSqlFolder {
     pub id: String,
     pub connection_id: String,
+    pub parent_folder_id: Option<String>,
     pub name: String,
     #[serde(default)]
     pub order_index: i64,
diff --git a/crates/dbx-core/src/storage.rs b/crates/dbx-core/src/storage.rs
index a57295f015..a7a9a10c68 100644
--- a/crates/dbx-core/src/storage.rs
+++ b/crates/dbx-core/src/storage.rs
@@ -130,6 +130,7 @@ const SCHEMA_STATEMENTS: &[&str] = &[
     "CREATE TABLE IF NOT EXISTS saved_sql_folders (
         id TEXT PRIMARY KEY,
         connection_id TEXT NOT NULL,
+        parent_folder_id TEXT,
         name TEXT NOT NULL DEFAULT '',
         order_index INTEGER NOT NULL DEFAULT 0,
         created_at TEXT NOT NULL DEFAULT '',
@@ -209,7 +210,8 @@ fn ensure_history_columns_sync(conn: &Connection) -> Result<(), String> {
 }
 
 fn ensure_saved_sql_columns_sync(conn: &Connection) -> Result<(), String> {
-    const FOLDER_COLUMNS: &[(&str, &str)] = &[("order_index", "INTEGER NOT NULL DEFAULT 0")];
+    const FOLDER_COLUMNS: &[(&str, &str)] =
+        &[("parent_folder_id", "TEXT"), ("order_index", "INTEGER NOT NULL DEFAULT 0")];
     const FILE_COLUMNS: &[(&str, &str)] = &[
         ("order_index", "INTEGER NOT NULL DEFAULT 0"),
         ("open_count", "INTEGER NOT NULL DEFAULT 0"),
@@ -860,11 +862,12 @@ impl Storage {
 
             for folder in &library.folders {
                 tx.execute(
-                    "INSERT INTO saved_sql_folders (id, connection_id, name, order_index, created_at, updated_at) \
-                     VALUES (?, ?, ?, ?, ?, ?)",
+                    "INSERT INTO saved_sql_folders (id, connection_id, parent_folder_id, name, order_index, created_at, updated_at) \
+                     VALUES (?, ?, ?, ?, ?, ?, ?)",
                     params![
                         folder.id,
                         folder.connection_id,
+                        folder.parent_folder_id,
                         folder.name,
                         folder.order_index,
                         folder.created_at,
@@ -906,8 +909,8 @@ impl Storage {
         self.with_conn(|conn| {
             let mut folder_stmt = conn
                 .prepare(
-                    "SELECT id, connection_id, name, order_index, created_at, updated_at \
-                     FROM saved_sql_folders ORDER BY order_index, connection_id, name COLLATE NOCASE",
+                    "SELECT id, connection_id, parent_folder_id, name, order_index, created_at, updated_at \
+                     FROM saved_sql_folders ORDER BY COALESCE(parent_folder_id, ''), order_index, connection_id, name COLLATE NOCASE",
                 )
                 .map_err(|e| e.to_string())?;
             let folders = folder_stmt
@@ -915,10 +918,11 @@ impl Storage {
                     Ok(SavedSqlFolder {
                         id: row.get(0)?,
                         connection_id: row.get(1)?,
-                        name: row.get(2)?,
-                        order_index: row.get(3)?,
-                        created_at: row.get(4)?,
-                        updated_at: row.get(5)?,
+                        parent_folder_id: row.get(2)?,
+                        name: row.get(3)?,
+                        order_index: row.get(4)?,
+                        created_at: row.get(5)?,
+                        updated_at: row.get(6)?,
                     })
                 })
                 .map_err(|e| e.to_string())?
@@ -961,16 +965,18 @@ impl Storage {
         let folder = folder.clone();
         self.with_conn(move |conn| {
             conn.execute(
-                "INSERT INTO saved_sql_folders (id, connection_id, name, order_index, created_at, updated_at) \
-                 VALUES (?, ?, ?, ?, ?, ?) \
+                "INSERT INTO saved_sql_folders (id, connection_id, parent_folder_id, name, order_index, created_at, updated_at) \
+                 VALUES (?, ?, ?, ?, ?, ?, ?) \
                  ON CONFLICT(id) DO UPDATE SET \
                  connection_id = excluded.connection_id, \
+                 parent_folder_id = excluded.parent_folder_id, \
                  name = excluded.name, \
                  order_index = excluded.order_index, \
                  updated_at = excluded.updated_at",
                 params![
                     folder.id,
                     folder.connection_id,
+                    folder.parent_folder_id,
                     folder.name,
                     folder.order_index,
                     folder.created_at,
@@ -987,8 +993,27 @@ impl Storage {
         let id = id.to_string();
         self.with_conn(move |conn| {
             let tx = conn.transaction().map_err(|e| e.to_string())?;
-            tx.execute("DELETE FROM saved_sql_files WHERE folder_id = ?1", [id.as_str()]).map_err(|e| e.to_string())?;
-            tx.execute("DELETE FROM saved_sql_folders WHERE id = ?1", [id.as_str()]).map_err(|e| e.to_string())?;
+            let mut folder_ids = vec![id.clone()];
+            let mut index = 0;
+            while index < folder_ids.len() {
+                let parent_id = folder_ids[index].clone();
+                let mut stmt = tx
+                    .prepare("SELECT id FROM saved_sql_folders WHERE parent_folder_id = ?1")
+                    .map_err(|e| e.to_string())?;
+                let child_ids = stmt
+                    .query_map([parent_id.as_str()], |row| row.get::<_, String>(0))
+                    .map_err(|e| e.to_string())?
+                    .collect::<Result<Vec<_>, _>>()
+                    .map_err(|e| e.to_string())?;
+                folder_ids.extend(child_ids);
+                index += 1;
+            }
+            for folder_id in folder_ids.iter().rev() {
+                tx.execute("DELETE FROM saved_sql_files WHERE folder_id = ?1", [folder_id.as_str()])
+                    .map_err(|e| e.to_string())?;
+                tx.execute("DELETE FROM saved_sql_folders WHERE id = ?1", [folder_id.as_str()])
+                    .map_err(|e| e.to_string())?;
+            }
             tx.commit().map_err(|e| e.to_string())
         })
         .await
diff --git a/packages/app-tests/sidebarLayoutNested.test.ts b/packages/app-tests/sidebarLayoutNested.test.ts
new file mode 100644
index 0000000000..5647e67256
--- /dev/null
+++ b/packages/app-tests/sidebarLayoutNested.test.ts
@@ -0,0 +1,93 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { buildTreeNodesFromLayout, deleteGroup, moveConnectionToGroup, reconcileLayout, reorderEntry } from "../../apps/desktop/src/lib/sidebarLayout.ts";
+import type { ConnectionConfig, SidebarLayout } from "../../apps/desktop/src/types/database.ts";
+
+function conn(id: string): ConnectionConfig {
+  return {
+    id,
+    name: id,
+    db_type: "mysql",
+    host: "localhost",
+    port: 3306,
+    username: "root",
+    password: "",
+  };
+}
+
+test("reconciles legacy grouped layout into nested children", () => {
+  const layout: SidebarLayout = {
+    groups: [{ id: "g1", name: "Group", collapsed: false }],
+    order: [{ type: "group", id: "g1", connectionIds: ["c1"] }],
+  };
+
+  const reconciled = reconcileLayout(["c1", "c2"], layout);
+
+  assert.deepEqual(reconciled.order, [
+    { type: "group", id: "g1", children: [{ type: "connection", id: "c1" }] },
+    { type: "connection", id: "c2" },
+  ]);
+});
+
+test("builds nested connection group tree nodes", () => {
+  const layout: SidebarLayout = {
+    groups: [
+      { id: "g1", name: "Parent", collapsed: false },
+      { id: "g2", name: "Child", collapsed: false },
+    ],
+    order: [
+      {
+        type: "group",
+        id: "g1",
+        children: [{ type: "group", id: "g2", children: [{ type: "connection", id: "c1" }] }],
+      },
+    ],
+  };
+
+  const nodes = buildTreeNodesFromLayout(layout, [conn("c1")], new Set());
+
+  assert.deepEqual(
+    nodes.map((node) => [node.type, node.label, node.children?.[0]?.type, node.children?.[0]?.children?.[0]?.id]),
+    [["connection-group", "Parent", "connection-group", "c1"]],
+  );
+});
+
+test("moves connections and groups into nested groups", () => {
+  const layout: SidebarLayout = {
+    groups: [
+      { id: "g1", name: "Parent", collapsed: false },
+      { id: "g2", name: "Child", collapsed: false },
+    ],
+    order: [
+      { type: "group", id: "g1", children: [] },
+      { type: "group", id: "g2", children: [] },
+      { type: "connection", id: "c1" },
+    ],
+  };
+
+  const withNestedGroup = reorderEntry(layout, "g2", "g1", "inside");
+  const withNestedConnection = moveConnectionToGroup(withNestedGroup, "c1", "g2");
+
+  assert.deepEqual(withNestedConnection.order, [
+    {
+      type: "group",
+      id: "g1",
+      children: [{ type: "group", id: "g2", children: [{ type: "connection", id: "c1" }] }],
+    },
+  ]);
+});
+
+test("deleting a parent group keeps nested child groups", () => {
+  const layout: SidebarLayout = {
+    groups: [
+      { id: "g1", name: "Parent", collapsed: false },
+      { id: "g2", name: "Child", collapsed: false },
+    ],
+    order: [{ type: "group", id: "g1", children: [{ type: "group", id: "g2", children: [{ type: "connection", id: "c1" }] }] }],
+  };
+
+  const next = deleteGroup(layout, "g1");
+
+  assert.deepEqual(next.groups, [{ id: "g2", name: "Child", collapsed: false }]);
+  assert.deepEqual(next.order, [{ type: "group", id: "g2", children: [{ type: "connection", id: "c1" }] }]);
+});
diff --git a/src-tauri/src/commands/saved_sql.rs b/src-tauri/src/commands/saved_sql.rs
index a90a2afb96..2125e27448 100644
--- a/src-tauri/src/commands/saved_sql.rs
+++ b/src-tauri/src/commands/saved_sql.rs
@@ -103,7 +103,12 @@ fn sync_saved_sql_directory_blocking(target_dir: &Path, entries: &[SavedSqlSyncE
     for entry in entries {
         let mut file_dir = sync_root.to_path_buf();
         if let Some(folder_name) = entry.folder_name.as_deref().map(str::trim).filter(|name| !name.is_empty()) {
-            file_dir.push(sanitize_file_segment(folder_name));
+            for segment in folder_name.split('/') {
+                let segment = segment.trim();
+                if !segment.is_empty() {
+                    file_dir.push(sanitize_file_segment(segment));
+                }
+            }
         }
         std::fs::create_dir_all(&file_dir).map_err(|e| e.to_string())?;