From 3b8c92ebdc64535f05650c18903b31f330ea5cad Mon Sep 17 00:00:00 2001
From: qer <wbxl2000@outlook.com>
Date: Tue, 23 Jun 2026 23:12:29 +0800
Subject: [PATCH 1/7] feat(web): stabilize and drag-reorder workspaces in the
 sidebar

---
 .changeset/web-draggable-workspace-order.md   |   5 +
 apps/kimi-web/src/App.vue                     |   1 +
 apps/kimi-web/src/components/Sidebar.vue      | 105 +++++++++++++-----
 .../src/components/WorkspaceGroup.vue         |  23 +++-
 .../src/composables/useKimiWebClient.ts       |  64 +++++++++--
 apps/kimi-web/src/lib/storage.ts              |  18 +++
 apps/kimi-web/src/lib/workspaceOrder.ts       |  50 +++++++++
 apps/kimi-web/test/storage-logic.test.ts      |  26 +++++
 apps/kimi-web/test/workspace-order.test.ts    |  69 ++++++++++++
 9 files changed, 326 insertions(+), 35 deletions(-)
 create mode 100644 .changeset/web-draggable-workspace-order.md
 create mode 100644 apps/kimi-web/src/lib/workspaceOrder.ts
 create mode 100644 apps/kimi-web/test/workspace-order.test.ts

