dsh-sidebar-row-menu 1.4.3 → 1.5.1

package/CHANGELOG.md

@@ -1,5 +1,77 @@
 # Changelog
 
+## 1.5.1 — 2026-11-05
+
+### Fixed
+
+- **Session-row right-click entries appear every time on DSH 0.2.2.** The entries
+  (pinned app, Open with, permanent delete, delete archived) used to be gated by a
+  400 ms time window measured from the `contextmenu` event. 0.2.2 mounts the menu
+  asynchronously and, when a menu is already open, tears the previous panel down
+  before mounting the new one — that teardown reset the window, so the next menu
+  could come up without the plugin entries. The gate is now a gesture mark that is
+  cleared only once the menu panel has actually mounted, so right-click keeps its
+  entries while the row's `…` button still opens the untouched native menu.
+  On 0.2.2 the plugin also stops intercepting `contextmenu` and forwarding it as an
+  ellipsis click: the row already carries the host trigger, so the host opens its
+  own menu at the pointer (no anchor rewriting, no synthetic click).
+
+### Changed
+
+- **Docs and registry metadata describe the 0.2.2 behavior.** README (both languages),
+  the npm description and the marketplace entry no longer present the plugin as a
+  self-drawn sidebar menu. They now state that DSH 0.2.2 renders the menus and the
+  plugin contributes entries (workspace items interleaved by `order`, session rows
+  extended in the host menu opened at the pointer), and that 0.2.1 keeps the
+  self-drawn workspace menu.
+
+### 中文摘要
+
+- **修复 0.2.2 上会话行右键菜单「有时没有插件条目」**：条目原来用 `contextmenu`
+  之后 400 ms 的时间窗口判断，而 0.2.2 的菜单是异步挂载的，替换已有菜单时还会
+  先卸载旧面板再挂新面板，这次卸载会把窗口清掉，于是下一次菜单可能不带插件条目。
+  改为「右键手势标记」：只有菜单面板真正挂载后才收尾，右键稳定带条目，行尾「…」
+  打开的菜单仍然保持原生内容。
+  0.2.2 上也不再拦截 `contextmenu` 后转成「…」点击：行本身已带宿主触发器，直接
+  由宿主把菜单开在指针处（不改锚点、不补发点击）。
+- **文档与市场文案改为描述 0.2.2 的真实行为**：README（中英）、npm 描述与市场条目
+  不再写成「插件自绘侧栏菜单」，而是说明 0.2.2 由宿主渲染菜单、插件按 `order` 贡献
+  条目（工作区项混排、会话行扩展宿主开在指针处的菜单），0.2.1 上保留自绘工作区菜单。
+
+## 1.5.0 — 2026-11-05
+
+### Added
+
+- **DSH 0.2.2 native context menus**: on hosts that expose `ctx.contextMenus`, the
+  workspace-row entries are registered as data contributions instead of a self-drawn
+  menu. Entries keep their positions relative to the host items —
+  New session 90, pinned app 150, Open with 180, Copy workspace path 250,
+  Open in new tab 260, Delete workspace and all sessions 310 — so they interleave
+  with the native Rename (100), Reveal (200) and Delete workspace (300). Right-click
+  and the row's `…` button open the same menu, because the host now shares one menu
+  between them. On 0.2.1 the plugin still draws its own workspace menu. Session-row
+  entries keep using the `sidebar.workspaces.session.menu.item` extension point.
+
+### Fixed
+
+- The permanent-delete confirmation falls back to “Untitled session” instead of
+  showing an empty `会话「」` for sessions whose title has not been generated yet.
+- On 0.2.2 the settings page now hides the workspace-row “Also show in the … menu”
+  switches: the host shares one native menu between right-click and the `…` button,
+  so those per-entry toggles could never take effect there. The session-row switches
+  still work and stay visible.
+
+### 中文摘要
+
+- **支持 DSH 0.2.2 的原生右键菜单**：宿主提供 `ctx.contextMenus` 时，工作区行条目改为
+  数据贡献注册，按 order 与原生项交错排列（新会话 90、置顶应用 150、打开方式 180、
+  复制工作区路径 250、在新标签打开 260、删除工作区及所有会话 310；原生为重命名 100、
+  在文件夹显示 200、删除工作区 300）。右键与行尾「…」共用宿主同一份菜单。0.2.1 上仍
+  走自绘工作区菜单；会话行条目继续通过 `sidebar.workspaces.session.menu.item` 扩展点渲染。
+- 修复未命名会话「永久删除」确认框显示空标题的问题，回退为「未命名会话」。
+- 0.2.2 的设置页隐藏工作区行「同时放进「…」菜单」开关（该版本右键与「…」共用同一份
+  菜单，开关无从生效）；会话行的同类开关保留且仍然有效。
+
 ## 1.4.3 — 2026-11-04
 
 ### Changed

package/README.en.md

