dsh-better-workspace 0.35.1 → 0.36.8

package/README.md

@@ -69,7 +69,7 @@
 ### 其余亮点
 
 - **文件夹式收起**:点工作区行 = 收起/展开该工作区的全部会话(收起后行上保留会话数角标;角标 v0.34.0 起默认隐藏、对齐官方,设置卡「显示会话数」可开);会话分组同样可收起;搜索时自动全部展开。
-- **拖拽还原原版能力**:工作区行可拖拽——拖到另一工作区行上/下半即调整顺序(写回宿主 registry 序),拖到分组行则移动进该分组(改写名称前缀);会话行可拖拽——同组内拖到另一会话上/下即调整顺序,拖到**别组的会话行**会把名字前缀改写到那个组(拖到根层的行 = 移出分组),拖到会话子分组行即移动进该分组,拖到**自己的工作区行**或**树里任何组外的地方**(含空白区域)同样移出分组 —— 拖拽期间工作区行整行高亮、树底部有一条淡虚线提示这个出口;带分组前缀的会话行右键还多一项「移出分组」。显示顺序 = 宿主手动序,拖拽结果立即生效。**磁盘层是文件系统事实,不随拖拽改变**:跨磁盘层的放置只重组名称分组(工作区落回自身磁盘层的末尾),同层放置才走锚点序。拖拽工作区期间,单链合并显示的行(如 工作/A)临时展开回文件夹树——路径里的每一级都是可投放的分组行,松手后自动合并回去。
+- **拖拽还原原版能力**:工作区行可拖拽——拖到另一工作区行上/下半即调整顺序(写回宿主 registry 序),拖到分组行中带则移动进该分组(改写名称前缀);**工作区分组行同样可拖拽(v0.36.0 起,三带悬停)**——拖到分组行时行分三个落区:上下 **30% 边带**=与该组**排序**(拖完立即重排、刷新后保留),**中带**=整组移入(组成员逐个改写名称前缀,与「重命名分组」同一语义;拖到自身/自己的子孙组上会被拒绝);**组行与工作区行同处一条混合序列(v0.36.5 起)**:一个层级里的行顺序只有一份(组行与裸工作区行交错),工作区可以拖到分组行的边带插到该组前面/后面,分组也可以拖到工作区行前面/后面——不再有「组永远排在裸工作区之前」的限制;拖到**另一层**的边带是**放置**(v0.36.6):工作区离开原组(或进入目标层)并插到落点,「插到第一个」画哪落哪(跨磁盘层不放行——磁盘层是文件系统事实);**拖入黑框统一(v0.36.7)**:工作区行拖到分组行中带 = 改名前缀进组(黑框反馈);组行拖到**它所属的磁盘层工作区行 / 直接父级分组行**中带 = 整组「放入」该容器、排到该层末尾(标题与磁盘位置都不动,同一套黑框视觉)——排序走边带、放入走中带,两类操作视觉上彻底分开;**撑开让位(v0.36.4)**:进入排序边带立刻把目标行撑开一行(工作区行与分组行同一套视觉),判定按**行未撑开时的原始位置**算——指针停在槽空出的新区里保持当前方向不闪烁;槽已打开的行只按原始中线二选一(上半=插在前,下半=插在后,**不会翻成「移入」**),三带里的中带 INTO 只在首次进入时决定,随时可改主意;会话行可拖拽——同组内拖到另一会话上/下即调整顺序,拖到**别组的会话行**会把名字前缀改写到那个组(拖到根层的行 = 移出分组),拖到会话子分组行即移动进该分组,拖到**自己的工作区行**或**树里任何组外的地方**(含空白区域)同样移出分组 —— 拖拽期间工作区行整行高亮、树底部有一条淡虚线提示这个出口;带分组前缀的会话行右键还多一项「移出分组」。显示顺序 = 宿主手动序(分组行 = 父容器下的持久化组序),拖拽结果立即生效。**磁盘层是文件系统事实,不随拖拽改变**:跨磁盘层不放行(边带不接管光标、不画落点线),同磁盘层内按落点锚定。拖拽期间树形保持不变(v0.36.4):单链合并行不再临时展开、归组成功也不自动展开目标组——指针下的行不会突然换人,展开状态只在点击时改变。
 - **不丢原生能力**:会话行(打开/重命名/分叉/归档;**双击标题**重命名,v0.34.0 起;**右键是唯一菜单入口**——行内「⋯」已退役,悬停只留快捷钮,工作区行同样只留新会话钮,v0.35.1 起)、**官方行样式逐项对齐**(v0.34.0 起:恒定 16px 状态槽——运行转圈不再挤动标题、悬停 800ms 弹官方 HoverCard(标题/路径/时间/状态,可复制)、超长标题悬停匀速滚动、活动链工作区文件夹图标着蓝、拖放指示用官方斜纹图案)、每工作区「新会话」(点 + 总是先展开该工作区,让新会话立刻可见)、当前会话高亮、官方状态灯(蓝色运行环 / 琥珀待交互 / 绿色完成提醒)、**状态呼吸灯**(折叠藏起的状态灯向外冒泡:工作区/分组行图标按状态色呼吸发光——琥珀待交互/绿完成,自定义过发光的标题一起呼吸;运行中只在会话行本层蓝色呼吸,不外渗;可在设置关闭)、**活跃定时任务角标**(有活动 Schedule 的会话显示闹钟图标;v0.23.0 起直接渲染官方 `sidebar.session.row.leading` 座位的占用者,与官方行同源)、未分组会话兜底、界面文案跟随 DSH 的语言设置(内置 21 种语言,含简繁中文)。
 - **新增项自动配色 + 图标(v0.25.0,默认关闭)**:设置卡里一个开关,打开后**新创建的会话**自动分到一个内置色、**新工作区**再额外分到一个图标,懒得逐个设置的人直接开箱即用。颜色来自**定死的 13 个槽位**,每个槽位配**两色**——浅色主题用深色系、深色主题用亮色系——按「洗牌袋 + 近期回避窗口」抽取:一轮之内绝不重复,跨轮也不会立刻撞上刚出过的 3 个,连续新建几项肉眼可辨。**可读性是真达标**:每个色在**对应主题**背景下的对比度都 **≥4.5**,即 WCAG **正文级 AA**(对比度是脚本真算的,测试逐色断言;浅色主题按比纯白更暗的悬停面、深色主题按最亮的面这种保守取值)。行里存的是**槽位 id(`auto:3`)而不是色值**,所以**切换深浅主题时颜色自动换成同色系的另一套**,既不用重新设置,也不会失配。**只影响打开开关之后新建的项**:你手动设置过外观的行(存的是 hex)永不被覆盖,关闭开关也不回收已分配的样式,同一项不会被二次随机。图标从既有图标候选集里取、按宿主实际导出过滤;**图标只给工作区**——会话行的那个位置是官方状态灯与日程角标,没有图标位。
 - **官方新语义与快捷键都接上(v0.23.0,对齐 dsh 0.1.7-rc.2)**:① 归档筛选是官方新版三态直选(**隐藏已归档** / **全部对话(显示已归档)** / **仅显示已归档**);选「仅显示已归档」时**没有归档会话的工作区整行隐藏**,空列表显示「暂无已归档会话」+「查看其他会话」一键回退;② 官方快捷键 **⌥⌘K 搜索 / ⌥⌘O 添加工作区 / ⌥⌘N 新会话**(桌面端为 ⌘K / ⌘O / ⌘N)在本插件的自绘侧栏里**真的生效**——搜索键打开并聚焦本插件的搜索框、添加键走同一个官方目录流(原生宿主弹系统选择器,browse 宿主弹应用内入口提示),按钮文案还会带上宿主当前的键位;③ 首次使用的工作区显示为本地化的「默认工作区」,不再露出磁盘目录名。

package/dsh.plugin.json

