dsh-sidebar-row-menu 1.5.0 → 1.6.0

package/CHANGELOG.md

@@ -1,5 +1,106 @@
 # Changelog
 
+## 1.6.0 — 2026-11-05
+
+### Added
+
+- **Workspace entries can opt into the native "…" menu on DSH 0.2.2.** The
+  workspace-row entries (New session, pinned app, Open with, Copy workspace path,
+  Open in new tab, Delete workspace and all sessions) are now right-click only by
+  default, matching the session rows: a provider answers only while a right-click
+  gesture is active. Enabling the matching switch under Settings → "Also show in the
+  "…" menu → workspace" makes it skip that check, so the entry also lands in the
+  host's "…" menu.
+
+### Fixed
+
+- **"Open with" keeps its icon on DSH 0.2.2.** The entry is contributed to the
+  host menu as data, so it had no icon of its own; it now registers an
+  `contextMenu.icon` slot (`sidebar-row-menu.open-with`) and points the action at
+  it, matching the self-drawn 0.2.1 menu.
+- **Menu separators stay visible at 125–150% display scaling.** The host draws
+  0.5px hairlines; at fractional device pixel ratios one of them was painted as a
+  ~0.4px smear and read as missing. A `min-resolution: 1.2dppx` media query now
+  thickens menu separators (and the 0.2.1 `.dsrm-sep`) to 1px in that range, and
+  leaves 1x and 2x displays untouched.
+- **The workspace menu follows the session menu's grouping.** On 0.2.2 the entries
+  were interleaved as right-click group → pinned/open-with → copy path, so the
+  separator before "Open with" landed in a different place than in the session
+  menu. The workspace providers now use the session order — row actions, then
+  Copy path/Reveal, then the open-with group, then Delete — so both menus split
+  into the same three blocks.
+- **"Open with" shows its submenu affordance again.** Host menu items draw no
+  caret for submenu parents. The action's label is rendered by the host as an
+  element, so the workspace entry now passes a label that lays the text out with
+  a right-aligned chevron, matching the session menu's arrow instead of a "›"
+  glued to the text (the 0.2.1 self-drawn menu keeps its own arrow icon).
+
+### Changed
+
+- **The workspace-row switches are no longer hidden on 0.2.2.** The section note now
+  explains that 0.2.2 shares one host menu between right-click and the `…` button
+  while the plugin's entries still follow the gesture, and that the switches opt
+  individual entries into that shared menu. This reverses the 1.5.0 decision to hide
+  the group.
+
+### 中文摘要
+
+- **0.2.2 上工作区条目默认只出现在右键菜单**：工作区 provider 解析时检查同一枚
+  右键手势标记，行尾「…」的 `pointerdown` 会先清标，所以「…」菜单保持原生内容。
+- **工作区行可以在设置里「同时放进「…」菜单」**：逐项开启后 provider 跳过手势判断，
+  对应条目也会进入宿主的「…」菜单；0.2.2 上这组开关不再隐藏，说明文字改成描述
+  共用菜单 + 手势区分的真实行为。0.2.1 仍由插件接管「…」按钮自绘。
+- **0.2.2 的「打开方式」恢复图标**：数据贡献的条目本身没有图标，现在注册
+  `contextMenu.icon`（`sidebar-row-menu.open-with`）并由动作引用，与 0.2.1 自绘
+  菜单一致。
+- **125%–150% 缩放下菜单分隔线可见**：宿主用的是 0.5px 细线，在分数像素比下会被
+  摊成约 0.4px 而像「消失」；现在该区间内分隔线（含 0.2.1 的 `.dsrm-sep`）补到
+  1px，1x 与 2x 显示不变。
+- **工作区菜单改用会话菜单的分组规则**：原来「打开方式」组夹在复制路径之前，分隔线
+  落点与会话菜单不一致；现在顺序为行内动作 → 复制路径/在文件夹显示 → 打开方式组 →
+  删除，两份菜单都分成同样三块。
+- **「打开方式」恢复子菜单箭头**：宿主不给子菜单父项画箭头，但 label 是当元素渲染的，
+  所以工作区条目改成「文字 + 右对齐箭头」的 label，与会话菜单的箭头位置一致（不再是
+  贴在文字后面的「›」）；0.2.1 自绘菜单仍用自己的箭头图标。
+
+## 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

package/README.en.md