@@ -9,42 +9,59 @@
 
 Right-click menus for the sidebar of [DeepSeek Harness](https://github.com/deepseek-ai) (DSH):
 
-- **Workspace rows** — right-click opens a menu (a reimplementation of
-  `dsh-sidebar-context-menu`'s capabilities);
-- **Session rows nested under a workspace** — right-click opens that row's native
-  "…" menu at the pointer, with the plugin's own entries appended.
-
-The workspace menu is drawn with DSH's official `MenuSurface` + `MenuItemButton`
-(the official `Menu` cannot nest submenus), so rows, icons, danger color and group
-separators reuse the built-in look, and keyboard navigation plus click-outside
-dismissal match the native menus. Session menu content comes from the
-`sidebar.workspaces.session.menu.item` slot — built-in actions and other plugins'
-actions are all there. This plugin only appends its own entries; it does not copy
-or hardcode any built-in action.
-
-> The "…" button menu stays exactly as DSH ships it. The plugin's entries appear
-> only when the menu is opened by right-click. A right-click menu does not
-> close when the pointer leaves it (same as the workspace menu); it closes only on
-> an outside click, an item selection, or Escape.
+- **Workspace rows** — right-click opens a menu (since DSH 0.2.2 it is part of the
+  host's native menu, the same one the row's "…" button opens);
+- **Session rows nested under a workspace** — right-click opens that row's own menu
+  at the pointer, with the plugin's own entries appended.
+
+DSH 0.2.2 turned the sidebar context menus into data: the host renders the workspace
+menu and this plugin contributes its items by `order`; the session menu is still
+rendered from its slot by the host, and the host also opens it at the pointer. On
+0.2.2 the look, row height, icons, danger color, keyboard navigation and
+click-outside / Escape dismissal are therefore exactly the built-in menu's — the
+plugin only supplies entries. Hosts before 0.2.2 have no such service: the plugin
+still draws the workspace menu with DSH's official `MenuSurface` + `MenuItemButton`,
+and still moves the row's "…" menu to the pointer on right-click.
+
+Session menu content comes from the `sidebar.workspaces.session.menu.item` slot —
+built-in actions and other plugins' actions are all there. This plugin only appends
+its own entries; it does not copy or hardcode any built-in action.
+
+> The "…" button menu stays exactly as DSH ships it. The plugin's session entries
+> appear only when the menu is opened by right-click. On 0.2.2 both gestures share
+> one host menu, so the plugin tells them apart by the gesture itself: a right-click
+> sets a mark that is released once the menu panel has actually mounted, while the
+> pointerdown on the "…" button clears it immediately. A right-click menu does not
+> close when the pointer leaves it; it closes only on an outside click, an item
+> selection, or Escape.
 
 ## Features
 
 ### Workspace row
 
+On 0.2.2 the host renders this menu, and the plugin's items interleave with the
+built-in Rename (100), Reveal in file manager (200) and Delete workspace (300):
+New session 90, pinned app 150, Open with 180, Copy workspace path 250, Open in new
+tab 260, Delete workspace and all sessions 310. On 0.2.1 the plugin draws the whole
+menu and runs the official dialogs for Rename and Delete workspace.
+
 | Item | Behavior |
 | --- | --- |
 | New session | Expands the workspace and starts a session (same as the row's `+`) |
-| Rename | Opens the official "Rename workspace" dialog |
+| Rename (built-in) | Opens the official "Rename workspace" dialog; on 0.2.1 the plugin renders this item itself |
 | Pinned open-with app | A pinned app shows directly at the top level (e.g. "Open with Visual Studio Code") and opens the workspace directory |
 | Open with | A submenu of external apps (editors, terminals, file managers) sharing the session menu's catalog, pinning and toggles; hover expands it |
+| Reveal in file manager (built-in) | Opens the workspace directory in Explorer; provided by the host on 0.2.2, absent on 0.2.1 |
 | Copy workspace path | Copies the directory path |
 | Open in new tab | Only when `dsh-project-tabs` (exposing `openWorkspaceInTab`) is installed |
-| Delete workspace | Opens the official delete confirmation; removes only the workspace registration and leaves its sessions under "Ungrouped" |
+| Delete workspace (built-in) | Opens the official delete confirmation; removes only the workspace registration and leaves its sessions under "Ungrouped". On 0.2.1 the plugin renders this item itself |
 | Delete workspace and all sessions | Permanently deletes every session and transcript under the workspace first, then the workspace registration. If any session fails, the workspace is kept so the user can retry. The directory itself is not deleted |
 
 ### Session row
 
-Right-click does not build a second menu; it opens the row's own "…" menu:
+Right-click does not build a second menu: on 0.2.2 the host opens the row's native
+menu at the pointer, and on 0.2.1 the plugin triggers the row's "…" menu and moves
+its anchor to the pointer. Either way the content comes from the same slot:
 
 | Source | Entries |
 | --- | --- |
@@ -69,17 +86,21 @@ unarchived sessions alone by default; the opt-in switch extends the single-sessi
 entry to them. Deletion never cascades into forked child sessions.
 
 These entries are **right-click only by default**: they do not mount when the "…"
-button opens the menu. A short-lived window flag is set before opening; outside that
-window the entries render `null`.
+button opens the menu. There is no time window any more; the plugin sets a
+right-click gesture mark and releases it only once the menu panel has actually
+appeared (0.2.2 mounts the menu asynchronously), and the pointerdown on the "…"
+button clears it at once. While the mark is live the entries render normally;
+otherwise they render `null`.
 
 To use them from the row's "…" button, enable them one by one under Settings →
 "Row menu" → "Also show in the "…" menu". Session entries mount into the native
-"…" menu; enabling any workspace entry makes this plugin take over the row's "…"
-button and render the official "Rename / Delete workspace" items alongside the
-enabled plugin entries. With everything off, the "…" button behaves exactly like
-DSH's own.
+"…" menu; on 0.2.1, enabling any workspace entry makes this plugin take over the
+row's "…" button and render the official "Rename / Delete workspace" items alongside
+the enabled plugin entries (on 0.2.2 the host has only one menu, so that group of
+switches is hidden). With everything off, the "…" button behaves exactly like DSH's
+own.
 
-Blank draft sessions have no native "…" menu and are left alone. Rows that are
+Blank draft sessions have no right-click menu and are left alone. Rows that are
 neither a workspace nor a session (e.g. "Show more") are not intercepted.
 
 ### Settings
@@ -93,12 +114,17 @@ Settings → "Row menu" toggles every new entry:
 | Delete session | Hides the single-session delete entry in session menus |
 | Allow deleting unarchived sessions | Off by default; also shows "Delete session permanently" on unarchived rows. Requires the previous switch |
 | Delete all archived sessions | Hides the bulk-delete entry |
-| Also show in the "…" menu → workspace | Adds workspace right-click entries one by one to the row's "…" menu: New session, Open with, Copy workspace path, Open in new tab, Delete workspace and all sessions. Enabling any of them makes this plugin render the "…" menu |
+| Also show in the "…" menu → workspace (0.2.1 only) | Adds workspace right-click entries one by one to the row's "…" menu: New session, Open with, Copy workspace path, Open in new tab, Delete workspace and all sessions. Enabling any of them makes this plugin render the "…" menu |
 | Also show in the "…" menu → session | Adds session right-click entries one by one to the native "…" menu: Open with, Delete session, Delete all archived sessions |
 
 The "Also show in the "…" menu" switches are all off by default; until one is
 enabled the "…" menu is exactly DSH's own.
 
+On DSH 0.2.2 and later, the workspace row's right-click and "…" already open the
+same host menu, so the plugin entries always show up there; the "Also show in the
+"…" menu → workspace" switches only affect 0.2.1 and older hosts, so they are hidden
+on 0.2.2.
+
 Switches live in browser `localStorage` (`dsh.sidebar-row-menu.items.v1`,
 `dsh.sidebar-row-menu.open-with.v1`, `dsh.sidebar-row-menu.open-with.pinned.v1` and
 `dsh.sidebar-row-menu.ellipsis.v1`)
@@ -328,46 +354,72 @@ row components are:
 
 The plugin reads `__reactFiber$` from the event target during the capture phase of
 `contextmenu`, then walks up to 60 `return` links looking for matching
-`memoizedProps`. If nothing matches it does not intercept at all.
+`memoizedProps`. If nothing matches it does not intercept at all. On 0.2.2 the fiber
+is also used to tell whether the row already carries the host's own context menu
+trigger (`memoizedProps.onContextMenu` is a function): if it does, the host opens the
+menu at the pointer by itself and the plugin only drops a gesture mark, never
+touching the event.
 
 ### Why session actions are not hardcoded
 
-The native "…" menu is not a hardcoded button list: it is
+The native session menu is not a hardcoded button list: it is
 `renderSlot('sidebar.workspaces.session.menu.item', ...)`. Fork, pin, archive and
 third-party actions are all slot entries. Slot ownership is enforced by the
 renderer: an entry may only render child slots it declared itself, so a third
 party cannot re-layout someone else's slot.
 
-Therefore a session right-click does exactly one thing: find the `Menu` in the
-row's fiber subtree and trigger its anchor (the ellipsis button). The same slot
-content opens. The plugin's own actions are registered through
-`ctx.slots.inject` + `ctx.slots.register`, so:
+So a session right-click never copies menu content:
+
+- 0.2.2: the row component carries the host's `getTriggerProps` (its `onContextMenu`
+  hands `kind:'session'` to `ctx.contextMenus`), so the host owns the gesture and the
+  plugin does not even need to find a `Menu` or click a button;
+- 0.2.1: find the `Menu` in the row's fiber subtree and trigger its anchor (the
+  ellipsis button), which opens the same slot content.
+
+The plugin's own actions are registered through `ctx.slots.inject` +
+`ctx.slots.register`, so:
 
 - they do not depend on built-in fork/pin entries existing;
 - new entries from DSH or other plugins show up automatically;
 - no built-in action is copied or hardcoded.
 
-Workspace rows have no such slot, so their menu is still composed by this plugin.
-The official `Menu` accepts only a flat `items` list and cannot express submenus, so
-the workspace menu is drawn with `MenuSurface` + `MenuItemButton`: rows, icons,
-danger styling and separators reuse the official controls.
+Workspace rows have no such slot on 0.2.1, so their menu is composed by this plugin.
+Since 0.2.2 the host provides `ctx.contextMenus` and the workspace items become data
+contributions — again just "adding its own items to the host's menu". The official
+`Menu` accepts only a flat `items` list and cannot express submenus, so the 0.2.1
+workspace menu is drawn with `MenuSurface` + `MenuItemButton`: rows, icons, danger
+styling and separators reuse the official controls.
 
 ### Why the session menu appears at the pointer
 
-The official `Menu` anchors to the ellipsis button, i.e. to the right of it. On
-right-click the plugin temporarily points that button's (and two ancestors')
+On 0.2.2 there is nothing to do: the host's `onContextMenu` passes `clientX /
+clientY` to `ctx.contextMenus.open()`, and the panel renders at the pointer.
+
+On 0.2.1 the official `Menu` anchors to the ellipsis button, i.e. to the right of it.
+On right-click the plugin temporarily points that button's (and two ancestors')
 `getBoundingClientRect` at the pointer as a `0×0` rect. `Menu` re-reads the anchor
 rect every frame, so the panel lands next to the cursor. The original methods are
 restored as soon as the panel leaves `body`, so the button menu keeps its normal
 position.
 
-The "…" menu and the right-click menu share one `Menu` instance and one slot
-content; the only difference is the `rightClickMenuUntil` window — the plugin's
-entries mount only inside it, and the window is cleared when the menu closes.
+### Why the right-click entries never show in the "…" menu
+
+On 0.2.2 both gestures open the same host menu, and React cannot tell where it came
+from, so the plugin watches the gesture: a right-click sets an in-process mark, and a
+`MutationObserver` waits for a new `[role="menu"]` panel to appear (0.2.2 mounts the
+menu asynchronously, after every provider is ready); once the panel shows up the mark
+is released 400 ms later, with a 3 s fallback in case another plugin swallows the
+gesture. The `pointerdown` on the row's "…" button clears the mark immediately, and
+only trusted input counts (`isTrusted`) — the synthetic `pointerdown` the plugin
+re-dispatches is not a gesture.
 
-### Why the workspace menu is mounted imperatively
+Entries read the mark once while mounting, so a slow panel does not matter, and the
+mark only lives until "the panel for this gesture appeared", never into the next one.
 
-A contextmenu event is not part of React's render flow. The workspace menu creates
+### Why the 0.2.1 menu is mounted imperatively
+
+On 0.2.2 the host mounts every menu and the plugin creates no container. On 0.2.1 a
+contextmenu event is not part of React's render flow, so the workspace menu creates
 a `0×0`, `z-index:2147483647` host on demand and `createRoot`s a self-drawn panel;
 after mount it measures once and clamps its corner into the viewport, then unmounts
 and removes the host on close. The session menu mounts nothing new; it only opens
@@ -422,19 +474,38 @@ The package declares its supported DSH range in `package.json` as
 incompatible installs, and the plugin market shows it as the supported version;
 0.3 and later need re-verification before the upper bound is raised.
 
-Built against DSH client `0.2.1-rc.5` (`ProjectRowItem`, `SessionNodeItem`,
-`Menu`). If a DSH upgrade changes those row components or the menu positioning:
-
-- workspace right-click silently stops appearing (no error, no UI breakage);
+Built against DSH client `0.2.1-rc.5` and `0.2.2` (`ProjectRowItem`,
+`SessionNodeItem`, `Menu`, `contextMenus`). DSH 0.2.2 moved the sidebar context
+menus to a data-driven service, and the plugin picks the path by host capability:
+
+- **0.2.2+**: workspace entries are registered with `ctx.contextMenus.register`
+  (New session 90, pinned app 150, Open with 180, Copy workspace path 250,
+  Open in new tab 260, Delete workspace and all sessions 310), interleaved by
+  order with the native Rename (100), Reveal (200) and Delete workspace (300).
+  Right-click and the "…" button share the host's single menu.
+- **0.2.1**: no `contextMenus` service, so the plugin keeps drawing its own
+  workspace menu.
+- **Session rows**: 0.2.2 still supports the
+  `sidebar.workspaces.session.menu.item` extension point; the plugin entries keep
+  mounting there, and right-click still opens the host menu at the pointer.
+
+If a DSH upgrade changes those row components or the menu positioning:
+
+- workspace right-click falls back to the self-drawn menu (0.2.1 path) or silently
+  stops appearing (no error, no UI breakage);
 - session right-click falls back to opening next to the "…" button, with correct content.
 
 ## Known limitations
 
-- Depends on the props shape of the built-in row components. If DSH changes them,
-  right-click silently does nothing.
-- Session right-click depends on the row's `Menu` staying in the fiber subtree. If
-  it is not found, the plugin clicks the row-actions ellipsis button; failing that
-  it gives up — it never builds a competing menu and never triggers row open.
+- On 0.2.1 the plugin depends on the props shape of the built-in row components.
+  From 0.2.2 the workspace entries use `contextMenus`, the session entries still
+  use the legacy extension point, and `memoizedProps.onContextMenu` decides whether
+  the host has taken the row over. If DSH changes that implementation, right-click
+  may silently do nothing.
+- On 0.2.1 session right-click depends on the row's `Menu` staying in the fiber
+  subtree. If it is not found, the plugin clicks the row-actions ellipsis button;
+  failing that it gives up — it never builds a competing menu and never triggers row
+  open. On 0.2.2 no fallback is needed: the host is the trigger.
 - Permanent deletion is offered for **archived** sessions by default; enable
   "Allow deleting unarchived sessions" to delete unarchived sessions from their
   right-click menu as well. Deletion does not cascade into forked child sessions —

package/README.md

@@ -9,36 +9,49 @@
 
 给 [DeepSeek Harness](https://github.com/deepseek-ai)（DSH）左侧边栏加右键菜单：
 
-- **工作区行**：右键弹出菜单（复刻 `dsh-sidebar-context-menu` 的能力）；
-- **工作区下层的会话行**：右键在指针处展开该行内置的「…」菜单，并追加本插件的条目。
+- **工作区行**：右键弹出菜单（DSH 0.2.2 起并入宿主原生菜单，与行尾「…」是同一份）；
+- **工作区下层的会话行**：右键在指针处展开该行自己的菜单，并追加本插件的条目。
 
-工作区菜单用 DSH 官方的 `MenuSurface` + `MenuItemButton` 自绘（官方 `Menu` 的条目不支持
-子菜单），视觉、行高、图标、危险色与分组分隔线都复用官方控件，键盘导航和“点外部关闭”
-与内置菜单一致。会话菜单的内容来自
+DSH 0.2.2 把侧栏右键改成数据驱动：工作区菜单由宿主统一渲染，本插件按 order 把条目混排
+进去；会话菜单仍由宿主渲染 slot 内容，右键也由宿主开在指针处。所以 0.2.2 上菜单的视觉、
+行高、图标、危险色、键盘导航，以及“点外部关闭 / Esc 关闭”全部与内置菜单一致，本插件只
+提供条目。0.2.1 及更早的宿主没有这套服务：工作区菜单仍由本插件用官方 `MenuSurface` +
+`MenuItemButton` 自绘，会话右键仍由插件把行尾「…」菜单搬到指针处。
+
+会话菜单的内容来自
 `sidebar.workspaces.session.menu.item` slot —— 内置动作和其他插件的动作都在里面，
 本插件只追加自己的条目，不复制、不硬编码任何内置动作。
 
-> 点行尾「…」按钮看到的菜单保持 DSH 原样；本插件自己的条目只在右键展开时出现。
-> 右键展开的菜单不会因为鼠标移出而关闭（与工作区右键一致），只有点击外部、选中条目或按 Esc 才关闭。
+> 点行尾「…」按钮看到的会话菜单保持 DSH 原样；本插件的会话条目只在右键展开时出现。
+> 0.2.2 上右键与「…」共用同一份宿主菜单，插件按“右键手势”区分：右键时打标，等菜单面板
+> 真正挂载后才收尾；点「…」的按下事件会立刻清标，所以那个菜单不带右键条目。
+> 右键展开的菜单不会因为鼠标移出而关闭，只有点击外部、选中条目或按 Esc 才关闭。
 
 ## 功能
 
 ### 工作区行右键
 
+0.2.2 上这份菜单由宿主渲染，本插件条目与内置「重命名」（100）、「在文件夹显示」（200）、
+「删除工作区」（300）按 order 交错：新会话 90、置顶应用 150、打开方式 180、复制工作区
+路径 250、在新标签打开 260、删除工作区及所有会话 310。0.2.1 上整份菜单由本插件自绘，
+「重命名」「删除工作区」由插件调用官方对话框。
+
 | 菜单项 | 行为 |
 | --- | --- |
 | 新会话 | 展开该工作区并新建会话（等价于行尾 `+`） |
-| 重命名 | 打开官方“重命名工作区”对话框 |
+| 重命名（内置） | 打开官方“重命名工作区”对话框；0.2.1 上由本插件代为渲染 |
 | 置顶的打开方式 | 被置顶的应用直接显示在一级菜单（例如「用 Visual Studio Code 打开」），点击后用该应用打开工作区目录 |
 | 打开方式 | 二级菜单列出宿主提供的外部应用（编辑器、终端、文件管理器）；与会话菜单共用同一套应用列表、置顶与开关设置，鼠标悬浮自动展开 |
+| 在文件夹显示（内置） | 在资源管理器里打开工作区目录；0.2.2 由宿主提供，0.2.1 上不出现 |
 | 复制工作区路径 | 复制目录路径到剪贴板 |
 | 在新标签中打开 | 仅在装有 `dsh-project-tabs`（暴露 `openWorkspaceInTab`）时出现 |
-| 删除工作区 | 打开官方删除确认对话框；只删除工作区登记，会话保留并归入「未分组」 |
+| 删除工作区（内置） | 打开官方删除确认对话框；只删除工作区登记，会话保留并归入「未分组」。0.2.1 上由本插件代为渲染 |
 | 删除工作区及所有会话 | 先永久删除该工作区下的每个会话及其日志，全部成功后再删除工作区登记；任一会话删除失败则保留工作区，便于重试。工作区目录本身不删除 |
 
 ### 会话行右键
 
-右键会话行不会另起一套菜单，而是展开该行自己的「…」菜单：
+右键会话行不会另起一套菜单：0.2.2 由宿主把该行的原生菜单开在指针处；0.2.1 由本插件触发行尾
+「…」菜单，并临时把它的锚点移到指针。两种情况下菜单内容都来自同一份 slot：
 
 | 来源 | 条目 |
 | --- | --- |
@@ -60,14 +73,16 @@
 一级菜单。两个删除入口由本插件自己的宿主路由完成，默认不会删除未归档会话；
 开启「允许删除未归档会话」后才会对普通会话开放。删除不会级联删除 fork 子会话。
 
-这些条目默认是**右键专属**：点行尾「…」按钮时它们不挂载。实现上使用一个只在右键展开瞬间
-有效的窗口标记，窗口外的渲染直接返回 `null`。
+这些条目默认是**右键专属**：点行尾「…」按钮时它们不挂载。实现上不再用时间窗口，而是
+「右键手势标记」：右键时打标，等菜单面板真正出现（0.2.2 的挂载是异步的）后才释放；点
+「…」的按下事件会立刻清标。标记有效期内的条目正常渲染，其余情况渲染直接返回 `null`。
 
 如果想直接使用行尾「…」菜单，可以在设置 →「行菜单」→「同时放进「…」菜单」里逐个开启：
-会话条目会挂进原生「…」菜单；工作区行开启任意一项后，本插件会接管行尾「…」按钮，用同一套
-菜单展示官方「重命名 / 删除工作区」加上已开启的插件条目。全部关闭时「…」按钮保持 DSH 原样。
+会话条目会挂进原生「…」菜单；0.2.1 上工作区行开启任意一项后，本插件会接管行尾「…」按钮，
+用同一套菜单展示官方「重命名 / 删除工作区」加上已开启的插件条目（0.2.2 的宿主本来就只有
+一份菜单，这组开关在设置页隐藏）。全部关闭时「…」按钮保持 DSH 原样。
 
-草稿会话（还没有任何消息的空白会话）没有内置「…」菜单，本插件同样不接管。
+草稿会话（还没有任何消息的空白会话）没有右键菜单，本插件同样不接管。
 非工作区 / 非会话的侧边栏行（如“显示更多”）也不会被拦截。
 
 ### 设置
@@ -81,11 +96,14 @@
 | 永久删除会话 | 关闭后会话菜单里不再出现单条删除入口 |
 | 允许删除未归档会话 | 默认关闭；开启后未归档会话的右键菜单也会出现「永久删除会话」，需先开启上一项 |
 | 删除所有已归档会话 | 关闭后不再出现批量删除入口 |
-| 同时放进「…」菜单 → 工作区 | 逐项把工作区行右键条目加进行尾「…」菜单：新会话、打开方式、复制工作区路径、在新标签中打开、删除工作区及所有会话。开启任意一项后「…」按钮改由本插件渲染 |
+| 同时放进「…」菜单 → 工作区（仅 0.2.1） | 逐项把工作区行右键条目加进行尾「…」菜单：新会话、打开方式、复制工作区路径、在新标签中打开、删除工作区及所有会话。开启任意一项后「…」按钮改由本插件渲染 |
 | 同时放进「…」菜单 → 会话 | 逐项把会话行右键条目加进原生「…」菜单：打开方式、永久删除会话、删除所有已归档会话 |
 
 「同时放进「…」菜单」下的开关默认全部关闭，`…` 菜单在未开启时与 DSH 完全一致。
 
+DSH 0.2.2 起，工作区行的右键与「…」本身就是同一份宿主菜单，插件条目会一直出现在「…」里，
+「同时放进「…」菜单 → 工作区」这组开关只影响 0.2.1 及更早的宿主，所以在 0.2.2 上隐藏。
+
 开关存在浏览器 `localStorage`（`dsh.sidebar-row-menu.items.v1`、
 `dsh.sidebar-row-menu.open-with.v1`、`dsh.sidebar-row-menu.open-with.pinned.v1` 与
 `dsh.sidebar-row-menu.ellipsis.v1`），
@@ -260,8 +278,9 @@ npm run build       # npm pack（prepack 会先跑 check），产出 .tgz
 测试覆盖宿主侧纯函数（路径校验、`vscode://file` 编码、loopback 判定、路由状态码）
 和客户端模块（模块 id、导出、依赖白名单、监听器安装/卸载、slot 注册表），并用伪造的
 `__reactFiber$`、DOM 与 `Menu` 宿主做集成测试：工作区右键的菜单项顺序、会话右键是否