@@ -1,6 +1,6 @@
 {
   "id": "dsh-external/dsh-better-workspace",
-  "version": "0.35.1",
+  "version": "0.36.8",
   "main": "./src/index.js",
   "description": "侧边栏工作区树:按官方磁盘目录嵌套(官方 workspace-tree 语义),可选按名称中的 / 分组(默认关闭,设置里开启);新会话页的工作区选择器同树。Workspace tree for the DSH sidebar workspace list, nested by official disk folders with optional \"/\"-name grouping; the New Session workspace picker shows the same tree.",
   "engines": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-better-workspace",
-  "version": "0.35.1",
+  "version": "0.36.8",
   "description": "侧边栏工作区树:按官方磁盘目录嵌套(官方 workspace-tree 语义),可选按名称中的 / 分组(默认关闭,设置里开启);新会话页的工作区选择器同树(同一份视图选项即时同步);添加工作区走官方目录流。Workspace tree for the DSH sidebar: disk-path nesting (official workspace-tree semantics), with optional \"/\"-name grouping (off by default), and the same tree in the New Session workspace picker; add-workspace rides the official directory flow.",
   "type": "module",
   "repository": {

package/src/client.js

@@ -4041,6 +4041,19 @@ window.__ModuleLoader__.load({
       return [...blanks, ...pins, ...rest]
     }
 
+    // Global and per-workspace recency share the same ordering contract:
+    // current blank first, then pinned Sessions, then ordinary Sessions.
+    // In flat mode this must run AFTER collecting every workspace and Ungrouped.
+    const orderSessionsByRecency = (rows, currentId) => {
+      const sorted = rows.slice().sort((a, b) => (b.updatedAt - a.updatedAt) || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))
+      const blank = currentId !== undefined && sorted.find((row) => row.id === currentId && row.blank)
+      if (blank) {
+        const at = sorted.indexOf(blank)
+        if (at > 0) { sorted.splice(at, 1); sorted.unshift(blank) }
+      }
+      return pinnedPartition(sorted)
+    }
+
     const sessionTitleOf = (summary, t, rememberedTitle) => {
       if (!summary) return ''
       if (summary.blank) return t('session.new')
@@ -4485,7 +4498,7 @@ window.__ModuleLoader__.load({
       return out
     }
 
-    function buildTree(items, groupMode, explicitWs) {
+    function buildTree(items, groupMode, explicitWs, folderOrder) {
       const list = items || []
       // Issue #7: 'disk' nests by disk only, 'disk-slash' adds the name
       // layer on top (the historical workspaceSlash-on shape), 'slash' runs
@@ -4564,11 +4577,76 @@ window.__ModuleLoader__.load({
           }
           ensure(segs.slice(0, -1)).workspaces.push(entry)
         }
-        const sortRec = (node) => {
-          node.folders.sort((a, b) => a.name.localeCompare(b.name, 'zh'))
-          for (const child of node.folders) sortRec(child)
+        // Group order: the NAME sort is only the seed. v0.36.4 keeps a
+        // persisted per-parent name list (folderOrder) so a dragged group
+        // keeps its place — before this the drop committed the registry
+        // order but the renderer re-sorted by name, which is why dragging a
+        // group row looked like a no-op. Names absent from the stored list
+        // (a just-created group) sort after the known ones by locale.
+        // v0.36.5: the SAME list may also carry "w:<workspaceId>" tokens,
+        // which interleave a BARE workspace row with the group rows of its
+        // level. Before this a level always rendered every folder first and
+        // every workspace after, so a top-level workspace could never be
+        // dropped "as the first row" — the probe showed the commit landing
+        // but the row staying at the bottom ("插到第一个永远失败").
+        // Tokens absent from the list (a new member, a workspace that just
+        // moved in) append in the default order: groups first, then
+        // workspaces in registry order.
+        const orderOf = (parentKey) => {
+          if (!folderOrder || typeof folderOrder !== 'object') return null
+          const list = folderOrder[parentKey]
+          return Array.isArray(list) ? list : null
+        }
+        const sortRec = (node, parentKey) => {
+          const order = orderOf(parentKey)
+          const names = order
+            ? order.filter((token) => typeof token === 'string' && token !== '' && !token.startsWith('w:'))
+            : null
+          if (names && names.length) {
+            const rank = new Map()
+            for (let i = 0; i < names.length; i += 1) rank.set(names[i], i)
+            node.folders.sort((a, b) => {
+              const ra = rank.has(a.name) ? rank.get(a.name) : names.length
+              const rb = rank.has(b.name) ? rank.get(b.name) : names.length
+              if (ra !== rb) return ra - rb
+              return a.name.localeCompare(b.name, 'zh')
+            })
+          } else {
+            node.folders.sort((a, b) => a.name.localeCompare(b.name, 'zh'))
+          }
+          // Level identity every workspace row carries into its drag payload:
+          // the mixed reorder is siblings-only, so the drop gate compares it
+          // with parentKeyOf(target group idPath).
+          for (const w of node.workspaces) w.levelKey = parentKey
+          // Mixed display sequence of THIS level: the persisted order first
+          // (groups and bare workspaces interleaved), then whatever the list
+          // does not mention, groups before workspaces.
+          const folderByName = new Map(node.folders.map((child) => [child.name, child]))
+          const wsById = new Map(node.workspaces.map((w) => [w.workspaceId, w]))
+          const seq = []
+          const seenFolders = new Set()
+          const seenWorkspaces = new Set()
+          for (const token of order || []) {
+            if (typeof token !== 'string' || token === '') continue
+            if (token.startsWith('w:')) {
+              const id = token.slice(2)
+              const entry = wsById.get(id)
+              if (!entry || seenWorkspaces.has(id)) continue
+              seq.push({ kind: 'ws', entry })
+              seenWorkspaces.add(id)
+            } else {
+              const child = folderByName.get(token)
+              if (!child || seenFolders.has(token)) continue
+              seq.push({ kind: 'folder', node: child })
+              seenFolders.add(token)
+            }
+          }
+          for (const child of node.folders) if (!seenFolders.has(child.name)) seq.push({ kind: 'folder', node: child })
+          for (const w of node.workspaces) if (!seenWorkspaces.has(w.workspaceId)) seq.push({ kind: 'ws', entry: w })
+          node.seq = seq
+          for (const child of node.folders) sortRec(child, child.idPath)
         }
-        sortRec(root)
+        sortRec(root, idPrefix)
         return root
       }
       const topLevel = list.filter((w) => diskParentOf.get(w.workspaceId) === undefined)
@@ -4673,7 +4751,7 @@ window.__ModuleLoader__.load({
       '.bw-rows-exits{position:fixed;inset:0;contain:strict;overflow:clip;pointer-events:none}',
       '.bw-tree[data-bw-density="compact"]{--bw-row-h:28px;--bw-session-h:26px}',
       '.bw-tree[data-bw-density="roomy"]{--bw-row-h:40px;--bw-session-h:38px}',
-      '.bw-row{display:flex;align-items:center;gap:6px;height:var(--bw-row-h,34px);padding:0 8px;padding-inline-start:calc(8px + var(--bw-indent,0px));border-radius:var(--dsw-radius-md,8px);cursor:pointer;user-select:none;font-size:14px;line-height:20px;color:var(--dsw-alias-label-primary,#e6e6e6);position:relative}',
+      '.bw-row{display:flex;align-items:center;gap:6px;height:var(--bw-row-h,34px);padding:0 8px;padding-inline-start:calc(8px + var(--bw-indent,0px));border-radius:var(--dsw-radius-md,8px);cursor:pointer;user-select:none;font-size:14px;line-height:20px;color:var(--dsw-alias-label-primary,#e6e6e6);position:relative;transition:height .15s ease-out,padding .15s ease-out}',
       '.bw-drop-before::before{content:"";position:absolute;z-index:1;left:0;right:4px;top:-7px;height:12px;pointer-events:none;background:linear-gradient(55deg,transparent 0,var(--dsw-alias-state-business-primary,#5b8def) 50%,transparent 100%) 0 0/5px 7px no-repeat,linear-gradient(125deg,transparent 0,var(--dsw-alias-state-business-primary,#5b8def) 50%,transparent 100%) 0 5px/5px 7px no-repeat,linear-gradient(var(--dsw-alias-state-business-primary,#5b8def),var(--dsw-alias-state-business-primary,#5b8def)) 4px 5px/calc(100% - 4px) 2px no-repeat}',
       '.bw-drop-after::after{content:"";position:absolute;z-index:1;left:0;right:4px;bottom:-7px;height:12px;pointer-events:none;background:linear-gradient(55deg,transparent 0,var(--dsw-alias-state-business-primary,#5b8def) 50%,transparent 100%) 0 0/5px 7px no-repeat,linear-gradient(125deg,transparent 0,var(--dsw-alias-state-business-primary,#5b8def) 50%,transparent 100%) 0 5px/5px 7px no-repeat,linear-gradient(var(--dsw-alias-state-business-primary,#5b8def),var(--dsw-alias-state-business-primary,#5b8def)) 4px 5px/calc(100% - 4px) 2px no-repeat}',
       '.bw-drop-into{outline:1.5px dashed var(--dsw-alias-brand-primary,#5b8def);outline-offset:-1.5px}',
@@ -4681,6 +4759,15 @@ window.__ModuleLoader__.load({
       // rim + a tinted wash so "this drop joins a group" reads stronger than
       // the reorder dashes above.
       '.bw-drop-into-strong{outline:2px solid var(--dsw-alias-brand-primary,#5b8def);outline-offset:-2px;background:color-mix(in srgb, var(--dsw-alias-brand-primary,#5b8def) 16%, transparent)}',
+      // v0.36.1 edge-band reorder slot on group rows: the row SPLITS OPEN to
+      // twice its height so "a row will land here" is visible without
+      // staring for the thin official line. Both the height and the content
+      // slide are transitioned (padding, which CAN animate — align-items
+      // cannot, it teleports the content and feels janky), so the row
+      // opens/closes like a drawer, not a flash. The gap fills with a faint
+      // brand wash; the middle half of the row (drop-into) never opens.
+      '.bw-slot-above{padding-top:var(--bw-row-h,34px);background:linear-gradient(to bottom, color-mix(in srgb, var(--dsw-alias-brand-primary,#5b8def) 10%, transparent) 0, transparent calc(var(--bw-row-h,34px)))}',
+      '.bw-slot-below{padding-bottom:var(--bw-row-h,34px);background:linear-gradient(to top, color-mix(in srgb, var(--dsw-alias-brand-primary,#5b8def) 10%, transparent) 0, transparent calc(var(--bw-row-h,34px)))}',
       // Session drag whose source sits in a group: a quiet dashed line at the
       // bottom of the tree says "anywhere outside a group = out of it". Kept
       // faint on purpose — the row outlines are the loud feedback.
@@ -4978,7 +5065,7 @@ window.__ModuleLoader__.load({
       // LITERAL, not a spread of DEFAULT_APPEARANCE: init() is eval-harness
       // friendly (no cross-section reference), and the smoke suite asserts the
       // two stay in lockstep field by field.
-      init: () => ({ expanded: {}, sessionsExpanded: {}, sessionGroups: {}, sessionOrder: {}, prefs: { compactChains: true, sessionLimit: 0, appearance: { color: '', glow: 0, weight: 0, shadow: false, stroke: false, strokeWidth: 1, strokeColor: '#808080' } }, styling: {}, groupBy: 'workspace-tree', orderBy: 'manual', archivedFilter: 'default', workspaceGroupMode: 'disk', sessionTitleSlash: true, workspaceTitleSlash: false, ungroupedOpen: true, folders: { ws: {}, sess: {} } }),
+      init: () => ({ expanded: {}, sessionsExpanded: {}, sessionGroups: {}, sessionOrder: {}, prefs: { compactChains: true, sessionLimit: 0, appearance: { color: '', glow: 0, weight: 0, shadow: false, stroke: false, strokeWidth: 1, strokeColor: '#808080' } }, styling: {}, groupBy: 'workspace-tree', orderBy: 'manual', archivedFilter: 'default', workspaceGroupMode: 'disk', sessionTitleSlash: true, workspaceTitleSlash: false, ungroupedOpen: true, folders: { ws: {}, sess: {} }, folderOrder: {} }),
       // NOTE: hydration REPLACES the state with the persisted whole value —
       // init defaults never merge. Every action must tolerate a missing key
       // (states persisted by older plugin versions lack sessionGroups), and
@@ -5038,6 +5125,19 @@ window.__ModuleLoader__.load({
         },
         // v0.21.0 collapsible Ungrouped block (issue #6).
         setUngroupedOpen: (d, value) => { d.ungroupedOpen = value },
+        // Persisted GROUP order (v0.36.4), one name list per PARENT identity
+        // (a level's idPrefix for the root level, else the parent group's
+        // idPath). Only sibling reorders are written here — a cross-parent
+        // move is a rename, not an order change, and stays refused in the
+        // drop handler. An empty list deletes the entry so the name sort
+        // comes back for that parent.
+        setFolderOrder: (d, parentKey, names) => {
+          if (!d.folderOrder || typeof d.folderOrder !== 'object') d.folderOrder = {}
+          const key = String(parentKey == null ? '' : parentKey)
+          const clean = (Array.isArray(names) ? names : []).map((n) => String(n)).filter((n) => n !== '')
+          if (clean.length === 0) delete d.folderOrder[key]
+          else d.folderOrder[key] = clean
+        },
         // Explicit (possibly EMPTY) groups, v0.17.0. A group has always been a
         // projection of "/" in member titles, so a group with no members simply
         // did not exist and "create a group" had nothing to write. These two
@@ -5977,7 +6077,7 @@ window.__ModuleLoader__.load({
       }
     }
 
-    function FolderRow({ node, depth, expanded, onToggle, onContextMenu, dropInto, dragEvents, custStyle, iconMode, pulse, active, dataRowKey, t }) {
+    function FolderRow({ node, depth, expanded, onToggle, onContextMenu, dropInto, dropSlot, dragEvents, custStyle, iconMode, pulse, active, dataRowKey, t }) {
       const total = countWorkspaces(node)
       const iconEl = iconOf(iconMode, expanded)
       // Hidden status dots breathe on the icon; with the icon hidden (mode
@@ -5986,7 +6086,14 @@ window.__ModuleLoader__.load({
         ? E(PulseGlow, { state: pulse }, iconEl || (typeof ui.StateDot === 'function' ? E(ui.StateDot, { state: pulse, size: 10 }) : null))
         : iconEl
       return E('div', {
-        className: cls('bw-row', 'bw-container-row', dropInto && 'bw-drop-into', dropInto && 'bw-drop-into-strong'),
+        // v0.36.4: an edge band opens the EMPTY reorder slot immediately —
+        // the row grows by one row height on the dropped side, so the
+        // insertion point is a real gap the block slides into (the user
+        // report: a thin line is not "撑开让位").
+        className: cls('bw-row', 'bw-container-row',
+          dropSlot === 'before' && 'bw-slot-above',
+          dropSlot === 'after' && 'bw-slot-below',
+          dropInto && 'bw-drop-into', dropInto && 'bw-drop-into-strong'),
         'data-row-key': dataRowKey,
         style: { '--bw-indent': (depth * 12) + 'px', ...(custStyle || {}), ...(pulse ? { '--bw-pulse-color': PULSE_COLORS[pulse] || PULSE_COLORS.ongoing } : null) },
         onClick: onToggle,
@@ -6012,7 +6119,11 @@ window.__ModuleLoader__.load({
         ? E(PulseGlow, { state: pulse }, iconEl || (typeof ui.StateDot === 'function' ? E(ui.StateDot, { state: pulse, size: 10 }) : null))
         : iconEl
       let row = E('div', {
-        className: cls('bw-row', 'bw-container-row', currentInside && 'bw-row-current', menuOpen && 'menu-open', dropHalf === 'before' && 'bw-drop-before', dropHalf === 'after' && 'bw-drop-after', dropInto && 'bw-drop-into', dropInto && 'bw-drop-into-strong'),
+        // v0.36.4: workspace rows open the same empty reorder slot a group
+        // row does (the official 12px insert line alone read as "没撑开").
+        // The half split is judged in LOGICAL height, so the grown row
+        // cannot flip its own band under the pointer.
+        className: cls('bw-row', 'bw-container-row', currentInside && 'bw-row-current', menuOpen && 'menu-open', dropHalf === 'before' && 'bw-slot-above', dropHalf === 'after' && 'bw-slot-below', dropInto && 'bw-drop-into', dropInto && 'bw-drop-into-strong'),
         'data-row-key': dataRowKey,
         style: { '--bw-indent': (depth * 12) + 'px', ...(custStyle || {}), ...(pulse ? { '--bw-pulse-color': PULSE_COLORS[pulse] || PULSE_COLORS.ongoing } : null) },
         onClick: onToggle,
@@ -7287,6 +7398,12 @@ window.__ModuleLoader__.load({
       const wsFolders = typeof useStore === 'function'
         ? useStore(state => (state && state.folders && state.folders.ws) || EMPTY_FOLDERS)
         : EMPTY_FOLDERS
+      // Same persisted group order the sidebar uses (v0.36.4) — a chooser that
+      // listed groups alphabetically while the tree showed the dragged order
+      // would contradict the surface it selects for.
+      const pickerFolderOrder = typeof useStore === 'function'
+        ? useStore(state => (state && state.folderOrder) || EMPTY_FOLDERS)
+        : EMPTY_FOLDERS
       // Occupancy is the only reactive fact here: the ledger read re-runs on
       // every render, so the count just forces the re-render when the shipped
       // occupant loads or unloads (its identity is stable while occupied).
@@ -7308,10 +7425,10 @@ window.__ModuleLoader__.load({
       // Same construction the sidebar runs (buildTree + optional chain
       // compression), so both surfaces answer the same view options.
       const tree = React.useMemo(() => {
-        const built = buildTree(items, groupMode, wsFolders)
+        const built = buildTree(items, groupMode, wsFolders, pickerFolderOrder)
         if (!compactChains) return built
         return { ...built, folders: built.folders.map((f) => materializeChain(compressTree(f))), workspaces: built.workspaces }
-      }, [items, groupMode, wsFolders, compactChains])
+      }, [items, groupMode, wsFolders, pickerFolderOrder, compactChains])
 
       const rows = React.useMemo(() => {
         const out = []
@@ -7542,6 +7659,10 @@ window.__ModuleLoader__.load({
       const foldersMap = useStore ? (useStore(s => s.folders) || {}) : {}
       const wsFolders = foldersMap && typeof foldersMap.ws === 'object' && foldersMap.ws !== null ? foldersMap.ws : EMPTY_FOLDERS
       const sessFolders = foldersMap && typeof foldersMap.sess === 'object' && foldersMap.sess !== null ? foldersMap.sess : EMPTY_FOLDERS
+      // Persisted group order (v0.36.4): { [parentKey]: name[] }. Absent on
+      // every snapshot written before it existed — the seed name sort then
+      // stands, so old states render unchanged.
+      const folderOrderMap = useStore ? (useStore(s => s.folderOrder) || EMPTY_FOLDERS) : EMPTY_FOLDERS
       // View options (v0.13). Selector reads take fallbacks: hydration
       // replaces the whole persisted value, so states written by older
       // plugin versions lack these keys (hard store discipline).
@@ -7886,13 +8007,22 @@ window.__ModuleLoader__.load({
       const [copyNotice, setCopyNotice] = React.useState(null) // { seq, ok } copy-session-id notice
       const [customize, setCustomize] = React.useState(null) // { kind, entryKey, name }
       const [errorText, setErrorText] = React.useState(null)
-      const [drag, setDrag] = React.useState(null) // { kind: 'workspace'|'session', source, over } | null
+      const [drag, setDrag] = React.useState(null) // { kind: 'workspace'|'session'|'folder', source, over } | null
       // Workspace drags arm their state one frame LATE (see workspaceDragEvents):
       // arming synchronously re-renders during the dragstart dispatch, the chain
       // expansion inserts rows above the drag source, the cursor leaves the
       // source element, and Chromium cancels the whole gesture. dragEnd clears
       // the timer so a same-tick cancel never leaves a ghost drag behind.
       const wsDragArmTimer = React.useRef(null)
+      // (v0.36.3) The 600ms group-hover auto-expand is retired: it kept
+      // opening groups under a passing cursor ("变下级会被撑开"). The
+      // deterministic reveal now lives in commitFolderMoveInto — the target
+      // group opens when the members actually land.
+      // (v0.36.4) The hover-intent arming is retired. It made the reorder
+      // slot appear only after a ~200ms rest on the band, so a normal drag
+      // across a group row showed the thin insert line and never the empty
+      // slot — the user report "还是一条蓝线,没拨开让我插入". The edge bands
+      // are 30% wide and geometrically judged, so they can answer at once.
       // Quote-on-land eligibility sets (mount-scoped):
       // - blankSeen: ids observed BLANK in any snapshot. A blank row is a
       //   freshly created New Session, so ONLY these may ever receive an
@@ -8049,7 +8179,12 @@ window.__ModuleLoader__.load({
       const normalizedQuery = query.trim().toLowerCase()
       const now = Date.now()
 
-      const fail = (text) => { setFlowOpen(false); setDialog(null); setErrorText(String(text || 'unknown error')) }
+      // v0.36.4: no setFlowOpen here. flowOpen belongs to the PICKER component
+      // (WorkspacePicker), not to this browser: referencing it from here threw
+      // 'ReferenceError: setFlowOpen is not defined' on every failure path —
+      // including the .catch(fail) of a group move-into, which then silently
+      // aborted the rename ('变下级没反应').
+      const fail = (text) => { setDialog(null); setErrorText(String(text || 'unknown error')) }
 
       const styleEntry = (key) => stylingMap[key] || null
       // Effective appearance = the settings card's default, overridden field by
@@ -8078,7 +8213,11 @@ window.__ModuleLoader__.load({
         return Object.keys(style).length > 0 ? style : null
       }
       const keyOf = (kind, payload) => {
-        if (kind === 'folder') return 'folder:' + payload.path
+        // Render keys folders by idPath (renderPlainFolder), which prefixes
+        // the ws id to disambiguate same-named groups across disk levels;
+        // saving by payload.path alone made sub-level group styling
+        // unreachable (name-slash group appearance never applied).
+        if (kind === 'folder') return 'folder:' + (payload.idPath || payload.path)
         if (kind === 'workspace') return 'workspace:' + payload.workspaceId
         if (kind === 'session') return 'session:' + payload.id
         if (kind === 'sgroup') return 'sgroup:' + payload.workspaceId + '|' + payload.path
@@ -8112,26 +8251,33 @@ window.__ModuleLoader__.load({
         pinnedPartitionInPlace(ungrouped)
       }
 
-      // While a workspace drag is active, single-child chains render UNCOMPRESSED:
-      // a merged "group/workspace" row hides every folder level of the chain inside
-      // its label, and those levels are exactly the drop targets for "move into
-      // this group". Suspending the merge for the drag's duration re-exposes each
-      // level as a real folder row (folder expansion defaults apply); when the
-      // drag ends, the chains merge back. Session drags keep the merged view —
-      // their drop targets live inside workspace rows, which compression merges.
-      const draggingWorkspace = drag !== null && drag.kind === 'workspace'
+      // (v0.36.4) The drag-time chain EXPANSION is retired. Suspending the
+      // merge while a workspace was dragged re-exposed every single-child
+      // chain as folder rows, so the tree visibly re-laid itself one frame
+      // after dragstart and every drop target below the source shifted —
+      // the user report "拖拽中树会乱/落点漂移". Drop targets are now
+      // answered by the stable render; nothing re-flows mid-drag.
       const tree = React.useMemo(() => {
-        const built = buildTree(items, workspaceGroupMode, wsFolders)
-        if (!compactChains || draggingWorkspace) return built
-        return { ...built, folders: built.folders.map((f) => materializeChain(compressTree(f))), workspaces: built.workspaces }
-      }, [items, compactChains, draggingWorkspace, workspaceGroupMode, wsFolders])
+        const built = buildTree(items, workspaceGroupMode, wsFolders, folderOrderMap)
+        if (!compactChains) return built
+        const folders = built.folders.map((f) => materializeChain(compressTree(f)))
+        // v0.36.5: keep the MIXED root sequence across chain compression —
+        // the compressed node stands in for the raw folder it came from, so
+        // a bare workspace stays interleaved where the user put it.
+        const byName = new Map()
+        for (let i = 0; i < built.folders.length; i += 1) byName.set(built.folders[i].name, folders[i])
+        const seq = Array.isArray(built.seq)
+          ? built.seq.map((item) => item.kind === 'folder' ? { kind: 'folder', node: byName.get(item.node.name) || item.node } : item)
+          : built.seq
+        return { ...built, folders, workspaces: built.workspaces, seq }
+      }, [items, compactChains, workspaceGroupMode, wsFolders, folderOrderMap])
       // UNCOMPRESSED tree, for the new-group dialog only. compressTree merges a
       // single-child chain into one row that stands for BOTH a group and the
       // workspace under it — fine for drawing, useless for choosing a
       // container: one half must stay unselectable and the other must be
       // selectable, and a merged row cannot be both. (It also carried no
       // `name`, which is how a lone "E" rendered blank.)
-      const rawTree = React.useMemo(() => buildTree(items, workspaceGroupMode, wsFolders), [items, workspaceGroupMode, wsFolders])
+      const rawTree = React.useMemo(() => buildTree(items, workspaceGroupMode, wsFolders, folderOrderMap), [items, workspaceGroupMode, wsFolders, folderOrderMap])
       // Disk-layer ancestry for drag semantics (same derivation as buildTree).
       const diskParentMap = React.useMemo(() => diskParentMapOf(items), [items])
 
@@ -8174,15 +8320,7 @@ window.__ModuleLoader__.load({
         // presentational: nothing is persisted, the host order is untouched,
         // and drag-to-reorder anchors are suppressed while active (an order
         // the very next render would re-sort is a lie).
-        if (orderBy === 'updated') {
-          const sorted = rows.slice().sort((a, b) => (b.updatedAt - a.updatedAt) || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))
-          const pin = currentId !== undefined && sorted.find((row) => row.id === currentId && row.blank)
-          if (pin) {
-            const at = sorted.indexOf(pin)
-            if (at > 0) { sorted.splice(at, 1); sorted.unshift(pin) }
-          }
-          return pinnedPartition(sorted)
-        }
+        if (orderBy === 'updated') return orderSessionsByRecency(rows, currentId)
         const local = typeof insertSessionBefore === 'function' ? [] : sessionOrderOf(workspace.workspaceId)
         if (local.length === 0) return pinnedPartition(rows)
         const remaining = new Map(rows.map((row) => [row.id, row]))
@@ -8634,11 +8772,72 @@ window.__ModuleLoader__.load({
         }
       }, [drag === null])
 
+      // Geometry helpers shared by both reorder targets. v0.36.4 judges in
+      // v0.36.4 geometry: an open reorder slot (bw-slot-above / -below) pads
+      // the row open by one logical row (padding, so the box grows to two
+      // rows). Judge the pointer against the row's ORIGINAL position, not the
+      // padded box: the original position is the half its content did NOT
+      // slide into — the pad above for a before-slot, the remaining content
+      // box for an after-slot. Judging there keeps a still pointer from
+      // flipping the slot the moment it opens (the reported "抽搐"), while
+      // still letting the pointer cross the original midpoint to switch
+      // direction — the padded half answers null instead of a stale band.
+      const originalBoxOf = (el) => {
+        const rect = el.getBoundingClientRect()
+        const style = getComputedStyle(el)
+        const padTop = parseFloat(style.paddingTop) || 0
+        const padBottom = parseFloat(style.paddingBottom) || 0
+        if (padTop > 0) return { top: rect.top, bottom: rect.top + padTop }
+        if (padBottom > 0) return { top: rect.top, bottom: rect.bottom - padBottom }
+        return { top: rect.top, bottom: rect.bottom }
+      }
+      // null = the pointer sits in the half the open slot vacated: the caller
+      // keeps its current drop target instead of re-deciding on geometry that
+      // only exists because of that slot.
+      // v0.36.5 MIXED LEVEL SEQUENCE. buildTree attaches a `seq` to every
+      // level (group rows and BARE workspace rows interleaved by the
+      // persisted folderOrder, whose tokens may be a group name or
+      // "w:<workspaceId>"); chain-compressed nodes carry no seq and keep the
+      // historical folders-then-workspaces order. Both the renderer and the
+      // reorder commit read the SAME sequence, so what the user sees is what
+      // the drop edits.
+      const levelSeqOf = (level) => (level && Array.isArray(level.seq))
+        ? level.seq
+        : [
+          ...(((level && level.folders) || []).map((node) => ({ kind: 'folder', node }))),
+          ...(((level && level.workspaces) || []).map((entry) => ({ kind: 'ws', entry }))),
+        ]
+      const levelTokenOf = (item) => item.kind === 'ws' ? 'w:' + item.entry.workspaceId : item.node.name
       const rowHalf = (event) => {
-        const rect = event.currentTarget.getBoundingClientRect()
-        return event.clientY < rect.top + rect.height / 2 ? 'before' : 'after'
+        const box = originalBoxOf(event.currentTarget)
+        const y = event.clientY
+        if (y < box.top || y > box.bottom) return null
+        return y < (box.top + box.bottom) / 2 ? 'before' : 'after'
+      }
+      // Three-band targeting for group rows (react-arborist style): the
+      // outer 30% of the CONTENT means "reorder against this group", the
+      // middle 40% means "drop into" — so move-into (the framed highlight)
+      // is easy to hit and reorder never swallows the pointer. v0.36.3
+      // widened the bands from a quarter: at 25% they were 8.5px on a 34px
+      // row and practically unhittable (every drop landed "into" instead
+      // of reordering beside).
+      const rowZone = (event) => {
+        const box = originalBoxOf(event.currentTarget)
+        const y = event.clientY
+        if (y < box.top || y > box.bottom) return null
+        const h = box.bottom - box.top
+        if (h < 2) return 'into'
+        const rel = (y - box.top) / h
+        if (rel < 0.3) return 'before'
+        if (rel > 0.7) return 'after'
+        return 'into'
       }
       const dragMatches = (kind) => drag !== null && drag.kind === kind
+      // A refused hover must DROP the highlight it already owns: leaving a
+      // stale {over} in place drew the previous target's INTO frame on a row
+      // that no longer accepts anything (the user reads it as "it will land
+      // here" and the drop then goes elsewhere).
+      const clearOver = (targetKind, target) => setDrag((current) => (current && current.over && current.over.kind === targetKind && current.over.target === target) ? { ...current, over: null } : current)
       const canDragWorkspace = typeof insertWorkspaceBefore === 'function'
       // Session REORDER needs the host insertSessionBefore action; dragging a
       // session onto a sub-group row (a pure rename) stays available without it.
@@ -8650,12 +8849,26 @@ window.__ModuleLoader__.load({
 
       /* --------------------- workspace drag & drop -------------------- */
 
+      // v0.36.5: a workspace row answers the SAME slot for both drag kinds —
+      // a workspace slides between workspace rows, a whole group block slides
+      // beside one (mixed reorder), so the visual is one shared mechanism.
       const wsDropHalf = (workspaceId) => {
-        if (!dragMatches('workspace')) return null
+        if (!dragMatches('workspace') && !dragMatches('folder')) return null
         const over = drag.over
         return over && over.kind === 'workspace' && over.target === workspaceId ? over.half : null
       }
-      const wsDropInto = (path) => dragMatches('workspace') && drag.over && drag.over.kind === 'folder' && drag.over.target === path
+      // Folder rows light up for a workspace drop (regroup one workspace)
+      // AND a folder drop (whole-group move) alike — the INTO band only:
+      // an edge-band reorder slot draws the official insert line instead.
+      const wsDropInto = (path) => (dragMatches('workspace') || dragMatches('folder')) && drag.over && drag.over.kind === 'folder' && drag.over.target === path && (!drag.over.zone || drag.over.zone === 'into')
+      // v0.36.4: an edge band on a group row answers IMMEDIATELY with the
+      // empty reorder slot (bw-slot-above/below) — the drop position is
+      // visible the moment the pointer enters the band, no intent wait.
+      // v0.36.5: BOTH sources open the slot on a group row. A folder source
+      // reorders the group block; a WORKSPACE source interleaves one bare
+      // workspace row beside the group — the gesture "insert as the first
+      // row" that used to be impossible because every group rendered first.
+      const wsFolderSlotOf = (folderIdPath) => ((dragMatches('folder') || dragMatches('workspace')) && drag.over && drag.over.kind === 'folder' && drag.over.target === folderIdPath && (drag.over.zone === 'before' || drag.over.zone === 'after')) ? drag.over.zone : null
       const workspaceDragEvents = (workspace) => ({
         draggable: !searching && canDragWorkspace,
         onDragStart: (event) => {
@@ -8684,7 +8897,7 @@ window.__ModuleLoader__.load({
           if (wsDragArmTimer.current !== null) clearTimeout(wsDragArmTimer.current)
           wsDragArmTimer.current = setTimeout(() => {
             wsDragArmTimer.current = null
-            setDrag({ kind: 'workspace', source: { workspaceId: workspace.workspaceId, leaf: sourceLeaf, folderPath: sourceFolder, disk: diskParentMap.get(workspace.workspaceId) }, over: null })
+            setDrag({ kind: 'workspace', source: { workspaceId: workspace.workspaceId, leaf: sourceLeaf, folderPath: sourceFolder, disk: diskParentMap.get(workspace.workspaceId), levelKey: workspace.levelKey || '' }, over: null })
           }, 0)
         },
         onDragEnd: () => {
@@ -8708,11 +8921,57 @@ window.__ModuleLoader__.load({
               : (current ? { ...current, over: { kind: 'ws-root', target: workspace.workspaceId } } : current))
             return
           }
+          // v0.36.5 MIXED REORDER: a GROUP block can slide beside a bare
+          // workspace row of the same level (the mirror gesture of a
+          // workspace sliding beside a group row). Siblings only — a group
+          // that lives in another container has no position in this level.
+          if (dragMatches('folder')) {
+            const sourceLevel = drag.source.levelKey || ''
+            if (sourceLevel !== (workspace.levelKey || '')) {
+              // v0.36.7 INTO on the OWNING disk row: a group block dropped on
+              // the workspace row that CONTAINS it answers the same framed
+              // INTO a workspace row gets on a group row ("放入这个工作区
+              // 下"). The only position that means without rewriting a path
+              // is the tail of the level it already lives in, so the drop
+              // commits moveFolderToLevelEnd. Every other cross-level target
+              // stays refused: the disk layer is a filesystem fact.
+              if (sourceLevel === (workspace.subPrefix || '')) {
+                event.preventDefault()
+                event.stopPropagation()
+                try { event.dataTransfer.dropEffect = 'move' } catch { }
+                setDrag(current => (current && current.over && current.over.kind === 'ws-level' && current.over.target === workspace.workspaceId)
+                  ? current
+                  : (current ? { ...current, over: { kind: 'ws-level', target: workspace.workspaceId } } : current))
+              } else {
+                clearOver('workspace', workspace.workspaceId)
+                clearOver('ws-level', workspace.workspaceId)
+              }
+              return
+            }
+            event.preventDefault()
+            event.stopPropagation()
+            try { event.dataTransfer.dropEffect = 'move' } catch { }
+            const half = rowHalf(event)
+            if (half === null) return
+            setDrag(current => (current && current.over && current.over.kind === 'workspace' && current.over.target === workspace.workspaceId && current.over.half === half)
+              ? current
+              : (current ? { ...current, over: { kind: 'workspace', target: workspace.workspaceId, half } } : current))
+            return
+          }
           if (!dragMatches('workspace')) return
+          // v0.36.4: the SOURCE row is never its own drop target. A reorder
+          // slot pads a row open by one logical row, so the row the drag
+          // started on ends up covering the pointer's first stop — without
+          // this gate the source row swallowed the target, the drop landed on
+          // itself, commitWorkspaceDrop no-oped and the gesture read as
+          // "拖了没反应".
+          if (drag.source && drag.source.workspaceId === workspace.workspaceId) return
           event.preventDefault()
           event.stopPropagation()
           try { event.dataTransfer.dropEffect = 'move' } catch { }
           const half = rowHalf(event)
+          // Pointer in the half the open slot vacated: keep this row's slot.
+          if (half === null) return
           setDrag(current => (current && current.over && current.over.kind === 'workspace' && current.over.target === workspace.workspaceId && current.over.half === half)
             ? current
             : (current ? { ...current, over: { kind: 'workspace', target: workspace.workspaceId, half } } : current))
@@ -8726,6 +8985,24 @@ window.__ModuleLoader__.load({
             commitSessionMoveOut(workspace.workspaceId)
             return
           }
+          if (dragMatches('folder')) {
+            const sourceLevel = drag.source.levelKey || ''
+            if (sourceLevel !== (workspace.levelKey || '')) {
+              // v0.36.7: the group's OWNING disk row accepts the framed INTO
+              // (see onDragOver) — put the block back at that level's tail.
+              if (sourceLevel === (workspace.subPrefix || '')) {
+                event.preventDefault()
+                event.stopPropagation()
+                commitFolderMoveToLevelEnd(drag.source)
+              }
+              return
+            }
+            event.preventDefault()
+            event.stopPropagation()
+            const half = drag.over && drag.over.kind === 'workspace' && drag.over.target === workspace.workspaceId ? drag.over.half : rowHalf(event)
+            commitLevelReorder({ kind: 'folder', source: drag.source }, { kind: 'workspace', workspace }, half || 'before')
+            return
+          }
           if (!dragMatches('workspace')) return
           event.preventDefault()
           event.stopPropagation()
@@ -8733,21 +9010,214 @@ window.__ModuleLoader__.load({
           commitWorkspaceDrop(workspace, half)
         },
       })
-      const folderDropEvents = (path) => ({
+      // A folder row accepts BOTH drag kinds: a workspace drop regroups that
+      // one workspace (commitWorkspaceMoveInto), a folder drop moves the
+      // whole group — every member retitled under the target prefix
+      // (commitFolderMoveInto, the drag twin of submitFolderRename).
+      // Dropping a group onto itself or its own descendant would loop, so
+      // the hover refuses there and the browser shows its "no drop" cursor.
+      const namePathOf = (folderIdPath) => {
+        const cutAt = folderIdPath.lastIndexOf('//')
+        return cutAt === -1 ? folderIdPath : folderIdPath.slice(cutAt + 2)
+      }
+      // idPath = [<wsId>//]*<namePath>: the owner prefix names the disk
+      // level a group renders in. Reordering only makes sense between
+      // groups of the SAME level — across levels a group's position
+      // belongs to its own container.
+      const ownerPrefixOf = (folderIdPath) => {
+        const cutAt = folderIdPath.lastIndexOf('//')
+        return cutAt === -1 ? '' : folderIdPath.slice(0, cutAt)
+      }
+      // PARENT container identity of a group row (v0.36.4) — the key its
+      // sibling order is persisted under. The ROOT level of a disk scope
+      // answers the scope prefix ('' at the top level, '<wsId>' one disk
+      // level down); a deeper group answers the idPath of its parent group.
+      const parentKeyOf = (folderIdPath) => {
+        const cutAt = folderIdPath.lastIndexOf('//')
+        const prefix = cutAt === -1 ? '' : folderIdPath.slice(0, cutAt)
+        const namePath = cutAt === -1 ? folderIdPath : folderIdPath.slice(cutAt + 2)
+        const segs = namePath.split('/')
+        segs.pop()
+        const parentNamePath = segs.join('/')
+        return parentNamePath === '' ? prefix : prefix + '//' + parentNamePath
+      }
+      // Locate the container a group order list belongs to inside the RAW
+      // (uncompressed) tree: the ROOT level, a disk sub-level (a
+      // workspace's `sub`), or a group node whose `folders` are its
+      // children. Compression never runs on rawTree, so every group the
+      // user can drop beside still has its own idPath here.
+      const folderContainerOf = (key) => {
+        if (key === '') return rawTree
+        let hit = null
+        const walk = (level) => {
+          if (hit || !level) return
+          for (const w of level.workspaces || []) {
+            if (hit) return
+            if (w.subPrefix === key && w.sub) { hit = w.sub; return }
+            if (w.sub) walk(w.sub)
+          }
+          for (const f of level.folders || []) {
+            if (hit) return
+            if (f.idPath === key) { hit = f; return }
+            walk(f)
+          }
+        }
+        walk(rawTree)
+        return hit
+      }
+      // Whole-block member ids of a name group, from this rendering level
+      // down: a reorder slides EVERY nested workspace (prefixes untouched,
+      // so sub-groups travel with the block; only the registry order
+      // shifts).
+      const collectMemberIds = (folderNode) => {
+        const acc = []
+        const walk = (level) => {
+          for (const w of level.workspaces || []) acc.push(w.workspaceId)
+          for (const f of level.folders || []) {
+            if (f.kind === 'ws') acc.push(f.workspace.workspaceId)
+            else walk(f)
+          }
+        }
+        walk(folderNode)
+        return acc
+      }
+      const folderDropEvents = (idPath, path, node) => ({
+        draggable: !searching,
+        onDragStart: (event) => {
+          if (searching) return
+          event.stopPropagation()
+          try {
+            event.dataTransfer.effectAllowed = 'move'
+            event.dataTransfer.setData('text/plain', idPath)
+          } catch { /* drag payload is best-effort */ }
+          // Same one-frame arm as the workspace drag: Chromium cancels a
+          // just-started drag whose source element moves under the cursor.
+          if (wsDragArmTimer.current !== null) clearTimeout(wsDragArmTimer.current)
+          wsDragArmTimer.current = setTimeout(() => {
+            wsDragArmTimer.current = null
+            setDrag({ kind: 'folder', source: { idPath, path, memberIds: collectMemberIds(node), levelKey: parentKeyOf(idPath) }, over: null })
+          }, 0)
+        },
+        onDragEnd: () => {
+          if (wsDragArmTimer.current !== null) { clearTimeout(wsDragArmTimer.current); wsDragArmTimer.current = null }
+          setDrag(null)
+        },
         onDragOver: (event) => {
-          if (!dragMatches('workspace')) return
+          // Three bands on a group row: the outer 30% bands reorder this
+          // group among its SIBLINGS (an empty slot opens at once — the
+          // drop position is visible the moment the band is entered); the
+          // middle 40% moves the source INSIDE the hovered group (framed,
+          // never opened). Workspace sources keep whole-row move-into
+          // semantics.
+          //
+          // SIBLINGS means the SAME PARENT (parentKeyOf): a band reorder
+          // only permutes one level's group name list, it never rewrites a
+          // title prefix. Cross-parent and self/descendant targets are
+          // refused — no preventDefault, so the platform shows its own
+          // 'no drop' cursor, which is the truth.
+          //
+          // v0.36.4: once THIS row already holds a reorder slot, the whole
+          // original row position answers before/after ONLY (a plain
+          // midpoint split). Judging the three bands again there reintroduced
+          // the INTO band on the very row that just padded open: a pointer
+          // drifting a few pixels inside it flipped to INTO, closed the slot
+          // and read as a flicker ("抽搐") — and worse, the drop then landed
+          // as move-into (a no-op) instead of the reorder the user aimed at.
+          // The three bands still decide the FIRST entry, so INTO (move the
+          // source inside this group) stays reachable.
+          const slotOpen = drag.over !== null && drag.over.kind === 'folder' && drag.over.target === idPath && (drag.over.zone === 'before' || drag.over.zone === 'after')
+          const zone = slotOpen ? rowHalf(event) : rowZone(event)
+          const isFolder = dragMatches('folder')
+          const isWorkspace = dragMatches('workspace')
+          if (isFolder) {
+            const targetPath = namePathOf(idPath)
+            // Self / descendant: looping.
+            if (drag.source.path === targetPath || targetPath.startsWith(drag.source.path + '/')) { clearOver('folder', idPath); return }
+            // Ancestor: the group already lives inside. The DIRECT parent is
+            // the container it lives in, so v0.36.7 reopens its MIDDLE band
+            // (the framed INTO): "放进那个组" can only mean "move to the end
+            // of that group", the same feedback a workspace row gets when
+            // dropped INTO its own group. Edge bands still mean nothing
+            // there (leaving a parent is a title rename, not an order
+            // change), and a further ancestor stays refused.
+            if (targetPath !== '' && drag.source.path.startsWith(targetPath + '/')) {
+              const cutAt = drag.source.path.lastIndexOf('/')
+              const directParent = cutAt === -1 ? '' : drag.source.path.slice(0, cutAt)
+              if (targetPath !== directParent || zone !== 'into') { clearOver('folder', idPath); return }
+            }
+            // Pointer in the half the open slot vacated: keep this row's slot
+            // (re-deciding there would flicker the slot it just opened).
+            if (zone === null) {
+              if (drag.over && drag.over.kind === 'folder' && drag.over.target === idPath && (drag.over.zone === 'before' || drag.over.zone === 'after')) {
+                event.preventDefault()
+                event.stopPropagation()
+                try { event.dataTransfer.dropEffect = 'move' } catch { }
+              }
+              return
+            }
+            // Edge bands permute ONE level's sibling list; a cross-parent
+            // band is refused. Move-into (the middle band) stays open across
+            // parents: it is a batch rename, which does reach another group.
+            if (zone !== 'into' && parentKeyOf(idPath) !== parentKeyOf(drag.source.idPath)) { clearOver('folder', idPath); return }
+          } else if (!isWorkspace) {
+            return
+          } else {
+            // v0.36.6 LIFT: a bare workspace row slides beside a group of ANY
+            // level it can reach. Same level keeps the v0.36.5 mixed reorder.
+            // Another level is a LIFT: the workspace leaves its current group
+            // and joins the target group's level, inserted right there. That
+            // is the "insert as the FIRST row" gesture the user kept
+            // reporting: the hover used to be refused silently, so {over}
+            // kept the previous frame's INTO, and the drop became a
+            // move-into that left the row last inside the group. A lift may
+            // not cross a DISK boundary (a workspace's folder is a
+            // filesystem fact), so the target level must live in the same
+            // disk scope as the source. The middle band keeps its old
+            // meaning: move the workspace INTO this group.
+            if (zone === null) {
+              if (drag.over && drag.over.kind === 'folder' && drag.over.target === idPath && (drag.over.zone === 'before' || drag.over.zone === 'after')) {
+                event.preventDefault()
+                event.stopPropagation()
+                try { event.dataTransfer.dropEffect = 'move' } catch { }
+              }
+              return
+            }
+            if (zone !== 'into' && (drag.source.levelKey || '') !== parentKeyOf(idPath) && (ownerPrefixOf(idPath) || '') !== (drag.source.disk || '')) { clearOver('folder', idPath); return }
+          }
           event.preventDefault()
           event.stopPropagation()
           try { event.dataTransfer.dropEffect = 'move' } catch { }
-          setDrag(current => (current && current.over && current.over.kind === 'folder' && current.over.target === path)
+          const reorder = zone !== 'into'
+          const nextOver = reorder
+            ? { kind: 'folder', target: idPath, zone }
+            : { kind: 'folder', target: idPath, zone: 'into' }
+          setDrag(current => (current && current.over && current.over.kind === 'folder' && current.over.target === idPath && current.over.zone === nextOver.zone)
             ? current
-            : (current ? { ...current, over: { kind: 'folder', target: path } } : current))
+            : (current ? { ...current, over: nextOver } : current))
         },
         onDrop: (event) => {
+          if (dragMatches('folder')) {
+            event.preventDefault()
+            event.stopPropagation()
+            const zone = drag.over && drag.over.kind === 'folder' && drag.over.target === idPath ? drag.over.zone : 'into'
+            if (zone === 'before' || zone === 'after') commitFolderReorder(drag.source, idPath, zone, node)
+            else commitFolderMoveInto(drag.source, idPath)
+            return
+          }
           if (!dragMatches('workspace')) return
           event.preventDefault()
           event.stopPropagation()
-          commitWorkspaceMoveInto(path)
+          // The live {over} wins; the geometry is the fallback for a drop that
+          // lands before any hover frame recorded a band on this row.
+          const overZone = drag.over && drag.over.kind === 'folder' && drag.over.target === idPath && (drag.over.zone === 'before' || drag.over.zone === 'after') ? drag.over.zone : null
+          const geoZone = rowZone(event) || 'into'
+          const zone = overZone || geoZone
+          if (zone === 'before' || zone === 'after') {
+            // Same level = plain mixed reorder; another level (same disk
+            // scope) = lift the workspace out of its group into that level.
+            if ((drag.source.levelKey || '') === parentKeyOf(idPath)) commitLevelReorder({ kind: 'workspace', source: drag.source }, { kind: 'folder', target: idPath }, zone)
+            else commitWorkspaceLift(drag.source, idPath, zone)
+          } else commitWorkspaceMoveInto(idPath)
         },
       })
       const nextWorkspaceAfter = (folderPath, workspaceId) => {
@@ -8756,6 +9226,87 @@ window.__ModuleLoader__.load({
         const index = node.workspaces.findIndex(w => w.workspaceId === workspaceId)
         return index === -1 ? undefined : (node.workspaces[index + 1] ? node.workspaces[index + 1].workspaceId : undefined)
       }
+      // v0.36.5 MIXED LEVEL REORDER. One persisted list per level decides the
+      // display order of BOTH kinds: a group name token and a "w:<id>"
+      // workspace token. Writes the list only — the registry keeps its own
+      // (workspace-only) order, because "above that group" is a VIEW position
+      // the registry has no vocabulary for: a workspace title still decides
+      // which group it belongs to, the list only decides where the row sits.
+      // v0.36.7: a group block dropped INTO the container it already lives in
+      // (the framed INTO on its DIRECT parent group row, or on the disk-level
+      // row that owns it) lands at that container's TAIL — the same
+      // "放入=排到最后" a workspace row gets when dropped INTO its own group.
+      // No prefix is rewritten (the block already lives under the right path),
+      // only the level order moves.
+      const moveFolderToLevelEnd = (source) => {
+        const containerKey = source.levelKey || ''
+        const container = folderContainerOf(containerKey)
+        if (!container) { console.warn('[bw] folder move refused: target level not found', containerKey); return false }
+        const token = namePathOf(source.idPath).split('/').pop()
+        const tokens = levelSeqOf(container).map(levelTokenOf)
+        if (!tokens.includes(token)) { console.warn('[bw] folder move refused: group not in this level', token); return false }
+        const next = tokens.filter((entry) => entry !== token)
+        next.push(token)
+        if (typeof actions.setFolderOrder === 'function') actions.setFolderOrder(containerKey, next)
+        return true
+      }
+      const commitFolderMoveToLevelEnd = (source) => {
+        setDrag(null)
+        moveFolderToLevelEnd(source)
+      }
+      const writeLevelOrder = (containerKey, sourceToken, targetToken, zone) => {
+        const container = folderContainerOf(containerKey)
+        if (!container) { console.warn('[bw] level reorder refused: container not found', containerKey); return false }
+        const tokens = levelSeqOf(container).map(levelTokenOf)
+        const at = tokens.indexOf(sourceToken)
+        if (at === -1) { console.warn('[bw] level reorder refused: source not in this level', sourceToken); return false }
+        tokens.splice(at, 1)
+        const targetAt = tokens.indexOf(targetToken)
+        if (targetAt === -1) { console.warn('[bw] level reorder refused: target not in this level', targetToken); return false }
+        tokens.splice(zone === 'after' ? targetAt + 1 : targetAt, 0, sourceToken)
+        if (typeof actions.setFolderOrder === 'function') actions.setFolderOrder(containerKey, tokens)
+        return true
+      }
+      // v0.36.6 LIFT writes: the source token does NOT exist in the target
+      // level yet (that is what a lift is), so writeLevelOrder's
+      // "source must already be here" precondition does not apply — the token
+      // is spliced straight in beside the target group.
+      const insertLevelToken = (containerKey, sourceToken, targetToken, zone) => {
+        const container = folderContainerOf(containerKey)
+        if (!container) { console.warn('[bw] workspace lift refused: target level not found', containerKey); return false }
+        const tokens = levelSeqOf(container).map(levelTokenOf).filter((token) => token !== sourceToken)
+        const targetAt = tokens.indexOf(targetToken)
+        if (targetAt === -1) { console.warn('[bw] workspace lift refused: target group not in this level', targetToken); return false }
+        tokens.splice(zone === 'after' ? targetAt + 1 : targetAt, 0, sourceToken)
+        if (typeof actions.setFolderOrder === 'function') actions.setFolderOrder(containerKey, tokens)
+        return true
+      }
+      // The level a lifted workspace LEFT keeps a stale "w:<id>" token
+      // otherwise (buildTree skips it harmlessly, but the list would grow
+      // forever and a later re-group could resurrect the old position).
+      const removeLevelToken = (containerKey, token) => {
+        const container = folderContainerOf(containerKey)
+        if (!container) return
+        const tokens = levelSeqOf(container).map(levelTokenOf)
+        if (!tokens.includes(token)) return
+        if (typeof actions.setFolderOrder === 'function') actions.setFolderOrder(containerKey, tokens.filter((entry) => entry !== token))
+      }
+      // Shared commit for both mixed directions — a workspace sliding beside a
+      // group row, and a group block sliding beside a workspace row. The
+      // target names the level it belongs to; the hover gate already refused
+      // cross-level targets and this re-checks it as belt and braces.
+      const commitLevelReorder = (sourceRef, targetRef, zone) => {
+        setDrag(null)
+        if (!canDragWorkspace) { console.warn('[bw] level reorder refused: workspace reorder unavailable on this host'); return }
+        const wsSource = sourceRef.kind === 'workspace'
+        const sourceToken = wsSource ? 'w:' + sourceRef.source.workspaceId : namePathOf(sourceRef.source.idPath).split('/').pop()
+        const folderTarget = targetRef.kind === 'folder'
+        const targetToken = folderTarget ? namePathOf(targetRef.target).split('/').pop() : 'w:' + targetRef.workspace.workspaceId
+        const containerKey = folderTarget ? parentKeyOf(targetRef.target) : (targetRef.workspace.levelKey || '')
+        const sourceLevelKey = sourceRef.source.levelKey || ''
+        if (sourceLevelKey !== containerKey) { console.warn('[bw] level reorder refused: cross-level target', sourceLevelKey, containerKey); return }
+        writeLevelOrder(containerKey, sourceToken, targetToken, zone)
+      }
       const commitWorkspaceDrop = (targetWorkspace, half) => {
         const source = drag.source
         setDrag(null)
@@ -8769,6 +9320,16 @@ window.__ModuleLoader__.load({
         // cross-level drop only re-groups the title (the registry append
         // lands it at the end of ITS disk level).
         const sameDisk = source.disk === diskParentMap.get(targetWorkspace.workspaceId)
+        // v0.36.6: a cross-LEVEL drop on a workspace row's half is a PLACEMENT,
+        // not a re-group. The user reported "the insert line shows but the row
+        // lands somewhere else": renaming into the target's group moved the row
+        // into that group's block at whatever position the group already had.
+        // Lifting to the target row's own level and anchoring at that row is
+        // what makes the drop land where the line was drawn.
+        if (workspaceSlash && (targetWorkspace.levelKey || '') !== (source.levelKey || '')) {
+          commitWorkspaceLift(source, targetWorkspace.levelKey || '', half === 'after' ? 'after' : 'before', targetWorkspace.workspaceId)
+          return
+        }
         const chain = sameFolder
           ? Promise.resolve()
           : Promise.resolve().then(() => {
@@ -8782,6 +9343,69 @@ window.__ModuleLoader__.load({
             : targetWorkspace.workspaceId)
         chain
           .then(() => (anchor !== undefined ? insertWorkspaceBefore(source.workspaceId, anchor) : insertWorkspaceBefore(source.workspaceId)))
+          // v0.36.5: once a level carries a MIXED list (it interleaves a bare
+          // workspace with its groups), the registry edit above no longer
+          // moves the row — rewrite the list too, keeping every other token.
+          .then(() => {
+            const levelKey = targetWorkspace.levelKey || ''
+            const container = folderContainerOf(levelKey)
+            const tokens = container ? levelSeqOf(container).map(levelTokenOf) : []
+            if (tokens.some((token) => token.startsWith('w:'))) {
+              writeLevelOrder(levelKey, 'w:' + source.workspaceId, 'w:' + targetWorkspace.workspaceId, half === 'after' ? 'after' : 'before')
+            }
+          })
+          .catch(fail)
+      }
+      // v0.36.6 LIFT. Dropping a bare workspace row on a group's EDGE band
+      // from a DIFFERENT level means: take the row out of its group, give it
+      // the target level's name prefix and place it right beside that group.
+      // The user's report was "I can never insert it as the first row" — the
+      // gesture existed visually but every path landed it inside the group
+      // (move-into) at the tail. The lift is a rename + a level token, never a
+      // disk move, so the caller has already checked the disk scope.
+      const commitWorkspaceLift = (source, targetIdPath, zone, anchorWorkspaceId) => {
+        setDrag(null)
+        if (!canDragWorkspace) { console.warn('[bw] workspace lift refused: workspace reorder unavailable on this host'); return }
+        const targetParentKey = parentKeyOf(targetIdPath)
+        if (!folderContainerOf(targetParentKey)) { console.warn('[bw] workspace lift refused: target level not found', targetParentKey); return }
+        const cutAt = targetParentKey.lastIndexOf('//')
+        const levelNamePath = cutAt === -1 ? targetParentKey : targetParentKey.slice(cutAt + 2)
+        const sourceKey = source.levelKey || ''
+        const targetNamePath = namePathOf(targetIdPath)
+        const targetNode = findTreeNode(rawTree, targetNamePath)
+        const targetMembers = targetNode ? collectMemberIds(targetNode) : []
+        const registryIds = (items || []).map((w) => w.workspaceId)
+        // after = insert before whatever follows the target block in the
+        // registry (undefined = append). before = before the block's head.
+        // A row-anchored lift (dropped on a workspace row's half) anchors at
+        // that row itself, not at the head/tail of its whole group block.
+        let anchor
+        if (anchorWorkspaceId) {
+          if (zone === 'before') {
+            anchor = anchorWorkspaceId
+          } else {
+            const rowAt = registryIds.indexOf(anchorWorkspaceId)
+            anchor = rowAt === -1 ? undefined : registryIds[rowAt + 1]
+          }
+        } else if (zone === 'before') {
+          anchor = targetMembers[0]
+        } else if (targetMembers.length) {
+          const tailAt = registryIds.indexOf(targetMembers[targetMembers.length - 1])
+          anchor = tailAt === -1 ? undefined : registryIds[tailAt + 1]
+        }
+        const newTitle = levelNamePath !== '' ? levelNamePath + '/' + source.leaf : source.leaf
+        const sameNameLevel = (source.folderPath || '') === levelNamePath
+        Promise.resolve()
+          .then(() => (sameNameLevel ? Promise.resolve() : renameWorkspace(source.workspaceId, newTitle)))
+          .then(() => insertWorkspaceBefore(source.workspaceId, anchor))
+          .then(() => {
+            // The level token is always a GROUP token: a workspace row dropped on
+            // from another level is painted beside the group that row lives in,
+            // so the token to place it next to is that group's name in the
+            // parent level's list (the row's own "w:" token lives one level in).
+            insertLevelToken(targetParentKey, 'w:' + source.workspaceId, targetNamePath.split('/').pop(), zone)
+            if (sourceKey !== targetParentKey) removeLevelToken(sourceKey, 'w:' + source.workspaceId)
+          })
           .catch(fail)
       }
       const commitWorkspaceMoveInto = (folderIdPath) => {
@@ -8798,6 +9422,102 @@ window.__ModuleLoader__.load({
           .then(() => insertWorkspaceBefore(source.workspaceId))
           .catch(fail)
       }
+      // Group drag (v0.36.0): moving a folder rewrites EVERY member's title
+      // under the target prefix — the same batch rename the rename-group
+      // dialog (submitFolderRename) performs. Titles are global name paths,
+      // so the member sweep is prefix-based over all items (same known
+      // limitation as that dialog: same-named groups on different disk
+      // levels move together). Self / descendant targets are already
+      // refused at hover time; re-checked here as belt and braces.
+      const commitFolderMoveInto = (source, targetIdPath) => {
+        setDrag(null)
+        const targetPath = namePathOf(targetIdPath)
+        // v0.36.7: the DIRECT parent is the container the group already lives
+        // in. The hover already showed the framed INTO there, so "放进那个
+        // 组" means "move to the end of that group" — no rename involved.
+        // Checked BEFORE the ancestor refusal below.
+        const cutAt = source.path.lastIndexOf('/')
+        const directParent = cutAt === -1 ? '' : source.path.slice(0, cutAt)
+        if (targetPath === directParent) { moveFolderToLevelEnd(source); return }
+        // An ANCESTOR target means the group already lives there: a prefix
+        // rewrite would duplicate a segment (工作/A → 工作/工作/A). Refuse.
+        if (source.path === targetPath || targetPath.startsWith(source.path + '/') || (targetPath !== '' && source.path.startsWith(targetPath + '/'))) { console.warn('[bw] folder move refused: target is self, descendant or ancestor of', source.path); return }
+        const prefix = source.path + '/'
+        const affected = (items || []).filter((w) => String(w.title || '').startsWith(prefix))
+        if (!affected.length) { console.warn('[bw] folder move refused: no members under', source.path); return }
+        Promise.resolve()
+          .then(async () => {
+            for (const w of affected) {
+              await renameWorkspace(w.workspaceId, targetPath + String(w.title).slice(source.path.length))
+            }
+          })
+          // (v0.36.4) NO automatic expand after a move-into. v0.36.3 opened
+          // the target group here so the move would be visible, but on the
+          // real tree a drop in the middle band is exactly the "变下级"
+          // gesture, and auto-opening made that read as "又被撑开了".
+          // The row the user just dropped into stays as it was; the moved
+          // members appear under it once the user opens that group.
+          .catch(fail)
+      }
+      // Group REORDER (v0.36.0): a name group's position IS the registry
+      // order of its members, so reordering = sliding the whole member
+      // block (prefixes untouched) to just before / after the target
+      // group's block. Anchored like commitWorkspaceDrop: before = the
+      // target's first member, after = whatever follows the target's last
+      // member (undefined = block-append at the level tail). Hover only
+      // arms this between same-level groups (identical owner prefix);
+      // re-checked here as belt and braces.
+      const commitFolderReorder = (source, targetIdPath, zone, targetNode) => {
+        setDrag(null)
+        if (!canDragWorkspace) { console.warn('[bw] folder reorder refused: workspace reorder unavailable on this host'); return }
+        if (ownerPrefixOf(source.idPath) !== ownerPrefixOf(targetIdPath)) { console.warn('[bw] folder reorder refused: cross-level target'); return }
+        // v0.36.4: SIBLINGS ONLY. A group's rendered position is decided by
+        // its parent's order list, so a target that hangs off a different
+        // parent cannot place it at all.
+        if (parentKeyOf(source.idPath) !== parentKeyOf(targetIdPath)) { console.warn('[bw] folder reorder refused: cross-parent target'); return }
+        const sourceIds = source.memberIds || []
+        if (!sourceIds.length) { console.warn('[bw] folder reorder refused: empty source block'); return }
+        // Whole-block anchors: the target's members include its nested
+        // sub-groups (a plain .workspaces read misses container groups and
+        // silently returned on them — the "drop did nothing" report).
+        // v0.36.3 drag-out: the source block IS part of the target's block
+        // (dropping a nested group onto its parent), so the source subtree
+        // is filtered out before anchoring — otherwise the anchor lands
+        // inside the moving subtree and the drop no-ops or oscillates.
+        const sourceSet = new Set(sourceIds)
+        const targetMembers = collectMemberIds(targetNode).filter((id) => !sourceSet.has(id))
+        if (!targetMembers.length) { console.warn('[bw] folder reorder refused: target has no members to anchor against'); return }
+        // before = the surviving block's first member; after = its last
+        // member (inserting before it = right after the block). Anchoring
+        // on the block tail itself replaces nextWorkspaceAfter, whose
+        // node.workspaces lookup missed nested tails (findIndex -1 →
+        // silent append).
+        const anchor = zone === 'after'
+          ? targetMembers[targetMembers.length - 1]
+          : targetMembers[0]
+        // v0.36.4: THE DISPLAYED ORDER IS PERSISTED HERE. Group order used to
+        // follow buildTree's name sort, so the registry edit below changed
+        // nothing the user could see ("拖了没反应"). folderOrder[parentKey]
+        // is the sibling name list buildTree sorts by; write it first so the
+        // drop is visible immediately, then sync the registry for the
+        // workspace order other surfaces read.
+        const orderParent = parentKeyOf(source.idPath)
+        const sourceName = namePathOf(source.idPath).split('/').pop()
+        const targetName = namePathOf(targetIdPath).split('/').pop()
+        // v0.36.5: write the MIXED token list (group names + w:<id> tokens),
+        // not just the folder names — a level that already interleaves a bare
+        // workspace with its groups must keep those workspace positions.
+        writeLevelOrder(orderParent, sourceName, targetName, zone)
+        Promise.resolve()
+          .then(async () => {
+            if (anchor === undefined) {
+              for (const id of sourceIds) await insertWorkspaceBefore(id)
+            } else {
+              for (const id of sourceIds) await insertWorkspaceBefore(id, anchor)
+            }
+          })
+          .catch(fail)
+      }
 
       /* ---------------------- session drag & drop --------------------- */
 
@@ -8925,6 +9645,10 @@ window.__ModuleLoader__.load({
           .catch(fail)
       }
       const wsRootDropActive = (workspaceId) => dragMatches('session') && drag.over !== null && drag.over.kind === 'ws-root' && drag.over.target === workspaceId
+      // v0.36.7: a group block hovering the disk-level row that OWNS it lights
+      // the SAME framed INTO a workspace row gets on a group row — the visual
+      // is one language: edge bands reorder, the middle band "puts inside".
+      const wsGroupIntoActive = (workspaceId) => dragMatches('folder') && drag.over !== null && drag.over.kind === 'ws-level' && drag.over.target === workspaceId
       const commitSessionMoveInto = (workspaceId, groupPath) => {
         const source = drag.source
         setDrag(null)
@@ -9191,7 +9915,7 @@ window.__ModuleLoader__.load({
           menuOpen: !!(ctx && ctx.kind === 'workspace' && ctx.payload && ctx.payload.workspaceId === workspace.workspaceId),
           hoverBody: workspaceHoverBody,
           dropHalf: wsDropHalf(workspace.workspaceId),
-          dropInto: wsRootDropActive(workspace.workspaceId),
+          dropInto: wsRootDropActive(workspace.workspaceId) || wsGroupIntoActive(workspace.workspaceId),
           dragEvents: workspaceDragEvents(workspace),
           custStyle: rowStyleOf('workspace:' + workspace.workspaceId),
           iconMode: (styleEntry('workspace:' + workspace.workspaceId) || {}).icon || 'solid',
@@ -9235,8 +9959,11 @@ window.__ModuleLoader__.load({
         : undefined
       const renderLevelRows = (level, depth) => {
         const rows = []
-        for (const folder of level.folders) rows.push(...renderPlainFolder(folder, depth))
-        for (const workspace of level.workspaces) rows.push(...renderWorkspaceEntry({ workspace }, depth, wsPulseOf(workspace)))
+        for (const item of levelSeqOf(level)) {
+          rows.push(...(item.kind === 'ws'
+            ? renderWorkspaceEntry({ workspace: item.entry }, depth, wsPulseOf(item.entry))
+            : renderPlainFolder(item.node, depth)))
+        }
         return rows
       }
 
@@ -9257,7 +9984,8 @@ window.__ModuleLoader__.load({
           onToggle: () => { if (!searching) actions.setExpanded(idPath, !expanded) },
           onContextMenu: (e) => openCtx('folder', { path: node.path, name: node.name, idPath, scope: node.scope, empty: countWorkspaces(node) === 0 }, e),
           dropInto: wsDropInto(idPath),
-          dragEvents: folderDropEvents(idPath),
+          dropSlot: wsFolderSlotOf(idPath),
+          dragEvents: folderDropEvents(idPath, node.path, node),
           custStyle: rowStyleOf('folder:' + idPath),
           iconMode: (styleEntry('folder:' + idPath) || {}).icon || 'solid',
           pulse: expanded ? null : folderPulseOf(node),
@@ -9265,8 +9993,11 @@ window.__ModuleLoader__.load({
           t,
         })]
         if (expanded) {
-          for (const child of node.folders) rows.push(...renderPlainFolder(child, depth + 1))
-          for (const workspace of node.workspaces) rows.push(...renderWorkspaceEntry({ workspace }, depth + 1, wsPulseOf(workspace)))
+          for (const item of levelSeqOf(node)) {
+            rows.push(...(item.kind === 'ws'
+              ? renderWorkspaceEntry({ workspace: item.entry }, depth + 1, wsPulseOf(item.entry))
+              : renderPlainFolder(item.node, depth + 1)))
+          }
         }
         return rows
       }
@@ -9280,7 +10011,10 @@ window.__ModuleLoader__.load({
         const rows = []
         for (const workspace of items || []) rows.push(...sessionsOf(workspace))
         rows.push(...ungrouped)
-        return rows.map((s) => renderSessionRow({ ...s, leaf: s.title }, 0, undefined))
+        // sessionsOf() sorts inside one workspace; flat mode needs one global
+        // recency sort, including the Ungrouped bucket (not per-workspace runs).
+        const ordered = orderBy === 'updated' ? orderSessionsByRecency(rows, currentId) : rows
+        return ordered.map((s) => renderSessionRow({ ...s, leaf: s.title }, 0, undefined))
       }
       const renderUngroupedBlock = () => {
         const rows = []
@@ -9321,8 +10055,11 @@ window.__ModuleLoader__.load({
         }
         bodyRows.push(...renderUngroupedBlock())
       } else {
-        for (const folder of tree.folders) bodyRows.push(...renderPlainFolder(folder, 0))
-        for (const workspace of tree.workspaces) bodyRows.push(...renderWorkspaceEntry({ workspace }, 0, wsPulseOf(workspace)))
+        for (const item of levelSeqOf(tree)) {
+          bodyRows.push(...(item.kind === 'ws'
+            ? renderWorkspaceEntry({ workspace: item.entry }, 0, wsPulseOf(item.entry))
+            : renderPlainFolder(item.node, 0)))
+        }
         bodyRows.push(...renderUngroupedBlock())
       }
       const isEmpty = bodyRows.length === 0
@@ -10195,33 +10932,54 @@ window.__ModuleLoader__.load({
         if (!result || !result.ok) throw new Error(result && result.error ? result.error.message : 'session search failed')
         return result.value
       }
-      // dsh 0.1.6-alpha.2 retention contract: rename borrows through
-      // sessions.using with an explicit source — the old plain binding(id)
-      // only ever saw already-retained sessions, so renaming a closed row
-      // reported "unknown session". Fork and open go through the uiWorkspace
-      // navigation service: ISessions no longer carries open() at all
-      // (navigation belongs to the view owner, replaceMain).
+      // Rename performance (issue #14): sessions.using retains the session and
+      // awaits reference.ready FIRST, so renaming a closed 5MB row stalled ~6s
+      // loading its whole history just to send a 20ms rename RPC (the rename
+      // itself is independent of the transcript). Tiered, cheapest first:
       //
-      // Host-era compat (0.1.5-rc.x hosts ship ISessions.binding only — the
-      // 0.1.6-alpha.2 contract replaced it with using): calling sessions.using
-      // there died with "sessions.using is not a function", which took down
-      // every rename path (row dialog, session-group batch, group move). Prefer
-      // the new contract, fall back to the old one, and only then fail loud.
+      // 1. Open session → borrow binding directly. On 0.1.6+ hosts binding(id)
+      //    only sees retained scopes (service.ts:539 `scopes.get(id)?.binding`,
+      //    undefined when closed), so "a binding comes back" IS the open test;
+      //    on 0.1.5-rc.x hosts every row is visible, identical to the old
+      //    fallback. Same SessionBinding object the using path borrows, so
+      //    title projection / list refresh behave exactly the same.
+      // 2. Closed session → sessions.manager.rename(id, title): "Rename a
+      //    Session ... without opening its history" (manager.ts:578) — a bare
+      //    remote.session.rename plus the title projection. manager is a
+      //    TS-private field of ClientSessions (service.ts:245), reachable at
+      //    runtime; feature-probed so hosts without it skip the tier.
+      // 3. Fallback → the 0.1.6-alpha.2 retention contract: sessions.using
+      //    with an explicit source (slow — loads history — but the only legal
+      //    path on hosts predating manager.rename). 0.1.5-rc.x hosts ship
+      //    ISessions.binding only; tier 1 already served them. Then fail loud.
+      // Fork and open go through the uiWorkspace navigation service: ISessions
+      // no longer carries open() at all (navigation belongs to the view owner,
+      // replaceMain).
       const renameSession = async (sessionId, title) => {
+        const fail = (result) => new Error(result && result.error ? result.error.message : 'session rename failed')
+        const binding = typeof sessions.binding === 'function' ? sessions.binding(sessionId) : undefined
+        const face = binding ? binding.session : undefined
+        if (face && typeof face.rename === 'function') {
+          const result = await face.rename(title)
+          if (!result || !result.ok) throw fail(result)
+          return
+        }
+        const manager = sessions.manager
+        if (manager && typeof manager.rename === 'function') {
+          const result = await manager.rename(sessionId, title)
+          if (!result || !result.ok) throw fail(result)
+          return
+        }
         if (typeof sessions.using === 'function') {
           const result = await sessions.using(
             sessionId,
             { source: 'workspaceOperation' },
             (reference) => reference.binding.session.rename(title),
           )
-          if (!result || !result.ok) throw new Error(result && result.error ? result.error.message : 'session rename failed')
+          if (!result || !result.ok) throw fail(result)
           return
         }
-        const binding = typeof sessions.binding === 'function' ? sessions.binding(sessionId) : undefined
-        const face = binding ? binding.session : undefined
-        if (!face || typeof face.rename !== 'function') throw new Error('session rename is unavailable on this host')
-        const result = await face.rename(title)
-        if (!result || !result.ok) throw new Error(result && result.error ? result.error.message : 'session rename failed')
+        throw new Error('session rename is unavailable on this host')
       }
       const forkSession = (sessionId) => {
         uiWorkspace.forkSession(sessionId)