@@ -9,42 +9,64 @@
 
 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.
+- **Workspace rows** — right-click opens a menu (since DSH 0.2.2 it is part of the
+  host's native menu, with the plugin's items interleaved by `order`);
+- **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 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.
+> only when the menu is opened by right-click — on 0.2.2 that holds for workspace
+> and session rows alike, and each entry can be opted into the "…" menu in Settings.
+> 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),
+using the same grouping rules as the session menu: New session 90, Open in new
+tab 110, Copy workspace path 150, pinned app 210, Open with 220, Delete workspace
+and all sessions 310. These items are right-click only by default; the row's "…"
+menu keeps its native content unless you opt entries in under Settings → "Also
+show in the "…" menu → workspace". 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 |
-| 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 |
-| Copy workspace path | Copies the directory path |
+| Rename (built-in) | Opens the official "Rename workspace" dialog; on 0.2.1 the plugin renders this item itself |
 | 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" |
+| Copy workspace path | Copies the directory path |
+| 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 |
+| 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. Host menu items draw no submenu caret, so the plugin renders the label as text plus a right-aligned chevron, matching the session menu; the 0.2.1 self-drawn menu uses an arrow icon |
+| 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 +91,26 @@ 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.
+"Row menu" → "Also show in the "…" menu":
+
+- session entries mount into the native "…" menu;
+- workspace entries on 0.2.2: the host menu is data-driven, so an enabled entry skips
+  the gesture check and appears in the "…" menu; with everything off that menu keeps
+  only the native items;
+- workspace entries on 0.2.1: enabling any of them 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.
 
-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,15 +124,16 @@ 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 | 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. On 0.2.1 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.
+On DSH 0.2.2 and later the "…" button and right-click share one host menu, yet the
+plugin's entries still appear only on right-click; flipping a switch also puts that
+entry into the "…" menu. On 0.2.1 workspace rows have no host menu to contribute to,
+so the plugin takes over the "…" button and draws the menu itself.
 
 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
@@ -332,46 +364,78 @@ 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.
+
+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.
+
+Workspace rows on 0.2.2 take a different path: the host menu is built from each
+`ctx.contextMenus.register` provider's `resolve`, which has no React entry to read the
+mark, so the provider checks the same mark while resolving. The "…" pointerdown
+clears it before the host resolves, hence the entries show on right-click only; the
+"Also show in the "…" menu → workspace" switches make the provider skip that check.
 
-### Why the workspace menu is mounted imperatively
+### Why the 0.2.1 menu is mounted imperatively
 