-展开内置菜单而不是自建菜单、草稿行是否被放过、复制工作区路径的 Toast 反馈都在断言里。
-真实 fiber 与服务仍需在运行中的 GUI 里做人工验证。
+展开内置菜单而不是自建菜单、行自身带宿主 `onContextMenu` 时是否完全不拦截（只补一次
+`pointerdown`）、点「…」后右键条目是否立刻消失、草稿行是否被放过、复制工作区路径的
+Toast 反馈都在断言里。真实 fiber 与服务仍需在运行中的 GUI 里做人工验证。
 
 目录：
 
@@ -291,43 +310,62 @@ test/*.test.mjs       node:test
   `{ id, title, blank, running, archived, pinned, updatedAt }`。
 
 插件在 `contextmenu` 捕获阶段从目标节点拿 `__reactFiber$`，向上最多 60 层找匹配的
-`memoizedProps`。找不到就完全不拦截，避免影响其他行和其他插件。
+`memoizedProps`。找不到就完全不拦截，避免影响其他行和其他插件。0.2.2 上 fiber 还用来判断
+这一行是否天生带宿主右键触发器（`memoizedProps.onContextMenu` 是函数）：有就说明宿主会把
+菜单开在指针处，插件只补一个手势标记，不再干预事件。
 
 ### 会话行为什么不硬编码
 
-内置「…」菜单不是硬编码的按钮列表，而是
+内置会话菜单不是硬编码的按钮列表，而是
 `renderSlot('sidebar.workspaces.session.menu.item', ...)` 的结果；内置的分叉、置顶、
 归档，以及第三方插件的能力，都以 slot 条目形式注册。slot 的所有权由渲染器校验：
 每个条目只能渲染自己声明过的子 slot，第三方无法直接把手伸进别人的 slot 重新排版。
 
-因此会话行右键只做一件事：在行组件的 fiber 子树里找到那个 `Menu`，触发它 anchor
-（省略号按钮）的点击，展开的自然是同一份 slot 内容。本插件自己的动作也通过
-`ctx.slots.inject` + `ctx.slots.register` 注册进去，所以：
+因此会话行右键从不复制菜单内容：
+
+- 0.2.2：行组件自己带宿主的 `getTriggerProps`（`onContextMenu` 直接把 `kind:'session'`
+  交给 `ctx.contextMenus`），右键由宿主处理，插件连「找 Menu、代点按钮」都不需要做；
+- 0.2.1：在行组件的 fiber 子树里找到那个 `Menu`，触发它 anchor（省略号按钮）的点击，
+  展开的自然是同一份 slot 内容。
+
+本插件自己的动作也通过 `ctx.slots.inject` + `ctx.slots.register` 注册进去，所以：
 
 - 不依赖「分叉」「置顶」这些内置条目是否存在；
 - 内置或别的插件以后新增条目，右键菜单自动出现；
 - 不复制、不硬编码任何内置动作。
 
-工作区行没有这样的 slot，所以工作区菜单仍由本插件自己组项。官方 `Menu` 的
-`items` 只支持单层条目，无法表达子菜单，因此工作区菜单用 `MenuSurface` +
-`MenuItemButton` 自绘：行、图标、危险色和分隔线都复用官方控件，交互与官方菜单一致。
+工作区行在 0.2.1 上没有这样的 slot，所以菜单由本插件自己组项；0.2.2 起宿主提供
+`ctx.contextMenus`，工作区条目改为数据贡献，同样只是“往宿主菜单里加自己的项”。
+官方 `Menu` 的 `items` 只支持单层条目，无法表达子菜单，因此 0.2.1 的工作区菜单用
+`MenuSurface` + `MenuItemButton` 自绘：行、图标、危险色和分隔线都复用官方控件。
 
 ### 为什么会话菜单能贴着鼠标
 
-官方 `Menu` 的 `anchor` 是那个省略号按钮，默认位置就在按钮右侧。右键时插件临时把
+0.2.2 上什么都不用做：宿主的 `onContextMenu` 直接把 `clientX / clientY` 交给
+`ctx.contextMenus.open()`，面板就渲染在指针处。
+
+0.2.1 上官方 `Menu` 的 `anchor` 是那个省略号按钮，默认位置就在按钮右侧。右键时插件临时把
 该按钮及其两层祖先的 `getBoundingClientRect` 指到指针位置（`0×0` 矩形），官方 `Menu`
 每帧读取锚点 rect 重新定位，于是面板出现在鼠标旁；面板从 `body` 移除时立即还原原始
 方法，不影响按钮菜单的默认位置。
 
-「…」按钮菜单与右键菜单共用同一个 `Menu` 实例和同一份 slot 内容，区别只在
-`rightClickMenuUntil` 窗口：本插件条目只在窗口内挂载，窗口随菜单关闭一并清零。
+### 为什么右键条目不会出现在「…」菜单里
+
+0.2.2 上右键与「…」打开的是同一份宿主菜单，React 侧无法区分来源，只能看手势：右键时在
+进程内打一个标记，用 `MutationObserver` 等一个新的 `[role="menu"]` 面板出现（0.2.2 的
+菜单是异步挂载的，还要等 provider 就绪），面板出现后再延迟 400 ms 收尾；3 秒兜底防止手势
+被别的插件吞掉。行尾「…」的 `pointerdown` 会立刻清标，只认真实输入（`isTrusted`），因为
+插件自己补发的合成 `pointerdown` 不算手势。
+
+条目在挂载时读一次标记，所以面板挂得晚也不影响；标记只活到“这次手势对应的面板出现”，
+不会漏进下一次。
 
-### 为什么菜单是命令式挂载
+### 为什么 0.2.1 的菜单是命令式挂载
 
-右键事件不是 React 渲染流的一部分。工作区菜单按需创建一个 `0×0`、
-`z-index:2147483647` 的容器，`createRoot` 渲染自绘面板；面板挂载后量一次尺寸，
-再把左上角夹进视口，避免贴边时被裁掉。关闭时 `unmount()` 并移除容器。会话菜单不挂载任何
-新容器，只是打开行内已有的官方菜单。
+0.2.2 的菜单全部由宿主挂载，插件不创建任何容器。0.2.1 上右键事件不是 React 渲染流的一部分，
+工作区菜单按需创建一个 `0×0`、`z-index:2147483647` 的容器，`createRoot` 渲染自绘面板；面板
+挂载后量一次尺寸，再把左上角夹进视口，避免贴边时被裁掉。关闭时 `unmount()` 并移除容器。
+会话菜单不挂载任何新容器，只是打开行内已有的官方菜单。
 
 ### 宿主路由
 
@@ -369,17 +407,30 @@ test/*.test.mjs       node:test
 DSH 宿主按该范围拒绝安装不兼容的宿主，插件市场也按它显示支持版本；0.3 起需要重新验证后
 再放宽上限。
 
-按 DSH 客户端 `0.2.1-rc.5` 的 `ProjectRowItem` / `SessionNodeItem` / `Menu` 实现。
+按 DSH 客户端 `0.2.1-rc.5` 与 `0.2.2` 的 `ProjectRowItem` / `SessionNodeItem` / `Menu`
+与 `contextMenus` 实现适配。DSH 0.2.2 起把侧栏右键菜单改成数据驱动，本包按宿主能力自动选路：
+
+- **0.2.2 及以上**：工作区行改用 `ctx.contextMenus.register` 贡献动作
+  （新会话 90、置顶应用 150、打开方式 180、复制路径 250、新标签 260、删除工作区及所有会话 310），
+  与原生「重命名」「在文件夹显示」「删除工作区」按 order 交错排列；右键与「…」共用同一份
+  宿主菜单，插件不再自绘，也不再接管「…」按钮。会话行由宿主自己把原生菜单开在指针处，
+  本包条目继续从 `sidebar.workspaces.session.menu.item` 渲染；
+- **0.2.1**：没有 `contextMenus` 服务，保持原来的自绘工作区菜单；会话右键仍由插件把
+  行尾「…」菜单搬到指针。
+
 DSH 升级若改动行组件或菜单定位实现：
 
-- 工作区右键会静默不弹（不会报错、不影响原界面）；
+- 工作区右键会退回自绘菜单（0.2.1 路径），或静默不弹（不会报错、不影响原界面）；
 - 会话右键会退回行尾「…」按钮旁，内容仍然正确。
 
 ## 已知限制
 
-- 依赖 DSH 内置行组件的 props 形状。DSH 升级若改了这两个组件，右键会静默不弹。
-- 会话右键依赖行内 `Menu` 组件仍在 fiber 子树里。找不到时退回点击行内操作区的
-  省略号按钮，再找不到就放弃 —— 不会自建菜单，也不会误触行的打开动作。
+- 0.2.1 下依赖 DSH 内置行组件的 props 形状；0.2.2 起工作区条目改走 `contextMenus`，
+  会话条目仍依赖旧扩展点，并用 `memoizedProps.onContextMenu` 判断这一行是否已由宿主接管。
+  DSH 升级若改掉对应实现，右键可能静默不弹。
+- 0.2.1 的会话右键依赖行内 `Menu` 组件仍在 fiber 子树里。找不到时退回点击行内操作区的
+  省略号按钮，再找不到就放弃 —— 不会自建菜单，也不会误触行的打开动作。0.2.2 上不需要
+  这段回退，宿主自己就是触发器。
 - 永久删除默认只对**已归档**会话开放；在设置里开启「允许删除未归档会话」后，未归档
   会话也能从右键菜单直接删除。删除不会级联删除 fork 出来的子会话，需要时请分别删除。
 - 删除操作直接作用于会话日志目录，宿主没有回收站；确认框里已明确提示不可恢复。

package/lib/client.js

@@ -187,6 +187,7 @@ window.__ModuleLoader__.load({
       'settings.collapse': '收起应用列表',
       'settings.ellipsisTitle': '同时放进「…」菜单',
       'settings.ellipsisHint': '勾选后，对应条目会额外出现在行尾「…」按钮的菜单里，并沿用上面的单项开关；不勾选则只在右键菜单出现。',
+      'settings.ellipsisHintNative': '当前 DSH 版本的「…」按钮与右键共用同一份菜单，工作区行无需单独登记；这里只保留会话行的开关。',
       'settings.ellipsisWorkspace': '工作区行',
       'settings.ellipsisSession': '会话行',
       'settings.ellipsis.newSession.label': '新建会话',
@@ -207,6 +208,7 @@ window.__ModuleLoader__.load({
       'settings.ellipsis.sessionDeleteArchived.hint': '在已归档会话的「…」菜单里一次清理全部归档会话。',
       'delete.title': '永久删除会话？',
       'delete.description': '会话「{name}」的日志将从磁盘永久删除，此操作无法撤销。',
+      'delete.untitled': '未命名会话',
       'delete.archivedTitle': '删除所有已归档会话？',
       'delete.archivedDescription': '将永久删除 {n} 个已归档会话及其日志，此操作无法撤销。',
       'delete.confirm': '永久删除',
@@ -270,6 +272,7 @@ window.__ModuleLoader__.load({
       'settings.collapse': 'Hide applications',
       'settings.ellipsisTitle': 'Also show in the "…" menu',
       'settings.ellipsisHint': 'Checked entries also appear in the row\'s "…" button menu, still subject to the switches above. Unchecked entries stay right-click only.',
+      'settings.ellipsisHintNative': 'In this DSH version the "…" button opens the same menu as right-click, so workspace rows need no separate entries; only the session row switches below apply.',
       'settings.ellipsisWorkspace': 'Workspace rows',
       'settings.ellipsisSession': 'Session rows',
       'settings.ellipsis.newSession.label': 'New session',
@@ -290,6 +293,7 @@ window.__ModuleLoader__.load({
       'settings.ellipsis.sessionDeleteArchived.hint': 'Clean up every archived session from an archived row\'s "…" menu.',
       'delete.title': 'Delete this session permanently?',
       'delete.description': 'The log of "{name}" will be removed from disk. This cannot be undone.',
+      'delete.untitled': 'Untitled session',
       'delete.archivedTitle': 'Delete all archived sessions?',
       'delete.archivedDescription': 'Permanently delete {n} archived sessions and their logs. This cannot be undone.',
       'delete.confirm': 'Delete permanently',
@@ -1140,7 +1144,7 @@ window.__ModuleLoader__.load({
             : t('delete.workspaceEmptyDescription', { name: request.displayTitle ?? '' }))
           : bulk
             ? t('delete.archivedDescription', { n: ids.length })
-            : t('delete.description', { name: request.displayTitle ?? '' }),
+            : t('delete.description', { name: request.displayTitle || t('delete.untitled') }),
         footer: h(Fragment, null,
           jsx(Button, { variant: 'outline', disabled: busy, onClick: close, children: t('delete.cancel') }),
           jsx(Button, {
@@ -1499,6 +1503,11 @@ window.__ModuleLoader__.load({
       const children = useChildren();
       const apps = useApps();
       usePinned();
+      // 0.2.2 起行尾「…」与右键共用同一份原生菜单，工作区行的附加开关不再生效。
+      const nativeEllipsis = contextMenusOf(rootCtx) !== null;
+      const ellipsisRows = nativeEllipsis
+        ? ELLIPSIS_ROWS.filter(([groupKey]) => groupKey !== 'workspace')
+        : ELLIPSIS_ROWS;
       const [expanded, setExpanded] = useState(false);
       const anyConflict = takenOver('openWith') || takenOver('deleteSession') || takenOver('deleteArchived');
       const locked = items.openWith === false;
@@ -1578,7 +1587,7 @@ window.__ModuleLoader__.load({
         return key === 'openWith' && childRows ? [row, childRows] : [row];
       });
 
-      const ellipsisGroups = ELLIPSIS_ROWS.map(([groupKey, titleKey, rows]) => h('div', {
+      const ellipsisGroups = ellipsisRows.map(([groupKey, titleKey, rows]) => h('div', {
         className: 'dsrm-settings-group',
         key: groupKey,
       },
@@ -1606,7 +1615,7 @@ window.__ModuleLoader__.load({
         anyConflict ? h('div', { className: 'dsrm-settings-note' }, t('settings.conflictNote')) : null,
         h('div', { className: 'dsrm-settings-list' }, rows),
         h('h2', { className: 'dsrm-settings-title dsrm-settings-subtitle' }, t('settings.ellipsisTitle')),
-        h('div', { className: 'dsrm-settings-note' }, t('settings.ellipsisHint')),
+        h('div', { className: 'dsrm-settings-note' }, t(nativeEllipsis ? 'settings.ellipsisHintNative' : 'settings.ellipsisHint')),
         h('div', { className: 'dsrm-settings-groups' }, ellipsisGroups),
       );
     }
@@ -1916,13 +1925,68 @@ window.__ModuleLoader__.load({
     /* ------------------------------------------------ 会话菜单的插件条目 */
 
     /**
-     * 条目只在「右键打开的菜单」里出现；点「…」打开的菜单保持原样。
-     * 在挂载时取值，避免菜单后续重渲染时条目突然消失。
+     * 条目只在「右键打开的菜单」里出现；点行尾「…」打开的菜单保持原样。
+     *
+     * 不能用时间窗口判断：0.2.2 的菜单是异步挂载的（要等所有 provider 的
+     * ready 和 prepare 延时），菜单一替换还会先卸载旧面板再挂新面板。
+     * 这里改成「手势标记 + 面板出现即收尾」：右键时打标记，条目在挂载时
+     * 读一次；新面板出现（或兜底超时）后标记立刻清掉，不会残留到下一次。
      */