diff --git a/.changeset/web-draggable-workspace-order.md b/.changeset/web-draggable-workspace-order.md
new file mode 100644
index 0000000000..811fdf675f
--- /dev/null
+++ b/.changeset/web-draggable-workspace-order.md
@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code": patch
+---
+
+Keep the web sidebar's workspace order stable and let workspaces be reordered by drag-and-drop, persisted locally instead of following recent activity.
diff --git a/apps/kimi-web/src/App.vue b/apps/kimi-web/src/App.vue
index 0fa5d7b0c9..176910afaf 100644
--- a/apps/kimi-web/src/App.vue
+++ b/apps/kimi-web/src/App.vue
@@ -561,6 +561,7 @@ function openPr(url: string): void {
         @fork="(id) => client.forkSession(id)"
         @rename-workspace="(id, name) => client.renameWorkspace(id, name)"
         @delete-workspace="(id) => client.deleteWorkspace(id)"
+        @reorder-workspaces="client.reorderWorkspaces($event)"
         @select-workspaces="handleSelectWorkspaces"
         @open-settings="showSettings = true"
         @collapse="toggleSidebarCollapse"
diff --git a/apps/kimi-web/src/components/Sidebar.vue b/apps/kimi-web/src/components/Sidebar.vue
index 65619c682d..1b166c8196 100644
--- a/apps/kimi-web/src/components/Sidebar.vue
+++ b/apps/kimi-web/src/components/Sidebar.vue
@@ -8,6 +8,7 @@ import { useI18n } from 'vue-i18n';
 import { serverEndpointLabel } from '../api/config';
 import { copyTextToClipboard } from '../lib/clipboard';
 import { loadCollapsedWorkspaces, saveCollapsedWorkspaces } from '../lib/storage';
+import { moveInOrder } from '../lib/workspaceOrder';
 import type { Session, WorkspaceGroup as WorkspaceGroupType, WorkspaceView } from '../types';
 import SessionRow from './SessionRow.vue';
 import WorkspaceGroup from './WorkspaceGroup.vue';
@@ -56,6 +57,7 @@ const emit = defineEmits<{
   fork: [id: string];
   renameWorkspace: [id: string, name: string];
   deleteWorkspace: [id: string];
+  reorderWorkspaces: [ids: string[]];
   openSettings: [];
   collapse: [];
 }>();
@@ -111,6 +113,41 @@ function toggleCollapse(id: string): void {
   saveCollapsedWorkspaces(next);
 }
 
+// ---------------------------------------------------------------------------
+// Workspace drag-to-reorder
+// ---------------------------------------------------------------------------
+// The header of each group is the drag handle (see WorkspaceGroup). We track
+// which group is being dragged and which one is the current drop target (for a
+// visual insertion marker), then on drop we emit the new id order upward — the
+// parent persists it and the computed `groups` re-sorts.
+const draggingWsId = ref<string | null>(null);
+const dragOverWsId = ref<string | null>(null);
+
+function onWsDragstart(id: string): void {
+  draggingWsId.value = id;
+}
+
+function onWsDragend(): void {
+  draggingWsId.value = null;
+  dragOverWsId.value = null;
+}
+
+function onGroupDragOver(event: DragEvent, targetId: string): void {
+  if (draggingWsId.value === null || draggingWsId.value === targetId) return;
+  event.preventDefault();
+  if (event.dataTransfer) event.dataTransfer.dropEffect = 'move';
+  dragOverWsId.value = targetId;
+}
+
+function onGroupDrop(targetId: string): void {
+  const fromId = draggingWsId.value;
+  dragOverWsId.value = null;
+  draggingWsId.value = null;
+  if (!fromId || fromId === targetId) return;
+  const next = moveInOrder(props.groups.map((g) => g.workspace.id), fromId, targetId);
+  emit('reorderWorkspaces', next);
+}
+
 // ---------------------------------------------------------------------------
 // Session list truncation per workspace
 // ---------------------------------------------------------------------------
@@ -529,35 +566,45 @@ function blinkOnce(): void {
         </div>
 
         <template v-else>
-          <WorkspaceGroup
+          <div
             v-for="g in groups"
             :key="g.workspace.id"
-            :group="g"
-            :active-workspace-id="activeWorkspaceId"
-            :active-id="activeId"
-            :selected-ids="selectedIds"
-            :renaming-id="renamingId"
-            :rename-value="renameValue"
-            :rename-input-ref="getRenameInputRef()"
-            :pending-by-session="pendingBySession"
-            :unread-by-session="unreadBySession"
-            :ws-menu-open-id="wsMenuOpenId"
-            :is-collapsed="isCollapsed"
-            :is-expanded="isExpanded"
-            :visible-sessions="visibleSessions"
-            @group-click="handleGhClick"
-            @group-contextmenu="openGhMenu"
-            @toggle-ws-menu="toggleWsMenu"
-            @create-in-workspace="(id) => emit('createInWorkspace', id)"
-            @select-session="onSelectSession"
-            @rename-session="(id, title) => emit('rename', id, title)"
-            @archive-session="(id) => emit('archive', id)"
-            @fork-session="(id) => emit('fork', id)"
-            @toggle-expand="toggleExpand"
-            @confirm-rename="confirmRenameWorkspace"
-            @cancel-rename="cancelRenameWorkspace"
-            @update-rename-value="onUpdateRenameValue"
-          />
+            class="ws-drop-target"
+            :class="{ 'drop-before': dragOverWsId === g.workspace.id }"
+            @dragover="onGroupDragOver($event, g.workspace.id)"
+            @drop="onGroupDrop(g.workspace.id)"
+          >
+            <WorkspaceGroup
+              :group="g"
+              :active-workspace-id="activeWorkspaceId"
+              :active-id="activeId"
+              :selected-ids="selectedIds"
+              :renaming-id="renamingId"
+              :rename-value="renameValue"
+              :rename-input-ref="getRenameInputRef()"
+              :pending-by-session="pendingBySession"
+              :unread-by-session="unreadBySession"
+              :ws-menu-open-id="wsMenuOpenId"
+              :dragging="draggingWsId === g.workspace.id"
+              :is-collapsed="isCollapsed"
+              :is-expanded="isExpanded"
+              :visible-sessions="visibleSessions"
+              @group-click="handleGhClick"
+              @group-contextmenu="openGhMenu"
+              @toggle-ws-menu="toggleWsMenu"
+              @create-in-workspace="(id) => emit('createInWorkspace', id)"
+              @select-session="onSelectSession"
+              @rename-session="(id, title) => emit('rename', id, title)"
+              @archive-session="(id) => emit('archive', id)"
+              @fork-session="(id) => emit('fork', id)"
+              @toggle-expand="toggleExpand"
+              @confirm-rename="confirmRenameWorkspace"
+              @cancel-rename="cancelRenameWorkspace"
+              @update-rename-value="onUpdateRenameValue"
+              @ws-dragstart="onWsDragstart"
+              @ws-dragend="onWsDragend"
+            />
+          </div>
         </template>
       </div>
     </div>
@@ -839,6 +886,10 @@ function blinkOnce(): void {
 }
 .sessions::-webkit-scrollbar-thumb:hover { background: var(--bd); }
 
+/* Workspace drag-to-reorder: a line at the top of the group under the cursor
+   marks where the dragged workspace will land. Inset shadow avoids layout shift. */
+.ws-drop-target.drop-before { box-shadow: inset 0 2px 0 var(--blue); }
+
 .empty {
   padding: 24px 12px;
   text-align: center;
diff --git a/apps/kimi-web/src/components/WorkspaceGroup.vue b/apps/kimi-web/src/components/WorkspaceGroup.vue
index 816b621500..4d026c042a 100644
--- a/apps/kimi-web/src/components/WorkspaceGroup.vue
+++ b/apps/kimi-web/src/components/WorkspaceGroup.vue
@@ -23,6 +23,8 @@ const props = defineProps<{
   pendingBySession: Record<string, { approvals: number; questions: number }>;
   unreadBySession: Record<string, boolean>;
   wsMenuOpenId: string | null;
+  /** True while this group is the active drag source (drag-to-reorder). */
+  dragging: boolean;
   isCollapsed: (id: string) => boolean;
   isExpanded: (id: string) => boolean;
   visibleSessions: (sessions: Session[], expanded: boolean, activeId?: string) => Session[];
@@ -41,6 +43,8 @@ const emit = defineEmits<{
   confirmRename: [];
   cancelRename: [];
   updateRenameValue: [value: string];
+  wsDragstart: [workspaceId: string];
+  wsDragend: [];
 }>();
 
 // v-model bridge: Sidebar owns renameValue (confirmRenameWorkspace reads it),
@@ -57,15 +61,28 @@ const renameValueModel = computed<string>({
 function setRenameInputRef(el: Element | ComponentPublicInstance | null): void {
   props.renameInputRef.value = el instanceof HTMLInputElement ? el : null;
 }
+
+// Drag-to-reorder: the group header is the drag handle. We stash the workspace
+// id on the dataTransfer (so drop targets elsewhere could read it) and tell the
+// sidebar which group is being dragged so it can compute the new order on drop.
+function onHeaderDragStart(event: DragEvent): void {
+  if (!event.dataTransfer) return;
+  event.dataTransfer.effectAllowed = 'move';
+  event.dataTransfer.setData('text/plain', props.group.workspace.id);
+  emit('wsDragstart', props.group.workspace.id);
+}
 </script>
 
 <template>
-  <div class="group">
+  <div class="group" :class="{ dragging }">
     <div
       class="gh"
       :class="{ on: group.workspace.id === activeWorkspaceId, sel: selectedIds.has(group.workspace.id) }"
+      draggable="true"
       @click.stop="emit('groupClick', group.workspace.id, $event)"
       @contextmenu="emit('groupContextmenu', group.workspace, $event)"
+      @dragstart="onHeaderDragStart"
+      @dragend="emit('wsDragend')"
     >
       <div class="gh-top">
         <!-- Folder icon -->
@@ -168,6 +185,7 @@ function setRenameInputRef(el: Element | ComponentPublicInstance | null): void {
 /* Workspace group. The --sb-* custom properties are inherited from .side in
    Sidebar.vue, so they don't need to be redeclared here. */
 .group { padding-bottom: 6px; }
+.group.dragging { opacity: 0.45; }
 .gh {
   display: flex;
   flex-direction: column;
@@ -176,7 +194,10 @@ function setRenameInputRef(el: Element | ComponentPublicInstance | null): void {
   font-size: max(9px, calc(var(--ui-font-size) - 3.5px));
   user-select: none;
   position: relative;
+  /* The header doubles as the drag handle for reordering. */
+  cursor: grab;
 }
+.gh:active { cursor: grabbing; }
 .gh-top {
   display: flex;
   align-items: center;
diff --git a/apps/kimi-web/src/composables/useKimiWebClient.ts b/apps/kimi-web/src/composables/useKimiWebClient.ts
index 1f04a3f563..80f9b3274e 100644
--- a/apps/kimi-web/src/composables/useKimiWebClient.ts
+++ b/apps/kimi-web/src/composables/useKimiWebClient.ts
@@ -2,11 +2,21 @@
 // Vue state composable — the only place that imports both src/api/* and src/types.ts.
 // Components consume computed view props and call actions; they never touch the API or reducer.
 
-import { computed, reactive, ref } from 'vue';
+import { computed, reactive, ref, watch } from 'vue';
 import { i18n } from '../i18n';
 import { getKimiWebApi } from '../api';
 import { isDaemonApiError, isDaemonNetworkError } from '../api/errors';
-import { loadUnread, safeGetString, safeRemove, safeSetString, saveUnread, STORAGE_KEYS } from '../lib/storage';
+import { reconcileWorkspaceOrder, sortByWorkspaceOrder } from '../lib/workspaceOrder';
+import {
+  loadUnread,
+  loadWorkspaceOrder,
+  safeGetString,
+  safeRemove,
+  safeSetString,
+  saveUnread,
+  saveWorkspaceOrder,
+  STORAGE_KEYS,
+} from '../lib/storage';
 import { useAppearance } from './client/useAppearance';
 import { useNotification } from './client/useNotification';
 import { useTaskPoller } from './client/useTaskPoller';
@@ -1679,17 +1689,46 @@ const mergedWorkspaces = computed<AppWorkspace[]>(() => {
   return result;
 });
 
-/** Sidebar-facing workspace list. */
-const workspacesView = computed<WorkspaceView[]>(() =>
-  mergedWorkspaces.value.map((w) => ({
+/**
+ * User-defined display order of workspace ids, persisted to localStorage. The
+ * sidebar stops following the daemon's recency-based order: once a workspace is
+ * known, its position is fixed until the user drags it elsewhere.
+ */
+const workspaceOrder = ref<string[]>(loadWorkspaceOrder());
+
+// Reconcile the persisted order with the set of currently-known workspaces:
+// drop ids that no longer exist, and prepend newly-seen ids (newest first,
+// matching "createdAt desc" — the closest signal we have without a real
+// workspace creation timestamp). Watched on the id *set* (joined) so a pure
+// daemon reorder of the same workspaces does not rewrite the user's order, and
+// a drag reorder (which also writes `workspaceOrder` but keeps the same id set)
+// does not re-trigger it. Skipped while nothing is loaded yet so an initial
+// empty `mergedWorkspaces` never wipes the stored order.
+watch(
+  () => mergedWorkspaces.value.map((w) => w.id).join('\0'),
+  () => {
+    const next = reconcileWorkspaceOrder(
+      mergedWorkspaces.value.map((w) => w.id),
+      workspaceOrder.value,
+    );
+    if (next === null) return;
+    workspaceOrder.value = next;
+    saveWorkspaceOrder(next);
+  },
+);
+
+/** Sidebar-facing workspace list, ordered by the persisted/dragged order. */
+const workspacesView = computed<WorkspaceView[]>(() => {
+  const views = mergedWorkspaces.value.map((w) => ({
     id: w.id,
     name: w.name,
     root: w.root,
     shortPath: shortenHome(w.root, rawState.fsHome),
     branch: w.branch,
     sessionCount: w.sessionCount,
-  })),
-);
+  }));
+  return sortByWorkspaceOrder(views, workspaceOrder.value);
+});
 
 /** The active workspace id, falling back to the first available workspace. */
 const activeWorkspaceId = computed<string | null>(() => {
@@ -1755,6 +1794,16 @@ const workspaceGroups = computed<WorkspaceGroup[]>(() => {
   }));
 });
 
+/**
+ * Replace the workspace display order (e.g. after a drag reorder in the
+ * sidebar) and persist it. The id set is unchanged, so the reconciliation
+ * watcher above will not fire — only the sort in `workspacesView` reacts.
+ */
+function reorderWorkspaces(ids: string[]): void {
+  workspaceOrder.value = ids;
+  saveWorkspaceOrder(ids);
+}
+
 /**
  * Per-session pending-attention count = pending approvals + pending questions.
  * For the active session this is live (driven by WS events). Other sessions
@@ -2090,6 +2139,7 @@ export function useKimiWebClient() {
     renameSession: workspaceState.renameSession,
     renameWorkspace: workspaceState.renameWorkspace,
     deleteWorkspace: workspaceState.deleteWorkspace,
+    reorderWorkspaces,
     archiveSession: workspaceState.archiveSession,
     compact: workspaceState.compact,
     forkSession: workspaceState.forkSession,
diff --git a/apps/kimi-web/src/lib/storage.ts b/apps/kimi-web/src/lib/storage.ts
index f83c86ef76..aad5b2b86a 100644
--- a/apps/kimi-web/src/lib/storage.ts
+++ b/apps/kimi-web/src/lib/storage.ts
@@ -23,6 +23,7 @@ export const STORAGE_KEYS = {
   colorScheme: 'kimi-web.color-scheme',
   hiddenWorkspaces: 'kimi-web.hidden-workspaces',
   collapsedWorkspaces: 'kimi-web.collapsed-workspaces',
+  workspaceOrder: 'kimi-web.workspace-order',
   betaToc: 'kimi-web.beta-toc',
   notifyOnComplete: 'kimi-web.notify-on-complete',
   inputHistory: 'kimi-web.input-history',
@@ -138,3 +139,20 @@ export function loadCollapsedWorkspaces(): string[] {
 export function saveCollapsedWorkspaces(ids: Iterable<string>): void {
   safeSetJson(STORAGE_KEYS.collapsedWorkspaces, Array.from(ids));
 }
+
+/**
+ * Display order of workspace ids in the sidebar. Persisted as a JSON array so
+ * the user can drag workspaces into a custom order that survives a page
+ * refresh. There is no server-side source of truth for this UI-only ordering;
+ * workspaces absent from the list are treated as "not yet placed" and inserted
+ * by the caller (newest first).
+ */
+export function loadWorkspaceOrder(): string[] {
+  const parsed = safeGetJson<unknown>(STORAGE_KEYS.workspaceOrder);
+  if (!Array.isArray(parsed)) return [];
+  return parsed.filter((id): id is string => typeof id === 'string');
+}
+
+export function saveWorkspaceOrder(ids: Iterable<string>): void {
+  safeSetJson(STORAGE_KEYS.workspaceOrder, Array.from(ids));
+}
diff --git a/apps/kimi-web/src/lib/workspaceOrder.ts b/apps/kimi-web/src/lib/workspaceOrder.ts
new file mode 100644
index 0000000000..809ad6f26d
--- /dev/null
+++ b/apps/kimi-web/src/lib/workspaceOrder.ts
@@ -0,0 +1,50 @@
+// apps/kimi-web/src/lib/workspaceOrder.ts
+// Pure helpers for the sidebar's user-defined workspace order. Kept separate
+// from the composable so the reconciliation and sort rules are unit-testable
+// without mounting Vue state.
+
+/**
+ * Merge the set of currently-known workspace ids into the persisted order.
+ * - Ids that no longer exist are dropped.
+ * - Newly-seen ids are prepended (newest first — the closest signal to a
+ *   creation time we have, since workspaces carry no createdAt timestamp).
+ * - Returns `null` when nothing changed, so callers can skip a redundant write.
+ * - Returns `null` for an empty `currentIds` so an initial not-yet-loaded state
+ *   never wipes the stored order.
+ */
+export function reconcileWorkspaceOrder(
+  currentIds: string[],
+  storedOrder: string[],
+): string[] | null {
+  if (currentIds.length === 0) return null;
+  const currentSet = new Set(currentIds);
+  const kept = storedOrder.filter((id) => currentSet.has(id));
+  const newIds = currentIds.filter((id) => !storedOrder.includes(id));
+  if (newIds.length === 0 && kept.length === storedOrder.length) return null;
+  return [...newIds, ...kept];
+}
+
+/**
+ * Sort items by their position in `order`. Items absent from `order` sort to
+ * the front (a just-discovered workspace appears at the top immediately, before
+ * the reconciliation watcher records it). The sort is stable, so items sharing
+ * a position keep their relative order.
+ */
+export function sortByWorkspaceOrder<T extends { id: string }>(items: T[], order: string[]): T[] {
+  const index = new Map(order.map((id, i) => [id, i]));
+  return items.toSorted((a, b) => (index.get(a.id) ?? -1) - (index.get(b.id) ?? -1));
+}
+
+/**
+ * Move `fromId` to `toId`'s position within `order`. Returns the original array
+ * unchanged when either id is missing or they are the same.
+ */
+export function moveInOrder(order: string[], fromId: string, toId: string): string[] {
+  const fromIdx = order.indexOf(fromId);
+  const toIdx = order.indexOf(toId);
+  if (fromIdx === -1 || toIdx === -1 || fromIdx === toIdx) return order;
+  const next = [...order];
+  next.splice(fromIdx, 1);
+  next.splice(toIdx, 0, fromId);
+  return next;
+}
diff --git a/apps/kimi-web/test/storage-logic.test.ts b/apps/kimi-web/test/storage-logic.test.ts
index 79284a3b11..d9dbefb543 100644
--- a/apps/kimi-web/test/storage-logic.test.ts
+++ b/apps/kimi-web/test/storage-logic.test.ts
@@ -2,8 +2,10 @@ import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 import {
   loadCollapsedWorkspaces,
   loadUnread,
+  loadWorkspaceOrder,
   saveCollapsedWorkspaces,
   saveUnread,
+  saveWorkspaceOrder,
   STORAGE_KEYS,
   draftStorageKey,
   safeGetJson,
@@ -195,3 +197,27 @@ describe('loadCollapsedWorkspaces / saveCollapsedWorkspaces', () => {
     expect(loadCollapsedWorkspaces()).toEqual([]);
   });
 });
+
+describe('loadWorkspaceOrder / saveWorkspaceOrder', () => {
+  it('returns an empty array when the key is missing', () => {
+    expect(loadWorkspaceOrder()).toEqual([]);
+  });
+
+  it('round-trips the ordered ids', () => {
+    saveWorkspaceOrder(['ws-2', 'ws-1']);
+    expect(loadWorkspaceOrder()).toEqual(['ws-2', 'ws-1']);
+  });
+
+  it('accepts any iterable of ids', () => {
+    saveWorkspaceOrder(new Set(['ws-3', 'ws-1']));
+    expect(loadWorkspaceOrder()).toEqual(['ws-3', 'ws-1']);
+  });
+
+  it('drops non-string entries and returns [] for malformed values', () => {
+    safeSetString(STORAGE_KEYS.workspaceOrder, JSON.stringify(['ws-1', 2, null]));
+    expect(loadWorkspaceOrder()).toEqual(['ws-1']);
+
+    safeSetString(STORAGE_KEYS.workspaceOrder, JSON.stringify({ ws: true }));
+    expect(loadWorkspaceOrder()).toEqual([]);
+  });
+});
diff --git a/apps/kimi-web/test/workspace-order.test.ts b/apps/kimi-web/test/workspace-order.test.ts
new file mode 100644
index 0000000000..e1373042ff
--- /dev/null
+++ b/apps/kimi-web/test/workspace-order.test.ts
@@ -0,0 +1,69 @@
+import { describe, expect, it } from 'vitest';
+import {
+  moveInOrder,
+  reconcileWorkspaceOrder,
+  sortByWorkspaceOrder,
+} from '../src/lib/workspaceOrder';
+
+describe('reconcileWorkspaceOrder', () => {
+  it('returns null for an empty current set so a not-yet-loaded state never wipes the order', () => {
+    expect(reconcileWorkspaceOrder([], ['ws-1', 'ws-2'])).toBeNull();
+  });
+
+  it('returns null when the id set is unchanged (a daemon reorder must not rewrite the order)', () => {
+    expect(reconcileWorkspaceOrder(['ws-2', 'ws-1'], ['ws-1', 'ws-2'])).toBeNull();
+  });
+
+  it('prepends newly-seen ids (newest first)', () => {
+    expect(reconcileWorkspaceOrder(['ws-3', 'ws-1', 'ws-2'], ['ws-1', 'ws-2'])).toEqual([
+      'ws-3',
+      'ws-1',
+      'ws-2',
+    ]);
+  });
+
+  it('drops ids that no longer exist', () => {
+    expect(reconcileWorkspaceOrder(['ws-1'], ['ws-2', 'ws-1', 'ws-3'])).toEqual(['ws-1']);
+  });
+
+  it('snapshots the initial order on first load', () => {
+    expect(reconcileWorkspaceOrder(['ws-2', 'ws-1'], [])).toEqual(['ws-2', 'ws-1']);
+  });
+});
+
+describe('sortByWorkspaceOrder', () => {
+  const items = [{ id: 'a' }, { id: 'b' }, { id: 'c' }];
+
+  it('orders items by their position in the order list', () => {
+    expect(sortByWorkspaceOrder(items, ['c', 'a', 'b']).map((x) => x.id)).toEqual(['c', 'a', 'b']);
+  });
+
+  it('places unknown ids at the front, keeping their relative order', () => {
+    expect(sortByWorkspaceOrder(items, ['b']).map((x) => x.id)).toEqual(['a', 'c', 'b']);
+  });
+
+  it('does not mutate the input array', () => {
+    const copy = [...items];
+    sortByWorkspaceOrder(items, ['c', 'a', 'b']);
+    expect(items).toEqual(copy);
+  });
+});
+
+describe('moveInOrder', () => {
+  it('moves an item down onto the target', () => {
+    expect(moveInOrder(['a', 'b', 'c', 'd'], 'a', 'c')).toEqual(['b', 'c', 'a', 'd']);
+  });
+
+  it('moves an item up onto the target', () => {
+    expect(moveInOrder(['a', 'b', 'c', 'd'], 'd', 'b')).toEqual(['a', 'd', 'b', 'c']);
+  });
+
+  it('is a no-op when from === to', () => {
+    expect(moveInOrder(['a', 'b', 'c'], 'b', 'b')).toEqual(['a', 'b', 'c']);
+  });
+
+  it('returns the original order when an id is missing', () => {
+    expect(moveInOrder(['a', 'b'], 'x', 'b')).toEqual(['a', 'b']);
+    expect(moveInOrder(['a', 'b'], 'a', 'x')).toEqual(['a', 'b']);
+  });
+});

From 80f8ec4ad678140d779bb69ba4d89195c9e67382 Mon Sep 17 00:00:00 2001
From: qer <wbxl2000@outlook.com>
Date: Tue, 23 Jun 2026 23:23:48 +0800
Subject: [PATCH 2/7] fix(web): preserve dragged workspace order after refresh

---
 .../src/composables/useKimiWebClient.ts       | 22 ++++++++++++-------
 apps/kimi-web/test/workspace-order.test.ts    | 14 ++++++++++++
 2 files changed, 28 insertions(+), 8 deletions(-)

diff --git a/apps/kimi-web/src/composables/useKimiWebClient.ts b/apps/kimi-web/src/composables/useKimiWebClient.ts
index 80f9b3274e..224970d4a8 100644
--- a/apps/kimi-web/src/composables/useKimiWebClient.ts
+++ b/apps/kimi-web/src/composables/useKimiWebClient.ts
@@ -1702,15 +1702,21 @@ const workspaceOrder = ref<string[]>(loadWorkspaceOrder());
 // workspace creation timestamp). Watched on the id *set* (joined) so a pure
 // daemon reorder of the same workspaces does not rewrite the user's order, and
 // a drag reorder (which also writes `workspaceOrder` but keeps the same id set)
-// does not re-trigger it. Skipped while nothing is loaded yet so an initial
-// empty `mergedWorkspaces` never wipes the stored order.
+// does not re-trigger it.
+//
+// The watch also tracks `loading` and bails out while a load is in progress.
+// During `load()`, sessions (and thus derived workspaces) are set *before* the
+// real workspaces arrive, so a real workspace with no sessions is momentarily
+// absent from `mergedWorkspaces`. Without the loading guard the reconciler would
+// drop it as "deleted" and then, when it appears a tick later, re-add it at the
+// top — undoing the user's drag on refresh. Waiting until the load settles
+// means we always reconcile against the complete set.
 watch(
-  () => mergedWorkspaces.value.map((w) => w.id).join('\0'),
-  () => {
-    const next = reconcileWorkspaceOrder(
-      mergedWorkspaces.value.map((w) => w.id),
-      workspaceOrder.value,
-    );
+  () => [mergedWorkspaces.value.map((w) => w.id).join('\0'), rawState.loading] as const,
+  ([idsKey, loading]) => {
+    if (loading) return;
+    const current = idsKey ? idsKey.split('\0') : [];
+    const next = reconcileWorkspaceOrder(current, workspaceOrder.value);
     if (next === null) return;
     workspaceOrder.value = next;
     saveWorkspaceOrder(next);
diff --git a/apps/kimi-web/test/workspace-order.test.ts b/apps/kimi-web/test/workspace-order.test.ts
index e1373042ff..4ba4ea6e95 100644
--- a/apps/kimi-web/test/workspace-order.test.ts
+++ b/apps/kimi-web/test/workspace-order.test.ts
@@ -29,6 +29,20 @@ describe('reconcileWorkspaceOrder', () => {
   it('snapshots the initial order on first load', () => {
     expect(reconcileWorkspaceOrder(['ws-2', 'ws-1'], [])).toEqual(['ws-2', 'ws-1']);
   });
+
+  // Regression guard for the "dragged empty workspace bounces back on refresh"
+  // bug: if the reconciler is ever fed a *partial* workspace set, it drops the
+  // missing workspace and the next call (with the full set) re-adds it at the
+  // top. The watcher avoids this by only reconciling once loading has settled,
+  // but the reconciler's own "drop + re-add at top" behavior is what makes the
+  // guard necessary — pinning it here documents the contract.
+  it('drops a temporarily-absent workspace and re-adds it at the top (why the watcher waits for load)', () => {
+    const dragged = ['ws-b', 'ws-c', 'ws-empty'];
+    const afterPartial = reconcileWorkspaceOrder(['ws-b', 'ws-c'], dragged);
+    expect(afterPartial).toEqual(['ws-b', 'ws-c']);
+    const afterFull = reconcileWorkspaceOrder(['ws-empty', 'ws-b', 'ws-c'], afterPartial!);
+    expect(afterFull).toEqual(['ws-empty', 'ws-b', 'ws-c']);
+  });
 });
 
 describe('sortByWorkspaceOrder', () => {

From 8b93aeeb4d7073b0b29ed4c1fad792a1e5b81370 Mon Sep 17 00:00:00 2001
From: qer <wbxl2000@outlook.com>
Date: Tue, 23 Jun 2026 23:31:35 +0800
Subject: [PATCH 3/7] fix(web): float session to top of its group on new
 message

---
 .changeset/web-draggable-workspace-order.md  |  2 +-
 apps/kimi-web/src/api/daemon/eventReducer.ts |  8 ++
 apps/kimi-web/test/event-reducer.test.ts     | 83 ++++++++++++++++++++
 3 files changed, 92 insertions(+), 1 deletion(-)
 create mode 100644 apps/kimi-web/test/event-reducer.test.ts

diff --git a/.changeset/web-draggable-workspace-order.md b/.changeset/web-draggable-workspace-order.md
index 811fdf675f..24fd88e130 100644
--- a/.changeset/web-draggable-workspace-order.md
+++ b/.changeset/web-draggable-workspace-order.md
@@ -2,4 +2,4 @@
 "@moonshot-ai/kimi-code": patch
 ---
 
-Keep the web sidebar's workspace order stable and let workspaces be reordered by drag-and-drop, persisted locally instead of following recent activity.
+Keep the web sidebar's workspace order stable and let workspaces be reordered by drag-and-drop, persisted locally instead of following recent activity; sessions now also float to the top of their group as soon as a new message arrives.
diff --git a/apps/kimi-web/src/api/daemon/eventReducer.ts b/apps/kimi-web/src/api/daemon/eventReducer.ts
index 6c50be9655..44f43e7090 100644
--- a/apps/kimi-web/src/api/daemon/eventReducer.ts
+++ b/apps/kimi-web/src/api/daemon/eventReducer.ts
@@ -350,6 +350,14 @@ export function reduceAppEvent(
     // -------------------------------------------------------------------------
     case 'messageCreated': {
       const sid = event.message.sessionId;
+      // A new message is activity on the session: bump its recency so it floats
+      // to the top of its workspace group in the sidebar immediately. The daemon
+      // does not always broadcast a fresh `session.updated` for message activity,
+      // so we rely on the message's own timestamp (and never move it backwards).
+      const createdAt = event.message.createdAt;
+      next.sessions = next.sessions.map((s) =>
+        s.id === sid && createdAt > s.updatedAt ? { ...s, updatedAt: createdAt } : s,
+      );
       const msgs = next.messagesBySession[sid] ?? [];
       const exists = msgs.some((m) => m.id === event.message.id);
       if (!exists) {
diff --git a/apps/kimi-web/test/event-reducer.test.ts b/apps/kimi-web/test/event-reducer.test.ts
new file mode 100644
index 0000000000..8d0531aacc
--- /dev/null
+++ b/apps/kimi-web/test/event-reducer.test.ts
@@ -0,0 +1,83 @@
+import { describe, expect, it } from 'vitest';
+import { createInitialState, reduceAppEvent } from '../src/api/daemon/eventReducer';
+import type { AppMessage, AppSession } from '../src/api/types';
+
+function makeSession(id: string, updatedAt: string): AppSession {
+  return {
+    id,
+    title: id,
+    createdAt: updatedAt,
+    updatedAt,
+    status: 'idle',
+    archived: false,
+    cwd: '/workspace',
+    model: 'kimi-code',
+    usage: {
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheReadTokens: 0,
+      cacheCreationTokens: 0,
+      totalCostUsd: 0,
+      contextTokens: 0,
+      contextLimit: 0,
+      turnCount: 0,
+    },
+    messageCount: 0,
+    lastSeq: 0,
+  };
+}
+
+function makeMessage(sessionId: string, createdAt: string): AppMessage {
+  return {
+    id: `msg_${createdAt}`,
+    sessionId,
+    role: 'user',
+    content: [{ type: 'text', text: 'hi' }],
+    createdAt,
+  };
+}
+
+describe('reduceAppEvent messageCreated', () => {
+  it('bumps the session updatedAt so it floats to the top of the sidebar', () => {
+    const state = {
+      ...createInitialState(),
+      sessions: [makeSession('s-old', '2026-01-01T00:00:00.000Z')],
+    };
+    const next = reduceAppEvent(
+      state,
+      { type: 'messageCreated', message: makeMessage('s-old', '2026-06-01T12:00:00.000Z') },
+      { sessionId: 's-old', seq: 1 },
+    );
+    expect(next.sessions[0]?.updatedAt).toBe('2026-06-01T12:00:00.000Z');
+  });
+
+  it('does not move a session backwards when an older message arrives', () => {
+    const state = {
+      ...createInitialState(),
+      sessions: [makeSession('s-new', '2026-06-01T12:00:00.000Z')],
+    };
+    const next = reduceAppEvent(
+      state,
+      { type: 'messageCreated', message: makeMessage('s-new', '2026-01-01T00:00:00.000Z') },
+      { sessionId: 's-new', seq: 1 },
+    );
+    expect(next.sessions[0]?.updatedAt).toBe('2026-06-01T12:00:00.000Z');
+  });
+
+  it('leaves other sessions untouched', () => {
+    const state = {
+      ...createInitialState(),
+      sessions: [
+        makeSession('s-a', '2026-01-01T00:00:00.000Z'),
+        makeSession('s-b', '2026-01-01T00:00:00.000Z'),
+      ],
+    };
+    const next = reduceAppEvent(
+      state,
+      { type: 'messageCreated', message: makeMessage('s-a', '2026-06-01T12:00:00.000Z') },
+      { sessionId: 's-a', seq: 1 },
+    );
+    expect(next.sessions.find((s) => s.id === 's-a')?.updatedAt).toBe('2026-06-01T12:00:00.000Z');
+    expect(next.sessions.find((s) => s.id === 's-b')?.updatedAt).toBe('2026-01-01T00:00:00.000Z');
+  });
+});

From f5d9220c4ffa88d757bc7aa4bb19a91df396a7be Mon Sep 17 00:00:00 2001
From: qer <wbxl2000@outlook.com>
Date: Tue, 23 Jun 2026 23:58:16 +0800
Subject: [PATCH 4/7] fix(web): align workspace drop order with insertion
 marker

---
 apps/kimi-web/src/lib/workspaceOrder.ts    | 10 +++++++---
 apps/kimi-web/test/workspace-order.test.ts | 13 ++++++++++---
 2 files changed, 17 insertions(+), 6 deletions(-)

diff --git a/apps/kimi-web/src/lib/workspaceOrder.ts b/apps/kimi-web/src/lib/workspaceOrder.ts
index 809ad6f26d..c4a18528f2 100644
--- a/apps/kimi-web/src/lib/workspaceOrder.ts
+++ b/apps/kimi-web/src/lib/workspaceOrder.ts
@@ -36,8 +36,11 @@ export function sortByWorkspaceOrder<T extends { id: string }>(items: T[], order
 }
 
 /**
- * Move `fromId` to `toId`'s position within `order`. Returns the original array
- * unchanged when either id is missing or they are the same.
+ * Move `fromId` so it lands immediately before `toId` — matching the
+ * "drop-before" insertion marker shown in the sidebar. Returns the original
+ * array unchanged when either id is missing or they are the same. After the
+ * source is removed, a downward move shifts the target left by one, so the
+ * insertion index is adjusted to keep the result "before the target".
  */
 export function moveInOrder(order: string[], fromId: string, toId: string): string[] {
   const fromIdx = order.indexOf(fromId);
@@ -45,6 +48,7 @@ export function moveInOrder(order: string[], fromId: string, toId: string): stri
   if (fromIdx === -1 || toIdx === -1 || fromIdx === toIdx) return order;
   const next = [...order];
   next.splice(fromIdx, 1);
-  next.splice(toIdx, 0, fromId);
+  const insertIdx = fromIdx < toIdx ? toIdx - 1 : toIdx;
+  next.splice(insertIdx, 0, fromId);
   return next;
 }
diff --git a/apps/kimi-web/test/workspace-order.test.ts b/apps/kimi-web/test/workspace-order.test.ts
index 4ba4ea6e95..ed706357bb 100644
--- a/apps/kimi-web/test/workspace-order.test.ts
+++ b/apps/kimi-web/test/workspace-order.test.ts
@@ -64,14 +64,21 @@ describe('sortByWorkspaceOrder', () => {
 });
 
 describe('moveInOrder', () => {
-  it('moves an item down onto the target', () => {
-    expect(moveInOrder(['a', 'b', 'c', 'd'], 'a', 'c')).toEqual(['b', 'c', 'a', 'd']);
+  // The drop indicator is a line at the *top* of the target ("insert before"),
+  // so the result must always place fromId immediately before toId.
+  it('moves an item down so it lands before the target', () => {
+    expect(moveInOrder(['a', 'b', 'c', 'd'], 'a', 'c')).toEqual(['b', 'a', 'c', 'd']);
   });
 
-  it('moves an item up onto the target', () => {
+  it('moves an item up so it lands before the target', () => {
     expect(moveInOrder(['a', 'b', 'c', 'd'], 'd', 'b')).toEqual(['a', 'd', 'b', 'c']);
   });
 
+  it('is a no-op when dropping on the adjacent item in the indicator direction', () => {
+    // "before b" keeps a above b; to move a below b you drop onto c instead.
+    expect(moveInOrder(['a', 'b', 'c'], 'a', 'b')).toEqual(['a', 'b', 'c']);
+  });
+
   it('is a no-op when from === to', () => {
     expect(moveInOrder(['a', 'b', 'c'], 'b', 'b')).toEqual(['a', 'b', 'c']);
   });

From f646bf45b3c18a51bc77f0079fd8b436fe62c30e Mon Sep 17 00:00:00 2001
From: qer <wbxl2000@outlook.com>
Date: Wed, 24 Jun 2026 11:35:25 +0800
Subject: [PATCH 5/7] fix(web): allow dropping a workspace after the last item

---
 apps/kimi-web/src/components/Sidebar.vue   | 42 +++++++++++++++-------
 apps/kimi-web/src/lib/workspaceOrder.ts    | 23 ++++++++----
 apps/kimi-web/test/workspace-order.test.ts | 26 ++++++++++----
 3 files changed, 65 insertions(+), 26 deletions(-)

diff --git a/apps/kimi-web/src/components/Sidebar.vue b/apps/kimi-web/src/components/Sidebar.vue
index 1b166c8196..b3ec0f0b48 100644
--- a/apps/kimi-web/src/components/Sidebar.vue
+++ b/apps/kimi-web/src/components/Sidebar.vue
@@ -8,7 +8,7 @@ import { useI18n } from 'vue-i18n';
 import { serverEndpointLabel } from '../api/config';
 import { copyTextToClipboard } from '../lib/clipboard';
 import { loadCollapsedWorkspaces, saveCollapsedWorkspaces } from '../lib/storage';
-import { moveInOrder } from '../lib/workspaceOrder';
+import { moveInOrder, type DropPosition } from '../lib/workspaceOrder';
 import type { Session, WorkspaceGroup as WorkspaceGroupType, WorkspaceView } from '../types';
 import SessionRow from './SessionRow.vue';
 import WorkspaceGroup from './WorkspaceGroup.vue';
@@ -117,11 +117,13 @@ function toggleCollapse(id: string): void {
 // Workspace drag-to-reorder
 // ---------------------------------------------------------------------------
 // The header of each group is the drag handle (see WorkspaceGroup). We track
-// which group is being dragged and which one is the current drop target (for a
-// visual insertion marker), then on drop we emit the new id order upward — the
-// parent persists it and the computed `groups` re-sorts.
+// which group is being dragged and where the insertion marker sits (before or
+// after the group under the pointer), then on drop we emit the new id order
+// upward — the parent persists it and the computed `groups` re-sorts. Using the
+// pointer's position within the target (top half = before, bottom half = after)
+// is what lets a workspace be dropped at the very bottom of the list.
 const draggingWsId = ref<string | null>(null);
-const dragOverWsId = ref<string | null>(null);
+const dragOver = ref<{ id: string; position: DropPosition } | null>(null);
 
 function onWsDragstart(id: string): void {
   draggingWsId.value = id;
@@ -129,22 +131,33 @@ function onWsDragstart(id: string): void {
 
 function onWsDragend(): void {
   draggingWsId.value = null;
-  dragOverWsId.value = null;
+  dragOver.value = null;
+}
+
+function dropPosition(event: DragEvent): DropPosition {
+  const rect = (event.currentTarget as HTMLElement).getBoundingClientRect();
+  return event.clientY < rect.top + rect.height / 2 ? 'before' : 'after';
 }
 
 function onGroupDragOver(event: DragEvent, targetId: string): void {
   if (draggingWsId.value === null || draggingWsId.value === targetId) return;
   event.preventDefault();
   if (event.dataTransfer) event.dataTransfer.dropEffect = 'move';
-  dragOverWsId.value = targetId;
+  dragOver.value = { id: targetId, position: dropPosition(event) };
 }
 
 function onGroupDrop(targetId: string): void {
   const fromId = draggingWsId.value;
-  dragOverWsId.value = null;
+  const position = dragOver.value?.id === targetId ? dragOver.value.position : 'before';
+  dragOver.value = null;
   draggingWsId.value = null;
   if (!fromId || fromId === targetId) return;
-  const next = moveInOrder(props.groups.map((g) => g.workspace.id), fromId, targetId);
+  const next = moveInOrder(
+    props.groups.map((g) => g.workspace.id),
+    fromId,
+    targetId,
+    position,
+  );
   emit('reorderWorkspaces', next);
 }
 
@@ -570,7 +583,10 @@ function blinkOnce(): void {
             v-for="g in groups"
             :key="g.workspace.id"
             class="ws-drop-target"
-            :class="{ 'drop-before': dragOverWsId === g.workspace.id }"
+            :class="{
+              'drop-before': dragOver?.id === g.workspace.id && dragOver.position === 'before',
+              'drop-after': dragOver?.id === g.workspace.id && dragOver.position === 'after',
+            }"
             @dragover="onGroupDragOver($event, g.workspace.id)"
             @drop="onGroupDrop(g.workspace.id)"
           >
@@ -886,9 +902,11 @@ function blinkOnce(): void {
 }
 .sessions::-webkit-scrollbar-thumb:hover { background: var(--bd); }
 
-/* Workspace drag-to-reorder: a line at the top of the group under the cursor
-   marks where the dragged workspace will land. Inset shadow avoids layout shift. */
+/* Workspace drag-to-reorder: a line at the top (drop-before) or bottom
+   (drop-after) of the group under the cursor marks where the dragged workspace
+   will land. Inset shadows avoid layout shift. */
 .ws-drop-target.drop-before { box-shadow: inset 0 2px 0 var(--blue); }
+.ws-drop-target.drop-after { box-shadow: inset 0 -2px 0 var(--blue); }
 
 .empty {
   padding: 24px 12px;
diff --git a/apps/kimi-web/src/lib/workspaceOrder.ts b/apps/kimi-web/src/lib/workspaceOrder.ts
index c4a18528f2..5381ec779b 100644
--- a/apps/kimi-web/src/lib/workspaceOrder.ts
+++ b/apps/kimi-web/src/lib/workspaceOrder.ts
@@ -35,20 +35,29 @@ export function sortByWorkspaceOrder<T extends { id: string }>(items: T[], order
   return items.toSorted((a, b) => (index.get(a.id) ?? -1) - (index.get(b.id) ?? -1));
 }
 
+export type DropPosition = 'before' | 'after';
+
 /**
- * Move `fromId` so it lands immediately before `toId` — matching the
- * "drop-before" insertion marker shown in the sidebar. Returns the original
- * array unchanged when either id is missing or they are the same. After the
- * source is removed, a downward move shifts the target left by one, so the
- * insertion index is adjusted to keep the result "before the target".
+ * Move `fromId` so it lands immediately before or after `toId` — matching the
+ * insertion marker shown in the sidebar (a line at the top of the target for
+ * "before", at the bottom for "after"). Returns the original array unchanged
+ * when either id is missing or they are the same. After the source is removed,
+ * a downward move shifts the target left by one, so the target index is
+ * rebased before applying the position.
  */
-export function moveInOrder(order: string[], fromId: string, toId: string): string[] {
+export function moveInOrder(
+  order: string[],
+  fromId: string,
+  toId: string,
+  position: DropPosition = 'before',
+): string[] {
   const fromIdx = order.indexOf(fromId);
   const toIdx = order.indexOf(toId);
   if (fromIdx === -1 || toIdx === -1 || fromIdx === toIdx) return order;
   const next = [...order];
   next.splice(fromIdx, 1);
-  const insertIdx = fromIdx < toIdx ? toIdx - 1 : toIdx;
+  const shiftedToIdx = fromIdx < toIdx ? toIdx - 1 : toIdx;
+  const insertIdx = position === 'before' ? shiftedToIdx : shiftedToIdx + 1;
   next.splice(insertIdx, 0, fromId);
   return next;
 }
diff --git a/apps/kimi-web/test/workspace-order.test.ts b/apps/kimi-web/test/workspace-order.test.ts
index ed706357bb..5caf7a6e1a 100644
--- a/apps/kimi-web/test/workspace-order.test.ts
+++ b/apps/kimi-web/test/workspace-order.test.ts
@@ -64,19 +64,31 @@ describe('sortByWorkspaceOrder', () => {
 });
 
 describe('moveInOrder', () => {
-  // The drop indicator is a line at the *top* of the target ("insert before"),
-  // so the result must always place fromId immediately before toId.
+  // The drop indicator is a line at the top (before) or bottom (after) of the
+  // target, so the result must place fromId immediately next to toId.
   it('moves an item down so it lands before the target', () => {
-    expect(moveInOrder(['a', 'b', 'c', 'd'], 'a', 'c')).toEqual(['b', 'a', 'c', 'd']);
+    expect(moveInOrder(['a', 'b', 'c', 'd'], 'a', 'c', 'before')).toEqual(['b', 'a', 'c', 'd']);
   });
 
   it('moves an item up so it lands before the target', () => {
-    expect(moveInOrder(['a', 'b', 'c', 'd'], 'd', 'b')).toEqual(['a', 'd', 'b', 'c']);
+    expect(moveInOrder(['a', 'b', 'c', 'd'], 'd', 'b', 'before')).toEqual(['a', 'd', 'b', 'c']);
   });
 
-  it('is a no-op when dropping on the adjacent item in the indicator direction', () => {
-    // "before b" keeps a above b; to move a below b you drop onto c instead.
-    expect(moveInOrder(['a', 'b', 'c'], 'a', 'b')).toEqual(['a', 'b', 'c']);
+  it('inserts after the target when position is "after"', () => {
+    expect(moveInOrder(['a', 'b', 'c', 'd'], 'a', 'c', 'after')).toEqual(['b', 'c', 'a', 'd']);
+  });
+
+  it('can move an item to the very bottom by dropping after the last item', () => {
+    expect(moveInOrder(['A', 'B', 'C'], 'A', 'C', 'after')).toEqual(['B', 'C', 'A']);
+  });
+
+  it('swaps with the adjacent item when dropping after it', () => {
+    expect(moveInOrder(['a', 'b', 'c'], 'a', 'b', 'after')).toEqual(['b', 'a', 'c']);
+  });
+
+  it('is a no-op when dropping before the adjacent item in the indicator direction', () => {
+    // "before b" keeps a above b; to move a below b you drop after b instead.
+    expect(moveInOrder(['a', 'b', 'c'], 'a', 'b', 'before')).toEqual(['a', 'b', 'c']);
   });
 
   it('is a no-op when from === to', () => {

From 85ae77cc0375a20c2acaaf1bed0394763c19446a Mon Sep 17 00:00:00 2001
From: qer <wbxl2000@outlook.com>
Date: Wed, 24 Jun 2026 11:46:01 +0800
Subject: [PATCH 6/7] fix(web): use reordered workspaces for active fallback

---
 apps/kimi-web/src/composables/useKimiWebClient.ts | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/apps/kimi-web/src/composables/useKimiWebClient.ts b/apps/kimi-web/src/composables/useKimiWebClient.ts
index 224970d4a8..bc8a71033f 100644
--- a/apps/kimi-web/src/composables/useKimiWebClient.ts
+++ b/apps/kimi-web/src/composables/useKimiWebClient.ts
@@ -1739,7 +1739,9 @@ const workspacesView = computed<WorkspaceView[]>(() => {
 /** The active workspace id, falling back to the first available workspace. */
 const activeWorkspaceId = computed<string | null>(() => {
   const id = rawState.activeWorkspaceId;
-  const list = mergedWorkspaces.value;
+  // Use the reordered list (not the raw daemon order) so the default/fallback
+  // workspace matches the first group the user actually sees in the sidebar.
+  const list = workspacesView.value;
   if (id && list.some((w) => w.id === id)) return id;
   return list[0]?.id ?? null;
 });

From b74c3f32677521ad7c14c6df6ec8a51c795de3de Mon Sep 17 00:00:00 2001
From: qer <wbxl2000@outlook.com>
Date: Wed, 24 Jun 2026 11:55:03 +0800
Subject: [PATCH 7/7] fix(web): honor drag order for next-workspace fallback on
 removal

---
 .../src/composables/client/useWorkspaceState.ts   | 15 ++++++++++++---
 apps/kimi-web/src/composables/useKimiWebClient.ts |  1 +
 apps/kimi-web/test/workspace-state.test.ts        |  1 +
 3 files changed, 14 insertions(+), 3 deletions(-)

diff --git a/apps/kimi-web/src/composables/client/useWorkspaceState.ts b/apps/kimi-web/src/composables/client/useWorkspaceState.ts
index 80fbd96ec9..b871041959 100644
--- a/apps/kimi-web/src/composables/client/useWorkspaceState.ts
+++ b/apps/kimi-web/src/composables/client/useWorkspaceState.ts
@@ -25,7 +25,13 @@ import { safeRemove, STORAGE_KEYS } from '../../lib/storage';
 import { parseDiff } from '../../lib/parseDiff';
 import { readSessionIdFromLocation, sessionUrl } from '../../lib/sessionRoute';
 import type { SessionUrlMode } from '../../lib/sessionRoute';
-import type { ActivityState, ConversationStatus, DiffViewLine, PermissionMode } from '../../types';
+import type {
+  ActivityState,
+  ConversationStatus,
+  DiffViewLine,
+  PermissionMode,
+  WorkspaceView,
+} from '../../types';
 import type { ExtendedState, PromptAttachment } from '../useKimiWebClient';
 import type { UseModelProviderState } from './useModelProviderState';
 import type { UseSideChat } from './useSideChat';
@@ -79,6 +85,8 @@ export interface UseWorkspaceStateDeps {
   refreshSessionStatus: (sessionId: string) => Promise<void>;
   persistSessionProfile: (patch: PersistSessionProfilePatch) => void;
   mergedWorkspaces: ComputedRef<AppWorkspace[]>;
+  /** Sidebar-facing workspaces in the user's (dragged) display order. */
+  workspacesView: ComputedRef<WorkspaceView[]>;
   status: ComputedRef<ConversationStatus>;
   workspaceIdForSession: (s: { workspaceId?: string; cwd: string }) => string;
   savePermissionToStorage: (mode: PermissionMode) => void;
@@ -121,6 +129,7 @@ export function useWorkspaceState(rawState: ExtendedState, deps: UseWorkspaceSta
     refreshSessionStatus,
     persistSessionProfile,
     mergedWorkspaces,
+    workspacesView,
     status,
     workspaceIdForSession,
     savePermissionToStorage,
@@ -446,7 +455,7 @@ export function useWorkspaceState(rawState: ExtendedState, deps: UseWorkspaceSta
     const removingActiveWorkspace =
       rawState.activeWorkspaceId === event.workspaceId || rawState.activeWorkspaceId === root;
     if (removingActiveWorkspace) {
-      const nextWorkspace = mergedWorkspaces.value[0]?.id ?? null;
+      const nextWorkspace = workspacesView.value[0]?.id ?? null;
       rawState.activeWorkspaceId = nextWorkspace;
       if (nextWorkspace) saveActiveWorkspaceToStorage(nextWorkspace);
       else {
@@ -1309,7 +1318,7 @@ export function useWorkspaceState(rawState: ExtendedState, deps: UseWorkspaceSta
     }
     rawState.workspaces = rawState.workspaces.filter((w) => w.id !== id && w.root !== root);
     if (removingActiveWorkspace || activeSessionInRemovedWorkspace) {
-      const nextWorkspace = mergedWorkspaces.value[0]?.id ?? null;
+      const nextWorkspace = workspacesView.value[0]?.id ?? null;
       rawState.activeWorkspaceId = nextWorkspace;
       if (nextWorkspace) saveActiveWorkspaceToStorage(nextWorkspace);
       else {
diff --git a/apps/kimi-web/src/composables/useKimiWebClient.ts b/apps/kimi-web/src/composables/useKimiWebClient.ts
index bc8a71033f..b9e9c35e2b 100644
--- a/apps/kimi-web/src/composables/useKimiWebClient.ts
+++ b/apps/kimi-web/src/composables/useKimiWebClient.ts
@@ -1924,6 +1924,7 @@ const workspaceState = useWorkspaceState(rawState, {
   refreshSessionStatus,
   persistSessionProfile,
   mergedWorkspaces,
+  workspacesView,
   status,
   workspaceIdForSession,
   savePermissionToStorage,
diff --git a/apps/kimi-web/test/workspace-state.test.ts b/apps/kimi-web/test/workspace-state.test.ts
index b5b7a8466f..533b138c91 100644
--- a/apps/kimi-web/test/workspace-state.test.ts
+++ b/apps/kimi-web/test/workspace-state.test.ts
@@ -104,6 +104,7 @@ function createDeps(): UseWorkspaceStateDeps {
     refreshSessionStatus: vi.fn(),
     persistSessionProfile: vi.fn(),
     mergedWorkspaces: computed(() => []),
+    workspacesView: computed(() => []),
     status: computed(() => ({})),
     workspaceIdForSession: vi.fn(),
     savePermissionToStorage: vi.fn(),