-A contextmenu event is not part of React's render flow. The workspace menu creates
+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
@@ -426,15 +490,18 @@ 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`). DSH 0.2.2 moved the sidebar context menus to data-driven
-`ctx.contextMenus`, and the plugin picks the path by host capability:
+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.
+  (New session 90, Open in new tab 110, Copy workspace path 150, pinned app 210,
+  Open with 220, Delete workspace and all sessions 310), interleaved by
+  order with the native Rename (100), Reveal (200) and Delete workspace (300) and
+  grouped with the same separators as the session menu.
+  Right-click and the "…" button share the host's single menu; providers answer only
+  during a right-click gesture (or when the matching "Also show in the "…" menu"
+  switch is on).
 - **0.2.1**: no `contextMenus` service, so the plugin keeps drawing its own
   workspace menu.
 - **Session rows**: 0.2.2 still supports the
@@ -450,12 +517,14 @@ If a DSH upgrade changes those row components or the menu positioning:
 ## Known limitations
 
 - 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
-  rely on the legacy extension point. If DSH changes the corresponding
-  implementation, right-click may silently do 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.
+  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,52 @@
 
 给 [DeepSeek Harness](https://github.com/deepseek-ai)（DSH）左侧边栏加右键菜单：
 
-- **工作区行**：右键弹出菜单（复刻 `dsh-sidebar-context-menu` 的能力）；
-- **工作区下层的会话行**：右键在指针处展开该行内置的「…」菜单，并追加本插件的条目。
+- **工作区行**：右键弹出菜单（DSH 0.2.2 起并入宿主原生菜单，条目按 order 与内置项交错）；
+- **工作区下层的会话行**：右键在指针处展开该行自己的菜单，并追加本插件的条目。
 
-工作区菜单用 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 上
+> 工作区行与会话行都是如此，可以在设置里逐项开启）。
+> 0.2.2 上右键与「…」共用同一份宿主菜单，插件按“右键手势”区分：右键时打标，等菜单面板
+> 真正挂载后才收尾；点「…」的按下事件会立刻清标，所以那个菜单不带右键条目。
+> 右键展开的菜单不会因为鼠标移出而关闭，只有点击外部、选中条目或按 Esc 才关闭。
 
 ## 功能
 
 ### 工作区行右键
 
+0.2.2 上这份菜单由宿主渲染，本插件条目与内置「重命名」（100）、「在文件夹显示」（200）、
+「删除工作区」（300）按 order 交错，分组规则与会话菜单一致：新会话 90、在新标签打开 110、
+复制工作区路径 150、置顶应用 210、打开方式 220、删除工作区及所有会话 310。这些条目默认
+只出现在右键菜单；行尾「…」里的菜单保持原生，想让它也带上插件条目，可在设置里逐项开启
+「同时放进「…」菜单 → 工作区」。0.2.1 上整份菜单由本插件自绘，「重命名」「删除工作区」
+由插件调用官方对话框。
+
 | 菜单项 | 行为 |
 | --- | --- |
 | 新会话 | 展开该工作区并新建会话（等价于行尾 `+`） |
-| 重命名 | 打开官方“重命名工作区”对话框 |
-| 置顶的打开方式 | 被置顶的应用直接显示在一级菜单（例如「用 Visual Studio Code 打开」），点击后用该应用打开工作区目录 |
-| 打开方式 | 二级菜单列出宿主提供的外部应用（编辑器、终端、文件管理器）；与会话菜单共用同一套应用列表、置顶与开关设置，鼠标悬浮自动展开 |
-| 复制工作区路径 | 复制目录路径到剪贴板 |
+| 重命名（内置） | 打开官方“重命名工作区”对话框；0.2.1 上由本插件代为渲染 |
 | 在新标签中打开 | 仅在装有 `dsh-project-tabs`（暴露 `openWorkspaceInTab`）时出现 |
-| 删除工作区 | 打开官方删除确认对话框；只删除工作区登记，会话保留并归入「未分组」 |
+| 复制工作区路径 | 复制目录路径到剪贴板 |
+| 在文件夹显示（内置） | 在资源管理器里打开工作区目录；0.2.2 由宿主提供，0.2.1 上不出现 |
+| 置顶的打开方式 | 被置顶的应用直接显示在一级菜单（例如「用 Visual Studio Code 打开」），点击后用该应用打开工作区目录 |
+| 打开方式 | 二级菜单列出宿主提供的外部应用（编辑器、终端、文件管理器）；与会话菜单共用同一套应用列表、置顶与开关设置，鼠标悬浮自动展开。宿主的菜单项不画二级箭头，本插件把标签渲染成「文字 + 右对齐箭头」，与会话菜单同一位置；0.2.1 自绘菜单画的是箭头图标 |
+| 删除工作区（内置） | 打开官方删除确认对话框；只删除工作区登记，会话保留并归入「未分组」。0.2.1 上由本插件代为渲染 |
 | 删除工作区及所有会话 | 先永久删除该工作区下的每个会话及其日志，全部成功后再删除工作区登记；任一会话删除失败则保留工作区，便于重试。工作区目录本身不删除 |
 
 ### 会话行右键
 
-右键会话行不会另起一套菜单，而是展开该行自己的「…」菜单：
+右键会话行不会另起一套菜单：0.2.2 由宿主把该行的原生菜单开在指针处；0.2.1 由本插件触发行尾
+「…」菜单，并临时把它的锚点移到指针。两种情况下菜单内容都来自同一份 slot：
 
 | 来源 | 条目 |
 | --- | --- |
@@ -60,14 +76,19 @@
 一级菜单。两个删除入口由本插件自己的宿主路由完成，默认不会删除未归档会话；
 开启「允许删除未归档会话」后才会对普通会话开放。删除不会级联删除 fork 子会话。
 
-这些条目默认是**右键专属**：点行尾「…」按钮时它们不挂载。实现上使用一个只在右键展开瞬间
-有效的窗口标记，窗口外的渲染直接返回 `null`。
+这些条目默认是**右键专属**：点行尾「…」按钮时它们不挂载。实现上不再用时间窗口，而是
+「右键手势标记」：右键时打标，等菜单面板真正出现（0.2.2 的挂载是异步的）后才释放；点
+「…」的按下事件会立刻清标。标记有效期内的条目正常渲染，其余情况渲染直接返回 `null`。
 
 如果想直接使用行尾「…」菜单，可以在设置 →「行菜单」→「同时放进「…」菜单」里逐个开启：
-会话条目会挂进原生「…」菜单；工作区行开启任意一项后，本插件会接管行尾「…」按钮，用同一套
-菜单展示官方「重命名 / 删除工作区」加上已开启的插件条目。全部关闭时「…」按钮保持 DSH 原样。
 
-草稿会话（还没有任何消息的空白会话）没有内置「…」菜单，本插件同样不接管。
+- 会话条目：开启后挂进原生「…」菜单；
+- 工作区条目（0.2.2）：宿主菜单本身是数据驱动的，开启后 provider 解析时不再看手势，
+  条目直接进入「…」菜单；全部关闭时「…」里只有原生项；
+- 工作区条目（0.2.1）：开启任意一项后，本插件接管行尾「…」按钮，用同一套菜单展示
+  官方「重命名 / 删除工作区」加上已开启的插件条目。
+
+草稿会话（还没有任何消息的空白会话）没有右键菜单，本插件同样不接管。
 非工作区 / 非会话的侧边栏行（如“显示更多”）也不会被拦截。
 
 ### 设置
@@ -81,13 +102,14 @@
 | 永久删除会话 | 关闭后会话菜单里不再出现单条删除入口 |
 | 允许删除未归档会话 | 默认关闭；开启后未归档会话的右键菜单也会出现「永久删除会话」，需先开启上一项 |
 | 删除所有已归档会话 | 关闭后不再出现批量删除入口 |
-| 同时放进「…」菜单 → 工作区 | 逐项把工作区行右键条目加进行尾「…」菜单：新会话、打开方式、复制工作区路径、在新标签中打开、删除工作区及所有会话。开启任意一项后「…」按钮改由本插件渲染 |
+| 同时放进「…」菜单 → 工作区 | 逐项把工作区行右键条目也放进行尾「…」菜单：新会话、打开方式、复制工作区路径、在新标签中打开、删除工作区及所有会话。0.2.1 上开启任意一项后「…」按钮改由本插件渲染 |
 | 同时放进「…」菜单 → 会话 | 逐项把会话行右键条目加进原生「…」菜单：打开方式、永久删除会话、删除所有已归档会话 |
 
 「同时放进「…」菜单」下的开关默认全部关闭，`…` 菜单在未开启时与 DSH 完全一致。
 
-DSH 0.2.2 起，工作区行的右键与「…」本身就是同一份宿主菜单，插件条目会一直出现在「…」里，
-「同时放进「…」菜单 → 工作区」这组开关只影响 0.2.1 及更早的宿主。
+DSH 0.2.2 起行尾「…」与右键共用同一份宿主菜单，但插件条目仍按手势只出现在右键菜单里；
+上表的开关打开后，对应条目才会同时进入「…」菜单。0.2.1 上工作区行没有宿主菜单可贡献，
+改由插件接管「…」按钮自绘。
 
 开关存在浏览器 `localStorage`（`dsh.sidebar-row-menu.items.v1`、
 `dsh.sidebar-row-menu.open-with.v1`、`dsh.sidebar-row-menu.open-with.pinned.v1` 与
@@ -263,8 +285,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 里做人工验证。
 
 目录：
 
@@ -294,43 +317,67 @@ 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.2 上走的是另一条路：宿主菜单的数据来自 `ctx.contextMenus.register` 的
+`resolve`，没有 React 条目可以读标记，所以 provider 在解析时直接判断同一枚手势标记，
+并且行尾「…」的 `pointerdown` 清标发生在宿主解析之前 —— 右键时条目进菜单，点「…」时
+不进。「同时放进「…」菜单 → 工作区」的开关则让 provider 跳过手势判断，条目不依赖右键。
 
-### 为什么菜单是命令式挂载
+### 为什么 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()` 并移除容器。
+会话菜单不挂载任何新容器，只是打开行内已有的官方菜单。
 
 ### 宿主路由
 