-    let rightClickMenuUntil = 0;
+    let rightClickMark = false;
+    let rightClickToken = 0;
+    let rightClickWatch = null;
+
+    /** 收掉右键标记；期间若又发生一次右键（token 变了）则保留新的标记。 */
+    function scheduleRightClickMarkEnd(delay) {
+      const token = rightClickToken;
+      window.setTimeout(() => {
+        if (rightClickToken === token) rightClickMark = false;
+      }, delay);
+    }
+
+    /** 当前文档里的菜单面板（测试里的最小 document stub 可能没有 querySelectorAll）。 */
+    function menuPanels() {
+      if (typeof document.querySelectorAll !== 'function') return [];
+      return [...document.querySelectorAll('[role="menu"]')];
+    }
+
+    /** 右键手势开始：打标记，并等菜单面板出现后收尾。 */
+    function markRightClickMenu() {
+      rightClickToken += 1;
+      rightClickMark = true;
+      if (rightClickWatch !== null) return;
+      const known = new Set(menuPanels());
+      const watch = { observer: null, timer: 0 };
+      rightClickWatch = watch;
+      const release = (delay) => {
+        if (rightClickWatch !== watch) return;
+        rightClickWatch = null;
+        window.clearTimeout(watch.timer);
+        if (watch.observer !== null) watch.observer.disconnect();
+        scheduleRightClickMarkEnd(delay);
+      };
+      // 面板迟迟不出现（手势被吞掉）也要收尾，避免标记残留。
+      watch.timer = window.setTimeout(() => release(0), 3000);
+      if (typeof MutationObserver !== 'function' || document.body === null) return;
+      watch.observer = new MutationObserver(() => {
+        if (rightClickWatch !== watch) return;
+        for (const panel of menuPanels()) {
+          if (known.has(panel)) continue;
+          release(400);
+          return;
+        }
+      });
+      watch.observer.observe(document.body, { childList: true, subtree: true });
+    }
+
+    /** 点行尾「…」时先清掉上一轮的右键标记：那个菜单不该出现右键条目。 */
+    function clearRightClickMark() {
+      rightClickToken += 1;
+      rightClickMark = false;
+    }
 
     function useRightClickEntry() {
-      const [visible] = useState(() => Date.now() < rightClickMenuUntil);
+      const [visible] = useState(() => rightClickMark);
       return visible;
     }
 
