feat(vscode): restore multi-project section and drag-and-drop support

.changeset/bright-project-dnd.md

@@ -0,0 +1,5 @@
+---
+"kilo-code": patch
+---
+
+Restore Agent Manager sections and worktree drag-and-drop when multiple projects are shown, with ordering and section moves scoped to the owning project.

packages/kilo-vscode/src/agent-manager/AgentManagerProvider.ts

@@ -734,7 +734,11 @@ export class AgentManagerProvider implements Disposable {
       return null
     }
     if (m.type === "agentManager.setWorktreeOrder") {
-      this.state?.setWorktreeOrder(m.order)
+      const state = this.getStateManager()
+      if (state) {
+        state.setWorktreeOrder(m.order)
+        this.pushState()
+      }
       return null
     }
     if (m.type === "agentManager.setSessionsCollapsed") {

packages/kilo-vscode/src/agent-manager/types.ts

@@ -626,6 +626,7 @@ interface SetTabOrderIn {
 
 interface SetWorktreeOrderIn {
   type: "agentManager.setWorktreeOrder"
+  projectId?: string
   order: string[]
 }
 

packages/kilo-vscode/tests/unit/project-store.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it } from "bun:test"
+import { createProjectStore } from "../../webview-ui/agent-manager/project/store"
+
+const state = (projectId: string, order: string[]) => ({
+  type: "agentManager.state" as const,
+  projectId,
+  worktrees: order.map((id) => ({
+    id,
+    branch: `${projectId}-${id}`,
+    path: `/repo/${projectId}/${id}`,
+    parentBranch: "main",
+    createdAt: "2026-01-01",
+  })),
+  sessions: [],
+  sections: [],
+  worktreeOrder: order,
+})
+
+describe("project stores", () => {
+  it("keeps worktree order isolated between projects", () => {
+    const first = createProjectStore("a")
+    const second = createProjectStore("b")
+    first.applyState(state("a", ["same", "other"]))
+    second.applyState(state("b", ["same", "other"]))
+
+    first.setWorktreeOrder(["other", "same"])
+
+    expect(first.worktreeOrder()).toEqual(["other", "same"])
+    expect(second.worktreeOrder()).toEqual(["same", "other"])
+  })
+
+  it("preserves live run statuses when state omits them", () => {
+    const store = createProjectStore("a")
+    store.applyState(state("a", ["same", "other"]))
+    store.setRunStatuses({
+      same: { worktreeId: "same", state: "running" },
+    })
+
+    store.applyState(state("a", ["other", "same"]))
+
+    expect(store.runStatuses()).toEqual({
+      same: { worktreeId: "same", state: "running" },
+    })
+  })
+})

packages/kilo-vscode/tests/unit/section-helpers.test.ts

@@ -7,6 +7,7 @@ import {
   isGrouped,
   isGroupStart,
   isGroupEnd,
+  sortWorktrees,
 } from "../../webview-ui/agent-manager/section-helpers"
 import type { WorktreeState, SectionState } from "../../webview-ui/src/types/messages"
 
@@ -112,6 +113,23 @@ describe("isGrouped", () => {
   })
 })
 
+describe("sortWorktrees", () => {
+  it("applies persisted order", () => {
+    const all = [wt("a"), wt("b"), wt("c")]
+    expect(sortWorktrees(all, ["c", "a", "b"]).map((item) => item.id)).toEqual(["c", "a", "b"])
+  })
+
+  it("keeps multi-version siblings adjacent at the first group position", () => {
+    const all = [wt("a", { groupId: "g" }), wt("b"), wt("c", { groupId: "g" })]
+    expect(sortWorktrees(all, ["b", "c", "a"]).map((item) => item.id)).toEqual(["b", "c", "a"])
+  })
+
+  it("appends worktrees missing from persisted order", () => {
+    const all = [wt("a"), wt("b"), wt("c")]
+    expect(sortWorktrees(all, ["b"]).map((item) => item.id)).toEqual(["b", "a", "c"])
+  })
+})
+
 describe("isGroupStart", () => {
   const list = [wt("a", { groupId: "g1" }), wt("b", { groupId: "g1" }), wt("c", { groupId: "g2" }), wt("d")]
 

packages/kilo-vscode/webview-ui/agent-manager/AgentManagerApp.tsx

@@ -159,6 +159,7 @@ import {
   isGrouped,
   isGroupStart,
   isGroupEnd,
+  sortWorktrees,
   type TopLevelItem,
 } from "./section-helpers"
 import {} from "./section-dnd"
@@ -845,39 +846,7 @@ const AgentManagerContent: Component = () => {
   const isSessionBusy = (id: string): boolean => isAnySessionBusy([id])
 
   /** Worktrees sorted so that grouped items are always adjacent, respecting custom order if set. */
-  const sortedWorktrees = createMemo(() => {
-    const ordered = applyTabOrder(worktrees(), sidebarWorktreeOrder())
-    if (ordered.length === 0) return []
-
-    // Collect grouped worktrees by groupId
-    const grouped = new Map<string, WorktreeState[]>()
-    for (const wt of ordered) {
-      if (!wt.groupId) continue
-      const list = grouped.get(wt.groupId) ?? []
-      list.push(wt)
-      grouped.set(wt.groupId, list)
-    }
-
-    // Build output: interleave groups at the position of their earliest member
-    const result: WorktreeState[] = []
-    const placed = new Set<string>()
-    for (const wt of ordered) {
-      if (placed.has(wt.id)) continue
-      if (wt.groupId) {
-        if (placed.has(wt.groupId)) continue
-        placed.add(wt.groupId)
-        const group = grouped.get(wt.groupId) ?? []
-        for (const g of group) {
-          result.push(g)
-          placed.add(g.id)
-        }
-      } else {
-        result.push(wt)
-        placed.add(wt.id)
-      }
-    }
-    return result
-  })
+  const sortedWorktrees = createMemo(() => sortWorktrees(worktrees(), sidebarWorktreeOrder()))
 
   const worktreesInSection = (id: string) => sortedWorktrees().filter((wt) => wt.sectionId === id)
   const ungrouped = createMemo(() => sortedWorktrees().filter((wt) => !wt.sectionId))
@@ -2328,6 +2297,7 @@ const AgentManagerContent: Component = () => {
           <ProjectList
             projects={projectList()}
             states={projectStates()}
+            store={(id) => registry.ensure(id)}
             stats={projectLive.stats()}
             local={projectLive.local()}
             prs={projectLive.prs()}

packages/kilo-vscode/webview-ui/agent-manager/ProjectList.tsx

@@ -19,11 +19,13 @@ import type { SidebarSearchItem } from "./sidebar-search"
 import { LOCAL } from "./navigate"
 import { NewWorktreeDialog } from "./NewWorktreeDialog"
 import { ProjectBranchDialog } from "./ProjectBranchDialog"
+import type { ProjectStore } from "./project/store"
 import type { ModeRouter } from "./mode-router"
 
 interface Props {
   projects: AgentProjectSnapshot[]
   states: Record<string, AgentManagerStateMessage>
+  store?: (projectId: string) => ProjectStore
   stats: Record<string, Record<string, WorktreeGitStats>>
   local: Record<string, LocalGitStats>
   prs: Record<string, Record<string, PRStatus | null>>
@@ -208,6 +210,7 @@ export const ProjectList: Component<Props> = (props) => {
         <ProjectSidebarBody
           project={project}
           state={props.states[project.id]}
+          store={props.store?.(project.id)}
           stats={props.stats[project.id]}
           local={props.local[project.id]}
           prs={props.prs[project.id]}