@@ -372,15 +419,17 @@ test/*.test.mjs       node:test
 DSH 宿主按该范围拒绝安装不兼容的宿主，插件市场也按它显示支持版本；0.3 起需要重新验证后
 再放宽上限。
 
-按 DSH 客户端 `0.2.1-rc.5` 的 `ProjectRowItem` / `SessionNodeItem` / `Menu` 实现。
-DSH 0.2.2 起把侧栏右键菜单改成数据驱动（`ctx.contextMenus`），本包会按宿主能力自动选择路径：
+按 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 交错排列，右键与「…」共用同一份菜单；
-- **0.2.1**：没有 `contextMenus` 服务，保持原来的自绘工作区菜单；
-- **会话行**：0.2.2 仍保留 `sidebar.workspaces.session.menu.item` 扩展点，本包条目继续从这里
-  渲染；右键仍按指针位置展开宿主菜单。
+  （新会话 90、新标签 110、复制路径 150、置顶应用 210、打开方式 220、删除工作区及所有会话 310），
+  与原生「重命名」「在文件夹显示」「删除工作区」按 order 交错排列；分组分隔线与会话菜单同一
+  套规则。右键与「…」共用同一份宿主菜单，插件不再自绘，也不再接管「…」按钮。provider 解析时
+  按右键手势（或设置里「同时放进「…」菜单」的开关）决定是否返回条目。会话行由宿主自己把原生
+  菜单开在指针处，本包条目继续从 `sidebar.workspaces.session.menu.item` 渲染；
+- **0.2.1**：没有 `contextMenus` 服务，保持原来的自绘工作区菜单；会话右键仍由插件把
+  行尾「…」菜单搬到指针。
 
 DSH 升级若改动行组件或菜单定位实现：
 
@@ -390,9 +439,11 @@ DSH 升级若改动行组件或菜单定位实现：
 ## 已知限制
 
 - 0.2.1 下依赖 DSH 内置行组件的 props 形状；0.2.2 起工作区条目改走 `contextMenus`，
-  会话条目仍依赖旧扩展点。DSH 升级若改掉对应实现，右键可能静默不弹。
-- 会话右键依赖行内 `Menu` 组件仍在 fiber 子树里。找不到时退回点击行内操作区的
-  省略号按钮，再找不到就放弃 —— 不会自建菜单，也不会误触行的打开动作。
+  会话条目仍依赖旧扩展点，并用 `memoizedProps.onContextMenu` 判断这一行是否已由宿主接管。
+  DSH 升级若改掉对应实现，右键可能静默不弹。
+- 0.2.1 的会话右键依赖行内 `Menu` 组件仍在 fiber 子树里。找不到时退回点击行内操作区的
+  省略号按钮，再找不到就放弃 —— 不会自建菜单，也不会误触行的打开动作。0.2.2 上不需要
+  这段回退，宿主自己就是触发器。
 - 永久删除默认只对**已归档**会话开放；在设置里开启「允许删除未归档会话」后，未归档
   会话也能从右键菜单直接删除。删除不会级联删除 fork 出来的子会话，需要时请分别删除。
 - 删除操作直接作用于会话日志目录，宿主没有回收站；确认框里已明确提示不可恢复。

package/lib/client.js

@@ -186,8 +186,7 @@ window.__ModuleLoader__.load({
       'settings.expand': '展开应用列表',
       'settings.collapse': '收起应用列表',
       'settings.ellipsisTitle': '同时放进「…」菜单',
-      'settings.ellipsisHint': '勾选后，对应条目会额外出现在行尾「…」按钮的菜单里，并沿用上面的单项开关；不勾选则只在右键菜单出现。',
-      'settings.ellipsisHintNative': '当前 DSH 版本的「…」按钮与右键共用同一份菜单，工作区行无需单独登记；这里只保留会话行的开关。',
+      'settings.ellipsisHint': 'DSH 0.2.2 起「…」按钮与右键共用同一份菜单：勾选后对应条目也会出现在「…」菜单里，并沿用上面的单项开关；不勾选则只在右键菜单出现。',
       'settings.ellipsisWorkspace': '工作区行',
       'settings.ellipsisSession': '会话行',
       'settings.ellipsis.newSession.label': '新建会话',
@@ -271,8 +270,7 @@ window.__ModuleLoader__.load({
       'settings.expand': 'Show applications',
       '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.ellipsisHint': 'Since DSH 0.2.2 the "…" button opens the same menu as right-click: checked entries also appear there, still subject to the switches above. Unchecked entries stay right-click only.',
       'settings.ellipsisWorkspace': 'Workspace rows',
       'settings.ellipsisSession': 'Session rows',
       'settings.ellipsis.newSession.label': 'New session',
@@ -1503,11 +1501,6 @@ 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;
@@ -1587,7 +1580,7 @@ window.__ModuleLoader__.load({
         return key === 'openWith' && childRows ? [row, childRows] : [row];
       });
 
-      const ellipsisGroups = ellipsisRows.map(([groupKey, titleKey, rows]) => h('div', {
+      const ellipsisGroups = ELLIPSIS_ROWS.map(([groupKey, titleKey, rows]) => h('div', {
         className: 'dsrm-settings-group',
         key: groupKey,
       },
@@ -1615,7 +1608,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(nativeEllipsis ? 'settings.ellipsisHintNative' : 'settings.ellipsisHint')),
+        h('div', { className: 'dsrm-settings-note' }, t('settings.ellipsisHint')),
         h('div', { className: 'dsrm-settings-groups' }, ellipsisGroups),
       );
     }
@@ -1895,6 +1888,9 @@ window.__ModuleLoader__.load({
       if (event.defaultPrevented || event.button !== 0) return;
       if (event.target === null || event.target === undefined) return;
       if (rootCtx === null || !workspaceEllipsisOn()) return;
+      // 0.2.2 起宿主菜单本身就是数据驱动的：附加条目由 provider 按开关加进去，
+      // 再接管「…」只会把原生菜单换成自绘的那一份。
+      if (contextMenusOf(rootCtx) !== null) return;
       const target = event.target;
       if (typeof target.closest !== 'function') return;
       const row = target.closest('[data-row-key]');
@@ -1925,13 +1921,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;
     }
 
@@ -2064,39 +2115,32 @@ window.__ModuleLoader__.load({
       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) {
+
+      // 与会话菜单同一套分组：行内动作 → 复制/在文件夹显示 → 打开方式 → 删除。
+      const tabs = serviceOf(rootCtx, 'projectTabs') ?? globalThis.__DSH_PROJECT_TABS__ ?? null;
+      if (tabs !== null && typeof tabs?.openWorkspaceInTab === 'function') {
         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),
-          })),
+          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: 'copy-path',
         group: 'copy',
-        separatorBefore: pinned.length === 0 && submenuApps.length === 0,
+        separatorBefore: true,
         label: t('copyPath'),
         icon: { key: 'sidebar-row-menu.copy' },
         run: () => {
@@ -2108,19 +2152,36 @@ window.__ModuleLoader__.load({
         },
       });
 
-      const tabs = serviceOf(rootCtx, 'projectTabs') ?? globalThis.__DSH_PROJECT_TABS__ ?? null;
-      if (tabs !== null && typeof tabs?.openWorkspaceInTab === 'function') {
+      pinned.forEach((id, index) => {
         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'));
-            });
-          },
+          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),
+        });
+      });
+
+      if (withApps && submenuApps.length > 0) {
+        items.push({
+          id: 'open-with',
+          group: 'open-with',
+          separatorBefore: pinned.length === 0,
+          // 宿主的菜单项对子菜单只设 aria-haspopup，不画右侧箭头。label 在宿主里
+          // 是直接当 children 渲染的，所以这里塞一个右对齐的箭头元素，与会话菜单
+          // 里的「打开方式」保持同一套外观（0.2.1 自绘菜单本来就是自己画的）。
+          label: h('span', { className: 'dsrm-host-label' },
+            h('span', { className: 'dsrm-host-label-text' }, t('openWith')),
+            jsx(IconChevronRightOutlineRegular, { size: 12, className: 'dsrm-submenu-chevron' }),
+          ),
+          icon: { key: 'sidebar-row-menu.open-with' },
+          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),
+          })),
         });
       }
 
@@ -2148,13 +2209,32 @@ window.__ModuleLoader__.load({
     /** 宿主只按 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: 'tab', order: 110 },
+      { key: 'copy', order: 150 },
+      { key: 'pinned', order: 210 },
+      { key: 'open-with', order: 220 },
       { key: 'delete', order: 310 },
     ];
 
+    /**
+     * 0.2.2 的「…」按钮与右键共用同一份宿主菜单，条目本身无法感知手势，
+     * 所以按右键标记决定是否进入这份菜单；打开对应附加开关后，点「…」也显示。
+     */
+    const WORKSPACE_GROUP_ELLIPSIS = {
+      new: 'newSession',
+      pinned: 'openWith',
+      'open-with': 'openWith',
+      copy: 'copyPath',
+      tab: 'openInTab',
+      delete: 'deleteSessions',
+    };
+
+    function workspaceGroupVisible(groupKey) {
+      if (rightClickMark) return true;
+      const key = WORKSPACE_GROUP_ELLIPSIS[groupKey];
+      return key !== undefined && ellipsisSettings[key] === true;
+    }
+
     /** 注册工作区动作；服务可能晚于插件 apply 出现，带有限重试。 */
     function registerWorkspaceContextMenu(ctx) {
       let disposers = null;
@@ -2168,6 +2248,7 @@ window.__ModuleLoader__.load({
           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.open-with' }, IconRightUpOutlineRegular);
           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);
         });