@@ -1961,6 +2025,257 @@ window.__ModuleLoader__.load({
       });
     }
 
+    /* -------------------------------- 工作区行：0.2.2 原生右键贡献 */
+
+    /**
+     * DSH 0.2.2 把右键菜单改成数据贡献（ctx.contextMenus），工作区行也不再向
+     * 行组件传 actions/onCreate，插件原来的自绘入口会取不到 props。这里改为
+     * 向宿主注册同一批动作；0.2.1 没有这个服务，保持自绘菜单不变。
+     */
+    function contextMenusOf(ctx) {
+      const usable = (menus) => (menus !== null && menus !== undefined && typeof menus.register === 'function' ? menus : null);
+      // 先走 ctx.get：未 inject 时直接读 ctx.contextMenus 会抛错，读不到服务。
+      try {
+        const viaGet = usable(ctx?.get?.('contextMenus'));
+        if (viaGet !== null) return viaGet;
+      } catch {
+        /* 服务容器尚未就绪 */
+      }
+      try {
+        return usable(ctx?.contextMenus);
+      } catch {
+        /* 未 inject 的服务属性访问会抛错，按不存在处理 */
+      }
+      return null;
+    }
+
+    /** 应用缓存包成宿主可订阅的数据源，应用列表到达后菜单会自动重解析。 */
+    const appsSource = {
+      getSnapshot: () => appsState,
+      subscribe: (listener) => subscribeApps(listener),
+    };
+
+    /** 应用图标走 data 贡献：resolve 里带 src，组件只负责渲染。 */
+    function ContextMenuAppIcon({ icon }) {
+      const src = typeof icon?.src === 'string' ? icon.src : '';
+      if (src === '') return null;
+      return jsx('img', {
+        className: 'dsrm-app-icon',
+        src,
+        alt: '',
+        onError: (event) => {
+          event.currentTarget.style.visibility = 'hidden';
+        },
+      });
+    }
+
+    function workspaceSessionIds(workspaceId) {
+      const snapshot = serviceOf(rootCtx, 'workspaces')?.list?.getSnapshot?.();
+      const entry = Array.isArray(snapshot?.items)
+        ? snapshot.items.find((candidate) => candidate?.workspaceId === workspaceId)
+        : undefined;
+      return Array.isArray(entry?.sessionIds)
+        ? entry.sessionIds.filter((id) => typeof id === 'string' && id !== '')
+        : [];
+    }
+
+    function openAppAt(appId, cwd, t) {
+      if (cwd === '') {
+        toast(t('noPath'));
+        return;
+      }
+      openApplication(appId, cwd).then((ok) => {
+        if (!ok) toast(t('openFailed'));
+      });
+    }
+
+    /**
+     * 数据贡献的一批工作区动作；group 字段决定它挂到哪个 order 的 provider，
+     * 从而夹在原生 rename(100)/reveal(200)/delete(300) 之间。
+     */
+    function workspaceMenuActions(ctx, value, t) {
+      const workspaceId = typeof value?.workspaceId === 'string' ? value.workspaceId : '';
+      if (workspaceId === '') return [];
+      const cwd = typeof value?.path === 'string' ? value.path : '';
+      const items = [];
+
+      items.push({
+        id: 'new-session',
+        group: 'new',
+        label: t('newSession'),
+        icon: { key: 'sidebar-row-menu.new' },
+        run: () => {
+          const ui = serviceOf(rootCtx, 'uiWorkspace');
+          if (typeof ui?.startSession === 'function') {
+            try {
+              ui.startSession(workspaceId, {});
+            } catch (error) {
+              console.warn('[dsh-sidebar-row-menu] new session failed:', error);
+            }
+          }
+        },
+      });
+
+      const apps = appsSnapshot();
+      const withApps = itemsSnapshot().openWith !== false;
+      const pinned = withApps ? effectivePinned(apps.ids).filter((id) => childOn(id)) : [];
+      pinned.forEach((id, index) => {
+        items.push({
+          id: `pinned-${id}`,
+          group: 'pinned',
+          separatorBefore: index === 0,
+          label: t('openWithApp', { name: appLabel(id, t) }),
+          icon: { key: 'sidebar-row-menu.app', src: ICON_ROUTE + encodeURIComponent(id) },
+          run: () => openAppAt(id, cwd, t),
+        });
+      });
+      const enabledApps = withApps ? apps.ids.filter((id) => childOn(id)) : [];
+      const pinnedSet = new Set(pinned);
+      const submenuApps = enabledApps.filter((id) => !pinnedSet.has(id));
+      if (withApps) ensureApps();
+      if (withApps && submenuApps.length > 0) {
+        items.push({
+          id: 'open-with',
+          group: 'open-with',
+          separatorBefore: pinned.length === 0,
+          label: t('openWith'),
+          children: submenuApps.map((id) => ({
+            id: `app-${id}`,
+            label: appLabel(id, t),
+            icon: { key: 'sidebar-row-menu.app', src: ICON_ROUTE + encodeURIComponent(id) },
+            run: () => openAppAt(id, cwd, t),
+          })),
+        });
+      }
+
+      items.push({
+        id: 'copy-path',
+        group: 'copy',
+        separatorBefore: pinned.length === 0 && submenuApps.length === 0,
+        label: t('copyPath'),
+        icon: { key: 'sidebar-row-menu.copy' },
+        run: () => {
+          if (cwd === '') {
+            toast(t('noPath'));
+            return;
+          }
+          copyText(cwd, t);
+        },
+      });
+
+      const tabs = serviceOf(rootCtx, 'projectTabs') ?? globalThis.__DSH_PROJECT_TABS__ ?? null;
+      if (tabs !== null && typeof tabs?.openWorkspaceInTab === 'function') {
+        items.push({
+          id: 'tab',
+          group: 'tab',
+          label: t('openInTab'),
+          icon: { key: 'sidebar-row-menu.tab' },
+          run: () => {
+            Promise.resolve().then(() => tabs.openWorkspaceInTab(workspaceId)).catch((reason) => {
+              console.warn('[dsh-sidebar-row-menu] open in tab failed:', reason);
+              toast(t('actionFailed'));
+            });
+          },
+        });
+      }
+
+      items.push({
+        id: 'delete-sessions',
+        group: 'delete',
+        danger: true,
+        separatorBefore: false,
+        label: t('deleteWorkspaceSessions'),
+        icon: { key: 'sidebar-row-menu.delete' },
+        run: () => {
+          const title = typeof value?.displayTitle === 'string' && value.displayTitle !== '' ? value.displayTitle : cwd;
+          requestDelete({
+            mode: 'workspace',
+            workspaceId,
+            sessionIds: workspaceSessionIds(workspaceId),
+            displayTitle: title,
+          });
+        },
+      });
+
+      return items;
+    }
+
+    /** 宿主只按 provider.order 排序，同组顺序即数组顺序；故每组单独注册。 */
+    const WORKSPACE_MENU_GROUPS = [
+      { key: 'new', order: 90 },
+      { key: 'pinned', order: 150 },
+      { key: 'open-with', order: 180 },
+      { key: 'copy', order: 250 },
+      { key: 'tab', order: 260 },
+      { key: 'delete', order: 310 },
+    ];
+
+    /** 注册工作区动作；服务可能晚于插件 apply 出现，带有限重试。 */
+    function registerWorkspaceContextMenu(ctx) {
+      let disposers = null;
+      let icons = null;
+      let timer = 0;
+      let attempts = 0;
+
+      const registerIcons = () => {
+        if (ctx.slots === null || ctx.slots === undefined) return;
+        icons = ctx.slots.inject('contextMenu.icon', function* () {
+          yield ctx.slots.register({ name: 'contextMenu.icon', key: 'sidebar-row-menu.new' }, IconNewChatOutlineRegular);
+          yield ctx.slots.register({ name: 'contextMenu.icon', key: 'sidebar-row-menu.copy' }, IconCopyOutlineRegular);
+          yield ctx.slots.register({ name: 'contextMenu.icon', key: 'sidebar-row-menu.tab' }, IconProjectAddOutlineRegular);
+          yield ctx.slots.register({ name: 'contextMenu.icon', key: 'sidebar-row-menu.delete' }, IconTrashOutlineRegular);
+          yield ctx.slots.register({ name: 'contextMenu.icon', key: 'sidebar-row-menu.app' }, ContextMenuAppIcon);
+        });
+      };
+
+      const register = () => {
+        timer = 0;
+        if (disposers !== null) return;
+        const menus = contextMenusOf(ctx);
+        if (menus === null) {
+          if (attempts >= 40 || typeof setTimeout !== 'function') return;
+          attempts += 1;
+          timer = setTimeout(register, 250);
+          return;
+        }
+        registerIcons();
+        const registered = [];
+        for (const group of WORKSPACE_MENU_GROUPS) {
+          try {
+            registered.push(menus.register({
+              id: `sidebar-row-menu.workspace.${group.key}`,
+              target: 'workspace',
+              order: group.order,
+              observe: () => [appsSource],
+              resolve: (target) => workspaceMenuActions(ctx, target, localeOf(ctx))
+                .filter((action) => action.group === group.key)
+                .map(({ group: _group, ...action }) => action),
+            }));
+          } catch (error) {
+            console.warn(`[dsh-sidebar-row-menu] workspace context registration failed (${group.key}):`, error);
+          }
+        }
+        if (registered.length > 0) disposers = registered;
+      };
+
+      register();
+      return () => {
+        if (timer !== 0) clearTimeout(timer);
+        for (const dispose of disposers ?? []) {
+          try {
+            dispose?.();
+          } catch {
+            /* 注册已随插件生命周期撤销 */
+          }
+        }
+        try {
+          icons?.();
+        } catch {
+          /* icon 条目可能未注册成功 */
+        }
+      };
+    }
+
     /** 删除确认框挂到 shell.overlay，避免菜单关闭时被一起卸载。 */
     function registerDeleteDialog(ctx) {
       return ctx.slots.inject('shell.overlay', function* () {
@@ -2042,7 +2357,6 @@ window.__ModuleLoader__.load({
           /* ignore */
         }
       }
-      rightClickMenuUntil = 0;
     }
 
     /**
@@ -2140,9 +2454,8 @@ window.__ModuleLoader__.load({
     }
 
     /**
-     * 右键会话行时在指针处展开该行自带的「…」菜单。
-     * 菜单内容来自 slot 注册表：内置条目和第三方条目都在，本插件不复制内置动作；
-     * 本插件自己的三条只在 rightClickMenuUntil 窗口内挂载。
+     * 右键会话行时在指针处展开该行自带的菜单（0.2.1 的旧内置 Menu）。
+     * 0.2.2 起宿主自己提供 contextmenu 触发器，不再走这里。
      */
     function openSessionRowMenu(row, x, y) {
       const trigger = typeof row.querySelector === 'function'
@@ -2151,12 +2464,8 @@ window.__ModuleLoader__.load({
       const fiber = fiberOf(row);
       const menu = fiber === null ? null : findMenuProps(fiber.child, 0, { count: 0 });
       if (menu !== null && menu.open === true) return;
-      // 先还原旧锚点（会清掉上一轮的窗口），再设置本轮窗口并挂新锚点。
       patchAnchorRect(trigger, x, y);
-      rightClickMenuUntil = Date.now() + 400;
-      window.setTimeout(() => {
-        rightClickMenuUntil = 0;
-      }, 600);
+      markRightClickMenu();
       primeRowActionPointer(trigger);
       if (menu !== null) {
         menu.anchor.props.onClick();
@@ -2221,6 +2530,17 @@ window.__ModuleLoader__.load({
 
     /* -------------------------------------------------------------- 安装 */
 
+    /**
+     * 0.2.2 的会话行自己带 contextmenu 触发器（宿主 getTriggerProps 展开的
+     * onContextMenu），它会把同一份菜单开在指针处。0.2.1 的行没有这个处理器，
+     * 只能由插件代点行尾「…」再改锚点。
+     */
+    function hasNativeRowMenu(row) {
+      const fiber = fiberOf(row);
+      const props = fiber === null ? null : fiber.memoizedProps;
+      return props !== null && props !== undefined && typeof props.onContextMenu === 'function';
+    }
+
     /** 全局 contextmenu 拦截：只有命中工作区 / 会话行才接管。 */
     function onContextMenu(event) {
       if (event.defaultPrevented) return;
@@ -2250,18 +2570,41 @@ window.__ModuleLoader__.load({
       }
 
       if (resolveSessionRow(start) === null) return;
+      // 宿主自己会处理右键（0.2.2）：只打手势标记，菜单交给宿主开在指针处。
+      // 这样既不用改锚点、也不用代点「…」，少两层时序假设。
+      if (hasNativeRowMenu(row)) {
+        markRightClickMenu();
+        primeRowActionPointer(typeof row.querySelector === 'function'
+          ? row.querySelector('[class*="rowActions"] button')
+          : null);
+        return;
+      }
       event.preventDefault();
       event.stopPropagation();
       event.stopImmediatePropagation?.();
       openSessionRowMenu(row, event.clientX, event.clientY);
     }
 
+    /** 行尾「…」按下时先收掉右键标记：那个菜单不该出现右键条目。 */
+    function onRowActionsPointerDown(event) {
+      // 只认真实输入：插件自己补发的 pointerdown（primeRowActionPointer）不算手势。
+      if (event.isTrusted === false) return;
+      const target = event.target;
+      if (target === null || target === undefined) return;
+      const start = target.nodeType === 3 ? target.parentElement : target;
+      if (start === null || start === undefined || typeof start.closest !== 'function') return;
+      if (start.closest('[class*="rowActions"]') === null) return;
+      clearRightClickMark();
+    }
+
     function install() {
       window.addEventListener('contextmenu', onContextMenu, true);
+      document.addEventListener('pointerdown', onRowActionsPointerDown, true);
       document.addEventListener('click', onWorkspaceEllipsisClick, true);
       console.info('[dsh-sidebar-row-menu] installed');
       return () => {
         window.removeEventListener('contextmenu', onContextMenu, true);
+        document.removeEventListener('pointerdown', onRowActionsPointerDown, true);
         document.removeEventListener('click', onWorkspaceEllipsisClick, true);
         closeMenu();
         closeToast();
@@ -2288,10 +2631,12 @@ window.__ModuleLoader__.load({
       if (typeof ctx.effect === 'function') {
         ctx.effect(() => installStyles(), 'sidebar-row-menu: styles');
       }
+      const stopWorkspaceMenu = registerWorkspaceContextMenu(ctx);
       const teardown = install();
       if (ctx !== null && typeof ctx.effect === 'function') {
         ctx.effect(() => () => {
           rootCtx = null;
+          stopWorkspaceMenu();
           teardown();
         }, 'sidebar-row-menu: row context menus');
       }

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "dsh-sidebar-row-menu",
-  "version": "1.4.3",
+  "version": "1.5.1",
   "type": "module",
-  "description": "DSH sidebar right-click menus: a self-composed menu for workspace rows, and the native slot menu opened at the pointer for session rows, with open-with and archived-session cleanup.",
+  "description": "Adds open-with and cleanup entries to the DSH sidebar context menus: interleaved with the built-in workspace menu and extending the session menu at the pointer on DSH 0.2.2+, with a self-drawn workspace menu on 0.2.1.",
   "keywords": [
     "deepseek",
     "dsh",