dsh-better-workspace 0.36.9 → 0.36.11

package/README.md

@@ -69,7 +69,7 @@
 ### 其余亮点
 
 - **文件夹式收起**:点工作区行 = 收起/展开该工作区的全部会话(收起后行上保留会话数角标;角标 v0.34.0 起默认隐藏、对齐官方,设置卡「显示会话数」可开);会话分组同样可收起;搜索时自动全部展开。
-- **拖拽还原原版能力**:工作区行可拖拽——拖到另一工作区行上/下半即调整顺序(写回宿主 registry 序),拖到分组行中带则移动进该分组(改写名称前缀);**工作区分组行同样可拖拽(v0.36.0 起,三带悬停)**——拖到分组行时行分三个落区:上下 **30% 边带**=与该组**排序**(拖完立即重排、刷新后保留),**中带**=整组移入(组成员逐个改写名称前缀,与「重命名分组」同一语义;拖到自身/自己的子孙组上会被拒绝);**组行与工作区行同处一条混合序列(v0.36.5 起)**:一个层级里的行顺序只有一份(组行与裸工作区行交错),工作区可以拖到分组行的边带插到该组前面/后面,分组也可以拖到工作区行前面/后面——不再有「组永远排在裸工作区之前」的限制;拖到**另一层**的边带是**放置**(v0.36.6):工作区离开原组(或进入目标层)并插到落点,「插到第一个」画哪落哪(跨磁盘层不放行——磁盘层是文件系统事实);**拖入黑框统一(v0.36.7)**:工作区行拖到分组行中带 = 改名前缀进组(黑框反馈);组行拖到**它所属的磁盘层工作区行 / 直接父级分组行**中带 = 整组「放入」该容器、排到该层末尾(标题与磁盘位置都不动,同一套黑框视觉)——排序走边带、放入走中带,两类操作视觉上彻底分开;**容器防环(v0.36.9)**:磁盘层的容器工作区不能被拖进它自己的名称组或子工作区——那会把容器改名成自己的子孙(如「工作/用户目录」甚至「<id>/用户目录」),现在整行拒绝、不留任何落点反馈,排序与放入父容器(v0.36.7)不受影响;**撑开让位(v0.36.4)**:进入排序边带立刻把目标行撑开一行(工作区行与分组行同一套视觉),判定按**行未撑开时的原始位置**算——指针停在槽空出的新区里保持当前方向不闪烁;槽已打开的行只按原始中线二选一(上半=插在前,下半=插在后,**不会翻成「移入」**),三带里的中带 INTO 只在首次进入时决定,随时可改主意;会话行可拖拽——同组内拖到另一会话上/下即调整顺序,拖到**别组的会话行**会把名字前缀改写到那个组(拖到根层的行 = 移出分组),拖到会话子分组行即移动进该分组,拖到**自己的工作区行**或**树里任何组外的地方**(含空白区域)同样移出分组 —— 拖拽期间工作区行整行高亮、树底部有一条淡虚线提示这个出口;带分组前缀的会话行右键还多一项「移出分组」。显示顺序 = 宿主手动序(分组行 = 父容器下的持久化组序),拖拽结果立即生效。**磁盘层是文件系统事实,不随拖拽改变**:跨磁盘层不放行(边带不接管光标、不画落点线),同磁盘层内按落点锚定。拖拽期间树形保持不变(v0.36.4):单链合并行不再临时展开、归组成功也不自动展开目标组——指针下的行不会突然换人,展开状态只在点击时改变。
+- **拖拽还原原版能力**:工作区行可拖拽——拖到另一工作区行上/下半即调整顺序(写回宿主 registry 序),拖到分组行中带则移动进该分组(改写名称前缀);**工作区分组行同样可拖拽(v0.36.0 起,三带悬停)**——拖到分组行时行分三个落区:上下 **30% 边带**=与该组**排序**(拖完立即重排、刷新后保留),**中带**=整组移入(组成员逐个改写名称前缀,与「重命名分组」同一语义;拖到自身/自己的子孙组上会被拒绝);**组行与工作区行同处一条混合序列(v0.36.5 起)**:一个层级里的行顺序只有一份(组行与裸工作区行交错),工作区可以拖到分组行的边带插到该组前面/后面,分组也可以拖到工作区行前面/后面——不再有「组永远排在裸工作区之前」的限制;拖到**另一层**的边带是**放置**(v0.36.6):工作区离开原组(或进入目标层)并插到落点,「插到第一个」画哪落哪(跨磁盘层不放行——磁盘层是文件系统事实);**拖入黑框统一(v0.36.7)**:工作区行拖到分组行中带 = 改名前缀进组(黑框反馈);组行拖到**它所属的磁盘层工作区行 / 直接父级分组行**中带 = 整组「放入」该容器、排到该层末尾(标题与磁盘位置都不动,同一套黑框视觉)——排序走边带、放入走中带,两类操作视觉上彻底分开;**容器防环(v0.36.9)**:磁盘层的容器工作区不能被拖进它自己的名称组或子工作区——那会把容器改名成自己的子孙(如「工作/用户目录」甚至「<id>/用户目录」),现在整行拒绝、不留任何落点反馈,排序与放入父容器(v0.36.7)不受影响;**平级组嵌套与提升(v0.36.10)**:组行拖到平级组行的**中带**=变成它的**子组**(成员标题落到新组之下,`工作/平行帮` → `工作/Fis管理后台/平行帮`,天然不撞名——旧的并入语义会在双方都有同名子工作区时报 name-conflict、整树不动);组行拖到**另一层工作区行的边带**(同磁盘、不在自己子树内)=**整组提升**到那行所在层并锚定在落点旁(「把平行帮拖到和用户目录、工作平级」);已打开的排序槽不再锁死判定——指针推回行**中带**即可翻成放入黑框,嵌套与排序随时互切;**静止松手兜底**:Chromium 把指针静止约一秒后的松手吞成 dragend 时,按最后悬停的落点补提交(Esc 取消不受影响),不再「松手没反应」;**撑开让位(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 宿主弹应用内入口提示),按钮文案还会带上宿主当前的键位;③ 首次使用的工作区显示为本地化的「默认工作区」,不再露出磁盘目录名。
@@ -129,7 +129,7 @@ DSH 的侧边栏浏览区是一个公开插槽 `sidebar.workspaces`(single),官
 
 - 会话**跨工作区**拖拽仍被拒绝(会话归属工作区);同一工作区内的分组归属已随拖拽生效(v0.18.0:拖到别组的行改写前缀,拖到自己的工作区行移出分组,右键也有「移出分组」)。
 - 搜索为本地标题过滤(两层扁平化后逐工作区匹配);宿主内容搜索(`session.search`)计划接回。