@@ -2192,9 +2273,12 @@ window.__ModuleLoader__.load({
               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),
+              resolve: (target) => {
+                if (!workspaceGroupVisible(group.key)) return [];
+                return 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);
@@ -2302,7 +2386,6 @@ window.__ModuleLoader__.load({
           /* ignore */
         }
       }
-      rightClickMenuUntil = 0;
     }
 
     /**
@@ -2400,9 +2483,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'
@@ -2411,12 +2493,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();
@@ -2433,11 +2511,15 @@ window.__ModuleLoader__.load({
 .dsrm-submenu-trigger:hover:not(:disabled),.dsrm-submenu-trigger:focus-visible{background:var(--dsw-alias-interactive-bg-hover);outline:none}
 .dsrm-submenu-label{flex:1;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
 .dsrm-submenu-chevron{color:var(--dsw-alias-label-caption)}
+.dsrm-host-label{display:flex;align-items:center;gap:6px;width:100%}
+.dsrm-host-label-text{flex:1;min-width:0;overflow:hidden;text-overflow:ellipsis}
 .dsrm-submenu{position:fixed;z-index:1101;min-width:180px;max-width:300px;max-height:min(380px,64vh);overflow:auto;padding:4px}
 .dsrm-submenu-empty{padding:6px 8px;color:var(--dsw-alias-label-tertiary);font-size:12px;line-height:18px}
 .dsrm-menu{position:fixed;z-index:2147483647}
 .dsrm-menu-surface{min-width:210px;padding:4px}
 .dsrm-sep{height:.5px;margin:3px 2px;background:var(--dsw-alias-border-l2)}
+/* 150% 缩放等分数像素比下，宿主 0.5px 的分隔线会被摊成两行近乎透明，补到 1px 才看得见。 */
+@media (min-resolution:1.2dppx) and (max-resolution:1.99dppx){[role="menu"] [role="separator"],.dsrm-sep{height:1px}}
 .dsrm-app-icon{width:14px;height:14px;border-radius:3px;display:block;object-fit:contain}
 .dsrm-settings{max-width:820px;margin:0 auto;padding:2px 0 36px}
 .dsrm-settings-title{margin:0;font-size:16px;line-height:24px;font-weight:600}
@@ -2481,6 +2563,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;
@@ -2494,6 +2587,18 @@ window.__ModuleLoader__.load({
       const rowKey = row.getAttribute('data-row-key') ?? '';
       if (!rowKey.startsWith('workspace:') && !rowKey.startsWith('session:')) return;
 
+      // 宿主自己会处理右键（0.2.2）：只打手势标记，菜单交给宿主开在指针处。
+      // 这样既不用改锚点、也不用代点「…」，少两层时序假设；provider 在解析时用
+      // 这个标记决定条目是否进入菜单（「…」的按下会先清标）。
+      if (hasNativeRowMenu(row)) {
+        if (rowKey.startsWith('session:') && resolveSessionRow(start) === null) return;
+        markRightClickMenu();
+        primeRowActionPointer(typeof row.querySelector === 'function'
+          ? row.querySelector('[class*="rowActions"] button')
+          : null);
+        return;
+      }
+
       if (rowKey.startsWith('workspace:')) {
         const props = resolveWorkspaceRow(start);
         if (props === null) {
@@ -2516,12 +2621,26 @@ window.__ModuleLoader__.load({
       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();

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "dsh-sidebar-row-menu",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "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",