-- flat(平铺)视图未接管,层级树即视图。侧栏切到「单列表 / 按工作区」时,新会话页的选择器退化为**一层完整标题**的工作区列表(仍可选,不再分组)。
+- flat(平铺)视图未接管,层级树即视图。侧栏切到「单列表」时,新会话页的选择器退化为**一层完整标题**的工作区列表(仍可选,不再分组);切到「按工作区」时(v0.36.11 起),只要「工作区分组」开着(磁盘+名称 / 仅名称),侧栏与新会话页选择器都显示**名称树挂顶层**的结构(名称组与磁盘容器平级,切换即时生效);「工作区分组」设为「磁盘目录」时保持官方的散开平铺。
 - 新会话页选择器里的分组开合是**选择器本地状态**(默认全展开):它不写侧栏的折叠状态,免得选工作区时被侧栏的折叠挡住目标。
 
 ## 开发

package/dsh.plugin.json

@@ -1,6 +1,6 @@
 {
   "id": "dsh-external/dsh-better-workspace",
-  "version": "0.36.9",
+  "version": "0.36.11",
   "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.36.9",
+  "version": "0.36.11",
   "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

@@ -8014,6 +8014,21 @@ window.__ModuleLoader__.load({
       // 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.10: Chromium CANCELS a drag whose pointer rests long enough —
+      // the mouse-up arrives as dragleave+dragend and 'drop' never fires
+      // (probe-measured: resting ~1-2s loses the drop every time). The
+      // user reads that as "松手没反应". dragStateRef mirrors {drag} for a
+      // dragEnd fallback that honors the armed {over}; dragDroppedRef
+      // tells dragEnd a real drop already committed; Escape still cancels.
+      const dragStateRef = React.useRef(null)
+      const dragDroppedRef = React.useRef(false)
+      const dragCancelledRef = React.useRef(false)
+      React.useEffect(() => { dragStateRef.current = drag }, [drag])
+      React.useEffect(() => {
+        const onKey = (event) => { if (event.key === 'Escape') dragCancelledRef.current = true }
+        window.addEventListener('keydown', onKey, true)
+        return () => window.removeEventListener('keydown', onKey, true)
+      }, [])
       // (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
@@ -8258,7 +8273,15 @@ window.__ModuleLoader__.load({
       // 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, folderOrderMap)
+        // v0.36.11: "workspaces" (groupBy === 'workspace') turns OFF disk
+        // nesting — official semantics — but the NAME tree stays on when the
+        // user enabled one (workspaceGroupMode !== 'disk'). A plain buildTree
+        // mode of 'slash' expresses exactly that: name groups at the root,
+        // every workspace at the top, entry.sub always null.
+        const treeMode = groupBy === 'workspace' && workspaceGroupMode !== 'disk'
+          ? 'slash'
+          : workspaceGroupMode
+        const built = buildTree(items, treeMode, 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 —
@@ -8270,14 +8293,21 @@ window.__ModuleLoader__.load({
           ? 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])
+      }, [items, compactChains, groupBy, 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, folderOrderMap), [items, workspaceGroupMode, wsFolders, folderOrderMap])
+      // v0.36.11: same groupBy-aware mode as the rendered tree — the
+      // new-group dialog must mirror the hierarchy the user actually sees.
+      const rawTree = React.useMemo(() => buildTree(
+        items,
+        groupBy === 'workspace' && workspaceGroupMode !== 'disk' ? 'slash' : workspaceGroupMode,
+        wsFolders,
+        folderOrderMap,
+      ), [items, groupBy, workspaceGroupMode, wsFolders, folderOrderMap])
       // Disk-layer ancestry for drag semantics (same derivation as buildTree).
       const diskParentMap = React.useMemo(() => diskParentMapOf(items), [items])
 
@@ -8604,7 +8634,10 @@ window.__ModuleLoader__.load({
         // hierarchy to mirror, so they fall back to a flat workspace list.
         // Offering a nesting the sidebar is not showing would be a lie about
         // where the new group lands.
+        // v0.36.11: "workspaces" + an enabled name layer shows a root-level
+        // name tree — mirror it instead of claiming there is no hierarchy.
         const treeView = groupBy === 'workspace-tree'
+          || (groupBy === 'workspace' && workspaceGroupMode !== 'disk')
         if (kind === 'workspace') {
           // "Top level" IS a real target here (a group at the root of the
           // workspace tree), so it is a node like any other.
@@ -8832,6 +8865,18 @@ window.__ModuleLoader__.load({
         if (rel > 0.7) return 'after'
         return 'into'
       }
+      // v0.36.10: TRUE when the pointer sits in the row's ORIGINAL content
+      // box (a possibly-open slot's padding excluded). While this row holds
+      // a reorder slot the padding band keeps the slot verdict, and the
+      // content box re-judges the three bands — that is what keeps the
+      // INTO middle reachable after a slot opened. The old slotOpen lock
+      // answered before/after forever, so a pointer that entered through an
+      // edge band could never reach the middle: "拖到另一个下面(嵌套)" was
+      // unreachable through the natural approach path.
+      const pointerInRowBox = (event) => {
+        const box = originalBoxOf(event.currentTarget)
+        return event.clientY >= box.top && event.clientY <= box.bottom
+      }
       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
@@ -8902,7 +8947,23 @@ window.__ModuleLoader__.load({
         },
         onDragEnd: () => {
           if (wsDragArmTimer.current !== null) { clearTimeout(wsDragArmTimer.current); wsDragArmTimer.current = null }
+          const committed = dragDroppedRef.current
+          dragDroppedRef.current = false
+          const cancelled = dragCancelledRef.current
+          dragCancelledRef.current = false
+          const live = dragStateRef.current
           setDrag(null)
+          // v0.36.10: same resting-drag fallback as the folder dragEnd.
+          if (committed || cancelled || !live || live.kind !== 'workspace' || !live.over) return
+          const over = live.over
+          if (over.kind === 'folder') {
+            const zone = over.zone === 'before' || over.zone === 'after' ? over.zone : 'into'
+            if (zone === 'into') commitWorkspaceMoveInto(live.source, over.target)
+            else if ((live.source.levelKey || '') === parentKeyOf(over.target)) commitLevelReorder({ kind: 'workspace', source: live.source }, { kind: 'folder', target: over.target }, zone)
+            else commitWorkspaceLift(live.source, over.target, zone)
+          } else if (over.kind === 'workspace' && over.half && over.workspace) {
+            commitWorkspaceDrop(over.workspace, over.half)
+          }
         },
         onDragOver: (event) => {
           // A SESSION dragged onto the workspace row lands at the root level of
@@ -8943,8 +9004,28 @@ window.__ModuleLoader__.load({
                   ? current
                   : (current ? { ...current, over: { kind: 'ws-level', target: workspace.workspaceId } } : current))
               } else {
-                clearOver('workspace', workspace.workspaceId)
-                clearOver('ws-level', workspace.workspaceId)
+                // v0.36.10 GROUP LIFT: an EDGE band on a cross-level row of
+                // the SAME disk scope lifts the whole group out to this
+                // row's level, anchored at the row — "把平行帮拖到和用户
+                // 目录、工作平级". The row must not live inside the dragged
+                // group (that would nest the group under itself) and not on
+                // another disk (a title rename cannot cross disks).
+                const half = rowHalf(event)
+                const sourceScope = diskScopeOf(drag.source.idPath)
+                const targetDisk = diskParentMap.get(workspace.workspaceId) || workspace.workspaceId
+                const targetLevel = workspace.levelKey || ''
+                const insideSource = targetLevel === drag.source.idPath || targetLevel.startsWith(drag.source.idPath + '/')
+                if (half !== null && sourceScope !== null && targetDisk === sourceScope && !insideSource) {
+                  event.preventDefault()
+                  event.stopPropagation()
+                  try { event.dataTransfer.dropEffect = 'move' } catch { }
+                  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, workspace, folderLift: true } } : current))
+                } else {
+                  clearOver('workspace', workspace.workspaceId)
+                  clearOver('ws-level', workspace.workspaceId)
+                }
               }
               return
             }
@@ -8953,9 +9034,11 @@ window.__ModuleLoader__.load({
             try { event.dataTransfer.dropEffect = 'move' } catch { }
             const half = rowHalf(event)
             if (half === null) return
+            // The row object rides along for the dragEnd fallback (same
+            // reason as the folder over's node above).
             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))
+              : (current ? { ...current, over: { kind: 'workspace', target: workspace.workspaceId, half, workspace } } : current))
             return
           }
           if (!dragMatches('workspace')) return
@@ -8978,7 +9061,7 @@ window.__ModuleLoader__.load({
           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))
+            : (current ? { ...current, over: { kind: 'workspace', target: workspace.workspaceId, half, workspace } } : current))
         },
         onDrop: (event) => {
           if (dragMatches('session')) {
@@ -8997,12 +9080,23 @@ window.__ModuleLoader__.load({
               if (sourceLevel === (workspace.subPrefix || '')) {
                 event.preventDefault()
                 event.stopPropagation()
+                dragDroppedRef.current = true
                 commitFolderMoveToLevelEnd(drag.source)
+              } else {
+                // v0.36.10: the lift band armed in onDragOver.
+                const over = drag.over
+                if (over && over.kind === 'workspace' && over.target === workspace.workspaceId && over.folderLift && over.half) {
+                  event.preventDefault()
+                  event.stopPropagation()
+                  dragDroppedRef.current = true
+                  commitFolderLift(drag.source, workspace, over.half)
+                }
               }
               return
             }
             event.preventDefault()
             event.stopPropagation()
+            dragDroppedRef.current = true
             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
@@ -9013,6 +9107,7 @@ window.__ModuleLoader__.load({
           if (isOwnDescendantScope(diskParentMap.get(workspace.workspaceId), drag.source.workspaceId)) return
           event.preventDefault()
           event.stopPropagation()
+          dragDroppedRef.current = true
           const half = drag.over && drag.over.kind === 'workspace' && drag.over.target === workspace.workspaceId ? drag.over.half : rowHalf(event)
           commitWorkspaceDrop(workspace, half)
         },
@@ -9132,7 +9227,29 @@ window.__ModuleLoader__.load({
         },
         onDragEnd: () => {
           if (wsDragArmTimer.current !== null) { clearTimeout(wsDragArmTimer.current); wsDragArmTimer.current = null }
+          const committed = dragDroppedRef.current
+          dragDroppedRef.current = false
+          const cancelled = dragCancelledRef.current
+          dragCancelledRef.current = false
+          const live = dragStateRef.current
           setDrag(null)
+          // v0.36.10: no drop AND not cancelled means Chromium killed a
+          // RESTING drag (mouse-up as dragleave+dragend, drop never fires).
+          // Honor the armed {over} instead of throwing the gesture away —
+          // the user aimed at a visible slot/into for seconds. Escape still
+          // cancels for real.
+          if (committed || cancelled || !live || live.kind !== 'folder' || !live.over) return
+          const over = live.over
+          if (over.kind === 'folder') {
+            if (over.zone === 'before' || over.zone === 'after') commitFolderReorder(live.source, over.target, over.zone, over.node)
+            else commitFolderMoveInto(live.source, over.target)
+          } else if (over.kind === 'ws-level') {
+            commitFolderMoveToLevelEnd(live.source)
+          } else if (over.kind === 'workspace' && over.half && over.folderLift && over.workspace) {
+            commitFolderLift(live.source, over.workspace, over.half)
+          } else if (over.kind === 'workspace' && over.half && over.workspace) {
+            commitLevelReorder({ kind: 'folder', source: live.source }, { kind: 'workspace', workspace: over.workspace }, over.half)
+          }
         },
         onDragOver: (event) => {
           // Three bands on a group row: the outer 30% bands reorder this
@@ -9158,7 +9275,13 @@ window.__ModuleLoader__.load({
           // 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)
+          // v0.36.10: an open slot no longer locks the verdict. The slot's
+          // padding band keeps the slot (rowHalf is null there and the
+          // zone-null branch below holds), but the ORIGINAL content box
+          // re-judges the three bands — the INTO middle stays reachable.
+          const zone = slotOpen
+            ? (pointerInRowBox(event) ? rowZone(event) : rowHalf(event))
+            : rowZone(event)
           const isFolder = dragMatches('folder')
           const isWorkspace = dragMatches('workspace')
           if (isFolder) {
@@ -9226,9 +9349,12 @@ window.__ModuleLoader__.load({
           event.stopPropagation()
           try { event.dataTransfer.dropEffect = 'move' } catch { }
           const reorder = zone !== 'into'
+          // The row's node rides along: the dragEnd fallback (a Chromium
+          // resting drag that never fires drop) commits from {over} alone
+          // and needs it for the target-block anchor.
           const nextOver = reorder
-            ? { kind: 'folder', target: idPath, zone }
-            : { kind: 'folder', target: idPath, zone: 'into' }
+            ? { kind: 'folder', target: idPath, zone, node }
+            : { kind: 'folder', target: idPath, zone: 'into', node }
           setDrag(current => (current && current.over && current.over.kind === 'folder' && current.over.target === idPath && current.over.zone === nextOver.zone)
             ? current
             : (current ? { ...current, over: nextOver } : current))
@@ -9237,6 +9363,7 @@ window.__ModuleLoader__.load({
           if (dragMatches('folder')) {
             event.preventDefault()
             event.stopPropagation()
+            dragDroppedRef.current = true
             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)
@@ -9248,6 +9375,7 @@ window.__ModuleLoader__.load({
           if (isOwnDescendantScope(diskScopeOf(idPath), drag.source.workspaceId)) return
           event.preventDefault()
           event.stopPropagation()
+          dragDroppedRef.current = true
           // 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
@@ -9470,6 +9598,47 @@ window.__ModuleLoader__.load({
       // 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.
+      // v0.36.10 GROUP LIFT. Dropping a group row on a cross-level
+      // workspace row's EDGE band (same disk scope) means: take the whole
+      // group out of its parent, give it the target level's name prefix and
+      // place it beside that row — "把平行帮拖到和用户目录、工作平级".
+      // Mirrors commitWorkspaceLift: member renames plus a level token,
+      // never a disk move; the hover gate already checked scope and nesting.
+      const commitFolderLift = (source, workspace, zone) => {
+        setDrag(null)
+        if (!canDragWorkspace) { console.warn('[bw] folder lift refused: workspace reorder unavailable on this host'); return }
+        const targetLevel = workspace.levelKey || ''
+        if (targetLevel === source.idPath || targetLevel.startsWith(source.idPath + '/')) { console.warn('[bw] folder lift refused: target level inside the source', targetLevel); return }
+        const sourceLeaf = namePathOf(source.idPath).split('/').pop()
+        // The target level's name prefix: '' = the disk root (the group
+        // becomes a plain top-level group), otherwise the level key's name
+        // path after the owner separator.
+        const cutAt = targetLevel.lastIndexOf('//')
+        const levelNamePath = cutAt === -1 ? '' : targetLevel.slice(cutAt + 2)
+        const newSourcePath = levelNamePath === '' ? sourceLeaf : levelNamePath + '/' + sourceLeaf
+        const prefix = source.path + '/'
+        const affected = (items || []).filter((w) => String(w.title || '').startsWith(prefix))
+        if (!affected.length) { console.warn('[bw] folder lift refused: no members under', source.path); return }
+        Promise.resolve()
+          .then(async () => {
+            for (const w of affected) {
+              await renameWorkspace(w.workspaceId, newSourcePath + String(w.title).slice(source.path.length))
+            }
+          })
+          .then(() => {
+            removeLevelToken(source.levelKey || '', sourceLeaf)
+            insertLevelToken(targetLevel, sourceLeaf, 'w:' + workspace.workspaceId, zone === 'after' ? 'after' : 'before')
+            // Carry the group's own member order across to its NEW level
+            // key, so the members keep their inside order after the rename.
+            const oldContainer = folderContainerOf(source.idPath)
+            if (oldContainer && typeof actions.setFolderOrder === 'function') {
+              const owner = ownerPrefixOf(source.idPath)
+              const newKey = owner === '' ? newSourcePath : owner + '//' + newSourcePath
+              if (newKey !== source.idPath) actions.setFolderOrder(newKey, levelSeqOf(oldContainer).map(levelTokenOf))
+            }
+          })
+          .catch(fail)
+      }
       const commitFolderMoveInto = (source, targetIdPath) => {
         setDrag(null)
         const targetPath = namePathOf(targetIdPath)
@@ -9486,10 +9655,37 @@ window.__ModuleLoader__.load({
         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 }
+        // v0.36.10 NEST semantics: the group keeps its identity UNDER the
+        // target (工作/平行帮 → 工作/Fis管理后台/平行帮). The old prefix
+        // swap merged the members straight into the target's own level —
+        // "平行帮/Web" became "Fis管理后台/Web", colliding with the
+        // target's own Web and dying on workspace/name-conflict before
+        // anything moved: the "平级的没法拖动" report. Nesting names every
+        // member BELOW the moved group, which cannot collide with the
+        // target's direct children.
+        const sourceLeaf = namePathOf(source.idPath).split('/').pop()
+        const newSourcePath = targetPath + '/' + sourceLeaf
         Promise.resolve()
           .then(async () => {
             for (const w of affected) {
-              await renameWorkspace(w.workspaceId, targetPath + String(w.title).slice(source.path.length))
+              await renameWorkspace(w.workspaceId, newSourcePath + String(w.title).slice(source.path.length))
+            }
+          })
+          .then(() => {
+            // The group token moves from the source's level to INSIDE the
+            // target group, and the member order follows to the new key.
+            removeLevelToken(source.levelKey || '', sourceLeaf)
+            const targetContainer = folderContainerOf(targetIdPath)
+            if (targetContainer) {
+              const tokens = levelSeqOf(targetContainer).map(levelTokenOf)
+              if (tokens.length) insertLevelToken(targetIdPath, sourceLeaf, tokens[tokens.length - 1], 'after')
+              else if (typeof actions.setFolderOrder === 'function') actions.setFolderOrder(targetIdPath, [sourceLeaf])
+            }
+            const oldContainer = folderContainerOf(source.idPath)
+            if (oldContainer && typeof actions.setFolderOrder === 'function') {
+              const owner = ownerPrefixOf(source.idPath)
+              const newKey = owner === '' ? newSourcePath : owner + '//' + newSourcePath
+              if (newKey !== source.idPath) actions.setFolderOrder(newKey, levelSeqOf(oldContainer).map(levelTokenOf))
             }
           })
           // (v0.36.4) NO automatic expand after a move-into. v0.36.3 opened
@@ -10085,14 +10281,28 @@ window.__ModuleLoader__.load({
       } else if (groupBy === 'flat') {
         bodyRows.push(...renderFlatRows())
       } else if (groupBy === 'workspace') {
-        // Official 'workspace' mode (v0.13): one level — every workspace at
-        // the root, no name groups, no disk nesting, no chain compression.
-        // Session rows keep the slash toggle; disk-nested children do not
-        // recurse here because raw items carry no .sub level.
-        // flatWorkspaceEntry, never the raw item: see its note — the raw one
-        // has no `leaf` and the row would render nameless.
-        for (const workspace of items || []) {
-          bodyRows.push(...renderWorkspaceEntry({ workspace: flatWorkspaceEntry(workspace) }, 0, wsPulseOf(workspace)))
+        if (workspaceGroupMode === 'disk') {
+          // Official 'workspace' mode (v0.13): one level — every workspace at
+          // the root, no name groups, no disk nesting, no chain compression.
+          // Session rows keep the slash toggle; disk-nested children do not
+          // recurse here because raw items carry no .sub level.
+          // flatWorkspaceEntry, never the raw item: see its note — the raw
+          // one has no `leaf` and the row would render nameless.
+          for (const workspace of items || []) {
+            bodyRows.push(...renderWorkspaceEntry({ workspace: flatWorkspaceEntry(workspace) }, 0, wsPulseOf(workspace)))
+          }
+        } else {
+          // v0.36.11: with a NAME layer enabled (disk-slash / slash), the
+          // official scatter contradicts the user's mental model — the name
+          // tree the sidebar has been rendering all along should stay a tree,
+          // just lifted to the root (disk nesting OFF = 'slash' mode in the
+          // tree memo above). Same render loop as the tree branch below:
+          // mixed sequence, drag events, ungrouped block all apply.
+          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())
       } else {