diff --git a/README.md b/README.md
index a98699e..6640210 100644
--- a/README.md
+++ b/README.md
@@ -48,7 +48,7 @@
 相比 DSH 官方侧边栏，本插件补上的关键能力：
 
 - **🖥️ 可编辑的代码编辑器**：官方文档预览是**只读**的 → 插件保留**可编辑**的 CodeMirror 编辑器（保存、语法高亮、预览切换）；Markdown / HTML 也走插件自有渲染（Mermaid 图表安全渲染 + 点击放大、README 级内嵌 HTML、浮动目录大纲、HTML 沙箱预览）
-- **🗂️ 增强文件树**：接管内置「文件」页——懒加载目录树、**展开的目录实时 watch 自动刷新**、软链接识别、全局文件名搜索、拖拽上传、悬浮 `@文件` 一键引用进输入框；**Ctrl/Cmd 多选 + Shift 连选**（批量复制路径 / 批量删除）、**Git 变更着色 + 状态字母**（VS Code 同款）、**新建文件夹**，右键「打开方式」直接复用 DSH 自带的 open-in-app（宿主探测到的系统关联应用 + 文件管理器显示）
+- **🗂️ 增强文件树**：接管内置「文件」页——懒加载目录树、**展开的目录实时 watch 自动刷新**、软链接识别、全局文件名搜索、拖拽上传、悬浮 `@文件` 一键引用进输入框；**Ctrl/Cmd 多选 + Shift 连选**（批量复制路径 / 批量删除）、**Git 变更着色 + 状态字母**（VS Code 同款）、**新建文件夹**、**多选右键「压缩并打包下载」**（服务端流式打 ZIP，无第三方依赖）；右键「打开方式」= **DSH 自带 open-in-app**（宿主探测到的本机关联应用 + 文件管理器显示）**+ 插件自研打开方式**（资源管理器 / VS Code / Cursor / Zed / 自定义编辑器 URL 模板、SSH 远端、固定到菜单）两者并存
 - **🌿 文件变动**（官方侧栏没有 Git 面板）：Git 视角（暂存 / 提交 / 历史 / 工作树与子仓库）+ 本轮 AI 改动视角双合一，统一 diff 渲染（行内字符级高亮、语法着色、敏感内容脱敏）；两视角共用一套 28px 行、单一空态/错误通道与吸底提交条
 - **🧩 任务管理**（官方没有）：子代理拓扑实时预览 + 后台任务清单（退出码 / 实时输出 / 强制终止）
 - **💬 侧边对话**（官方没有，beta）：Codex 风格侧边线程——继承主会话完整上下文独立运行，可持续追问，一键提升为顶层会话
@@ -171,9 +171,9 @@ dsh registry enable dsh-external/dsh-better-sidebar
 
 | | |
 |---|---|
-| **🗂️ 文件工作台：资源管理器**<br/><sub>支持两种格式的资源管理器：内嵌在文件预览中 / 独立显示文件树。懒加载目录树、**展开的目录由宿主按目录 watch、改动后自动重列**、软链接按目标类型展示（目录软链接可展开、失效链接标红）、全局文件名搜索、上传文件/文件夹与拖放上传、右键菜单（在新 Tab 打开 / 在侧边打开 / 新建文件夹 / 打开方式（DSH 自带 open-in-app：系统关联应用 + 文件管理器显示）/ 复制路径 / 重命名 / 删除）、**Ctrl/Cmd 多选与 Shift 连选**（批量复制路径 / 批量删除）、**Git 变更按状态着色并带 M/A/D/U 字母**、悬浮 `@文件` 一键引用进输入框。</sub><br/><div align="center"><img width="420" alt="文件资源管理器" src="https://github.com/user-attachments/assets/a410bfd2-a8ba-43e6-873e-22417756e94d" /></div> | **📝 Markdown · HTML 内联预览**<br/><sub>Markdown 预览支持 **Mermaid 图表**（`securityLevel: 'strict'` 安全渲染 + 二次清洗；点击图表弹窗放大、滚轮缩放、拖拽平移）、**README 级内嵌 HTML**（徽章墙 `<div align=center>`、`<details>` 折叠块内嵌 markdown、表格单元格内联标签——DOMPurify 白名单消毒真实渲染，`<script>` 等活性内容剥除，本地图片经会话媒体路由重写）与**浮动目录大纲**（≥3 标题出现，点击平滑跳转、自动展开折叠块）；HTML 走插件自带的**沙箱预览**，并带 `htmlViewerNoSandbox` / `htmlViewerDefaultUnsafe` 两个宿主没有的逃生门开关。**图片 / PDF / 表格 / Office 不再是插件能力**——那些格式由 DSH 自己的文档预览渲染。</sub><br/><div align="center"><img width="420" alt="Markdown + Mermaid 预览" src="https://github.com/user-attachments/assets/fe0e5182-55bb-45cc-b98b-a2877c2bdd38" /></div> |
+| **🗂️ 文件工作台：资源管理器**<br/><sub>支持两种格式的资源管理器：内嵌在文件预览中 / 独立显示文件树。懒加载目录树、**展开的目录由宿主按目录 watch、改动后自动重列**、软链接按目标类型展示（目录软链接可展开、失效链接标红）、全局文件名搜索、上传文件/文件夹与拖放上传、右键菜单（在新 Tab 打开 / 在侧边打开 / 新建文件夹 / 打开方式：**宿主探测到的系统关联应用**（open-in-app）+ **插件自研目标**（资源管理器 / VS Code / Cursor / Zed / 自定义编辑器，支持 SSH 远端与固定到菜单）/ 复制路径 / 重命名 / 删除）、**Ctrl/Cmd 多选与 Shift 连选**（批量复制路径 / 批量删除 / **压缩并下载**）、**Git 变更按状态着色并带 M/A/D/U 字母**、悬浮 `@文件` 一键引用进输入框。</sub><br/><div align="center"><img width="420" alt="文件资源管理器" src="https://github.com/user-attachments/assets/a410bfd2-a8ba-43e6-873e-22417756e94d" /></div> | **📝 Markdown · HTML 内联预览**<br/><sub>Markdown 预览支持 **Mermaid 图表**（`securityLevel: 'strict'` 安全渲染 + 二次清洗；点击图表弹窗放大、滚轮缩放、拖拽平移）、**README 级内嵌 HTML**（徽章墙 `<div align=center>`、`<details>` 折叠块内嵌 markdown、表格单元格内联标签——DOMPurify 白名单消毒真实渲染，`<script>` 等活性内容剥除，本地图片经会话媒体路由重写）与**浮动目录大纲**（≥3 标题出现，点击平滑跳转、自动展开折叠块）；HTML 走插件自带的**沙箱预览**，并带 `htmlViewerNoSandbox` / `htmlViewerDefaultUnsafe` 两个宿主没有的逃生门开关。**图片 / PDF / 表格 / Office 不再是插件能力**——那些格式由 DSH 自己的文档预览渲染。</sub><br/><div align="center"><img width="420" alt="Markdown + Mermaid 预览" src="https://github.com/user-attachments/assets/fe0e5182-55bb-45cc-b98b-a2877c2bdd38" /></div> |
 | **🖥️ CodeMirror 代码编辑器**<br/><sub>**可编辑**的文本 / 代码编辑器（保存、语法高亮、预览切换）——宿主自己的文档预览是**只读**的，这是插件保留 catch-all viewer 的理由。</sub><br/><div align="center"><img width="420" alt="CodeMirror 代码编辑器" src="https://github.com/user-attachments/assets/b44b488e-568c-4ee0-b96c-e9c906598a77" /></div> | **🖼️ 图片 / PDF / 表格 / Office 预览（由 DSH 内置提供）**<br/><sub>这些只读格式由 DSH 自己的 `ui-sidebar-documentpreview` 渲染：宿主侧 Office→PDF 转换、电子表格 worker 表格、图片 / PDF 缩放视口，并**按目录自动刷新**。插件已删除自己的 image / pdf / 下载兜底 viewer，也不再认领这些扩展名。</sub><br/><div align="center"><img width="420" alt="图片内联预览" src="https://github.com/user-attachments/assets/f9a58c30-5b7a-48b5-9e22-37d7e071f593" /></div> |
-| **💻 终端（由 DSH 内置提供）**<br/><sub>右侧栏终端由 DSH 自己的 `ui-sidebar-terminal` 提供：shell 选择、双击重命名、断线重连、刷新后恢复、主题与对比度跟随。插件不再自带终端实现。<br/><br/>⚠️ **模型侧提示**：插件原来自带的 8 个 `terminal_*` 工具（默认关）是模型唯一的**跨调用持久**终端；上游等价物 `@deepseek-ai/dsh-tool-terminal` 未被任何内置 bundle 默认挂载，若你需要该能力，请在 profile 的 `cordis.patch.yml` 里自行插入一行 `tool-terminal`。</sub><br/><div align="center"><img width="420" alt="真实终端" src="https://github.com/user-attachments/assets/0dad6ad3-ff3f-4b5a-86d2-f832ce65323e" /></div> | **🌿 文件变动：Git 视角 + 本轮文件**<br/><sub>双视角合一：**Git 视角**保留完整源代码管理（暂存 / 取消暂存 / 提交（`Ctrl+Enter`）/ 还原、历史、worktree 与子仓库选择）；**本轮文件视角**实时折叠会话事件日志，记录模型读 / 写 / 编辑的每个文件（按文件分组、按类型筛选、操作数角标）。点击任意改动在底部**可拖拽预览面板**查看统一 diff——删红 / 增绿 / 改蓝配对 + 行内字符级高亮 + 语法着色 + 上下文折叠——也可一键展开为 VSCode 式独立 diff tab（同一渲染栈）。两个视角共用 36px 头（宿主 SegmentedControl 切换）、28px 行、单一空态与吸底提交条；git 状态与文件树共享同一份快照，暂存/提交后文件树着色同步刷新。</sub><br/><div align="center"><img width="420" alt="文件变动" src="https://github.com/user-attachments/assets/e7fc1220-305f-4bca-8583-e77ab4f4fa78" /></div> |
+| **💻 终端（由 DSH 内置提供）**<br/><sub>右侧栏终端由 DSH 自己的 `ui-sidebar-terminal` 提供：shell 选择、双击重命名、断线重连、刷新后恢复、主题与对比度跟随。插件不再自带终端实现。<br/><br/>⚠️ **模型侧提示**：插件原来自带的 8 个 `terminal_*` 工具（默认关）是模型唯一的**跨调用持久**终端；上游等价物 `@deepseek-ai/dsh-tool-terminal` 未被任何内置 bundle 默认挂载，若你需要该能力，请在 profile 的 `cordis.patch.yml` 里自行插入一行 `tool-terminal`。</sub><br/><div align="center"><img width="420" alt="真实终端" src="https://github.com/user-attachments/assets/0dad6ad3-ff3f-4b5a-86d2-f832ce65323e" /></div> | **🌿 文件变动：Git 视角 + 本轮文件**<br/><sub>双视角合一：**Git 视角**保留完整源代码管理（暂存 / 取消暂存 / 提交（`Ctrl+Enter`）/ 还原、历史、worktree 与子仓库选择）；**本轮文件视角**实时折叠会话事件日志，记录模型读 / 写 / 编辑的每个文件（按文件分组、按类型筛选、操作数角标）。点击任意改动在底部**可拖拽预览面板**查看统一 diff——删红 / 增绿 / 改蓝配对 + 行内字符级高亮 + 语法着色 + 上下文折叠——也可一键展开为 VSCode 式独立 diff tab（同一渲染栈）。两个视角共用 36px 头（宿主 SegmentedControl 切换）、28px 行、单一空态与吸底提交条；**Git 视角按目录层级（树）展示变更**——单子目录链压缩成一行、目录行可折叠并带下级变更数、文件行带状态字母与文件图标；git 状态与文件树共享同一份快照，暂存/提交后文件树着色同步刷新。</sub><br/><div align="center"><img width="420" alt="文件变动" src="https://github.com/user-attachments/assets/e7fc1220-305f-4bca-8583-e77ab4f4fa78" /></div> |
 | **🌐 外链接管（浏览器视图由 DSH 提供）**<br/><sub>网页 tab 是 DSH 自己的 `ui-sidebar-browser`（多开 / 后退前进刷新 / 地址栏 / 沙箱 iframe），**0.1.7 起只在 desktop profile 挂载**——Web profile 里没有这个 kind。插件保留宿主没有的那一半：**只认领有 tab 类型通过 `urlTarget` 明确声明的链接**（Ctrl/Cmd 点击始终放行），**其余一律放行给宿主**（正文链接的去向由宿主的用户设置 `linkOpening` 决定）；按协议分流的三个外链接管设置项已删除，认领成功但目标类型此刻不可用时兜底到 `window.open`。</sub><br/><div align="center"><img width="420" alt="内嵌浏览器" src="https://github.com/user-attachments/assets/9bc6b65a-64fc-4942-a685-76e391e55606" /></div> | **🧩 任务页：子代理拓扑 + 后台任务**<br/><sub>子代理树实时拓扑（运行状态、批量实时预览）+ 后台任务清单（退出码 / 实时输出 / 强制终止）；新子代理 / 新任务可自动激活任务页，宽屏同时展开侧边栏，窄屏不强制展开全屏抽屉（可关）。</sub><br/><div align="center"><img width="420" alt="任务页：子代理拓扑" src="https://github.com/user-attachments/assets/dcd8ed2f-59fa-405b-937b-2d250f5034dd" /></div> |
 | **💬 侧边对话(beta)**<br/><sub>Codex 风格侧边线程：**每个对话一个独立 Tab**；线程继承主会话完整上下文（含进行中回合，以 interrupted 诚实冻结）独立运行，不污染主会话；可持续追问、重启冷恢复；一键「保存为新会话」提升为顶层会话。</sub><br/><div align="center"><img width="420" alt="侧边对话(beta)" src="https://github.com/user-attachments/assets/3a338c36-f5de-4000-95f3-4b1cd04f60fc" /></div> | **🖥️ DSH 原生右侧栏 + 插件底部工作台**<br/><sub>右列是 DSH 自己的右侧栏：插件把每个 tab 类型注册成原生 tab（含接管内置「文件」页），聊天里的文件点击直接落到原生栏——**宿主自己的文档预览已覆盖的格式由宿主渲染**，插件只认领 Markdown / HTML / 可编辑代码；插件自有底部面板可与其同时展开，拖 Tab 到分栏边缘**拆分**、拖到中间**合并**，高度拖上缘调节；开合按钮在会话头右侧。</sub><br/><div align="center"><img width="420" alt="双工作台（右侧栏 + 底部面板）" src="https://github.com/user-attachments/assets/dfdb875e-a1a8-4d4b-8340-353736b1708f" /></div> |
 | **⚙️ 声明式设置**<br/><sub>设置页「侧边卡片」分区：每个 tab / 预览器一张小卡片，独立开关（高亮启用态 + 品牌开关滑块）；二级设置经卡片底部「功能设置」条弹窗（开关 / 文本 / 数字 / 下拉）；插件自有设置持久化在 `pluginSettings`，整份偏好则写在 profile 里本插件的**挂载行**上（DSH 0.1.7 起设置按 Loader entry id 寻址）。</sub><br/><div align="center"><img width="420" alt="声明式设置：侧边卡片" src="https://github.com/user-attachments/assets/0800ca64-621e-48da-b7df-aecfddc3ec29" /></div> | **📱 移动端**<br/><sub>窄屏（<768px）自动切换为全宽抽屉：底栏 tab 一次性并入右侧栏，触屏拖拽可调。</sub><br/><div align="center"><img width="360" alt="移动端全宽抽屉" src="https://github.com/user-attachments/assets/a82ba78a-f4cf-4d85-80e8-050a05beb144" /></div> |
diff --git a/README_EN.md b/README_EN.md
index fd7e929..0f797d3 100644
--- a/README_EN.md
+++ b/README_EN.md
@@ -48,7 +48,7 @@
 What this plugin adds on top of DSH's stock sidebar:
 
 - **✏️ Editable editor**: the host's document preview is **read-only** → the plugin keeps an **editable** CodeMirror editor (save, syntax highlighting, preview toggle); Markdown / HTML also render through the plugin's own pipeline (Mermaid diagrams with safe rendering + click-to-zoom, README-level inline HTML, floating table of contents, sandboxed HTML preview)
-- **🗂️ Enhanced file tree**: takes over the built-in Files page — lazy-loading tree, **expanded directories watched live and auto-refreshed**, symlink awareness, global filename search, drag-and-drop upload, hover `@file` to drop a reference into the input box; **Ctrl/Cmd multi-select and Shift range-select** (copy or delete a batch), **VS Code-style git status colors + M/A/D/U letters**, **new folder**, and an “Open with” menu that reuses DSH’s own open-in-app (the host’s probed OS handlers + file-manager reveal)
+- **🗂️ Enhanced file tree**: takes over the built-in Files page — lazy-loading tree, **expanded directories watched live and auto-refreshed**, symlink awareness, global filename search, drag-and-drop upload, hover `@file` to drop a reference into the input box; **Ctrl/Cmd multi-select and Shift range-select** (copy or delete a batch), **VS Code-style git status colors + M/A/D/U letters**, **new folder**, **multi-select “Zip and download”** (the host streams a ZIP built with no third-party dependency), and an “Open with” menu that COMBINES DSH’s own open-in-app (the host’s probed OS handlers + file-manager reveal) with the plugin’s own targets (file manager / VS Code / Cursor / Zed / custom editor URL templates, SSH remotes, pin-to-menu)
 - **🌿 Changes** (no Git panel in the stock sidebar): two lenses in one tab — **Git** (diff / history / stage·commit·revert) and **This Session** (every file the model touched) — with a unified diff renderer (intra-line character highlights, syntax coloring, secret redaction); the two lenses now share one 36px header (host SegmentedControl), 28px rows, a single empty state and a sticky commit bar, and the git snapshot is shared with the file tree so staging recolors the tree too
 - **🧩 Background Tasks** (absent upstream): agent topology preview + background task list (exit codes / live output / force-kill)
 - **💬 Side Chat** (absent upstream, beta): Codex-style side threads — inheriting the full parent context, running independently, promotable to a top-level session
@@ -171,9 +171,9 @@ Update: `git pull && pnpm install && pnpm build` → `node scripts/package-regis
 
 | | |
 |---|---|
-| **🗂️ File Workbench: Explorer**<br/><sub>Two explorer modes: embedded in the file preview / standalone file tree. Lazy-loading directory tree whose **expanded directories the host watches per directory and re-lists on change**, symlinks classified by target kind (directory links expand, dangling links flagged), global filename search, file/folder upload buttons plus drag-drop upload, context menu (open in new tab / open to the side / new folder / Open with (DSH’s own open-in-app: probed OS handlers + file-manager reveal) / copy paths / rename / delete), **Ctrl/Cmd multi-select with Shift range-select** (batch copy paths, batch delete), **git changes colored by status with M/A/D/U letters**, and a hover `@file` button that references a file straight into the composer.</sub><br/><div align="center"><img width="420" alt="File explorer" src="https://github.com/user-attachments/assets/a410bfd2-a8ba-43e6-873e-22417756e94d" /></div> | **📝 Inline Preview: Markdown · HTML**<br/><sub>The Markdown preview renders **Mermaid diagrams** (strict-mode safe rendering + a second sanitize pass; click a diagram for a zoom modal with wheel-zoom and drag-pan), **README-level inline HTML** (badge walls `<div align=center>`, `<details>` blocks nesting markdown, inline tags in table cells — DOMPurify-sanitized, `<script>` stripped, local media rewritten to the session media route) and a floating **table of contents** (appears with ≥3 headings, smooth-scroll jumping, auto-expanding folded blocks); HTML uses the plugin's own **sandboxed preview** with the two escape hatches the host does not have (`htmlViewerNoSandbox` / `htmlViewerDefaultUnsafe`). **Images / PDF / spreadsheets / Office are no longer a plugin capability** — the host's own document preview renders those formats.</sub><br/><div align="center"><img width="420" alt="Markdown + Mermaid preview" src="https://github.com/user-attachments/assets/fe0e5182-55bb-45cc-b98b-a2877c2bdd38" /></div> |
+| **🗂️ File Workbench: Explorer**<br/><sub>Two explorer modes: embedded in the file preview / standalone file tree. Lazy-loading directory tree whose **expanded directories the host watches per directory and re-lists on change**, symlinks classified by target kind (directory links expand, dangling links flagged), global filename search, file/folder upload buttons plus drag-drop upload, context menu (open in new tab / open to the side / new folder / Open with — the host’s probed OS handlers PLUS the plugin’s own targets (file manager / VS Code / Cursor / Zed / custom editors, SSH remotes, pin-to-menu) / copy paths / rename / delete), **Ctrl/Cmd multi-select with Shift range-select** (batch copy paths, batch delete, **zip and download**), **git changes colored by status with M/A/D/U letters**, and a hover `@file` button that references a file straight into the composer.</sub><br/><div align="center"><img width="420" alt="File explorer" src="https://github.com/user-attachments/assets/a410bfd2-a8ba-43e6-873e-22417756e94d" /></div> | **📝 Inline Preview: Markdown · HTML**<br/><sub>The Markdown preview renders **Mermaid diagrams** (strict-mode safe rendering + a second sanitize pass; click a diagram for a zoom modal with wheel-zoom and drag-pan), **README-level inline HTML** (badge walls `<div align=center>`, `<details>` blocks nesting markdown, inline tags in table cells — DOMPurify-sanitized, `<script>` stripped, local media rewritten to the session media route) and a floating **table of contents** (appears with ≥3 headings, smooth-scroll jumping, auto-expanding folded blocks); HTML uses the plugin's own **sandboxed preview** with the two escape hatches the host does not have (`htmlViewerNoSandbox` / `htmlViewerDefaultUnsafe`). **Images / PDF / spreadsheets / Office are no longer a plugin capability** — the host's own document preview renders those formats.</sub><br/><div align="center"><img width="420" alt="Markdown + Mermaid preview" src="https://github.com/user-attachments/assets/fe0e5182-55bb-45cc-b98b-a2877c2bdd38" /></div> |
 | **🖥️ CodeMirror editor**<br/><sub>An **editable** text / code editor (save, syntax highlighting, preview toggle) — the host's own document preview is **read-only**, which is exactly why the plugin keeps its catch-all viewer.</sub><br/><div align="center"><img width="420" alt="CodeMirror editor" src="https://github.com/user-attachments/assets/b44b488e-568c-4ee0-b96c-e9c906598a77" /></div> | **🖼️ Images / PDF / spreadsheets / Office (provided by DSH)**<br/><sub>These read-only formats render in DSH's own `ui-sidebar-documentpreview`: host-side Office→PDF conversion, worker-backed spreadsheet tables, image / PDF zoom viewports, and **per-directory auto-refresh**. The plugin deleted its own image / pdf / download-fallback viewers and no longer claims those extensions.</sub><br/><div align="center"><img width="420" alt="Inline image preview" src="https://github.com/user-attachments/assets/f9a58c30-5b7a-48b5-9e22-37d7e071f593" /></div> |
-| **💻 Terminal (provided by DSH)**<br/><sub>The right-Sidebar terminal is provided by DSH's own `ui-sidebar-terminal`: shell picker, double-click rename, reconnect, restore after reload, theme and contrast following. The plugin no longer ships xterm + node-pty.<br/><br/>⚠️ **Model-side caveat**: the plugin's own 8 `terminal_*` tools (off by default) were the model's only **cross-call persistent** terminal; the upstream equivalent `@deepseek-ai/dsh-tool-terminal` is not mounted by any shipped bundle, so if you need that capability, add a `tool-terminal` row to your profile's `cordis.patch.yml` yourself.</sub><br/><div align="center"><img width="420" alt="Terminal" src="https://github.com/user-attachments/assets/0dad6ad3-ff3f-4b5a-86d2-f832ce65323e" /></div> | **🌿 Changes: Git lens + This-Session lens**<br/><sub>Two lenses on "what changed?": the **Git lens** keeps the full source-control surface (stage / unstage / commit (`Ctrl+Enter`) / revert, history, worktree and child-repo selectors); the **This Session** lens folds the session event log live, recording every file the model read / wrote / edited (grouped by file, kind-filtered, op-count badge). Both lenses now share one 36px header, 28px rows, a single empty state and a sticky commit bar; the git snapshot is shared with the file tree, so staging recolors the tree as well. Clicking any change previews it in the **draggable bottom pane** with the unified diff — del red / add green / mod-blue pairing + intra-line character highlights + syntax coloring + context folding — or expands into a VSCode-style dedicated diff tab (same rendering stack).</sub><br/><div align="center"><img width="420" alt="Changes" src="https://github.com/user-attachments/assets/e7fc1220-305f-4bca-8583-e77ab4f4fa78" /></div> |
+| **💻 Terminal (provided by DSH)**<br/><sub>The right-Sidebar terminal is provided by DSH's own `ui-sidebar-terminal`: shell picker, double-click rename, reconnect, restore after reload, theme and contrast following. The plugin no longer ships xterm + node-pty.<br/><br/>⚠️ **Model-side caveat**: the plugin's own 8 `terminal_*` tools (off by default) were the model's only **cross-call persistent** terminal; the upstream equivalent `@deepseek-ai/dsh-tool-terminal` is not mounted by any shipped bundle, so if you need that capability, add a `tool-terminal` row to your profile's `cordis.patch.yml` yourself.</sub><br/><div align="center"><img width="420" alt="Terminal" src="https://github.com/user-attachments/assets/0dad6ad3-ff3f-4b5a-86d2-f832ce65323e" /></div> | **🌿 Changes: Git lens + This-Session lens**<br/><sub>Two lenses on "what changed?": the **Git lens** keeps the full source-control surface (stage / unstage / commit (`Ctrl+Enter`) / revert, history, worktree and child-repo selectors); the **This Session** lens folds the session event log live, recording every file the model read / wrote / edited (grouped by file, kind-filtered, op-count badge). Both lenses now share one 36px header, 28px rows, a single empty state and a sticky commit bar; the **Git lens lists changes as a directory tree** (single-child chains collapsed into one row, collapsible folders with descendant counts, status letters and file icons on the leaves); the git snapshot is shared with the file tree, so staging recolors the tree as well. Clicking any change previews it in the **draggable bottom pane** with the unified diff — del red / add green / mod-blue pairing + intra-line character highlights + syntax coloring + context folding — or expands into a VSCode-style dedicated diff tab (same rendering stack).</sub><br/><div align="center"><img width="420" alt="Changes" src="https://github.com/user-attachments/assets/e7fc1220-305f-4bca-8583-e77ab4f4fa78" /></div> |
 | **🌐 External-link takeover (browser view provided by DSH)**<br/><sub>Web tabs are DSH's own `ui-sidebar-browser` (multiple tabs / back-forward-reload / address bar / sandboxed iframe), mounted **only in the desktop profile since 0.1.7** — the Web profile has no such kind. The plugin keeps the half the host does not provide: it takes over **only links a tab type explicitly claims through `urlTarget`** (Ctrl/Cmd-clicks always pass through) and **lets everything else through to the host** (whose `linkOpening` user setting decides where prose links go); the three protocol-routing settings are gone, and a claim whose target type is unavailable at open time falls back to `window.open`.</sub><br/><div align="center"><img width="420" alt="Browser" src="https://github.com/user-attachments/assets/9bc6b65a-64fc-4942-a685-76e391e55606" /></div> | **🧩 Tasks: Agent Topology + Background Jobs**<br/><sub>Live subagent-tree topology (run states, batched live previews) plus the background-jobs list (exit codes / live output / force-kill); new subagents / jobs can auto-activate the Tasks page, expanding the sidebar on wide viewports without forcing narrow full-screen drawers open (configurable).</sub><br/><div align="center"><img width="420" alt="Tasks: subagent topology" src="https://github.com/user-attachments/assets/dcd8ed2f-59fa-405b-937b-2d250f5034dd" /></div> |
 | **💬 Side Chat (beta)**<br/><sub>Codex-style side threads: **one independent tab per conversation**; the thread inherits the parent's full context (including the in-progress turn, honestly frozen as "interrupted") and runs independently without polluting the main session; follow-ups survive restarts; one click promotes the thread to a top-level session.</sub><br/><div align="center"><img width="420" alt="Side Chat (beta)" src="https://github.com/user-attachments/assets/3a338c36-f5de-4000-95f3-4b1cd04f60fc" /></div> | **🖥️ DSH's native right sidebar + plugin bottom workbench**<br/><sub>The right column is DSH's own sidebar: the plugin registers every tab type as a native tab (including taking over the built-in Files page), so clicking a file in the chat lands there directly — **formats the host's own document preview already covers are rendered by the host**, and the plugin claims only Markdown / HTML / editable code; the plugin's own bottom panel can stay open alongside it — drag a tab to a pane edge to **split**, to the middle to **merge**, drag the top edge to resize; the toggle lives in the session header.</sub><br/><div align="center"><img width="420" alt="Dual workbench (right sidebar + bottom panel)" src="https://github.com/user-attachments/assets/dfdb875e-a1a8-4d4b-8340-353736b1708f" /></div> |
 | **⚙️ Declarative Settings**<br/><sub>The "Side card" section in DSH settings: one small card per tab / viewer with an independent toggle (highlighted enabled state + brand switch); secondary settings open from the "Feature settings" strip at the card bottom (switch / text / number / select rows); plugin-owned settings persist under `pluginSettings`, while the whole preference set lives on this plugin's **mount row** in the profile (since DSH 0.1.7 settings are addressed by Loader entry id).</sub><br/><div align="center"><img width="420" alt="Declarative settings: side cards" src="https://github.com/user-attachments/assets/0800ca64-621e-48da-b7df-aecfddc3ec29" /></div> | **📱 Mobile**<br/><sub>On narrow screens (<768px) the panels become a full-width drawer: bottom-panel tabs merge into the sidebar once, with touch-friendly dragging.</sub><br/><div align="center"><img width="360" alt="Mobile full-width drawer" src="https://github.com/user-attachments/assets/a82ba78a-f4cf-4d85-80e8-050a05beb144" /></div> |
diff --git a/docs/plans/2026-09-27-files-changes-uiux.md b/docs/plans/2026-09-27-files-changes-uiux.md
index 84b2533..46f6b87 100644
--- a/docs/plans/2026-09-27-files-changes-uiux.md
+++ b/docs/plans/2026-09-27-files-changes-uiux.md
@@ -407,3 +407,72 @@ ChangesTab
 - 真实挂载 lane：`DSH_CMD='npx -y --package @deepseek-ai/dsh@0.1.7-rc.1 dsh' pnpm test:mount` → **7/7 通过**（含 tab sweep、perf lane）。
 - 截图级证据（临时 Playwright 取证脚本，已删除，不留在仓库）：真实宿主上文件树行显示 **M/U 字母与状态色**、右键菜单出现宿主探测到的应用列表、文件变动页显示 36px `Git | Session` 头 + 未暂存/已暂存分组 + 吸底提交条 + 历史。
 - 仍属未验证：拖拽上传的视觉观感与手动多选手感（只有 token/尺度证据与行为测试）、Windows 宿主差异。
+
+---
+
+## 9. 第二轮：open-with 与宿主能力并存 + 打包下载 + 文件变动树（用户追加需求）
+
+用户追加三条：
+
+1. **打开方式 = 宿主探测到的本机关联应用 + 插件自研 open-with**（两者并存，不是二选一）；
+2. **文件页多选时右键新增「压缩打包并下载」**；
+3. **文件变动页再次重构：更美观 + 以层级（树）方式显示更改**。
+
+### 9.1 冻结接口
+
+#### A. open-with 恢复并与 open-in-app 并存
+
+- 恢复 `src/client/open-with.ts`（`OpenWithConfig` / `OpenWithTarget` / `parseOpenWithConfig` / `resolveOpenWithTargets` / `openWithUrl` / `openWithSshActive` / `newCustomEditorId` / `isValidCustomEditor`，与 main 逐字一致）、`src/client/open-with-settings.tsx`、`src/client/plugin-settings.ts`、宿主 `src/open-external.ts` 与 `open.external` 路由、`api.openExternal`、editor descriptor 的 `settings.render`，以及 20 个 `openWith*` 词条。
+- `FileTree` / `TreePanel` 恢复 main 的可选 props：`openWithTargets` / `openWithPinned` / `openWithSsh` / `onOpenWith` / `onToggleOpenWithPin`，与既有 `openInApp` **并存**。
+- 菜单形状（`打开方式` 段）：
+  1. 宿主行（`openInApp` 可用时）：`用默认应用打开` + 各系统关联应用；
+  2. 插件行：pinned 目标直达 + `在应用中打开 >` 子菜单（含图钉，main 原样）；**当宿主可用时隐藏插件的 `explorer` 目标**（宿主已有「在文件管理器中显示」，避免重复）；
+  3. 分隔线 + 宿主 `在文件管理器中显示`（宿主不可用时该行不出现，插件的 `explorer` 目标保留，保证仍能 reveal）。
+- 宿主完全不可用（`available() === false` / 无 handle）时：宿主行整段隐藏，插件行照旧可用（SSH 远端场景因此保持可用）。
+
+#### B. 压缩打包并下载
+
+- 新增 `src/zip.ts`：`buildZip(entries, opts)` 产出 ZIP（store + `zlib.deflateRaw` 两种方法按压缩收益选择；UTF-8 名称标志位；目录条目；CRC32；无第三方依赖）。
+- 新增宿主 GET 路由 `/sidebar/archive?sessionId=&cwd=&name=<archive.zip>&path=<p>&path=<p>…`：每个 `path` 经既有 workspace fence 校验，文件/目录（递归）都接受；上限（条目数 / 总字节）超限返回 JSON 错误；成功时 `content-type: application/zip` + `content-disposition: attachment`。
+- 客户端 `api.archiveUrl(scope, paths, name)`（与 `downloadUrl` 同形的 GET URL）。
+- 交互：多选（≥2）时右键菜单出现 `压缩并下载（{count} 项）`；单选且为目录时同样出现（单文件不出，避免与「下载」重复）。
+- 新词条：`zipDownload` / `zipDownloadCount` / `zipFailed`。
+
+#### C. 文件变动页层级显示
+
+- Git 视角的两个分组（未暂存 / 已暂存）各自渲染为**目录树**：单子目录压缩（`a/b/c` 一行显示为 `a/b`），目录行有 disclosure chevron + 文件夹图标，文件行有文件图标 + 状态字母 + 名称 + 弱化目录；行尾仍可暂存/取消暂存；默认展开。
+- 纯函数 `buildChangeTree(entries)`（`src/client/changes/change-tree.ts`）产出树 + 压缩规则，独立单测。
+- 视觉打磨：分组头吸顶、计数胶囊、hover 与选中态、缩进参考线、提交条与历史行间距统一到 §1 尺度。
+
+### 9.2 分工与写入范围
+
+| 范围 | 归属 |
+|---|---|
+| 计划文档、验证裁决、集成、最终门禁 | Lead |
+| `src/index.ts`、`src/zip.ts`、`src/client/api.ts`、`src/client/open-with.ts`、`src/client/open-with-settings.tsx`、`src/client/plugin-settings.ts`、`src/open-external.ts`、`src/client/EditorHost.tsx`、`src/client/builtins/tabs.tsx`、相关测试 | 宿主接入实现者 |
+| `src/client/FileTree.tsx`、`src/client/TreePanel.tsx`、`src/client/sidebar.module.css`、文件页测试 | 文件页实现者 |
+| `src/client/changes/**`、`src/client/diff/**`、变动页测试 | 文件变动页实现者 |
+| `src/client/locales-*.ts`（19 份） | 词典实现者 |
+| 独立验证 | 验证者 |
+
+### 9.3 实施记录（第二轮）
+
+- **打开方式并存**（落地形状）：菜单段无标题行 —— 宿主行（`用默认应用打开` + 系统关联应用，仅宿主可用）→ 分隔线 → 插件 pinned 直达行 + `在应用中打开 >` 子菜单（图钉 / SSH 后缀原样）→ 分隔线 → 宿主 `在文件管理器中显示`。宿主可用时过滤插件的 `explorer` 目标；宿主不可用/无 handle 时只留插件行（含 `explorer`，reveal 不丢）。
+  - 自研链路逐字恢复：`src/client/open-with.ts`、`open-with-settings.tsx`、`plugin-settings.ts`、`src/open-external.ts`、`open.external` 路由、`api.openExternal`、editor descriptor 的 `settings.render`，以及 20 个 `openWith*` 词条（19 份词典从 `git show main:` 逐字取回）。
+  - 因菜单去掉标题行，`openInApp` 词条成为死键 → 已从 21 份词典删除（zh 507 键）。
+  - 子菜单需要 `useSubmenuFlip`：第一轮删除的 `src/client/menu-flip.ts` + `layout.css` 翻转规则 + `tests/menu-flip.spec.tsx` 一并恢复。
+- **压缩打包下载**：新增 `src/zip.ts`（自研 ZIP 写入器，无第三方依赖）+ `src/archive-route.ts`（下载名净化 + 递归收集）+ `GET /sidebar/archive` + `api.archiveUrl`；`FileTree` 多选右键「压缩并下载（N 项）」（单选目录亦可，单文件不出），下载走 `fetch → blob → objectURL`，**路由错误（超限 / fence 拒绝 / 非 GET）现在会以 `zipFailed` 显示在错误条**。
+  - 上限：10 000 条目 / 256 MiB 未压缩负载（收集期即中止）。
+  - 实施中由系统 `unzip` 抓到的真实缺陷：central directory 只写 MS-DOS 位而 version-made-by 声称 Unix → Info-ZIP 把每个文件解成 `mode 000`；改为 Unix 语义（`0o100644 * 0x10000`，注意 `<< 16` 溢出 int32）。复验：mode 644/755、UTF-8 名、`unzip -t` 无错。
+- **文件变动层级树**：新增 `src/client/changes/change-tree.ts`（`buildChangeTree`：'/' 分段、单子目录链压缩成一行、目录先于文件、大小写不敏感排序、文件带 `GitFileStatus`、目录带下级变更数），两个分组各自渲染树；折叠状态按「组 + 路径」独立保存、默认展开；分组头吸顶 + 计数胶囊；`Stage all`/`Unstage all` 改为带 aria-label 的 IconButton；选中 = `interactive-bg-active` + 2px 内嵌强调条；12px/级缩进 + `-l1` 参考线；历史行 hash 徽标 / ref 胶囊 / 作者·时间右对齐。
+  - 契约偏差（已批准）：文件行不再重复渲染目录文本（树已用父行表达层级，重复是噪声）；`ChangeDir` 额外带 `changes` 计数以免每行重扫子树。
+
+### 9.4 第二轮验证证据
+
+- `pnpm typecheck` / `pnpm lint` / `pnpm test`（**134 文件、1422 通过、9 跳过**）/ `pnpm build` 全绿。
+- 真实挂载 lane：`DSH_CMD='npx -y --package @deepseek-ai/dsh@0.1.7-rc.1 dsh' pnpm test:mount` → **7/7 通过**。
+- 截图取证（临时 Playwright 脚本，已删除）：真实宿主上确认
+  ① 文件树多选 5 项 + 右键菜单同时含 **宿主探测应用**（Open with default app / Visual Studio Code / QuickTime Player）与 **插件 `Open with >` 子菜单** + **Zip and download (5 items)**；
+  ② 变动页 Git 视角以树显示：`src/client/changes`（单子目录链压缩成一行，带计数胶囊 1）→ `GitLens.tsx`（M 徽标），已暂存组 `src` → `app.ts`。
+- 单文件页回归：14 个 spec / 91 用例绿（含新增 `file-tree-archive.spec.tsx` 9 例：出现条件、成功链、三条失败路径、in-flight 守卫）。
+- 仍未验证：真实浏览器里 ZIP 的落盘行为（jsdom spy 证据）、拖拽/多选手感、Windows 宿主差异。
diff --git a/src/archive-route.ts b/src/archive-route.ts
new file mode 100644
index 0000000..d31df3d
--- /dev/null
+++ b/src/archive-route.ts
@@ -0,0 +1,100 @@
+/**
+ * Helpers for the `/sidebar/archive` route (the file tree's "zip and
+ * download" action): the download-name sanitizer and the recursive entry
+ * walk. Kept apart from index.ts so both are directly unit-testable — the
+ * walk's bounds live inside the collector, and the route module is a
+ * cordis plugin whose setup needs a whole fake context.
+ *
+ * The walk is the security-relevant half: every row comes from an already
+ * fenced path (index.ts resolves each selection through
+ * `ensureWorkspacePath` first), and a symlink is skipped rather than followed,
+ * so it can neither escape the workspace nor cycle.
+ */
+import { lstat, readdir } from 'node:fs/promises'
+import { join } from 'node:path'
+import { SidebarError } from './wire.ts'
+import { ZIP_MAX_ENTRIES, type ZipEntry } from './zip.ts'
+
+/** Maximum archive-name length (keeps the Content-Disposition header sane). */
+export const ARCHIVE_NAME_MAX = 120
+
+/**
+ * Sanitize the archive's download name: one flat file name, never a path.
+ * Separators, control characters, quotes and leading dots are stripped (a
+ * name cannot look like a traversal or hide as a dotfile); an empty result
+ * falls back to `archive.zip`, and a `.zip` suffix is applied once.
+ */
+export function archiveNameOf(raw: string | null): string {
+  // A bare `.zip` (or nothing at all) is the caller asking for the default:
+  // check BEFORE the leading-dot strip below, which would turn it into `zip`.
+  const trimmed = (raw ?? '').trim()
+  if (trimmed === '' || trimmed === '.zip') return 'archive.zip'
+  // Character filter (not a character-class regex): separators, quotes and
+  // C0/DEL control characters cannot survive into the header.
+  const cleaned = [...trimmed]
+    .filter((char) => {
+      const code = char.codePointAt(0)!
+      return char !== '\\' && char !== '/' && char !== '"' && char !== '\'' && code >= 0x20 && code !== 0x7F
+    })
+    .join('')
+    .trim()
+    .replace(/^\.+/, '')
+    .slice(0, ARCHIVE_NAME_MAX)
+  if (cleaned === '') return 'archive.zip'
+  return cleaned.toLowerCase().endsWith('.zip') ? cleaned : `${cleaned}.zip`
+}
+
+/**
+ * Collect one selected path into the archive: a file becomes one entry, a
+ * directory is walked depth-first and each level contributes its own entry
+ * (a trailing '/' name), files keep their layout under the directory's own
+ * name. Symlinks are skipped, never followed. Iterative (an explicit stack)
+ * because a deep tree must not blow the JS stack, and the count bound is
+ * enforced HERE so a runaway directory fails before its rows pile up.
+ *
+ * @param absolute - the (already fenced) absolute path of the selection.
+ * @param name - the in-archive name of that selection (its basename).
+ * @param out - the entry list appended to, in archive order.
+ * @param maxEntries - entry-count bound.
+ * @throws {SidebarError} fs-error when a row cannot be read or the bound is hit.
+ */
+export async function collectZipEntries(
+  absolute: string,
+  name: string,
+  out: ZipEntry[],
+  maxEntries = ZIP_MAX_ENTRIES,
+): Promise<void> {
+  const stack: Array<{ path: string; name: string }> = [{ path: absolute, name }]
+  while (stack.length > 0) {
+    const item = stack.pop()!
+    if (out.length >= maxEntries) {
+      throw new SidebarError('fs-error', `too many entries for one archive (> ${maxEntries})`, 400)
+    }
+    const info = await lstat(item.path).catch((error: unknown) => {
+      throw new SidebarError('fs-error', `cannot read "${item.path}": ${error instanceof Error ? error.message : String(error)}`, 400)
+    })
+    if (info.isSymbolicLink()) {
+      // A link row is not a file to read and not a directory to walk: it is
+      // skipped (an archive of a dangling link has nothing to store). Never
+      // followed — no escape and no cycle.
+      continue
+    }
+    if (!info.isDirectory()) {
+      out.push({ path: item.path, name: item.name })
+      continue
+    }
+    out.push({ path: item.path, name: item.name, isDir: true })
+    let level
+    try {
+      level = await readdir(item.path, { withFileTypes: true })
+    } catch (error) {
+      throw new SidebarError('fs-error', `cannot list "${item.path}": ${error instanceof Error ? error.message : String(error)}`, 400)
+    }
+    // Reverse order: the stack pops the first child next, so the archive reads
+    // top-down in directory order.
+    for (let index = level.length - 1; index >= 0; index -= 1) {
+      const child = level[index]!
+      stack.push({ path: join(item.path, child.name), name: `${item.name}/${child.name}` })
+    }
+  }
+}
diff --git a/src/client/EditorHost.tsx b/src/client/EditorHost.tsx
index 4de1ce4..ac3f729 100644
--- a/src/client/EditorHost.tsx
+++ b/src/client/EditorHost.tsx
@@ -34,6 +34,8 @@ import { planFirstMatch, planFsReadOutcome, type EditorLoadAction } from './edit
 import { baseName } from './FileTree.tsx'
 import { createFrameBatcher } from './frame-batcher.ts'
 import { openSidebarFile } from './sidebar-file.ts'
+import { openWithSshActive, openWithUrl, parseOpenWithConfig, resolveOpenWithTargets } from './open-with.ts'
+import { updatePluginSettings } from './plugin-settings.ts'
 import { createOpenInApp } from './open-in-app.ts'
 import { TreePanel } from './TreePanel.tsx'
 import { t } from './locales.ts'
@@ -55,6 +57,10 @@ const TREE_WIDTH_DEFAULT = 240
 const TREE_WIDTH_MIN = 160
 const TREE_WIDTH_MAX = 480
 
+/** Stable empty blob for the editor pluginSettings read (a fresh `?? {}`
+ *  would change identity every snapshot and loop useSyncExternalStore). */
+const EMPTY_PLUGIN_BLOB: Record<string, unknown> = {}
+
 /** The tab's persisted meta object (a malformed meta reads as empty). */
 function metaOf(tab: SidebarTab): Record<string, unknown> {
   return tab.meta !== null && typeof tab.meta === 'object' && !Array.isArray(tab.meta)
@@ -139,6 +145,16 @@ export function EditorHost(props: {
   // target list, a URL vocabulary or a spawn route — the host reports which
   // applications are actually installed for THIS path.
   const openInApp = useMemo(() => createOpenInApp(ctx), [ctx])
+  // The file tree's "open with" configuration (pluginSettings['editor']): a
+  // blob subscription, so a pin click or a settings-page edit re-renders the
+  // menu immediately. The parsed config also drives which targets are shown
+  // (SSH mode hides the host-local ones).
+  const editorBlob = useSyncExternalStore(
+    useCallback((callback: () => void) => store.subscribe(callback), [store]),
+    useCallback(() => store.getSnapshot().prefs.pluginSettings['editor'] ?? EMPTY_PLUGIN_BLOB, [store]),
+  )
+  const openWithConfig = useMemo(() => parseOpenWithConfig(editorBlob.openWith), [editorBlob])
+  const openWithTargets = useMemo(() => resolveOpenWithTargets(openWithConfig), [openWithConfig])
   // A path-less tab shows the empty-state hint in merged mode — and in split
   // mode it is the standalone explorer (tree-only, see the render below). A
   // folder tab is a folder window in BOTH modes: the tree rooted at the
@@ -185,6 +201,40 @@ export function EditorHost(props: {
     })
   }
 
+  /** The context menu's "open with" action: reveal the path in the OS file
+   *  manager, or hand the target's URL to its opener — local `file` URLs go
+   *  to the host's external opener, while the SSH-remote form for
+   *  VSCode-family editors launches on the browser/client machine (see
+   *  api.openExternal). Failures are logged only — a missing handler is the
+   *  OS's/browser's dialog, not a sidebar error. */
+  const openWith = (targetId: string, absolute: string): void => {
+    const target = openWithTargets.find(item => item.id === targetId)
+    if (target === undefined) return
+    if (target.kind === 'reveal') {
+      void api.openExternal({ action: 'reveal', path: absolute }).catch(
+        (error: unknown) => { console.error('open external failed', error) },
+      )
+      return
+    }
+    const url = openWithUrl(target, absolute, openWithConfig)
+    if (url === undefined) return
+    void api.openExternal({ action: 'url', url }).catch(
+      (error: unknown) => { console.error('open external failed', error) },
+    )
+  }
+
+  /** Toggle one target's pinned state. The write is serialized (see
+   *  plugin-settings.ts) and the menu re-renders when the store prefs land. */
+  const toggleOpenWithPin = (targetId: string): void => {
+    updatePluginSettings(store, 'editor', (blob) => {
+      const config = parseOpenWithConfig(blob.openWith)
+      const pinned = config.pinned.includes(targetId)
+        ? config.pinned.filter(id => id !== targetId)
+        : [...config.pinned, targetId]
+      return { ...blob, openWith: { ...config, pinned } }
+    })
+  }
+
   // Tree mutations reconcile the OPEN tabs (both split trees, the bottom
   // panel, free windows): a rename retargets its tab to the new path; a
   // delete closes tabs at or under the removed path. See tree-mutations.ts.
@@ -355,6 +405,11 @@ export function EditorHost(props: {
           onOpenFileNewTab={openFileNewTab}
           onOpenFileSide={openFileSide}
           openInApp={openInApp}
+          openWithTargets={openWithTargets}
+          openWithPinned={openWithConfig.pinned}
+          openWithSsh={openWithSshActive(openWithConfig)}
+          onOpenWith={openWith}
+          onToggleOpenWithPin={toggleOpenWithPin}
           onReferenceFile={onReferenceFile}
           onPathRenamed={onPathRenamed}
           onPathDeleted={onPathDeleted}
@@ -477,6 +532,11 @@ export function EditorHost(props: {
               onOpenFileNewTab={openFileNewTab}
               onOpenFileSide={openFileSide}
               openInApp={openInApp}
+              openWithTargets={openWithTargets}
+              openWithPinned={openWithConfig.pinned}
+              openWithSsh={openWithSshActive(openWithConfig)}
+              onOpenWith={openWith}
+              onToggleOpenWithPin={toggleOpenWithPin}
               onReferenceFile={onReferenceFile}
               onPathRenamed={onPathRenamed}
               onPathDeleted={onPathDeleted}
diff --git a/src/client/FileTree.tsx b/src/client/FileTree.tsx
index ef8e5d4..99978bc 100644
--- a/src/client/FileTree.tsx
+++ b/src/client/FileTree.tsx
@@ -42,16 +42,21 @@ import { memo, useCallback, useEffect, useMemo, useRef, useState, type DragEvent
 import { createPortal } from 'react-dom'
 import clsx from 'clsx'
 import {
-  IconCloseFillRegular, IconCodeOutlineRegular, IconCopyOutlineRegular, IconDownloadOutlineRegular,
+  IconArchiveOutlineRegular, IconChevronRightOutlineRegular, IconCloseFillRegular, IconCodeOutlineRegular, IconCopyOutlineRegular,
+  IconDownloadOutlineRegular,
   IconEditOutlineRegular, IconFolderOpenRegular, IconLinkOutlineRegular, IconPlusOutlineRegular, IconTrashOutlineRegular,
   Menu, type MenuEntry, type MenuItem, writeClipboard,
 } from '@deepseek-ai/dsh-client-ui-primitives'
-import { api, downloadUrl, isOutsideWorkspaceMessage, type FsEntry } from './api.ts'
+import { SiCursor, SiZedindustries } from 'react-icons/si'
+import { VscFolderOpened, VscLinkExternal, VscPin, VscPinned } from 'react-icons/vsc'
+import { api, archiveUrl, downloadUrl, isOutsideWorkspaceMessage, type FsEntry } from './api.ts'
 import { FenceErrorNotice } from './FenceErrorNotice.tsx'
 import { builtinFileIcon, builtinFolderIcon } from './file-icons.tsx'
-import { IconUploadOutline16 } from './icons.tsx'
+import { IconUploadOutline16, IconVscode16 } from './icons.tsx'
 import { isImeComposition } from './ime-guard.ts'
+import { useSubmenuFlip } from './menu-flip.ts'
 import type { OpenInApp, OpenInAppEntry } from './open-in-app.ts'
+import type { OpenWithTarget } from './open-with.ts'
 import { relativeTo } from './paths.ts'
 import { t } from './locales.ts'
 import type { BetterSidebarService } from './service.ts'
@@ -344,9 +349,23 @@ export function FileTree(props: {
   /**
    * The host's open-in-app handle (EditorHost builds it and injects it).
    * Absent, or reporting the host cannot hand paths to the desktop, hides the
-   * whole "open in app" section.
+   * HOST half of the "打开方式" section (the plugin's own targets stay).
    */
   openInApp?: OpenInApp
+  /**
+   * The PLUGIN's own "open with" menu: resolved external targets (already
+   * SSH-filtered and in menu order). Absent → no plugin half. Coexists with
+   * {@link openInApp} — the section lists both.
+   */
+  openWithTargets?: OpenWithTarget[]
+  /** Ids of targets pinned to the menu's top level (subset of the ids). */
+  openWithPinned?: string[]
+  /** Whether the workspace is remote (appends the SSH hint to target labels). */
+  openWithSsh?: boolean
+  /** Open one plugin target externally (reveal or URL — the caller decides). */
+  onOpenWith?: (targetId: string, path: string) => void
+  /** Toggle one plugin target's pinned state (the submenu row's pushpin). */
+  onToggleOpenWithPin?: (targetId: string) => void
   /** Insert `@<relative path>` into the composer draft (file vs directory). */
   onReferenceFile: (path: string, isDir: boolean) => void
   /** A rename landed (old row path → new path): the caller retargets open tabs. */
@@ -382,7 +401,8 @@ export function FileTree(props: {
   // callbacks must not change identity when the caller re-renders).
   const {
     sessionId, cwd, store, expanded, revealed, onOpenFileNewTab, onOpenFileSide,
-    openInApp, onReferenceFile, onPathRenamed, onPathDeleted, refreshTick, onUploadRequest, busy, hidden, visible, service,
+    openInApp, openWithTargets, openWithPinned, openWithSsh, onOpenWith, onToggleOpenWithPin,
+    onReferenceFile, onPathRenamed, onPathDeleted, refreshTick, onUploadRequest, busy, hidden, visible, service,
   } = props
   /** The live props for the stable callbacks below (identity churns per render). */
   const propsRef = useRef(props)
@@ -414,6 +434,9 @@ export function FileTree(props: {
   const [copiedPath, setCopiedPath] = useState<string | null>(null)
   /** Open context menu: the row path (and whether it is a directory) plus the cursor position. */
   const [rowMenu, setRowMenu] = useState<{ path: string; isDir: boolean; x: number; y: number } | null>(null)
+  // The plugin submenu can tower past the viewport; publish its flip geometry
+  // for layout.css while the row menu is open.
+  useSubmenuFlip(rowMenu)
   /** The open-in-app rows for the open menu (null entries = listing failed). */
   const [apps, setApps] = useState<{ path: string; entries: readonly OpenInAppEntry[] | null } | null>(null)
   /** The row being renamed inline: its path plus the edit buffer. */
@@ -892,12 +915,6 @@ export function FileTree(props: {
     setActionError(t('openInAppFailed', { path }))
   }, [])
 
-  /**
-   * The open menu's app rows are fetched while the menu is open: the host
-   * resolves a file's registered applications (or a directory's application
-   * catalogue). Availability is re-read per open — a host that cannot hand
-   * paths to the desktop hides the section entirely.
-   */
   /**
    * Whether the host can hand paths to a native desktop — probed ONCE per
    * handle, on mount. The adapter starts in its `null` (unprobed) state, and
@@ -928,6 +945,12 @@ export function FileTree(props: {
     return () => { cancelled = true }
   }, [openInApp])
 
+  /**
+   * The open menu's app rows are fetched while the menu is open: the host
+   * resolves a file's registered applications (or a directory's application
+   * catalogue). A host that cannot hand paths to a desktop keeps `appReady`
+   * false, so no listing is attempted.
+   */
   useEffect(() => {
     if (rowMenu === null || openInApp === undefined || !appReady) {
       setApps(null)
@@ -962,22 +985,110 @@ export function FileTree(props: {
     void handle.reveal(path).then((ok) => { if (!ok) reportOpenFailure(path) }).catch(() => { reportOpenFailure(path) })
   }, [reportOpenFailure])
 
+  /** The menu label of one plugin open target: a locale key for the built-ins,
+   *  the user's own name for custom editors, plus the SSH hint in remote mode. */
+  const openWithLabelOf = (target: OpenWithTarget): string => {
+    const name = target.nameKey !== undefined ? t(target.nameKey) : target.name
+    return openWithSsh === true && !target.localOnly ? `${name}${t('openWithSshSuffix')}` : name
+  }
+
   /**
-   * The menu's "open in app" section for one row: a heading label plus the
-   * host's rows (the default-application row first for files), a separator,
-   * and reveal-in-file-manager. Absent when the caller wired no handle or the
-   * host cannot open desktop paths; an empty/failed listing degrades to one
-   * disabled line so the section never silently disappears mid-interaction.
+   * The PLUGIN half of the "open with" section: the pinned targets as DIRECT
+   * rows, then the parent row with every target as a nested submenu (main's
+   * shape — pins, chevron, SSH suffixes). The section only renders when the
+   * caller wired the feature and at least one target is left.
+   *
+   * `hostReady` filters out the built-in `explorer` target: the host's own
+   * reveal row replaces it, and two identical "File Manager" rows would be
+   * noise. When the host is NOT ready the target stays, so reveal is never
+   * lost.
    */
-  const openInAppEntries = (target: { path: string; isDir: boolean }): MenuEntry[] => {
-    if (openInApp === undefined || !appReady) return []
-    const head: MenuEntry = { type: 'label', id: 'open-in-app-label', text: t('openInApp') }
-    const entries = apps !== null && apps.path === target.path ? apps.entries : undefined
-    if (entries === undefined) return [head, { id: 'open-in-app-loading', label: t('loading'), disabled: true }]
-    if (entries === null || entries.length === 0) {
-      return [head, { id: 'open-in-app-empty', label: t('openInAppEmpty'), disabled: true }]
+  const openWithEntries = (hostReady: boolean): MenuEntry[] => {
+    if (openWithTargets === undefined || onOpenWith === undefined) return []
+    const targets = hostReady ? openWithTargets.filter(target => target.id !== 'explorer') : openWithTargets
+    if (targets.length === 0) return []
+    const pinnedIds = openWithPinned ?? []
+    /** Brand marks for the built-ins (monochrome silhouettes, currentColor);
+     *  reveal gets the folder glyph, custom editors a generic code mark.
+     *  The compact menu's icon slot is 14px, so every mark renders at 14. */
+    const itemIcon = (target: OpenWithTarget): ReactNode => {
+      if (target.kind === 'reveal') return <VscFolderOpened size={14} />
+      if (target.id === 'vscode') return <IconVscode16 size={14} />
+      if (target.id === 'cursor') return <SiCursor size={14} />
+      if (target.id === 'zed') return <SiZedindustries size={14} />
+      return <IconCodeOutlineRegular size={14} />
     }
-    const rows: MenuItem[] = []
+    const pinned = targets
+      .filter(target => pinnedIds.includes(target.id))
+      .map<MenuItem>(target => ({
+        id: `open-with:${target.id}`,
+        label: openWithLabelOf(target),
+        icon: itemIcon(target),
+      }))
+    const submenu = targets.map<MenuItem>(target => {
+      const pinnedNow = pinnedIds.includes(target.id)
+      return {
+        id: `open-with:${target.id}`,
+        label: (
+          <span className={css.openWithLabel}>
+            <span className={css.openWithName}>{openWithLabelOf(target)}</span>
+            {/* The pushpin: a span (never a button — the Menu row itself is
+                a button, so a nested interactive element would be invalid).
+                Clicking it pins/unpins the target at the menu's top level
+                WITHOUT selecting the row: the pin stops propagation, so the
+                menu stays open and the icon flips on the next render. */}
+            <span
+              role="button"
+              tabIndex={-1}
+              className={clsx(css.openWithPin, pinnedNow && css.openWithPinActive)}
+              aria-label={pinnedNow ? t('unpinOpenWith') : t('pinOpenWith')}
+              title={pinnedNow ? t('unpinOpenWith') : t('pinOpenWith')}
+              onClick={(event) => {
+                event.preventDefault()
+                event.stopPropagation()
+                onToggleOpenWithPin?.(target.id)
+              }}
+            >
+              {pinnedNow ? <VscPinned size={12} /> : <VscPin size={12} />}
+            </span>
+          </span>
+        ),
+        icon: itemIcon(target),
+      }
+    })
+    return [
+      ...pinned,
+      ...(pinned.length > 0 ? [{ id: 'open-with-sep', type: 'separator' } as MenuEntry] : []),
+      {
+        id: 'open-with-menu',
+        // The primitives Menu renders no chevron for submenu parents — the
+        // trailing arrow is supplied inside the label (full-width flex row,
+        // right-aligned), matching how the submenu rows right-align the pin.
+        label: (
+          <span className={css.openWithLabel}>
+            <span className={css.openWithName}>{t('openWithMenu')}</span>
+            <IconChevronRightOutlineRegular size={14} className={css.openWithChevron} aria-hidden />
+          </span>
+        ),
+        icon: <VscLinkExternal size={14} />,
+        submenu,
+      },
+    ]
+  }
+
+  /**
+   * The HOST half of the section: the default-application row (files, when the
+   * OS reports one) followed by every registered handler. A pending listing
+   * shows one disabled line, an empty/failed listing the disabled
+   * `openInAppEmpty` line — the reveal row below still renders either way.
+   */
+  const hostAppEntries = (target: { path: string; isDir: boolean }): MenuEntry[] => {
+    const entries = apps !== null && apps.path === target.path ? apps.entries : undefined
+    if (entries === undefined) return [{ id: 'open-in-app-loading', label: t('loading'), disabled: true }]
+    if (entries === null || entries.length === 0) {
+      return [{ id: 'open-in-app-empty', label: t('openInAppEmpty'), disabled: true }]
+    }
+    const rows: MenuEntry[] = []
     const fallback = entries.find(entry => entry.isDefault)
     if (!target.isDir && fallback !== undefined) {
       rows.push({ id: 'open-in-app:default', label: t('openInAppDefault'), icon: <AppGlyph entry={fallback} /> })
@@ -986,12 +1097,60 @@ export function FileTree(props: {
       if (!target.isDir && entry.isDefault) continue
       rows.push({ id: `open-in-app:${entry.id}`, label: entry.name, icon: <AppGlyph entry={entry} /> })
     }
-    return [
-      head,
-      ...rows,
-      { id: 'open-in-app-sep', type: 'separator' },
-      { id: 'reveal-in-file-manager', label: t('revealInFileManager'), icon: <IconFolderOpenRegular size={14} /> },
-    ]
+    return rows
+  }
+
+  /**
+   * The menu's "打开方式" section, where the host's capability and the plugin's
+   * own targets COEXIST (the user asked for both). No heading row: the host
+   * group is self-describing (application names + "用默认应用打开"), and
+   * `openInApp` / `openWithMenu` read as near-duplicates in every dictionary —
+   * two synonyms stacked in one menu read as a repeated item. The frozen order:
+   *   host rows → separator → plugin rows (pinned direct + submenu) →
+   *   separator → host reveal.
+   * Separators only appear between two non-empty groups. The host rows (and
+   * reveal) vanish entirely when no handle was injected or the host cannot
+   * hand paths to a desktop; the plugin rows then stand alone, which is what
+   * keeps a remote/SSH session usable. The plugin's `explorer` target is
+   * dropped only while the host is ready (see {@link openWithEntries}).
+   */
+  const openWithSection = (target: { path: string; isDir: boolean }): MenuEntry[] => {
+    const plugin = openWithEntries(appReady)
+    if (!appReady && plugin.length === 0) return []
+    const entries: MenuEntry[] = []
+    const separate = (): void => {
+      if (entries.length > 0) entries.push({ id: `open-with-group-${entries.length}`, type: 'separator' })
+    }
+    if (appReady) entries.push(...hostAppEntries(target))
+    if (plugin.length > 0) {
+      separate()
+      entries.push(...plugin)
+    }
+    if (appReady) {
+      separate()
+      entries.push({ id: 'reveal-in-file-manager', label: t('revealInFileManager'), icon: <IconFolderOpenRegular size={14} /> })
+    }
+    return entries
+  }
+
+  /**
+   * The selection's ZIP row: two or more selected rows archive together, and a
+   * LONE directory archives its own subtree. A lone FILE is skipped — it would
+   * only duplicate the plain download row.
+   */
+  const zipEntries = (target: { path: string; isDir: boolean }): MenuEntry[] => {
+    const count = selected.size
+    if (count >= 2) {
+      return [{
+        id: 'archive-selection',
+        label: t('zipDownloadCount', { count }),
+        icon: <IconArchiveOutlineRegular size={14} />,
+      }]
+    }
+    if (count === 1 && target.isDir) {
+      return [{ id: 'archive-selection', label: t('zipDownload'), icon: <IconArchiveOutlineRegular size={14} /> }]
+    }
+    return []
   }
 
   /** Download a file through the host route (raw bytes, binary-safe). */
@@ -1005,6 +1164,59 @@ export function FileTree(props: {
     anchor.remove()
   }
 
+  /**
+   * Download one archive of `paths` through the host route. Unlike the
+   * single-file download — a bare anchor whose failures belong to the browser
+   * — the archive route answers the plugin's JSON error envelope for its caps
+   * and refusals, and an anchor would happily save that envelope as a broken
+   * `.zip`. So the bytes are fetched explicitly: a non-2xx answer is parsed for
+   * its `{error: {message}}` envelope (the shape `api.ts` reads) and reported
+   * through `zipFailed`; a 2xx body becomes an object URL handed to the same
+   * hidden-anchor mechanics. `archiveBusyRef` keeps a double click from
+   * packaging the same selection twice.
+   */
+  const archiveBusyRef = useRef(false)
+  const downloadArchive = (paths: readonly string[]): void => {
+    if (archiveBusyRef.current) return
+    const name = paths.length === 1 ? `${baseName(paths[0]!)}.zip` : 'archive.zip'
+    let url: string
+    try {
+      url = archiveUrl({ sessionId, cwd }, paths, name)
+    } catch (error: unknown) {
+      setActionError(t('zipFailed', { message: error instanceof Error ? error.message : String(error) }))
+      return
+    }
+    archiveBusyRef.current = true
+    void fetch(url)
+      .then(async (response) => {
+        if (!response.ok) {
+          const envelope: { error?: { message?: string } } | null = await response.json().catch(() => null)
+          throw new Error(envelope?.error?.message ?? `HTTP ${response.status}`)
+        }
+        return await response.blob()
+      })
+      .then((blob) => {
+        setActionError(null)
+        const objectUrl = URL.createObjectURL(blob)
+        const anchor = document.createElement('a')
+        anchor.href = objectUrl
+        anchor.download = name
+        anchor.style.display = 'none'
+        document.body.appendChild(anchor)
+        anchor.click()
+        anchor.remove()
+        // Revoke on the next task, not synchronously: some engines have not
+        // committed the download when click() returns, and revoking the URL
+        // under them loses the file. One tick is enough and keeps the blob
+        // from outliving the download.
+        window.setTimeout(() => { URL.revokeObjectURL(objectUrl) }, 0)
+      })
+      .catch((error: unknown) => {
+        setActionError(t('zipFailed', { message: error instanceof Error ? error.message : String(error) }))
+      })
+      .finally(() => { archiveBusyRef.current = false })
+  }
+
   const root = cwd
 
   // Membership is tested per rendered row (deep trees run this thousands of
@@ -1357,7 +1569,7 @@ export function FileTree(props: {
           ...(rowMenu?.isDir === false && onOpenFileSide !== undefined
             ? [{ id: 'open-side', label: t('openFileSide'), icon: <IconFolderOpenRegular size={14} /> }]
             : []),
-          ...(rowMenu === null ? [] : openInAppEntries(rowMenu)),
+          ...(rowMenu === null ? [] : openWithSection(rowMenu)),
           // Download applies to files only (the host route refuses directories).
           ...(rowMenu?.isDir === false
             ? [{ id: 'download', label: t('download'), icon: <IconDownloadOutlineRegular size={14} /> }]
@@ -1370,6 +1582,8 @@ export function FileTree(props: {
           ...(rowMenu?.isDir === true
             ? [{ id: 'new-folder', label: t('newFolder'), icon: <IconPlusOutlineRegular size={14} /> }]
             : []),
+          // ZIP of the current selection (≥2 rows, or one lone directory).
+          ...(rowMenu === null ? [] : zipEntries(rowMenu)),
           { id: 'relative', label: t('copyRelative'), icon: <IconCopyOutlineRegular size={14} /> },
           { id: 'absolute', label: t('copyAbsolute'), icon: <IconCopyOutlineRegular size={14} /> },
           // Explorer mutations close the menu; the workspace ROOT row is the
@@ -1402,10 +1616,20 @@ export function FileTree(props: {
             openWithApp(target.path, id.slice('open-in-app:'.length))
             return
           }
+          // The plugin's own targets share one id space (pinned rows and
+          // submenu children alike), so the caller gets the target id + path.
+          if (id.startsWith('open-with:')) {
+            onOpenWith?.(id.slice('open-with:'.length), target.path)
+            return
+          }
           if (id === 'reveal-in-file-manager') {
             revealPath(target.path)
             return
           }
+          if (id === 'archive-selection') {
+            downloadArchive([...selected])
+            return
+          }
           if (id === 'download') {
             downloadFile(target.path)
             return
@@ -1418,8 +1642,7 @@ export function FileTree(props: {
           if (id === 'new-folder') {
             startNewFolder(target.path)
             return
-          }
-          if (id === 'rename') {
+          }          if (id === 'rename') {
             setRenaming({ path: target.path, value: baseName(target.path) })
             return
           }
diff --git a/src/client/TreePanel.tsx b/src/client/TreePanel.tsx
index 5d0e278..fe30acd 100644
--- a/src/client/TreePanel.tsx
+++ b/src/client/TreePanel.tsx
@@ -27,6 +27,7 @@ import type { SidebarStore } from './state.ts'
 import { FileTree } from './FileTree.tsx'
 import { IconUploadOutline16 } from './icons.tsx'
 import type { OpenInApp } from './open-in-app.ts'
+import type { OpenWithTarget } from './open-with.ts'
 import { t } from './locales.ts'
 import { resolveSidebarPath } from './paths.ts'
 import { IconButton } from './ui/index.ts'
@@ -61,8 +62,15 @@ export function TreePanel(props: {
   /** File context-menu "open to the side" (passed through to FileTree). */
   onOpenFileSide?: (path: string) => void
   /** The host's open-in-app handle (passed through to FileTree; absent →
-   *  the whole section is hidden). */
+   *  the HOST half of the "打开方式" section is hidden). */
   openInApp?: OpenInApp
+  /** The plugin's own open-with targets (passed through to FileTree; coexists
+   *  with `openInApp`; absent → no plugin half). */
+  openWithTargets?: OpenWithTarget[]
+  openWithPinned?: string[]
+  openWithSsh?: boolean
+  onOpenWith?: (targetId: string, path: string) => void
+  onToggleOpenWithPin?: (targetId: string) => void
   onReferenceFile: (path: string, isDir: boolean) => void
   /** A tree rename landed (passed through to FileTree for tab retargeting). */
   onPathRenamed?: (oldPath: string, newPath: string) => void
@@ -79,7 +87,8 @@ export function TreePanel(props: {
 }) {
   const {
     sessionId, cwd, store, expanded, revealed, onToggle, onOpenFile, onOpenFileNewTab, onOpenFileSide,
-    openInApp, onReferenceFile, onPathRenamed, onPathDeleted, visible, full, service,
+    openInApp, openWithTargets, openWithPinned, openWithSsh, onOpenWith, onToggleOpenWithPin,
+    onReferenceFile, onPathRenamed, onPathDeleted, visible, full, service,
   } = props
   const [query, setQuery] = useState('')
   const [results, setResults] = useState<{ matches: string[]; truncated: boolean } | null>(null)
@@ -281,6 +290,11 @@ export function TreePanel(props: {
         onOpenFileNewTab={onOpenFileNewTab}
         onOpenFileSide={onOpenFileSide}
         openInApp={openInApp}
+        openWithTargets={openWithTargets}
+        openWithPinned={openWithPinned}
+        openWithSsh={openWithSsh}
+        onOpenWith={onOpenWith}
+        onToggleOpenWithPin={onToggleOpenWithPin}
         onReferenceFile={onReferenceFile}
         onPathRenamed={onPathRenamed}
         onPathDeleted={onPathDeleted}
diff --git a/src/client/api.ts b/src/client/api.ts
index ad7394c..ec6b03d 100644
--- a/src/client/api.ts
+++ b/src/client/api.ts
@@ -239,6 +239,51 @@ function gitPayload(scope: SessionScope, worktree: string | undefined, extra: Re
   return scopePayload(scope, { ...(worktree !== undefined && worktree !== '' ? { worktree } : {}), ...extra })
 }
 
+/** One external-open request from the file tree. */
+type OpenExternalPayload =
+  | { action: 'reveal'; path: string }
+  | { action: 'url'; url: string }
+
+/** The host route's success shape. */
+type OpenExternalResult = { started: boolean }
+
+/**
+ * Remote VSCode-family URLs must be consumed on the browser/client machine:
+ * the DSH host can be a headless remote server with no editor or DISPLAY.
+ * Local editor URLs and reveal actions still belong to the host opener.
+ */
+function shouldOpenExternalOnClient(payload: OpenExternalPayload): payload is { action: 'url'; url: string } {
+  if (payload.action !== 'url') return false
+  let parsed: URL
+  try {
+    parsed = new URL(payload.url)
+  } catch {
+    return false
+  }
+  return parsed.protocol !== 'http:'
+    && parsed.protocol !== 'https:'
+    && parsed.hostname === 'vscode-remote'
+    && parsed.pathname.startsWith('/ssh-remote+')
+}
+
+/**
+ * Dispatch an external-open request to the correct machine. SSH remote-editor
+ * URLs stay in the synchronous user-click chain and navigate the client so
+ * its registered vscode:// / cursor:// handler can launch. Everything else
+ * keeps using the DSH host route.
+ */
+function openExternal(payload: OpenExternalPayload): Promise<OpenExternalResult> {
+  if (!shouldOpenExternalOnClient(payload)) {
+    return call<OpenExternalResult>('open.external', payload)
+  }
+  try {
+    window.location.assign(payload.url)
+    return Promise.resolve({ started: true })
+  } catch (error) {
+    return Promise.reject(error)
+  }
+}
+
 /** The sidebar API surface (session scope threaded through every call). */
 export const api = {
   sessionCwd: (scope: SessionScope, signal?: AbortSignal) =>
@@ -377,6 +422,10 @@ export const api = {
       patch,
       ...(expectedRevision !== undefined ? { expectedRevision } : {}),
     }),
+  /** External open for the file tree's "open with" menu. Remote SSH editor
+   *  URLs are launched on the browser/client machine; reveal and local URLs
+   *  keep using the host's platform opener. */
+  openExternal,
 }
 
 /** Absolute URL of the media route for one path (images only). */
@@ -390,6 +439,18 @@ export function downloadUrl(scope: SessionScope, path: string): string {
   return fileUrl(scope, path, true)
 }
 
+/**
+ * Absolute URL of the archive route: one ZIP of every `paths` entry (files
+ * and directories, recursive) served as an attachment. Same GET shape as
+ * {@link downloadUrl}; the repeated `path` parameter is the only difference.
+ */
+export function archiveUrl(scope: SessionScope, paths: readonly string[], name: string): string {
+  const params = new URLSearchParams({ sessionId: scope.sessionId, name })
+  if (scope.cwd !== undefined && scope.cwd !== '') params.set('cwd', scope.cwd)
+  for (const path of paths) params.append('path', path)
+  return `/sidebar/archive?${params.toString()}`
+}
+
 /** Shared URL builder for the /sidebar/file route (media vs download). */
 function fileUrl(scope: SessionScope, path: string, download: boolean): string {
   const params = new URLSearchParams({ sessionId: scope.sessionId, path })
diff --git a/src/client/builtins/tabs.tsx b/src/client/builtins/tabs.tsx
index 2ea465a..e94c789 100644
--- a/src/client/builtins/tabs.tsx
+++ b/src/client/builtins/tabs.tsx
@@ -19,6 +19,7 @@ import {
 import { t } from '../locales.ts'
 import { openSidebarFile } from '../sidebar-file.ts'
 import { EditorHost } from '../EditorHost.tsx'
+import { OpenWithSettings } from '../open-with-settings.tsx'
 import { ChangesTab, opCountOf } from '../changes/ChangesTab.tsx'
 import { DiffTab } from '../DiffTab.tsx'
 import { SubagentView } from '../SubagentView.tsx'
@@ -44,9 +45,9 @@ export function builtinTabs(): readonly TabDescriptor[] {
       // vs per-path windows) renders as an iconed select row under the
       // editor card's gear in the Side card settings page, followed by the
       // workspace fence switch (the host's containment guard over every
-      // sidebar filesystem route). The old "open with" configuration panel
-      // (SSH host + custom editors) is gone: external opening is the host's
-      // own open-in-app capability now, with nothing to configure here.
+      // sidebar filesystem route); the "open with" configuration (SSH host +
+      // custom editors) is the custom panel BELOW those rows — the settings
+      // seam renders rows first, custom panel after.
       settings: {
         toggles: [{
           key: 'editorExplorer',
@@ -72,6 +73,9 @@ export function builtinTabs(): readonly TabDescriptor[] {
           title: () => t('settingsFenceTitle'),
           desc: () => t('settingsFenceDesc'),
         }],
+        render: ({ pluginSettings, updatePluginSetting }) => (
+          <OpenWithSettings pluginSettings={pluginSettings} updatePluginSetting={updatePluginSetting} />
+        ),
       },
       component: ({ ctx, store, scope, tab, visible, expanded, revealed, onToggleDir, onReferenceFile }) => (
         <EditorHost
diff --git a/src/client/changes/ChangesTab.tsx b/src/client/changes/ChangesTab.tsx
index 6bb888d..ee8dbc8 100644
--- a/src/client/changes/ChangesTab.tsx
+++ b/src/client/changes/ChangesTab.tsx
@@ -225,6 +225,7 @@ export function ChangesTab({ ctx, store, scope, tab, visible, onOpenFile, onOpen
       {lens === 'git'
         ? (
           <GitLens
+            ctx={ctx}
             scope={scope}
             store={store}
             visible={visible}
diff --git a/src/client/changes/GitLens.tsx b/src/client/changes/GitLens.tsx
index 7f7756b..009dfdc 100644
--- a/src/client/changes/GitLens.tsx
+++ b/src/client/changes/GitLens.tsx
@@ -1,11 +1,18 @@
 /**
  * The Git lens of the changes tab: repository truth — the changed files
- * (unstaged / staged), stage/unstage, commit with a message box, branch and
- * checkout switching, and a VSCode-like history with decorations, author and
- * relative time. Clicking a changed file or a history row previews it in the
- * tab's shared bottom pane (see {@link DiffPane}); rows carry right-click
- * context menus with advanced operations (open in editor, discard, revert,
- * cherry-pick, copy paths/hashes).
+ * (unstaged / staged) as a directory tree, stage/unstage, commit with a
+ * message box, branch and checkout switching, and a VSCode-like history with
+ * decorations, author and relative time. Clicking a changed file or a history
+ * row previews it in the tab's shared bottom pane (see {@link DiffPane}); rows
+ * carry right-click context menus with advanced operations (open in editor,
+ * discard, revert, cherry-pick, copy paths/hashes).
+ *
+ * The change list is a TREE, not a flat list: {@link buildChangeTree} folds
+ * each group's paths into directories (single-child chains compressed), so a
+ * nested change reads as structure instead of as a wall of rows. Directory
+ * rows disclose their subtree (`aria-expanded`); file rows carry the host's
+ * own file artwork, the porcelain letter and the trailing stage action, which
+ * only shows on hover/focus to keep the row quiet.
  *
  * The git status itself is NOT fetched here: it comes from the plugin's one
  * shared store (`ui/git-status.ts`), which the file tree also subscribes to,
@@ -19,13 +26,15 @@
  * failures used to land under the commit box, which read as "your commit
  * failed" for an action the user never ran.
  */
-import { useCallback, useEffect, useRef, useState, type MouseEvent, type ReactNode } from 'react'
+import { useCallback, useEffect, useMemo, useRef, useState, type MouseEvent, type ReactNode } from 'react'
 import {
-  Button, IconCodeOutlineRegular, IconCopyOutlineRegular, IconPlusOutlineRegular,
+  Button, IconChevronRightOutlineRegular, IconCodeOutlineRegular, IconCopyOutlineRegular, IconPlusOutlineRegular,
   IconTrashOutlineRegular, Input, Menu, writeClipboard,
 } from '@deepseek-ai/dsh-client-ui-primitives'
+import type { Context } from '../../context-types.ts'
 import type { GitLogEntry, GitStatusEntry, GitStatusResult, GitWorktree, SessionScope } from '../api.ts'
 import { api } from '../api.ts'
+import { builtinFileIcon, builtinFolderIcon } from '../file-icons.tsx'
 import { usePolling } from '../use-polling.ts'
 import { baseName, isWithinWorkspace, relativeTo } from '../paths.ts'
 import { resolveSidebarPath } from '../paths.ts'
@@ -35,6 +44,7 @@ import {
   ConfirmDialog, IconButton, Notice, SectionHeader, StatusBadge, invalidateGitStatus, statusOfXY,
   useGitStatus, type GitFileStatus, type GitTone, type StatusTone,
 } from '../ui/index.ts'
+import { buildChangeTree, type ChangeDir, type ChangeFile, type ChangeNode } from './change-tree.ts'
 import css from './changes.module.css'
 
 /** Whether the entry carries STAGED (index) changes — the X letter is set. */
@@ -49,9 +59,10 @@ function isUnstagedEntry(entry: GitStatusEntry): boolean {
   return statusOfXY(entry.xy)?.unstaged === true
 }
 
-/** Whether the entry is untracked (`??`): git diff never includes it. */
-function isUntracked(entry: GitStatusEntry): boolean {
-  return entry.xy === '??'
+/** Whether a row is untracked (`??`): git diff never includes it, so the
+ *  preview and the discard action must know. */
+function isUntrackedStatus(status: GitFileStatus): boolean {
+  return status.tone === 'untracked'
 }
 
 /** The porcelain tone → the kit badge tone (a copy reads as a rename). */
@@ -65,13 +76,6 @@ const BADGE_TONE: Record<GitTone, StatusTone> = {
   conflict: 'conflict',
 }
 
-/** Split a repo-relative path into the row's name (kept) and its directory
- *  (dimmed context). */
-function splitPath(path: string): { name: string; dir: string } {
-  const at = path.lastIndexOf('/')
-  return at === -1 ? { name: path, dir: '' } : { name: path.slice(at + 1), dir: path.slice(0, at) }
-}
-
 /** The ref names of one log row's decorations (`HEAD -> main` → `main`), deduped. */
 function refNames(refs: string): string[] {
   return [...new Set(
@@ -98,6 +102,15 @@ interface ConfirmState {
   onConfirm: () => Promise<unknown>
 }
 
+/** One open file-row context menu (cursor position for the portaled Menu). */
+interface FileMenuState {
+  path: string
+  staged: boolean
+  untracked: boolean
+  x: number
+  y: number
+}
+
 /** History batch size: the log loads lazily in pages so a long history never
  *  floods the panel at once (the end of the log is reached by paging). */
 const LOG_BATCH = 20
@@ -108,11 +121,15 @@ const LOG_BATCH = 20
  *  within ~30s, without a second git process per status tick. */
 const WORKTREE_POLL_MS = 30_000
 
-/** One changed file's row: badge letter + file name + dimmed directory +
- *  the trailing stage/unstage action. The ONE renderer both sections use. */
-function ChangeRow(props: {
-  entry: GitStatusEntry
-  status: GitFileStatus | undefined
+/** A stable empty entry list: the tree memo must not rebuild on every render
+ *  just because `snapshot?.entries ?? []` minted a new array. */
+const NO_ENTRIES: readonly GitStatusEntry[] = []
+
+/** One changed file's row: the host's file artwork + porcelain letter + name
+ *  + the trailing stage action (revealed on hover/focus). */
+function FileRow(props: {
+  node: ChangeFile
+  icon: ReactNode
   staged: boolean
   busy: boolean
   selected: boolean
@@ -120,27 +137,25 @@ function ChangeRow(props: {
   onContextMenu(event: MouseEvent): void
   onToggleStage(): void
 }): ReactNode {
-  const { entry, status, staged, busy, selected } = props
-  const { name, dir } = splitPath(entry.path)
+  const { node, staged, busy, selected } = props
   const action = staged ? t('unstage') : t('stage')
   return (
     <div className={css.row} data-selected={selected ? 'true' : undefined}>
       <button
         type="button"
         className={css.rowMain}
-        data-path={entry.path}
-        title={entry.path}
+        data-path={node.path}
+        title={node.path}
         onClick={props.onPreview}
         onContextMenu={props.onContextMenu}
       >
-        <StatusBadge tone={status === undefined ? 'neutral' : BADGE_TONE[status.tone]}>
-          {status?.letter ?? '?'}
-        </StatusBadge>
-        <span className={css.rowName}>{name}</span>
-        {dir !== '' && <span className={css.rowDir}>{dir}</span>}
+        <span className={css.rowIcon} aria-hidden="true">{props.icon}</span>
+        <StatusBadge tone={BADGE_TONE[node.status.tone]} title={node.path}>{node.status.letter}</StatusBadge>
+        <span className={css.rowName}>{node.name}</span>
       </button>
       <IconButton
         size="sm"
+        className={css.rowAction}
         disabled={busy}
         label={action}
         icon={staged ? <IconTrashOutlineRegular size={14} /> : <IconPlusOutlineRegular size={14} />}
@@ -150,6 +165,29 @@ function ChangeRow(props: {
   )
 }
 
+/** One directory row: the disclosure chevron + folder artwork + the label
+ *  (a compressed chain reads as one 'a/b/c' line) + how much changed below. */
+function DirRow(props: { node: ChangeDir; icon: ReactNode; open: boolean; onToggle(): void }): ReactNode {
+  const { node, open } = props
+  return (
+    <button
+      type="button"
+      className={css.dirRow}
+      data-dir={node.path}
+      aria-expanded={open}
+      title={node.path}
+      onClick={props.onToggle}
+    >
+      <span className={css.chevron} data-open={open ? 'true' : undefined} aria-hidden="true">
+        <IconChevronRightOutlineRegular size={12} />
+      </span>
+      <span className={css.rowIcon} aria-hidden="true">{props.icon}</span>
+      <span className={css.dirName}>{node.name}</span>
+      <span className={css.countPill}>{node.changes}</span>
+    </button>
+  )
+}
+
 export interface GitLensProps {
   scope: SessionScope
   /** The sidebar store: reads the `workspaceFence` pref (see the open guard below). */
@@ -163,10 +201,23 @@ export interface GitLensProps {
   visible: boolean
   /** Bumped by the tab header's refresh action (0 = never asked). */
   refreshTick?: number
+  /** The tab's context, for the registered file/folder icon chain (absent →
+   *  the host's built-in artwork, exactly like the file tree falls back). */
+  ctx?: Context
 }
 
 export function GitLens(props: GitLensProps) {
-  const { scope, store, onOpenFile, onPreview, selectedRef, visible, refreshTick = 0 } = props
+  const { scope, store, onOpenFile, onPreview, selectedRef, visible, refreshTick = 0, ctx } = props
+
+  const service = ctx?.get('betterSidebar')
+  /** The file row's artwork: a registered icon wins, else the host's own
+   *  (the same chain the file tree runs, so both pages agree). */
+  const fileGlyph = useCallback((path: string): ReactNode => (
+    service === undefined ? builtinFileIcon(path, 14) : service.fileIcon(path, 14)
+  ), [service])
+  const folderGlyph = useCallback((path: string, open: boolean): ReactNode => (
+    service === undefined ? builtinFolderIcon(open, 14) : service.folderIcon(path, open, 14)
+  ), [service])
 
   const [worktrees, setWorktrees] = useState<GitWorktree[]>([])
   const [selectedWorktree, setSelectedWorktree] = useState<string | undefined>()
@@ -191,11 +242,15 @@ export function GitLens(props: GitLensProps) {
   const [viewError, setViewError] = useState<string | null>(null)
 
   /** The open file-row context menu (cursor position for the portaled Menu). */
-  const [fileMenu, setFileMenu] = useState<{ entry: GitStatusEntry; staged: boolean; x: number; y: number } | null>(null)
+  const [fileMenu, setFileMenu] = useState<FileMenuState | null>(null)
   /** The open history-row context menu. */
   const [historyMenu, setHistoryMenu] = useState<{ entry: GitLogEntry; x: number; y: number } | null>(null)
   /** The pending destructive action awaiting confirmation. */
   const [confirm, setConfirm] = useState<ConfirmState | null>(null)
+  /** Collapsed directory rows, keyed per GROUP + path: a directory that has
+   *  changes on both sides folds independently in each section (and the two
+   *  groups never fight over one key). Default: everything expanded. */
+  const [collapsed, setCollapsed] = useState<ReadonlySet<string>>(() => new Set<string>())
 
   /** The selected checkout, readable synchronously by the refresh chain
    *  without making every callback depend on the state it writes. */
@@ -418,9 +473,9 @@ export function GitLens(props: GitLensProps) {
 
   const stageError = (reason: unknown): string => t('changesStageFailed', { message: errorMessage(reason) })
 
-  const stageEntry = (entry: GitStatusEntry, staged: boolean): void => {
+  const stageEntry = (path: string, staged: boolean): void => {
     void runAction(
-      () => (staged ? api.gitUnstage(gitScopeNow(), entry.path, selectedWorktree) : api.gitStage(gitScopeNow(), entry.path, selectedWorktree)),
+      () => (staged ? api.gitUnstage(gitScopeNow(), path, selectedWorktree) : api.gitStage(gitScopeNow(), path, selectedWorktree)),
       stageError,
     )
   }
@@ -520,10 +575,10 @@ export function GitLens(props: GitLensProps) {
     void writeClipboard(text)
   }
 
-  const openFileMenu = (event: MouseEvent, entry: GitStatusEntry, staged: boolean): void => {
+  const openFileMenu = (event: MouseEvent, path: string, staged: boolean, untracked: boolean): void => {
     event.preventDefault()
     event.stopPropagation()
-    setFileMenu({ entry, staged, x: event.clientX, y: event.clientY })
+    setFileMenu({ path, staged, untracked, x: event.clientX, y: event.clientY })
   }
 
   const openHistoryMenu = (event: MouseEvent, entry: GitLogEntry): void => {
@@ -533,11 +588,11 @@ export function GitLens(props: GitLensProps) {
   }
 
   /** The preview ref for one changed file (one ref per path+side). */
-  const worktreeRefOf = (entry: GitStatusEntry, staged: boolean): SidebarDiffRef => ({
+  const worktreeRefOf = (path: string, untracked: boolean, staged: boolean): SidebarDiffRef => ({
     kind: 'worktree',
-    path: entry.path,
+    path,
     staged,
-    untracked: isUntracked(entry),
+    untracked,
     worktree: selectedWorktree,
     repoRoot,
   })
@@ -553,35 +608,78 @@ export function GitLens(props: GitLensProps) {
   })
 
   /** Whether a worktree row is the one currently previewed. */
-  const isPreviewedWorktree = (entry: GitStatusEntry, staged: boolean): boolean => {
+  const isPreviewedWorktree = (path: string, staged: boolean): boolean => {
     if (selectedRef === null || selectedRef.kind !== 'worktree') return false
-    return selectedRef.path === entry.path && selectedRef.staged === staged
+    return selectedRef.path === path && selectedRef.staged === staged
       && (selectedRef.worktree ?? '') === (selectedWorktree ?? '')
   }
 
-  const entries = snapshot?.entries ?? []
-  const stagedEntries = entries.filter(isStagedEntry)
-  const unstagedEntries = entries.filter(isUnstagedEntry)
+  const entries = snapshot?.entries ?? NO_ENTRIES
+  // One fold per group, memoized on the snapshot's own entry array: the tree
+  // (compression + sorting + counts) is rebuilt only when git answers anew.
+  const { stagedEntries, unstagedEntries, stagedTree, unstagedTree } = useMemo(() => {
+    const staged = entries.filter(isStagedEntry)
+    const unstaged = entries.filter(isUnstagedEntry)
+    return {
+      stagedEntries: staged,
+      unstagedEntries: unstaged,
+      stagedTree: buildChangeTree(staged),
+      unstagedTree: buildChangeTree(unstaged),
+    }
+  }, [entries])
   const isRepo = snapshot?.isRepo === true
   const branch = snapshot?.branch ?? ''
   const branchOptions = branch === '' ? branchNames : [branch, ...branchNames.filter(name => name !== branch)]
   const clean = isRepo && stagedEntries.length === 0 && unstagedEntries.length === 0
 
-  /** One change row (the single renderer of both sections). */
-  const renderEntry = (entry: GitStatusEntry, staged: boolean): ReactNode => (
-    <ChangeRow
-      key={`${staged ? 's' : 'u'}:${entry.path}`}
-      entry={entry}
-      status={statusOfXY(entry.xy)}
+  /** Fold or unfold one directory row (keyed per group, see `collapsed`). */
+  const toggleDir = (key: string): void => {
+    setCollapsed((current) => {
+      const next = new Set(current)
+      if (next.has(key)) next.delete(key)
+      else next.add(key)
+      return next
+    })
+  }
+
+  /** One file row of a group's tree (the single file-row renderer). */
+  const renderFile = (node: ChangeFile, staged: boolean): ReactNode => (
+    <FileRow
+      key={`${staged ? 's' : 'u'}:${node.path}`}
+      node={node}
+      icon={fileGlyph(node.path)}
       staged={staged}
       busy={busy}
-      selected={isPreviewedWorktree(entry, staged)}
-      onPreview={() => { onPreview(worktreeRefOf(entry, staged)) }}
-      onContextMenu={(event) => { openFileMenu(event, entry, staged) }}
-      onToggleStage={() => { stageEntry(entry, staged) }}
+      selected={isPreviewedWorktree(node.path, staged)}
+      onPreview={() => { onPreview(worktreeRefOf(node.path, isUntrackedStatus(node.status), staged)) }}
+      onContextMenu={(event) => { openFileMenu(event, node.path, staged, isUntrackedStatus(node.status)) }}
+      onToggleStage={() => { stageEntry(node.path, staged) }}
     />
   )
 
+  /** One directory row plus its (default-expanded) subtree. */
+  const renderDir = (node: ChangeDir, staged: boolean): ReactNode => {
+    const key = `${staged ? 's' : 'u'}:${node.path}`
+    const open = !collapsed.has(key)
+    return (
+      <div key={key}>
+        <DirRow node={node} icon={folderGlyph(node.path, open)} open={open} onToggle={() => { toggleDir(key) }} />
+        {open && (
+          <div className={css.treeChildren}>
+            {node.children.map(child => (child.kind === 'dir' ? renderDir(child, staged) : renderFile(child, staged)))}
+          </div>
+        )}
+      </div>
+    )
+  }
+
+  /** One group's whole tree. */
+  const renderTree = (nodes: readonly ChangeNode[], staged: boolean): ReactNode => (
+    <div className={css.tree}>
+      {nodes.map(node => (node.kind === 'dir' ? renderDir(node, staged) : renderFile(node, staged)))}
+    </div>
+  )
+
   return (
     <div className={css.git}>
       {(repoChoices.length > 1 || worktrees.length > 1 || branch !== '') && (
@@ -639,30 +737,50 @@ export function GitLens(props: GitLensProps) {
 
       {isRepo && !clean && (
         <>
-          <SectionHeader
-            label={t('unstaged')}
-            count={unstagedEntries.length}
-            action={unstagedEntries.length > 0
-              ? (
-                <button type="button" className={css.link} disabled={busy} onClick={() => { stageAll(false) }}>
-                  {t('stageAll')}
-                </button>
-              )
-              : undefined}
-          />
-          {unstagedEntries.map(entry => renderEntry(entry, false))}
-          <SectionHeader
-            label={t('staged')}
-            count={stagedEntries.length}
-            action={stagedEntries.length > 0
-              ? (
-                <button type="button" className={css.link} disabled={busy} onClick={() => { stageAll(true) }}>
-                  {t('unstageAll')}
-                </button>
-              )
-              : undefined}
-          />
-          {stagedEntries.map(entry => renderEntry(entry, true))}
+          {/* Each group is its own block so its sticky header is released (and
+              replaced) exactly when the group scrolls away. */}
+          <div className={css.group} data-group="unstaged">
+            <SectionHeader
+              className={css.groupHeader}
+              label={t('unstaged')}
+              action={unstagedEntries.length > 0
+                ? (
+                  <IconButton
+                    className={css.headerAction}
+                    size="sm"
+                    disabled={busy}
+                    label={t('stageAll')}
+                    icon={<IconPlusOutlineRegular size={14} />}
+                    onClick={() => { stageAll(false) }}
+                  />
+                )
+                : undefined}
+            >
+              <span className={css.countPill} data-count={unstagedEntries.length}>{unstagedEntries.length}</span>
+            </SectionHeader>
+            {renderTree(unstagedTree, false)}
+          </div>
+          <div className={css.group} data-group="staged">
+            <SectionHeader
+              className={css.groupHeader}
+              label={t('staged')}
+              action={stagedEntries.length > 0
+                ? (
+                  <IconButton
+                    className={css.headerAction}
+                    size="sm"
+                    disabled={busy}
+                    label={t('unstageAll')}
+                    icon={<IconTrashOutlineRegular size={14} />}
+                    onClick={() => { stageAll(true) }}
+                  />
+                )
+                : undefined}
+            >
+              <span className={css.countPill} data-count={stagedEntries.length}>{stagedEntries.length}</span>
+            </SectionHeader>
+            {renderTree(stagedTree, true)}
+          </div>
         </>
       )}
 
@@ -753,13 +871,13 @@ export function GitLens(props: GitLensProps) {
           // action for that checkout so the menu does not offer a no-op
           // that confuses the user; with the fence disarmed (the
           // `workspaceFence` pref) the open is allowed through.
-          ...(fileMenu !== null && (store.getPrefs().workspaceFence === false || isWithinWorkspace(scope.cwd ?? '', resolveSidebarPath(repoRoot ?? selectedWorktree ?? scope.cwd, fileMenu.entry.path)))
+          ...(fileMenu !== null && (store.getPrefs().workspaceFence === false || isWithinWorkspace(scope.cwd ?? '', resolveSidebarPath(repoRoot ?? selectedWorktree ?? scope.cwd, fileMenu.path)))
             ? [{ id: 'open', label: t('openEditor'), icon: <IconCodeOutlineRegular size={14} /> }]
             : []),
           fileMenu?.staged === true
             ? { id: 'stage', label: t('unstage'), icon: <IconTrashOutlineRegular size={14} /> }
             : { id: 'stage', label: t('stage'), icon: <IconPlusOutlineRegular size={14} /> },
-          ...(fileMenu !== null && !isUntracked(fileMenu.entry)
+          ...(fileMenu !== null && !fileMenu.untracked
             ? [{ id: 'discard', label: t('discard'), icon: <IconTrashOutlineRegular size={14} />, danger: true }]
             : []),
           { type: 'separator', id: 'sep1' },
@@ -771,7 +889,7 @@ export function GitLens(props: GitLensProps) {
           if (target === null) return
           setFileMenu(null)
           if (id === 'open') {
-            const resolved = resolveSidebarPath(repoRoot ?? selectedWorktree ?? scope.cwd, target.entry.path)
+            const resolved = resolveSidebarPath(repoRoot ?? selectedWorktree ?? scope.cwd, target.path)
             // Defense-in-depth: the menu hides this action when the
             // resolved path escapes the session workspace, but a
             // racing repo switch could still reach here with a path
@@ -782,23 +900,23 @@ export function GitLens(props: GitLensProps) {
             return
           }
           if (id === 'stage') {
-            stageEntry(target.entry, target.staged)
+            stageEntry(target.path, target.staged)
             return
           }
           if (id === 'discard') {
             runConfirmed({
               title: t('discardTitle'),
-              description: t('discardDesc', { path: target.entry.path }),
+              description: t('discardDesc', { path: target.path }),
               confirmLabel: t('discard'),
-              onConfirm: () => api.gitDiscard(gitScopeNow(), target.entry.path, selectedWorktree),
+              onConfirm: () => api.gitDiscard(gitScopeNow(), target.path, selectedWorktree),
             })
             return
           }
           if (id === 'relative') {
-            copy(relativeTo(repoRoot ?? selectedWorktree ?? scope.cwd ?? '', target.entry.path))
+            copy(relativeTo(repoRoot ?? selectedWorktree ?? scope.cwd ?? '', target.path))
             return
           }
-          if (id === 'absolute') copy(resolveSidebarPath(repoRoot ?? selectedWorktree ?? scope.cwd, target.entry.path))
+          if (id === 'absolute') copy(resolveSidebarPath(repoRoot ?? selectedWorktree ?? scope.cwd, target.path))
         }}
         portal
         compact
diff --git a/src/client/changes/change-tree.ts b/src/client/changes/change-tree.ts
new file mode 100644
index 0000000..eead591
--- /dev/null
+++ b/src/client/changes/change-tree.ts
@@ -0,0 +1,124 @@
+/**
+ * The changes list's hierarchy.
+ *
+ * A `git status` answer is a flat list of repo-relative paths, and the Git
+ * lens used to render exactly that: one row per file, with the file name and
+ * its directory squeezed onto the same line. Nested work (a refactor touching
+ * `src/client/changes/*`) then read as a wall of near-identical rows. This
+ * module folds the list into the directory tree the lens renders — VS Code's
+ * SCM tree, including its single-child directory compression — so the shape
+ * of the change is legible at a glance.
+ *
+ * Pure — no React, no DOM. `buildChangeTree` runs once per group per fold;
+ * the renderer only walks the result.
+ */
+import type { GitStatusEntry } from '../api.ts'
+import { statusOfXY, type GitFileStatus } from '../ui/index.ts'
+
+/** One changed file (a leaf), carrying its porcelain status. */
+export interface ChangeFile {
+  kind: 'file'
+  /** The file's own name (the last path segment). */
+  name: string
+  /** The repo-relative path exactly as git reported it (the row's identity). */
+  path: string
+  status: GitFileStatus
+}
+
+/** One directory row: its children plus the number of changed files beneath. */
+export interface ChangeDir {
+  kind: 'dir'
+  /** The display label: one segment, or the compressed chain ('src/client'). */
+  name: string
+  /** The deepest directory this row stands for. */
+  path: string
+  children: ChangeNode[]
+  /** Changed files anywhere under this row (the row's count pill). */
+  changes: number
+}
+
+export type ChangeNode = ChangeDir | ChangeFile
+
+/** A directory being assembled (children keyed by their own segment). */
+interface DirDraft {
+  name: string
+  path: string
+  dirs: Map<string, DirDraft>
+  files: ChangeFile[]
+}
+
+/** Directories before files, then by name — case-insensitively, with the raw
+ *  name breaking ties so the order never depends on the locale's collation. */
+function compareNodes(left: ChangeNode, right: ChangeNode): number {
+  if (left.kind !== right.kind) return left.kind === 'dir' ? -1 : 1
+  const folded = left.name.toLowerCase().localeCompare(right.name.toLowerCase())
+  return folded !== 0 ? folded : left.name.localeCompare(right.name)
+}
+
+/** The number of changed files under a finished child list. */
+function countFiles(nodes: readonly ChangeNode[]): number {
+  let count = 0
+  for (const node of nodes) count += node.kind === 'dir' ? node.changes : 1
+  return count
+}
+
+/** Materialize one draft directory, compressing its single-child chain. */
+function finishDir(draft: DirDraft): ChangeDir {
+  let name = draft.name
+  let current = draft
+  // A directory with no file of its own and exactly one subdirectory is not
+  // worth a row: the whole chain reads as one label (`a/b/c`). Compression
+  // stops the moment the path branches or a file sits at this level, so a row
+  // always stands for a place where something actually changed.
+  while (current.files.length === 0 && current.dirs.size === 1) {
+    const only = [...current.dirs.values()][0]!
+    name = `${name}/${only.name}`
+    current = only
+  }
+  const children = finishChildren(current)
+  return { kind: 'dir', name, path: current.path, children, changes: countFiles(children) }
+}
+
+/** Finish a draft's children (directories first, then its own files). */
+function finishChildren(draft: DirDraft): ChangeNode[] {
+  const nodes: ChangeNode[] = []
+  for (const child of draft.dirs.values()) nodes.push(finishDir(child))
+  nodes.push(...draft.files)
+  nodes.sort(compareNodes)
+  return nodes
+}
+
+/**
+ * Fold one group's changed files (unstaged or staged) into a directory tree.
+ * Rows without a porcelain status (clean, ignored) are skipped, a repeated
+ * path counts once, and an empty input yields an empty list.
+ * @param entries - the group's `git status` entries.
+ * @returns the tree's roots, ready to render in order.
+ */
+export function buildChangeTree(entries: readonly GitStatusEntry[]): ChangeNode[] {
+  const root: DirDraft = { name: '', path: '', dirs: new Map(), files: [] }
+  const seen = new Set<string>()
+  for (const entry of entries) {
+    const status = statusOfXY(entry.xy)
+    if (status === undefined) continue
+    const segments = entry.path.replace(/\\/g, '/').split('/').filter(segment => segment !== '' && segment !== '.')
+    if (segments.length === 0) continue
+    const normalized = segments.join('/')
+    if (seen.has(normalized)) continue
+    seen.add(normalized)
+    let at = root
+    for (let index = 0; index < segments.length - 1; index += 1) {
+      const name = segments[index]!
+      let next = at.dirs.get(name)
+      if (next === undefined) {
+        next = { name, path: segments.slice(0, index + 1).join('/'), dirs: new Map(), files: [] }
+        at.dirs.set(name, next)
+      }
+      at = next
+    }
+    // The FILE keeps git's own spelling (the lane previews, copies and menus
+    // all resolve this path); only the directory rows use the split form.
+    at.files.push({ kind: 'file', name: segments[segments.length - 1]!, path: entry.path, status })
+  }
+  return finishChildren(root)
+}
diff --git a/src/client/changes/changes.module.css b/src/client/changes/changes.module.css
index 5bcd6f5..97f20d2 100644
--- a/src/client/changes/changes.module.css
+++ b/src/client/changes/changes.module.css
@@ -49,30 +49,125 @@
 /* A single branch has nothing to choose: it reads as the row's label. */
 .branchLabel { min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; color: var(--dsw-alias-label-secondary); font: var(--dsw-font-xxxs-11); }
 
-/* The section band's text action ("stage all" / "unstage all"). */
-.link { border: none; background: transparent; padding: 0; font: var(--dsw-font-xxxs-strong-11); color: var(--dsw-alias-brand-primary); cursor: pointer; }
-.link:hover:not(:disabled) { text-decoration: underline; }
-.link:disabled { opacity: 0.4; cursor: default; }
+/* ── Change groups (one directory tree each) ───────────────────────────── */
 
-/* One changed file: badge + name + dimmed directory + the trailing action. */
+/* One group is its own block so its sticky header is released exactly when the
+   group scrolls past (two headers in one block would stack on top of each
+   other). */
+.group { display: flex; flex-direction: column; padding-bottom: 2px; }
+
+/* The header band stays readable while its group scrolls under it. The extra
+   class keeps the opaque fill above the kit's transparent band no matter which
+   sheet lands first in the bundle. */
+.group .groupHeader {
+  position: sticky;
+  top: 0;
+  z-index: 2;
+  background: var(--dsw-alias-bg-base);
+}
+
+/* The group's change count, as a small capsule on the label's baseline. */
+.countPill {
+  flex: none;
+  min-width: 16px;
+  height: 16px;
+  padding: 0 5px;
+  border-radius: 999px;
+  background: var(--dsw-alias-interactive-bg-hover);
+  color: var(--dsw-alias-label-secondary);
+  font: var(--dsw-font-xxxs-strong-11);
+  line-height: 16px;
+  text-align: center;
+  font-variant-numeric: tabular-nums;
+}
+
+/* A band action (stage all / unstage all) stays out of the way until the band
+   is hovered or holds focus — a keyboard tab reveals it too. Touch devices
+   have no hover, so there it is always visible. */
+.group .headerAction { opacity: 0; transition: opacity 120ms var(--ds-ease-in-out); }
+.group .groupHeader:hover .headerAction,
+.group .groupHeader:focus-within .headerAction { opacity: 1; }
+@media (hover: none) {
+  .group .headerAction { opacity: 1; }
+}
+
+/* The tree body: rows are flush bands, the gutter lives here. */
+.tree { display: flex; flex-direction: column; padding: 0 6px; }
+
+/* One nesting level: 12px of indent, with the guide line drawn at its edge so
+   the depth stays readable without a second colour. */
+.treeChildren {
+  display: flex;
+  flex-direction: column;
+  margin-left: 11px;
+  border-left: 1px solid var(--dsw-alias-border-l1);
+}
+
+/* One directory row: disclosure chevron + folder artwork + label + count. */
+.dirRow {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  width: 100%;
+  min-height: 28px;
+  padding: 0 6px 0 2px;
+  border: none;
+  border-radius: 4px;
+  background: transparent;
+  color: var(--dsw-alias-label-secondary);
+  font: inherit;
+  cursor: pointer;
+  text-align: left;
+}
+.dirRow:hover { background: var(--dsw-alias-interactive-bg-hover); }
+.dirRow:focus-visible { outline: 2px solid var(--dsw-alias-interactive-bg-hover-accent); outline-offset: -1px; }
+
+.chevron { flex: none; display: inline-flex; color: var(--dsw-alias-label-tertiary); transition: transform 140ms var(--ds-ease-in-out); }
+.chevron[data-open='true'] { transform: rotate(90deg); }
+
+.dirName { flex: 1; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; font: var(--dsw-font-xxs-12); }
+
+/* One changed file: file artwork + porcelain badge + name + the trailing
+   action (revealed on hover/focus). */
 .row {
   display: flex;
   align-items: center;
   gap: 6px;
+  position: relative;
   min-height: 28px;
-  margin: 0 6px;
-  padding: 0 4px 0 8px;
+  padding: 0 2px;
   border-radius: 4px;
   animation: dsh-row-in 150ms var(--ds-ease-in-out);
 }
 .row:hover { background: var(--dsw-alias-interactive-bg-hover); }
-.row[data-selected='true'] { background: var(--dsw-alias-interactive-bg-active); }
+/* Selected and hovered are different pictures: the selected row keeps the
+   active fill AND the design's 2px accent marker — a pseudo element inset 4px
+   (the tasks page's own recipe), so the row stays shadowless and no metric
+   shifts between rows. */
+.row[data-selected='true'],
+.opRow[data-selected='true'],
+.logRow[data-selected='true'] {
+  background: var(--dsw-alias-interactive-bg-active);
+}
+
+.row[data-selected='true']::before,
+.opRow[data-selected='true']::before,
+.logRow[data-selected='true']::before {
+  content: '';
+  position: absolute;
+  left: 0;
+  top: 4px;
+  bottom: 4px;
+  width: 2px;
+  border-radius: 1px;
+  background: var(--dsw-alias-state-business-primary);
+}
 
 .rowMain {
   flex: 1;
   min-width: 0;
   display: flex;
-  align-items: baseline;
+  align-items: center;
   gap: 6px;
   border: none;
   background: transparent;
@@ -80,17 +175,30 @@
   cursor: pointer;
   text-align: left;
 }
+.rowMain:focus-visible { outline: 2px solid var(--dsw-alias-interactive-bg-hover-accent); outline-offset: -1px; }
 
-.rowName { flex: none; max-width: 100%; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; color: var(--dsw-alias-label-primary); }
-/* The directory is context, not identity: it shrinks first and stays quiet. */
-.rowDir { flex: 1; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; color: var(--dsw-alias-label-tertiary); font: var(--dsw-font-xxxs-11); direction: rtl; text-align: left; }
+/* The row's icons are content at the plugin's own scale, not chrome. */
+.rowIcon { flex: none; display: inline-flex; align-items: center; }
+
+.rowName { flex: 1; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; font: var(--dsw-font-xxs-12); color: var(--dsw-alias-label-primary); }
+
+/* The row action is invisible until its row is hovered or holds focus (a
+   keyboard tab lands on it and reveals it). The three-class form outranks the
+   kit's own disabled rule, which would otherwise pin every button to a dim but
+   visible 0.4 whenever a git action is in flight. */
+.row:not(:hover):not(:focus-within) .rowAction { opacity: 0; }
+@media (hover: none) {
+  .row:not(:hover):not(:focus-within) .rowAction { opacity: 1; }
+}
 
 /* ── Commit bar (docked to the bottom edge of the scroll area) ─────────── */
 
 .commitBar {
   position: sticky;
   bottom: 0;
-  z-index: 1;
+  /* Above the sticky group headers: the commit bar is the surface the user
+     interacts with when they scroll to the bottom of the list. */
+  z-index: 3;
   flex: none;
   display: flex;
   flex-direction: column;
@@ -104,26 +212,34 @@
 
 /* ── History ───────────────────────────────────────────────────────────── */
 
-/* A history row: line 1 = hash + subject, line 2 = ref badges + author/date
-   (badges live on the second line so they never crowd the subject). */
+/* A history row: line 1 = short-hash badge + subject, line 2 = ref pills +
+   author·time flushed right (the badges live on the second line so they never
+   crowd the subject, and the time never pushes the refs around). */
 .logRow {
+  position: relative;
   display: flex;
   flex-direction: column;
-  gap: 2px;
-  padding: 4px 12px;
+  gap: 3px;
+  padding: 6px 10px;
   margin: 0 6px;
   border-radius: 4px;
   cursor: pointer;
 }
 .logRow:hover { background: var(--dsw-alias-interactive-bg-hover); }
-.logRow[data-selected='true'] { background: var(--dsw-alias-interactive-bg-active); }
 
 .logLine1 { display: flex; align-items: baseline; gap: 8px; min-width: 0; }
-.logHash { flex: none; font: var(--dsw-font-markdown-code-block-small); color: var(--dsw-alias-label-tertiary); }
+.logHash {
+  flex: none;
+  padding: 1px 4px;
+  border-radius: 2px;
+  background: var(--dsw-alias-interactive-bg-hover);
+  color: var(--dsw-alias-label-secondary);
+  font: var(--dsw-font-markdown-code-block-small);
+}
 .logLine2 { display: flex; align-items: center; gap: 6px; min-width: 0; flex-wrap: wrap; }
-.logRef { flex: none; padding: 0 5px; border: 1px solid var(--dsw-alias-border-l2); border-radius: 2px; font: var(--dsw-font-xxxs-strong-11); color: var(--dsw-alias-brand-primary); white-space: nowrap; }
-.logSubject { flex: 1; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; color: var(--dsw-alias-label-primary); }
-.logMeta { font: var(--dsw-font-xxxs-11); color: var(--dsw-alias-label-tertiary); }
+.logRef { flex: none; padding: 0 6px; border: 1px solid var(--dsw-alias-border-l2); border-radius: 999px; font: var(--dsw-font-xxxs-strong-11); color: var(--dsw-alias-brand-primary); white-space: nowrap; }
+.logSubject { flex: 1; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; font: var(--dsw-font-xxs-strong-12); color: var(--dsw-alias-label-primary); }
+.logMeta { margin-left: auto; font: var(--dsw-font-xxxs-11); color: var(--dsw-alias-label-tertiary); white-space: nowrap; }
 
 .logMore {
   display: block;
@@ -152,9 +268,8 @@
 .filePath { display: block; color: var(--dsw-alias-label-tertiary); font-family: var(--ds-font-family-code, monospace); font-size: 11px; padding: 6px 4px 2px; word-break: break-all; }
 .fileGroup:first-child .filePath { padding-top: 2px; }
 
-.opRow { display: flex; align-items: center; gap: 6px; width: 100%; min-height: 24px; border: 0; border-radius: 4px; background: transparent; color: var(--dsw-alias-label-primary); font: inherit; font-size: 11px; padding: 0 5px; cursor: pointer; text-align: left; }
+.opRow { position: relative; display: flex; align-items: center; gap: 6px; width: 100%; min-height: 24px; border: 0; border-radius: 4px; background: transparent; color: var(--dsw-alias-label-primary); font: inherit; font-size: 11px; padding: 0 5px; cursor: pointer; text-align: left; }
 .opRow:hover { background: var(--dsw-alias-interactive-bg-hover); }
-.opRow[data-selected='true'] { background: var(--dsw-alias-interactive-bg-active); }
 /* A failed op carries a quiet error inset bar (the flag chip names it). */
 .opRow[data-op-error='true'] { box-shadow: inset 2px 0 0 var(--dsw-alias-state-error-primary); }
 /* Size + relative time ride as one right-aligned cluster so the kind badges
@@ -197,10 +312,9 @@
   from { opacity: 0; }
 }
 
-/* Keyboard focus rings match the shared sidebar convention (the kit atoms
-   carry their own). */
-.link:focus-visible, .rowMain:focus-visible, .logRow:focus-visible,
-.logMore:focus-visible, .select:focus-visible, .dragHandle:focus-visible {
+/* Keyboard focus rings match the shared sidebar convention (the kit atoms and
+   the tree rows carry their own). */
+.logRow:focus-visible, .logMore:focus-visible, .select:focus-visible, .dragHandle:focus-visible {
   outline: 2px solid var(--dsw-alias-interactive-bg-hover-accent);
   outline-offset: -1px;
 }
diff --git a/src/client/layout.css b/src/client/layout.css
index f7d18cc..de01d88 100644
--- a/src/client/layout.css
+++ b/src/client/layout.css
@@ -78,3 +78,63 @@ body[data-dsh-sidebar-dragging] #root [data-dsh-center-col] {
   #root [data-dsh-center-col] {
     transition: none;
   }
+
+/* Context-menu submenu flip (viewport clamping for the portaled menus).
+ *
+ * The ui-primitives Menu clamps its main portal list into the viewport but
+ * positions nested submenus with static CSS only — anchored at the parent
+ * row's bottom, growing UP and to the RIGHT — with no clamp whatsoever.
+ * Both defaults are the worst case for our menus: a tall "open with" submenu
+ * escapes past the viewport top when the row menu opens near the top, and
+ * past the right edge in a narrow workbench pane (a pane can be far narrower
+ * than the card 218 + gap + submenu 165 a submenu needs).
+ *
+ * menu-flip.ts publishes `data-dsh-sidebar-submenu` on <body> — with the
+ * words "down" and/or "left" — for exactly the lifetime of one of OUR
+ * submenu-bearing menus (FileTree row menu, TabBar tab menu). The tokens
+ * flip the growth direction; the attribute's absence restores the
+ * primitive's own geometry untouched, and host-owned menus are never
+ * affected because they never open while the attribute exists (each side
+ * closes on the other's outside pointerdown).
+ *
+ * No max-height/overflow scroll cap here on purpose: overflow clipping
+ * would cut the submenu's ::before hover bridge (the corridor that keeps
+ * itemWrap's mouseleave from closing the card mid-crossing). */
+
+/* Visual tether, part 1 — the parent row stays lit while its submenu is
+ * open. The primitive only styles :hover, so once the pointer crossed into
+ * the side card the parent row's fill cleared and the floating card read as
+ * unrelated. The Menu marks the open parent row with aria-expanded="true"
+ * (host-rendered, stable), so the same hover token re-applies for the
+ * submenu's whole lifetime. */
+body[data-dsh-sidebar-submenu] div[role="menu"] button[aria-expanded="true"] {
+  background: var(--dsw-alias-interactive-bg-hover);
+}
+
+/* Visual tether, part 2 — the side card hugs its parent (10px → 4px gap),
+ * with the ::before hover corridor narrowed to match. Ordered BEFORE the
+ * flip overrides below so their left/right flips still win. */
+body[data-dsh-sidebar-submenu] div[role="menu"] div[role="menu"] {
+  left: calc(100% + 4px);
+}
+
+body[data-dsh-sidebar-submenu] div[role="menu"] div[role="menu"]::before {
+  left: -4px;
+  width: 4px;
+}
+
+body[data-dsh-sidebar-submenu~="down"] div[role="menu"] div[role="menu"] {
+  top: -4px;
+  bottom: auto;
+}
+
+body[data-dsh-sidebar-submenu~="left"] div[role="menu"] div[role="menu"] {
+  left: auto;
+  right: calc(100% + 4px);
+}
+
+/* The hover bridge follows the card to the left side of the parent row. */
+body[data-dsh-sidebar-submenu~="left"] div[role="menu"] div[role="menu"]::before {
+  left: auto;
+  right: -4px;
+}
diff --git a/src/client/locales-ar.ts b/src/client/locales-ar.ts
index ca4d1bd..b62c4ef 100644
--- a/src/client/locales-ar.ts
+++ b/src/client/locales-ar.ts
@@ -58,7 +58,29 @@ export const ar: Record<string, string> = {
   editorEmptyHint: 'اختر ملفاً من لوحة الشجرة أو من حقل المسار بالأعلى لبدء المعاينة',
   openFileNewTab: 'فتح في تبويب جديد',
   openFileSide: 'فتح إلى الجانب',
-  openInApp: 'فتح باستخدام',
+  zipDownload: 'ضغط وتنزيل',
+  zipDownloadCount: 'ضغط وتنزيل ({count} عناصر)',
+  zipFailed: 'فشل إنشاء الأرشيف: {message}',
+  openWithMenu: 'فتح بواسطة',
+  openWithSshSuffix: ' (SSH)',
+  pinOpenWith: 'تثبيت في القائمة',
+  unpinOpenWith: 'إلغاء التثبيت',
+  openWithExplorer: 'مدير الملفات',
+  openWithVscode: 'VS Code',
+  openWithCursor: 'Cursor',
+  openWithZed: 'Zed',
+  openWithSettingsSshTitle: 'مضيف SSH البعيد',
+  openWithSettingsSshDesc: 'فارغ = مساحة عمل محلية؛ مع user@host أو اسم مستعار SSH، تتحوّل فواتح عائلة VSCode إلى بروتوكول vscode-remote/ssh-remote ويُخفى مدير الملفات وZed والمحرّرات المخصّصة غير التابعة لعائلة VSCode من القائمة',
+  openWithSettingsSshPlaceholder: 'user@host أو اسم مستعار SSH',
+  openWithSettingsCustomTitle: 'محرّرات مخصّصة',
+  openWithSettingsCustomDesc: 'اسم + قالب URL (عنصر نائب {path}) + علامة عائلة VSCode؛ في الوضع البعيد، يمكن فقط لمحرّرات عائلة VSCode فتح مسار بعيد',
+  openWithSettingsAdd: 'إضافة',
+  openWithSettingsName: 'الاسم',
+  openWithSettingsTemplate: 'مثل cursor://file/{path}',
+  openWithSettingsFamily: 'عائلة VSCode',
+  openWithSettingsFamilyDesc: 'يتحدّث هذا المحرّر لهجة URL لـ VSCode (يدعم الفتح عبر SSH البعيد)',
+  openWithSettingsRemove: 'إزالة',
+  openWithSettingsInvalidHint: 'لن تظهر المحرّرات التي تفتقر إلى الاسم أو القالب (يلزم أن يحتوي على {path} ويبدأ بـ scheme://) في القائمة',
   openInAppDefault: 'فتح بالتطبيق الافتراضي',
   openInAppEmpty: 'لا يوجد تطبيق يمكنه فتحه',
   openInAppFailed: 'تعذّر الفتح: {path}',
diff --git a/src/client/locales-de.ts b/src/client/locales-de.ts
index 12ea9c9..fb96906 100644
--- a/src/client/locales-de.ts
+++ b/src/client/locales-de.ts
@@ -43,7 +43,29 @@ export const de: Record<string, string> = {
   editorEmptyHint: 'Wählen Sie eine Datei aus dem Dateibaum rechts oder dem Pfadeingabefeld oben, um mit der Vorschau zu beginnen',
   openFileNewTab: 'In neuem Tab öffnen',
   openFileSide: 'Seitlich öffnen',
-  openInApp: 'Öffnen mit',
+  zipDownload: 'Zippen und herunterladen',
+  zipDownloadCount: 'Zippen und herunterladen ({count} Elemente)',
+  zipFailed: 'Archivierung fehlgeschlagen: {message}',
+  openWithMenu: 'Öffnen mit',
+  openWithSshSuffix: ' (SSH)',
+  pinOpenWith: 'Im Menü anheften',
+  unpinOpenWith: 'Lösen',
+  openWithExplorer: 'Dateimanager',
+  openWithVscode: 'VS Code',
+  openWithCursor: 'Cursor',
+  openWithZed: 'Zed',
+  openWithSettingsSshTitle: 'SSH-Remote-Host',
+  openWithSettingsSshDesc: 'Leer = lokaler Arbeitsbereich; bei Angabe von user@host oder eines SSH-Alias verwenden die VSCode-Familienöffner das vscode-remote/ssh-remote-Protokoll, und Dateimanager / Zed / benutzerdefinierte Editoren außerhalb der VSCode-Familie werden im Menü ausgeblendet',
+  openWithSettingsSshPlaceholder: 'user@host oder SSH-Alias',
+  openWithSettingsCustomTitle: 'Benutzerdefinierte Editoren',
+  openWithSettingsCustomDesc: 'Name + URL-Vorlage ({path}-Platzhalter) + VSCode-Familien-Kennzeichen; im SSH-Modus können nur Editoren der VSCode-Familie Remote-Pfade öffnen',
+  openWithSettingsAdd: 'Hinzufügen',
+  openWithSettingsName: 'Name',
+  openWithSettingsTemplate: 'z. B. cursor://file/{path}',
+  openWithSettingsFamily: 'VSCode-Familie',
+  openWithSettingsFamilyDesc: 'Dieser Editor spricht das VSCode-URL-Protokoll (unterstützt SSH-Remote-Öffnen)',
+  openWithSettingsRemove: 'Entfernen',
+  openWithSettingsInvalidHint: 'Editoren ohne Namen oder mit Vorlage ohne {path} / scheme:// erscheinen nicht im Menü',
   openInAppDefault: 'Mit Standard-App öffnen',
   openInAppEmpty: 'Keine App kann diese Datei öffnen',
   openInAppFailed: 'Öffnen fehlgeschlagen: {path}',
diff --git a/src/client/locales-fr.ts b/src/client/locales-fr.ts
index 647d67a..8d3d9f3 100644
--- a/src/client/locales-fr.ts
+++ b/src/client/locales-fr.ts
@@ -50,7 +50,29 @@ export const fr: Record<string, string> = {
   editorEmptyHint: 'Choisissez un fichier dans l’arborescence à droite ou dans le champ de chemin ci-dessus pour commencer l’aperçu',
   openFileNewTab: 'Ouvrir dans un nouvel onglet',
   openFileSide: 'Ouvrir de côté',
-  openInApp: 'Ouvrir avec',
+  zipDownload: 'Compresser et télécharger',
+  zipDownloadCount: 'Compresser et télécharger ({count} éléments)',
+  zipFailed: 'Échec de l’archivage : {message}',
+  openWithMenu: 'Ouvrir avec',
+  openWithSshSuffix: ' (SSH)',
+  pinOpenWith: 'Épingler au menu',
+  unpinOpenWith: 'Désépingler',
+  openWithExplorer: 'Explorateur de fichiers',
+  openWithVscode: 'VS Code',
+  openWithCursor: 'Cursor',
+  openWithZed: 'Zed',
+  openWithSettingsSshTitle: 'Hôte distant SSH',
+  openWithSettingsSshDesc: 'Vide = espace de travail local ; avec un user@host ou un alias SSH, les ouvreurs de la famille VSCode passent aux protocoles vscode-remote/ssh-remote, et l’explorateur de fichiers / Zed / les éditeurs personnalisés hors famille VSCode sont masqués du menu',
+  openWithSettingsSshPlaceholder: 'user@host ou alias SSH',
+  openWithSettingsCustomTitle: 'Éditeurs personnalisés',
+  openWithSettingsCustomDesc: 'Nom + modèle d’URL (placeholder {path}) + famille VSCode ou non ; en mode SSH, seuls les éditeurs de la famille VSCode peuvent ouvrir un distant',
+  openWithSettingsAdd: 'Ajouter',
+  openWithSettingsName: 'Nom',
+  openWithSettingsTemplate: 'ex. cursor://file/{path}',
+  openWithSettingsFamily: 'Famille VSCode',
+  openWithSettingsFamilyDesc: 'Cet éditeur utilise le protocole d’URL de VSCode (prend en charge l’ouverture à distance via SSH)',
+  openWithSettingsRemove: 'Supprimer',
+  openWithSettingsInvalidHint: 'Les éditeurs sans nom ou sans modèle (contenant {path} et commençant par scheme://) n’apparaissent pas dans le menu',
   openInAppDefault: 'Ouvrir avec l’application par défaut',
   openInAppEmpty: 'Aucune application ne peut l’ouvrir',
   openInAppFailed: 'Impossible d’ouvrir : {path}',
diff --git a/src/client/locales-hi.ts b/src/client/locales-hi.ts
index 7393594..863a64c 100644
--- a/src/client/locales-hi.ts
+++ b/src/client/locales-hi.ts
@@ -57,7 +57,29 @@ export const hi: Record<string, string> = {
   editorEmptyHint: 'पूर्वावलोकन शुरू करने के लिए दाएँ फ़ाइल ट्री या ऊपर पथ इनपुट से फ़ाइल चुनें',
   openFileNewTab: 'नए टैब में खोलें',
   openFileSide: 'बाजू में खोलें',
-  openInApp: 'इसके साथ खोलें',
+  zipDownload: 'ज़िप कर डाउनलोड करें',
+  zipDownloadCount: 'ज़िप कर डाउनलोड करें ({count} आइटम)',
+  zipFailed: 'संग्रह बनाना विफल: {message}',
+  openWithMenu: 'इसके साथ खोलें',
+  openWithSshSuffix: ' (SSH)',
+  pinOpenWith: 'मेन्यू पर पिन करें',
+  unpinOpenWith: 'पिन हटाएं',
+  openWithExplorer: 'फ़ाइल मैनेजर',
+  openWithVscode: 'VS Code',
+  openWithCursor: 'Cursor',
+  openWithZed: 'Zed',
+  openWithSettingsSshTitle: 'SSH रिमोट होस्ट',
+  openWithSettingsSshDesc: 'खाली = स्थानीय वर्कस्पेस; user@host या SSH उपनाम के साथ, VSCode-परिवार ओपनर vscode-remote/ssh-remote प्रोटोकॉल पर स्विच हो जाते हैं और फ़ाइल मैनेजर / Zed / ग़ैर-VSCode-परिवार कस्टम एडिटर मेन्यू से छिप जाते हैं',
+  openWithSettingsSshPlaceholder: 'user@host या SSH उपनाम',
+  openWithSettingsCustomTitle: 'कस्टम एडिटर',
+  openWithSettingsCustomDesc: 'नाम + URL टेम्पलेट ({path} प्लेसहोल्डर) + VSCode-परिवार फ़्लैग; रिमोट मोड में केवल VSCode-परिवार एडिटर रिमोट पथ खोल सकते हैं',
+  openWithSettingsAdd: 'जोड़ें',
+  openWithSettingsName: 'नाम',
+  openWithSettingsTemplate: 'जैसे cursor://file/{path}',
+  openWithSettingsFamily: 'VSCode-परिवार',
+  openWithSettingsFamilyDesc: 'यह एडिटर VSCode URL बोली बोलता है (SSH-रिमोट खोलने का समर्थन)',
+  openWithSettingsRemove: 'हटाएं',
+  openWithSettingsInvalidHint: 'नाम या {path} / scheme:// के बिना टेम्पलेट वाले एडिटर मेन्यू में नहीं दिखते',
   openInAppDefault: 'डिफ़ॉल्ट ऐप से खोलें',
   openInAppEmpty: 'इसे खोलने के लिए कोई ऐप नहीं',
   openInAppFailed: 'खोल नहीं सका: {path}',
diff --git a/src/client/locales-id.ts b/src/client/locales-id.ts
index 709afd9..8498d0c 100644
--- a/src/client/locales-id.ts
+++ b/src/client/locales-id.ts
@@ -55,7 +55,29 @@ export const id: Record<string, string> = {
   editorEmptyHint: 'Pilih berkas dari panel pohon atau input path di atas untuk mulai pratinjau',
   openFileNewTab: 'Buka di Tab Baru',
   openFileSide: 'Buka di Samping',
-  openInApp: 'Buka dengan',
+  zipDownload: 'Zip dan unduh',
+  zipDownloadCount: 'Zip dan unduh ({count} item)',
+  zipFailed: 'Gagal membuat arsip: {message}',
+  openWithMenu: 'Buka dengan',
+  openWithSshSuffix: ' (SSH)',
+  pinOpenWith: 'Sematkan ke menu',
+  unpinOpenWith: 'Lepas sematan',
+  openWithExplorer: 'File Manager',
+  openWithVscode: 'VS Code',
+  openWithCursor: 'Cursor',
+  openWithZed: 'Zed',
+  openWithSettingsSshTitle: 'Host remote SSH',
+  openWithSettingsSshDesc: 'Kosong = ruang kerja lokal; dengan user@host atau alias SSH, opener VSCode-family beralih ke protokol vscode-remote/ssh-remote dan File Manager / Zed / editor kustom non-VSCode-family disembunyikan dari menu',
+  openWithSettingsSshPlaceholder: 'user@host atau alias SSH',
+  openWithSettingsCustomTitle: 'Editor kustom',
+  openWithSettingsCustomDesc: 'Nama + template URL (placeholder {path}) + flag VSCode-family; dalam mode remote hanya editor VSCode-family yang dapat membuka path remote',
+  openWithSettingsAdd: 'Tambah',
+  openWithSettingsName: 'Nama',
+  openWithSettingsTemplate: 'mis. cursor://file/{path}',
+  openWithSettingsFamily: 'VSCode-family',
+  openWithSettingsFamilyDesc: 'Editor ini menggunakan dialek URL VSCode (mendukung pembukaan remote SSH)',
+  openWithSettingsRemove: 'Hapus',
+  openWithSettingsInvalidHint: 'Editor dengan nama hilang atau template tanpa {path} / scheme:// tidak ditampilkan di menu',
   openInAppDefault: 'Buka dengan aplikasi default',
   openInAppEmpty: 'Tidak ada aplikasi yang bisa membukanya',
   openInAppFailed: 'Gagal membuka: {path}',
diff --git a/src/client/locales-it.ts b/src/client/locales-it.ts
index 31a76a5..19b6aba 100644
--- a/src/client/locales-it.ts
+++ b/src/client/locales-it.ts
@@ -48,7 +48,29 @@ export const it: Record<string, string> = {
   editorEmptyHint: 'Scelga un file dal pannello dell’albero a destra o dal campo del percorso in alto per iniziare l’anteprima',
   openFileNewTab: 'Apri in una nuova scheda',
   openFileSide: 'Apri a lato',
-  openInApp: 'Apri con',
+  zipDownload: 'Comprimi e scarica',
+  zipDownloadCount: 'Comprimi e scarica ({count} elementi)',
+  zipFailed: 'Creazione archivio non riuscita: {message}',
+  openWithMenu: 'Apri con',
+  openWithSshSuffix: ' (SSH)',
+  pinOpenWith: 'Fissa al menu',
+  unpinOpenWith: 'Rimuovi dal fisso',
+  openWithExplorer: 'Esplora risorse',
+  openWithVscode: 'VS Code',
+  openWithCursor: 'Cursor',
+  openWithZed: 'Zed',
+  openWithSettingsSshTitle: 'Host remoto SSH',
+  openWithSettingsSshDesc: 'Vuoto = spazio di lavoro locale; con un user@host o un alias SSH, gli apritori della famiglia VSCode passano al protocollo vscode-remote/ssh-remote e l’Esplora risorse / Zed / gli editor personalizzati non VSCode vengono nascosti dal menu',
+  openWithSettingsSshPlaceholder: 'user@host o alias SSH',
+  openWithSettingsCustomTitle: 'Editor personalizzati',
+  openWithSettingsCustomDesc: 'Nome + modello URL (segnaposto {path}) + flag famiglia VSCode; in modalità remota solo gli editor della famiglia VSCode possono aprire un percorso remoto',
+  openWithSettingsAdd: 'Aggiungi',
+  openWithSettingsName: 'Nome',
+  openWithSettingsTemplate: 'es. cursor://file/{path}',
+  openWithSettingsFamily: 'Famiglia VSCode',
+  openWithSettingsFamilyDesc: 'Questo editor usa il protocollo URL di VSCode (supporta aperture SSH remote)',
+  openWithSettingsRemove: 'Rimuovi',
+  openWithSettingsInvalidHint: 'Gli editor con nome mancante o modello senza {path} / scheme:// non vengono mostrati nel menu',
   openInAppDefault: 'Apri con l’app predefinita',
   openInAppEmpty: 'Nessuna applicazione può aprirlo',
   openInAppFailed: 'Impossibile aprire: {path}',
diff --git a/src/client/locales-ja.ts b/src/client/locales-ja.ts
index 70bc83d..7c4370b 100644
--- a/src/client/locales-ja.ts
+++ b/src/client/locales-ja.ts
@@ -57,7 +57,29 @@ export const ja: Record<string, string> = {
   editorEmptyHint: '右のファイルツリーまたは上のパス入力欄からファイルを選んでプレビュー',
   openFileNewTab: '新しいタブで開く',
   openFileSide: '横に開く',
-  openInApp: 'アプリで開く',
+  zipDownload: '圧縮してダウンロード',
+  zipDownloadCount: '圧縮してダウンロード（{count} 件）',
+  zipFailed: 'アーカイブの作成に失敗しました：{message}',
+  openWithMenu: 'アプリで開く',
+  openWithSshSuffix: ' (SSH)',
+  pinOpenWith: 'メニューに固定',
+  unpinOpenWith: '固定を解除',
+  openWithExplorer: 'エクスプローラー',
+  openWithVscode: 'VS Code',
+  openWithCursor: 'Cursor',
+  openWithZed: 'Zed',
+  openWithSettingsSshTitle: 'SSH リモートホスト',
+  openWithSettingsSshDesc: '空欄 = ローカルワークスペース。user@host または SSH エイリアスを入力すると、VSCode 系の起動方法は vscode-remote/ssh-remote プロトコルに切り替わり、エクスプローラー / Zed / 非 VSCode 系カスタムエディターはメニューから非表示になります',
+  openWithSettingsSshPlaceholder: 'user@host または SSH エイリアス',
+  openWithSettingsCustomTitle: 'カスタムエディター',
+  openWithSettingsCustomDesc: '名前 + URL テンプレート（{path} プレースホルダー）+ VSCode 系かどうか。SSH モードでは VSCode 系のみリモートパスを開けます',
+  openWithSettingsAdd: '追加',
+  openWithSettingsName: '名前',
+  openWithSettingsTemplate: '例: cursor://file/{path}',
+  openWithSettingsFamily: 'VSCode 系',
+  openWithSettingsFamilyDesc: 'このエディターは VSCode の URL プロトコルを使います（SSH リモートオープンをサポート）',
+  openWithSettingsRemove: '削除',
+  openWithSettingsInvalidHint: '名前またはテンプレート（{path} を含み scheme:// で始まる必要あり）が未入力の編集者はメニューに表示されません',
   openInAppDefault: '既定のアプリで開く',
   openInAppEmpty: '開けるアプリがありません',
   openInAppFailed: '開けませんでした：{path}',
diff --git a/src/client/locales-ko.ts b/src/client/locales-ko.ts
index 5742c59..223de64 100644
--- a/src/client/locales-ko.ts
+++ b/src/client/locales-ko.ts
@@ -49,7 +49,29 @@ export const ko: Record<string, string> = {
   editorEmptyHint: '오른쪽 파일 트리나 위쪽 경로 입력란에서 파일을 선택해 미리보기를 시작하세요',
   openFileNewTab: '새 Tab으로 열기',
   openFileSide: '측면에 열기',
-  openInApp: '앱으로 열기',
+  zipDownload: '압축하여 다운로드',
+  zipDownloadCount: '압축하여 다운로드({count}개 항목)',
+  zipFailed: '압축 파일 생성 실패: {message}',
+  openWithMenu: '앱에서 열기',
+  openWithSshSuffix: ' (SSH)',
+  pinOpenWith: '메뉴에 고정',
+  unpinOpenWith: '고정 해제',
+  openWithExplorer: '파일 탐색기',
+  openWithVscode: 'VS Code',
+  openWithCursor: 'Cursor',
+  openWithZed: 'Zed',
+  openWithSettingsSshTitle: 'SSH 원격 호스트',
+  openWithSettingsSshDesc: '비워두면 로컬 작업 공간입니다. user@host 또는 SSH 별칭을 입력하면 VSCode 계열 열기 방식이 vscode-remote/ssh-remote 프로토콜을 사용하게 되며, 파일 탐색기 / Zed / 비 VSCode 계열 사용자 지정 편집기는 메뉴에서 숨겨집니다',
+  openWithSettingsSshPlaceholder: 'user@host 또는 SSH 별칭',
+  openWithSettingsCustomTitle: '사용자 지정 편집기',
+  openWithSettingsCustomDesc: '이름 + URL 템플릿({path} 자리 표시자) + VSCode 계열 여부. SSH 모드에서는 VSCode 계열만 원격을 열 수 있습니다',
+  openWithSettingsAdd: '추가',
+  openWithSettingsName: '이름',
+  openWithSettingsTemplate: '예: cursor://file/{path}',
+  openWithSettingsFamily: 'VSCode 계열',
+  openWithSettingsFamilyDesc: '이 편집기는 VSCode의 URL 프로토콜을 사용합니다(SSH 원격 열기 지원)',
+  openWithSettingsRemove: '삭제',
+  openWithSettingsInvalidHint: '이름이나 템플릿({path} 포함, scheme:// 로 시작해야 함)을 입력하지 않은 편집기는 메뉴에 표시되지 않습니다',
   openInAppDefault: '기본 앱으로 열기',
   openInAppEmpty: '이 파일을 열 수 있는 앱이 없습니다',
   openInAppFailed: '열 수 없습니다: {path}',
diff --git a/src/client/locales-nl.ts b/src/client/locales-nl.ts
index c55e87e..3a5aeb2 100644
--- a/src/client/locales-nl.ts
+++ b/src/client/locales-nl.ts
@@ -55,7 +55,29 @@ export const nl: Record<string, string> = {
   editorEmptyHint: 'Kies een bestand uit het boompaneel of het pad-invoerveld hierboven om te beginnen met previewen',
   openFileNewTab: 'Openen in nieuw tabblad',
   openFileSide: 'Openen aan de zijkant',
-  openInApp: 'Openen met',
+  zipDownload: 'Zippen en downloaden',
+  zipDownloadCount: 'Zippen en downloaden ({count} items)',
+  zipFailed: 'Archiveren mislukt: {message}',
+  openWithMenu: 'Openen met',
+  openWithSshSuffix: ' (SSH)',
+  pinOpenWith: 'Vastmaken aan menu',
+  unpinOpenWith: 'Losmaken',
+  openWithExplorer: 'Bestandsbeheerder',
+  openWithVscode: 'VS Code',
+  openWithCursor: 'Cursor',
+  openWithZed: 'Zed',
+  openWithSettingsSshTitle: 'SSH externe host',
+  openWithSettingsSshDesc: 'Leeg = lokale werkruimte; met een user@host of SSH-alias schakelen VSCode-familie-openers over op het vscode-remote/ssh-remote protocol en worden de Bestandsbeheerder / Zed / niet-VSCode-familie custom editors verborgen uit het menu',
+  openWithSettingsSshPlaceholder: 'user@host of SSH-alias',
+  openWithSettingsCustomTitle: 'Aangepaste editors',
+  openWithSettingsCustomDesc: 'Naam + URL-sjabloon ({path} placeholder) + VSCode-familie-vlag; in externe modus kunnen alleen VSCode-familie-editors een extern pad openen',
+  openWithSettingsAdd: 'Toevoegen',
+  openWithSettingsName: 'Naam',
+  openWithSettingsTemplate: 'bijv. cursor://file/{path}',
+  openWithSettingsFamily: 'VSCode-familie',
+  openWithSettingsFamilyDesc: 'Deze editor spreekt het VSCode URL-dialect (ondersteunt SSH-externe openingen)',
+  openWithSettingsRemove: 'Verwijderen',
+  openWithSettingsInvalidHint: 'Editors met een ontbrekende naam of een sjabloon zonder {path} / scheme:// worden niet in het menu getoond',
   openInAppDefault: 'Openen met standaardapp',
   openInAppEmpty: 'Geen app kan dit openen',
   openInAppFailed: 'Kan niet openen: {path}',
diff --git a/src/client/locales-pl.ts b/src/client/locales-pl.ts
index c454b3c..c88946d 100644
--- a/src/client/locales-pl.ts
+++ b/src/client/locales-pl.ts
@@ -59,7 +59,29 @@ export const pl: Record<string, string> = {
   editorEmptyHint: 'Wybierz plik z panelu drzewa lub pola ścieżki powyżej, aby rozpocząć podgląd',
   openFileNewTab: 'Otwórz w nowej karcie',
   openFileSide: 'Otwórz z boku',
-  openInApp: 'Otwórz za pomocą',
+  zipDownload: 'Spakuj i pobierz',
+  zipDownloadCount: 'Spakuj i pobierz ({count} elementów)',
+  zipFailed: 'Tworzenie archiwum nie powiodło się: {message}',
+  openWithMenu: 'Otwórz za pomocą',
+  openWithSshSuffix: ' (SSH)',
+  pinOpenWith: 'Przypnij do menu',
+  unpinOpenWith: 'Odepnij',
+  openWithExplorer: 'Menedżer plików',
+  openWithVscode: 'VS Code',
+  openWithCursor: 'Cursor',
+  openWithZed: 'Zed',
+  openWithSettingsSshTitle: 'Zdalny host SSH',
+  openWithSettingsSshDesc: 'Puste = lokalny obszar roboczy; z user@host lub aliasem SSH otwieracze rodziny VSCode przełączają się na protokół vscode-remote/ssh-remote, a Menedżer plików / Zed / niestandardowe edytory spoza rodziny VSCode są ukrywane w menu',
+  openWithSettingsSshPlaceholder: 'user@host lub alias SSH',
+  openWithSettingsCustomTitle: 'Niestandardowe edytory',
+  openWithSettingsCustomDesc: 'Nazwa + szablon URL (zastępnik {path}) + flaga rodziny VSCode; w trybie zdalnym tylko edytory rodziny VSCode mogą otwierać ścieżkę zdalną',
+  openWithSettingsAdd: 'Dodaj',
+  openWithSettingsName: 'Nazwa',
+  openWithSettingsTemplate: 'np. cursor://file/{path}',
+  openWithSettingsFamily: 'Rodzina VSCode',
+  openWithSettingsFamilyDesc: 'Ten edytor używa dialektu URL VSCode (obsługuje otwieranie zdalne przez SSH)',
+  openWithSettingsRemove: 'Usuń',
+  openWithSettingsInvalidHint: 'Edytory z brakującą nazwą lub szablonem bez {path} / scheme:// nie są pokazywane w menu',
   openInAppDefault: 'Otwórz w domyślnej aplikacji',
   openInAppEmpty: 'Brak aplikacji, która może to otworzyć',
   openInAppFailed: 'Nie udało się otworzyć: {path}',
diff --git a/src/client/locales-pt.ts b/src/client/locales-pt.ts
index 26f3a67..2cead4b 100644
--- a/src/client/locales-pt.ts
+++ b/src/client/locales-pt.ts
@@ -40,7 +40,29 @@ export const pt: Record<string, string> = {
   editorEmptyHint: 'Escolha um arquivo na árvore do painel ou no campo de caminho acima para começar a pré-visualizar',
   openFileNewTab: 'Abrir em nova aba',
   openFileSide: 'Abrir ao lado',
-  openInApp: 'Abrir com',
+  zipDownload: 'Compactar e baixar',
+  zipDownloadCount: 'Compactar e baixar ({count} itens)',
+  zipFailed: 'Falha ao compactar: {message}',
+  openWithMenu: 'Abrir com',
+  openWithSshSuffix: ' (SSH)',
+  pinOpenWith: 'Fixar no menu',
+  unpinOpenWith: 'Desafixar',
+  openWithExplorer: 'Gerenciador de arquivos',
+  openWithVscode: 'VS Code',
+  openWithCursor: 'Cursor',
+  openWithZed: 'Zed',
+  openWithSettingsSshTitle: 'Host remoto SSH',
+  openWithSettingsSshDesc: 'Vazio = workspace local; com user@host ou um alias SSH, os abridores da família VSCode passam a usar o protocolo vscode-remote/ssh-remote e o Gerenciador de arquivos / Zed / editores personalizados fora da família VSCode ficam ocultos do menu',
+  openWithSettingsSshPlaceholder: 'user@host ou alias SSH',
+  openWithSettingsCustomTitle: 'Editores personalizados',
+  openWithSettingsCustomDesc: 'Nome + modelo de URL (espaço reservado {path}) + sinalizador de família VSCode; no modo remoto, apenas editores da família VSCode podem abrir um caminho remoto',
+  openWithSettingsAdd: 'Adicionar',
+  openWithSettingsName: 'Nome',
+  openWithSettingsTemplate: 'ex.: cursor://file/{path}',
+  openWithSettingsFamily: 'Família VSCode',
+  openWithSettingsFamilyDesc: 'Este editor fala o dialeto de URL do VSCode (suporta aberturas SSH remotas)',
+  openWithSettingsRemove: 'Remover',
+  openWithSettingsInvalidHint: 'Editores com nome ausente ou modelo sem {path} / scheme:// não aparecem no menu',
   openInAppDefault: 'Abrir com o aplicativo padrão',
   openInAppEmpty: 'Nenhum aplicativo pode abri-lo',
   openInAppFailed: 'Não foi possível abrir: {path}',
diff --git a/src/client/locales-ru.ts b/src/client/locales-ru.ts
index 0a7992e..25e2aa5 100644
--- a/src/client/locales-ru.ts
+++ b/src/client/locales-ru.ts
@@ -53,7 +53,29 @@ export const ru: Record<string, string> = {
   editorEmptyHint: 'Выберите файл из дерева справа или введите путь выше, чтобы начать предпросмотр',
   openFileNewTab: 'Открыть в новой вкладке',
   openFileSide: 'Открыть сбоку',
-  openInApp: 'Открыть с помощью',
+  zipDownload: 'Сжать в архив и скачать',
+  zipDownloadCount: 'Сжать в архив и скачать ({count} элементов)',
+  zipFailed: 'Сбой создания архива: {message}',
+  openWithMenu: 'Открыть в приложении',
+  openWithSshSuffix: ' (SSH)',
+  pinOpenWith: 'Закрепить в меню',
+  unpinOpenWith: 'Открепить',
+  openWithExplorer: 'Проводник',
+  openWithVscode: 'VS Code',
+  openWithCursor: 'Cursor',
+  openWithZed: 'Zed',
+  openWithSettingsSshTitle: 'Удалённый хост SSH',
+  openWithSettingsSshDesc: 'Пусто = локальная рабочая область; при указании user@host или псевдонима SSH способы открытия семейства VSCode переключаются на протокол vscode-remote/ssh-remote, а проводник / Zed / сторонние редакторы вне семейства VSCode скрываются из меню',
+  openWithSettingsSshPlaceholder: 'user@host или псевдоним SSH',
+  openWithSettingsCustomTitle: 'Собственные редакторы',
+  openWithSettingsCustomDesc: 'Имя + шаблон URL (плейсхолдер {path}) + признак семейства VSCode; в режиме SSH только редакторы семейства VSCode могут открывать удалённые пути',
+  openWithSettingsAdd: 'Добавить',
+  openWithSettingsName: 'Имя',
+  openWithSettingsTemplate: 'напр. cursor://file/{path}',
+  openWithSettingsFamily: 'Семейство VSCode',
+  openWithSettingsFamilyDesc: 'Этот редактор использует URL-протокол VSCode (поддерживает удалённое открытие по SSH)',
+  openWithSettingsRemove: 'Удалить',
+  openWithSettingsInvalidHint: 'Редакторы без имени или с шаблоном без {path} / scheme:// не появятся в меню',
   openInAppDefault: 'Открыть приложением по умолчанию',
   openInAppEmpty: 'Нет приложения, которое может это открыть',
   openInAppFailed: 'Не удалось открыть: {path}',
diff --git a/src/client/locales-sv.ts b/src/client/locales-sv.ts
index ade5136..15b8b4c 100644
--- a/src/client/locales-sv.ts
+++ b/src/client/locales-sv.ts
@@ -40,7 +40,29 @@ export const sv: Record<string, string> = {
   editorEmptyHint: 'Välj en fil från trädpanelen eller sökvägsinmatningen ovan för att börja förhandsgranska',
   openFileNewTab: 'Öppna i ny flik',
   openFileSide: 'Öppna vid sidan',
-  openInApp: 'Öppna med',
+  zipDownload: 'Zippa och ladda ner',
+  zipDownloadCount: 'Zippa och ladda ner ({count} objekt)',
+  zipFailed: 'Kunde inte skapa arkivet: {message}',
+  openWithMenu: 'Öppna med',
+  openWithSshSuffix: ' (SSH)',
+  pinOpenWith: 'Fäst i meny',
+  unpinOpenWith: 'Lossa',
+  openWithExplorer: 'Filhanterare',
+  openWithVscode: 'VS Code',
+  openWithCursor: 'Cursor',
+  openWithZed: 'Zed',
+  openWithSettingsSshTitle: 'SSH-fjärrvärd',
+  openWithSettingsSshDesc: 'Tomt = lokal arbetsyta; med user@host eller SSH-alias byter VSCode-familjens öppnare till vscode-remote/ssh-remote-protokollet och Filhanterare / Zed / icke-VSCode-familjens anpassade editorer döljs från menyn',
+  openWithSettingsSshPlaceholder: 'user@host eller SSH-alias',
+  openWithSettingsCustomTitle: 'Anpassade editorer',
+  openWithSettingsCustomDesc: 'Namn + URL-mall ({path}-platshållare) + VSCode-familj-flagga; i fjärrläge kan endast VSCode-familjens editorer öppna en fjärrsökväg',
+  openWithSettingsAdd: 'Lägg till',
+  openWithSettingsName: 'Namn',
+  openWithSettingsTemplate: 't.ex. cursor://file/{path}',
+  openWithSettingsFamily: 'VSCode-familj',
+  openWithSettingsFamilyDesc: 'Denna editor talar VSCode:s URL-dialekt (stöder SSH-fjärröppning)',
+  openWithSettingsRemove: 'Ta bort',
+  openWithSettingsInvalidHint: 'Editorer med saknat namn eller en mall utan {path} / scheme:// visas inte i menyn',
   openInAppDefault: 'Öppna med standardapp',
   openInAppEmpty: 'Ingen app kan öppna den',
   openInAppFailed: 'Kunde inte öppna: {path}',
diff --git a/src/client/locales-th.ts b/src/client/locales-th.ts
index d4cf2f1..471c23b 100644
--- a/src/client/locales-th.ts
+++ b/src/client/locales-th.ts
@@ -57,7 +57,29 @@ export const th: Record<string, string> = {
   editorEmptyHint: 'เลือกไฟล์จากพาเนลต้นไม้ไฟล์หรือช่องกรอกพาธด้านบนเพื่อเริ่มพรีวิว',
   openFileNewTab: 'เปิดใน Tab ใหม่',
   openFileSide: 'เปิดด้านข้าง',
-  openInApp: 'เปิดด้วย',
+  zipDownload: 'บีบอัดและดาวน์โหลด',
+  zipDownloadCount: 'บีบอัดและดาวน์โหลด ({count} รายการ)',
+  zipFailed: 'สร้างไฟล์บีบอัดไม่สำเร็จ: {message}',
+  openWithMenu: 'เปิดด้วย',
+  openWithSshSuffix: ' (SSH)',
+  pinOpenWith: 'ปักหมุดในเมนู',
+  unpinOpenWith: 'ยกเลิกการปักหมุด',
+  openWithExplorer: 'ตัวจัดการไฟล์',
+  openWithVscode: 'VS Code',
+  openWithCursor: 'Cursor',
+  openWithZed: 'Zed',
+  openWithSettingsSshTitle: 'โฮสต์ระยะไกล SSH',
+  openWithSettingsSshDesc: 'ว่าง = พื้นที่ทำงานในเครื่อง; เมื่อกรอก user@host หรือ alias SSH ตัวเปิดตระกูล VSCode จะสลับไปใช้โปรโตคอล vscode-remote/ssh-remote และตัวจัดการไฟล์ / Zed / ตัวแก้ไขที่กำหนดเองที่ไม่ใช่ตระกูล VSCode จะถูกซ่อนจากเมนู',
+  openWithSettingsSshPlaceholder: 'user@host หรือ alias SSH',
+  openWithSettingsCustomTitle: 'ตัวแก้ไขที่กำหนดเอง',
+  openWithSettingsCustomDesc: 'ชื่อ + เทมเพลต URL (placeholder {path}) + แฟล็กตระกูล VSCode; ในโหมดระยะไกลเฉพาะตัวแก้ไขตระกูล VSCode เท่านั้นที่เปิดพาธระยะไกลได้',
+  openWithSettingsAdd: 'เพิ่ม',
+  openWithSettingsName: 'ชื่อ',
+  openWithSettingsTemplate: 'เช่น cursor://file/{path}',
+  openWithSettingsFamily: 'ตระกูล VSCode',
+  openWithSettingsFamilyDesc: 'ตัวแก้ไขนี้ใช้โปรโตคอล URL ของ VSCode (รองรับการเปิดจากระยะไกลผ่าน SSH)',
+  openWithSettingsRemove: 'ลบ',
+  openWithSettingsInvalidHint: 'ตัวแก้ไขที่ไม่มีชื่อหรือเทมเพลตที่ไม่มี {path} / scheme:// จะไม่ปรากฏในเมนู',
   openInAppDefault: 'เปิดด้วยแอปเริ่มต้น',
   openInAppEmpty: 'ไม่มีแอปที่เปิดไฟล์นี้ได้',
   openInAppFailed: 'เปิดไม่สำเร็จ: {path}',
diff --git a/src/client/locales-tr.ts b/src/client/locales-tr.ts
index 9cbbb44..45e00fa 100644
--- a/src/client/locales-tr.ts
+++ b/src/client/locales-tr.ts
@@ -57,7 +57,29 @@ export const tr: Record<string, string> = {
   editorEmptyHint: 'Önizlemeye başlamak için sağdaki dosya ağacından veya yukarıdaki yol girişinden bir dosya seçin',
   openFileNewTab: 'Yeni sekmede aç',
   openFileSide: 'Yana aç',
-  openInApp: 'Birlikte aç',
+  zipDownload: 'Sıkıştır ve indir',
+  zipDownloadCount: 'Sıkıştır ve indir ({count} öğe)',
+  zipFailed: 'Arşiv oluşturulamadı: {message}',
+  openWithMenu: 'Birlikte aç',
+  openWithSshSuffix: ' (SSH)',
+  pinOpenWith: 'Menüye sabitle',
+  unpinOpenWith: 'Sabitlemeyi kaldır',
+  openWithExplorer: 'Dosya yöneticisi',
+  openWithVscode: 'VS Code',
+  openWithCursor: 'Cursor',
+  openWithZed: 'Zed',
+  openWithSettingsSshTitle: 'SSH uzak ana makine',
+  openWithSettingsSshDesc: 'Boş = yerel çalışma alanı; bir user@host veya SSH rumuzu verilirse VSCode ailesi açıcılar vscode-remote/ssh-remote protokolüne geçer ve Dosya yöneticisi / Zed / VSCode ailesi olmayan özel düzenleyiciler menüden gizlenir',
+  openWithSettingsSshPlaceholder: 'user@host veya SSH rumuzu',
+  openWithSettingsCustomTitle: 'Özel düzenleyiciler',
+  openWithSettingsCustomDesc: 'Ad + URL şablonu ({path} yer tutucusu) + VSCode ailesi bayrağı; uzak modda yalnızca VSCode ailesi düzenleyiciler uzak yolu açabilir',
+  openWithSettingsAdd: 'Ekle',
+  openWithSettingsName: 'Ad',
+  openWithSettingsTemplate: 'ör. cursor://file/{path}',
+  openWithSettingsFamily: 'VSCode ailesi',
+  openWithSettingsFamilyDesc: 'Bu düzenleyici VSCode URL dilini konuşur (SSH uzak açmayı destekler)',
+  openWithSettingsRemove: 'Kaldır',
+  openWithSettingsInvalidHint: 'Adı eksik veya {path}/scheme:// içermeyen şablonlu düzenleyiciler menüde gösterilmez',
   openInAppDefault: 'Varsayılan uygulamayla aç',
   openInAppEmpty: 'Bunu açabilecek bir uygulama yok',
   openInAppFailed: 'Açılamadı: {path}',
diff --git a/src/client/locales-vi.ts b/src/client/locales-vi.ts
index ba728ba..dcd41ea 100644
--- a/src/client/locales-vi.ts
+++ b/src/client/locales-vi.ts
@@ -57,7 +57,29 @@ export const vi: Record<string, string> = {
   editorEmptyHint: 'Chọn tệp từ cây tệp bên phải hoặc ô nhập đường dẫn phía trên để xem trước',
   openFileNewTab: 'Mở trong Tab mới',
   openFileSide: 'Mở ở bên cạnh',
-  openInApp: 'Mở bằng',
+  zipDownload: 'Nén và tải xuống',
+  zipDownloadCount: 'Nén và tải xuống ({count} mục)',
+  zipFailed: 'Tạo tệp nén thất bại: {message}',
+  openWithMenu: 'Mở bằng',
+  openWithSshSuffix: ' (SSH)',
+  pinOpenWith: 'Ghim vào menu',
+  unpinOpenWith: 'Bỏ ghim',
+  openWithExplorer: 'Trình quản lý tệp',
+  openWithVscode: 'VS Code',
+  openWithCursor: 'Cursor',
+  openWithZed: 'Zed',
+  openWithSettingsSshTitle: 'Máy chủ từ xa SSH',
+  openWithSettingsSshDesc: 'Để trống cho không gian làm việc cục bộ; nhập user@host hoặc alias SSH, các trình mở họ VSCode sẽ chuyển sang giao thức vscode-remote/ssh-remote, Trình quản lý tệp / Zed / trình soạn thảo tùy chỉnh không phải VSCode sẽ ẩn khỏi menu',
+  openWithSettingsSshPlaceholder: 'user@host hoặc alias SSH',
+  openWithSettingsCustomTitle: 'Trình soạn thảo tùy chỉnh',
+  openWithSettingsCustomDesc: 'Tên + mẫu URL (placeholder {path}) + cờ họ VSCode; ở chế độ SSH chỉ họ VSCode mở được đường dẫn từ xa',
+  openWithSettingsAdd: 'Thêm',
+  openWithSettingsName: 'Tên',
+  openWithSettingsTemplate: 'vd: cursor://file/{path}',
+  openWithSettingsFamily: 'Họ VSCode',
+  openWithSettingsFamilyDesc: 'Trình soạn thảo này dùng giao thức URL của VSCode (hỗ trợ mở từ xa qua SSH)',
+  openWithSettingsRemove: 'Xóa',
+  openWithSettingsInvalidHint: 'Trình soạn thảo thiếu tên hoặc mẫu (cần chứa {path} và bắt đầu bằng scheme://) sẽ không xuất hiện trong menu',
   openInAppDefault: 'Mở bằng ứng dụng mặc định',
   openInAppEmpty: 'Không có ứng dụng nào mở được tệp này',
   openInAppFailed: 'Không mở được: {path}',
diff --git a/src/client/locales-zh-HK.ts b/src/client/locales-zh-HK.ts
index 54a5e51..be33898 100644
--- a/src/client/locales-zh-HK.ts
+++ b/src/client/locales-zh-HK.ts
@@ -72,7 +72,29 @@ export const zhHK: Record<string, string> = {
   editorEmptyHint: '從右側檔案樹或上方路徑輸入框選擇檔案開始預覽',
   openFileNewTab: '在新 Tab 中開啟',
   openFileSide: '在側邊開啟',
-  openInApp: '開啟方式',
+  zipDownload: '壓縮並下載',
+  zipDownloadCount: '壓縮並下載（{count} 項）',
+  zipFailed: '壓縮失敗：{message}',
+  openWithMenu: '在應用程式中開啟',
+  openWithSshSuffix: ' (SSH)',
+  pinOpenWith: '固定到選單',
+  unpinOpenWith: '取消固定',
+  openWithExplorer: '檔案總管',
+  openWithVscode: 'VS Code',
+  openWithCursor: 'Cursor',
+  openWithZed: 'Zed',
+  openWithSettingsSshTitle: 'SSH 遠端主機',
+  openWithSettingsSshDesc: '留空為本地工作區；填入 user@host 或 SSH 別名後，VSCode 系開啟方式將改用 vscode-remote/ssh-remote 協議，檔案總管 / Zed / 非 VSCode 系自訂編輯器將從選單隱藏',
+  openWithSettingsSshPlaceholder: 'user@host 或 SSH 別名',
+  openWithSettingsCustomTitle: '自訂編輯器',
+  openWithSettingsCustomDesc: '名稱 + URL 範本（{path} 佔位符）+ 是否 VSCode 系；SSH 模式下僅 VSCode 系可開啟遠端',
+  openWithSettingsAdd: '新增',
+  openWithSettingsName: '名稱',
+  openWithSettingsTemplate: '如 cursor://file/{path}',
+  openWithSettingsFamily: 'VSCode 系',
+  openWithSettingsFamilyDesc: '該編輯器使用 VSCode 的 URL 協議（支援 SSH 遠端開啟）',
+  openWithSettingsRemove: '刪除',
+  openWithSettingsInvalidHint: '名稱或範本（需含 {path} 且以 scheme:// 開頭）未填寫的編輯器不會出現在選單中',
   openInAppDefault: '用預設應用程式開啟',
   openInAppEmpty: '沒有可用於開啟它的應用程式',
   openInAppFailed: '無法開啟：{path}',
diff --git a/src/client/locales-zh-MO.ts b/src/client/locales-zh-MO.ts
index 0bd62ab..33f4284 100644
--- a/src/client/locales-zh-MO.ts
+++ b/src/client/locales-zh-MO.ts
@@ -72,7 +72,29 @@ export const zhMO: Record<string, string> = {
   editorEmptyHint: '從右側檔案樹或上方路徑輸入框選擇檔案開始預覽',
   openFileNewTab: '在新 Tab 中開啟',
   openFileSide: '在側邊開啟',
-  openInApp: '開啟方式',
+  zipDownload: '壓縮並下載',
+  zipDownloadCount: '壓縮並下載（{count} 項）',
+  zipFailed: '壓縮失敗：{message}',
+  openWithMenu: '在應用程式中開啟',
+  openWithSshSuffix: ' (SSH)',
+  pinOpenWith: '固定到選單',
+  unpinOpenWith: '取消固定',
+  openWithExplorer: '檔案總管',
+  openWithVscode: 'VS Code',
+  openWithCursor: 'Cursor',
+  openWithZed: 'Zed',
+  openWithSettingsSshTitle: 'SSH 遠端主機',
+  openWithSettingsSshDesc: '留空為本地工作區；填入 user@host 或 SSH 別名後，VSCode 系開啟方式將改用 vscode-remote/ssh-remote 協議，檔案總管 / Zed / 非 VSCode 系自訂編輯器將從選單隱藏',
+  openWithSettingsSshPlaceholder: 'user@host 或 SSH 別名',
+  openWithSettingsCustomTitle: '自訂編輯器',
+  openWithSettingsCustomDesc: '名稱 + URL 範本（{path} 佔位符）+ 是否 VSCode 系；SSH 模式下僅 VSCode 系可開啟遠端',
+  openWithSettingsAdd: '新增',
+  openWithSettingsName: '名稱',
+  openWithSettingsTemplate: '如 cursor://file/{path}',
+  openWithSettingsFamily: 'VSCode 系',
+  openWithSettingsFamilyDesc: '該編輯器使用 VSCode 的 URL 協議（支援 SSH 遠端開啟）',
+  openWithSettingsRemove: '刪除',
+  openWithSettingsInvalidHint: '名稱或範本（需含 {path} 且以 scheme:// 開頭）未填寫的編輯器不會出現在選單中',
   openInAppDefault: '用預設應用程式開啟',
   openInAppEmpty: '沒有可用於開啟它的應用程式',
   openInAppFailed: '無法開啟：{path}',
diff --git a/src/client/locales-zh-TW.ts b/src/client/locales-zh-TW.ts
index bcf0efa..ce09a7c 100644
--- a/src/client/locales-zh-TW.ts
+++ b/src/client/locales-zh-TW.ts
@@ -72,7 +72,29 @@ export const zhTW: Record<string, string> = {
   editorEmptyHint: '從右側檔案樹或上方路徑輸入框選擇檔案開始預覽',
   openFileNewTab: '在新 Tab 中開啟',
   openFileSide: '在側邊開啟',
-  openInApp: '開啟方式',
+  zipDownload: '壓縮並下載',
+  zipDownloadCount: '壓縮並下載（{count} 項）',
+  zipFailed: '壓縮失敗：{message}',
+  openWithMenu: '在應用程式中開啟',
+  openWithSshSuffix: ' (SSH)',
+  pinOpenWith: '固定到選單',
+  unpinOpenWith: '取消固定',
+  openWithExplorer: '檔案總管',
+  openWithVscode: 'VS Code',
+  openWithCursor: 'Cursor',
+  openWithZed: 'Zed',
+  openWithSettingsSshTitle: 'SSH 遠端主機',
+  openWithSettingsSshDesc: '留空為本地工作區；填入 user@host 或 SSH 別名後，VSCode 系開啟方式將改用 vscode-remote/ssh-remote 協議，檔案總管 / Zed / 非 VSCode 系自訂編輯器將從選單隱藏',
+  openWithSettingsSshPlaceholder: 'user@host 或 SSH 別名',
+  openWithSettingsCustomTitle: '自訂編輯器',
+  openWithSettingsCustomDesc: '名稱 + URL 範本（{path} 佔位符）+ 是否 VSCode 系；SSH 模式下僅 VSCode 系可開啟遠端',
+  openWithSettingsAdd: '新增',
+  openWithSettingsName: '名稱',
+  openWithSettingsTemplate: '如 cursor://file/{path}',
+  openWithSettingsFamily: 'VSCode 系',
+  openWithSettingsFamilyDesc: '該編輯器使用 VSCode 的 URL 協議（支援 SSH 遠端開啟）',
+  openWithSettingsRemove: '刪除',
+  openWithSettingsInvalidHint: '名稱或範本（需含 {path} 且以 scheme:// 開頭）未填寫的編輯器不會出現在選單中',
   openInAppDefault: '用預設應用程式開啟',
   openInAppEmpty: '沒有可用來開啟它的應用程式',
   openInAppFailed: '無法開啟：{path}',
diff --git a/src/client/locales.ts b/src/client/locales.ts
index 56f2f90..9fb2087 100644
--- a/src/client/locales.ts
+++ b/src/client/locales.ts
@@ -69,7 +69,29 @@ export const zh = {
   editorEmptyHint: '从右侧文件树或上方路径输入框选择文件开始预览',
   openFileNewTab: '在新 Tab 中打开',
   openFileSide: '在侧边打开',
-  openInApp: '打开方式',
+  zipDownload: '压缩并下载',
+  zipDownloadCount: '压缩并下载（{count} 项）',
+  zipFailed: '打包失败：{message}',
+  openWithMenu: '在应用中打开',
+  openWithSshSuffix: ' (SSH)',
+  pinOpenWith: '固定到菜单',
+  unpinOpenWith: '取消固定',
+  openWithExplorer: '资源管理器',
+  openWithVscode: 'VS Code',
+  openWithCursor: 'Cursor',
+  openWithZed: 'Zed',
+  openWithSettingsSshTitle: 'SSH 远端主机',
+  openWithSettingsSshDesc: '留空为本地工作区；填入 user@host 或 SSH 别名后，VSCode 系打开方式将改用 vscode-remote/ssh-remote 协议，资源管理器 / Zed / 非 VSCode 系自定义编辑器将从菜单隐藏',
+  openWithSettingsSshPlaceholder: 'user@host 或 SSH 别名',
+  openWithSettingsCustomTitle: '自定义编辑器',
+  openWithSettingsCustomDesc: '名称 + URL 模板（{path} 占位符）+ 是否 VSCode 系；SSH 模式下仅 VSCode 系可打开远端',
+  openWithSettingsAdd: '添加',
+  openWithSettingsName: '名称',
+  openWithSettingsTemplate: '如 cursor://file/{path}',
+  openWithSettingsFamily: 'VSCode 系',
+  openWithSettingsFamilyDesc: '该编辑器使用 VSCode 的 URL 协议（支持 SSH 远端打开）',
+  openWithSettingsRemove: '删除',
+  openWithSettingsInvalidHint: '名称或模板（需含 {path} 且以 scheme:// 开头）未填写的编辑器不会出现在菜单中',
   openInAppDefault: '用默认应用打开',
   openInAppEmpty: '没有可用于打开它的应用',
   openInAppFailed: '无法打开：{path}',
@@ -558,7 +580,29 @@ export const en: Record<keyof typeof zh, string> = {
   editorEmptyHint: 'Pick a file from the tree panel or the path input above to start previewing',
   openFileNewTab: 'Open in New Tab',
   openFileSide: 'Open to the Side',
-  openInApp: 'Open with',
+  zipDownload: 'Zip and download',
+  zipDownloadCount: 'Zip and download ({count} items)',
+  zipFailed: 'Archive failed: {message}',
+  openWithMenu: 'Open with',
+  openWithSshSuffix: ' (SSH)',
+  pinOpenWith: 'Pin to menu',
+  unpinOpenWith: 'Unpin',
+  openWithExplorer: 'File Manager',
+  openWithVscode: 'VS Code',
+  openWithCursor: 'Cursor',
+  openWithZed: 'Zed',
+  openWithSettingsSshTitle: 'SSH remote host',
+  openWithSettingsSshDesc: 'Empty = local workspace; with a user@host or SSH alias, VSCode-family openers switch to the vscode-remote/ssh-remote protocol and the File Manager / Zed / non-VSCode-family custom editors are hidden from the menu',
+  openWithSettingsSshPlaceholder: 'user@host or SSH alias',
+  openWithSettingsCustomTitle: 'Custom editors',
+  openWithSettingsCustomDesc: 'Name + URL template ({path} placeholder) + VSCode-family flag; in remote mode only VSCode-family editors can open a remote path',
+  openWithSettingsAdd: 'Add',
+  openWithSettingsName: 'Name',
+  openWithSettingsTemplate: 'e.g. cursor://file/{path}',
+  openWithSettingsFamily: 'VSCode-family',
+  openWithSettingsFamilyDesc: 'This editor speaks the VSCode URL dialect (supports SSH-remote opens)',
+  openWithSettingsRemove: 'Remove',
+  openWithSettingsInvalidHint: 'Editors with a missing name or a template without {path} / scheme:// are not shown in the menu',
   openInAppDefault: 'Open with default app',
   openInAppEmpty: 'No application can open it',
   openInAppFailed: 'Could not open: {path}',
diff --git a/src/client/menu-flip.ts b/src/client/menu-flip.ts
new file mode 100644
index 0000000..7168fec
--- /dev/null
+++ b/src/client/menu-flip.ts
@@ -0,0 +1,68 @@
+/**
+ * Submenu flip geometry for the portaled context menus.
+ *
+ * The primitives `Menu` clamps its main list into the viewport (portal mode,
+ * 12px margin) but positions nested submenus with pure CSS — `bottom: -4px`
+ * (grow UP from the parent row) and `left: calc(100% + 10px)` (open RIGHT of
+ * the card) — with no viewport clamp at all. This sidebar lives docked on the
+ * RIGHT edge of the window, so both defaults are the worst case here: a tall
+ * "open with" submenu pokes past the viewport top when the row menu opens
+ * near the top, and past the right edge whenever the panel is narrow.
+ *
+ * The host primitive is not ours to patch, so the fix is a body attribute
+ * written while one of OUR submenu-bearing menus is open: layout.css flips
+ * the submenu's growth direction per token. The attribute's lifetime IS the
+ * scope — only our menus set it, and layout.css rules for
+ * `div[role="menu"] div[role="menu"]` only apply while it exists, so
+ * host-owned menus are never touched.
+ */
+
+import { useEffect } from 'react'
+
+/** body attribute carrying the flip tokens (whitespace-separated words). */
+export const SUBMENU_FLIP_ATTR = 'data-dsh-sidebar-submenu'
+
+/**
+ * Mirror of the primitive's submenu geometry (Menu.module.css): card
+ * min-width 218 + card-to-submenu gap 10 + submenu min-width 163..165 +
+ * viewport margin 12 ≈ 400px of right-hand room a right-growing submenu
+ * needs. If the cursor is within that of the right edge, open left instead.
+ * The estimate is conservative (the primitive's own clamp can only move the
+ * card further left), so a wrong guess flips left unnecessarily — never into
+ * a new overflow — and drifting from future host metrics degrades the same
+ * way, back to today's behavior at worst.
+ */
+const SUBMENU_RIGHT_ROOM = 400
+
+/** Below the vertical midpoint the parent row usually has more room above. */
+function isUpperHalf(y: number, vh: number): boolean {
+  return y < vh / 2
+}
+
+/**
+ * The flip tokens for a menu opened at viewport coordinates (x, y):
+ * `down` — open the submenu downward from the parent row (cursor in the
+ * upper half; the sidebar's tab strip is always up there);
+ * `left` — open the submenu leftward of the card (not enough right-hand
+ * room). Empty string when the primitive's defaults already fit.
+ */
+export function submenuFlipTokens(x: number, y: number, vw: number, vh: number): string {
+  const tokens: string[] = []
+  if (isUpperHalf(y, vh)) tokens.push('down')
+  if (x + SUBMENU_RIGHT_ROOM > vw) tokens.push('left')
+  return tokens.join(' ')
+}
+
+/**
+ * Publish the flip tokens on <body> while the given cursor-anchored menu
+ * state is open; clear them on close and on unmount (a menu left open by an
+ * unmounting panel must not leave stale geometry on the shared body).
+ * `menu` only needs the viewport coordinates the Menu anchored to.
+ */
+export function useSubmenuFlip(menu: { x: number; y: number } | null): void {
+  useEffect(() => {
+    if (menu === null) return
+    document.body.setAttribute(SUBMENU_FLIP_ATTR, submenuFlipTokens(menu.x, menu.y, window.innerWidth, window.innerHeight))
+    return () => { document.body.removeAttribute(SUBMENU_FLIP_ATTR) }
+  }, [menu])
+}
diff --git a/src/client/open-with-settings.tsx b/src/client/open-with-settings.tsx
new file mode 100644
index 0000000..ee9604a
--- /dev/null
+++ b/src/client/open-with-settings.tsx
@@ -0,0 +1,135 @@
+/**
+ * The editor tab's custom settings panel ("打开方式"): the file tree's
+ * "open with" configuration — the optional SSH host marking the workspace as
+ * remote, and the user-defined editors (name + URL template with `{path}` +
+ * whether they speak the VSCode URL dialect). Persisted as the editor
+ * blob's `openWith` key through the settings popup's `updatePluginSetting`.
+ *
+ * The popup renders the declarative rows (the editorExplorer picker) ABOVE
+ * this panel — SettingsBody renders the custom panel after the row list, so
+ * this component owns only its own section.
+ */
+import { useState } from 'react'
+import { IconCloseOutlineRegular } from '@deepseek-ai/dsh-client-ui-primitives'
+import {
+  isValidCustomEditor,
+  newCustomEditorId,
+  parseOpenWithConfig,
+  type CustomEditor,
+  type OpenWithConfig,
+} from './open-with.ts'
+import { t } from './locales.ts'
+import css from './SideCardSection.module.css'
+
+export function OpenWithSettings(props: {
+  pluginSettings: Record<string, unknown>
+  updatePluginSetting: (key: string, value: unknown) => void
+}) {
+  const { pluginSettings, updatePluginSetting } = props
+  // Local draft seeded from the persisted blob (each commit re-renders the
+  // popup with the round-tripped prefs; the local state stays authoritative
+  // while the popup is open, so typing never fights an in-flight write).
+  const [draft, setDraft] = useState<OpenWithConfig>(() => parseOpenWithConfig(pluginSettings.openWith))
+
+  const commit = (next: OpenWithConfig): void => {
+    setDraft(next)
+    updatePluginSetting('openWith', next)
+  }
+
+  const setSshHost = (sshHost: string): void => commit({ ...draft, sshHost })
+
+  const patchCustom = (id: string, patch: Partial<CustomEditor>): void => {
+    commit({
+      ...draft,
+      customEditors: draft.customEditors.map(editor => editor.id === id ? { ...editor, ...patch } : editor),
+    })
+  }
+
+  const removeCustom = (id: string): void => {
+    commit({
+      ...draft,
+      customEditors: draft.customEditors.filter(editor => editor.id !== id),
+      // A removed editor can never stay pinned (the menu prunes unknown ids
+      // anyway; this keeps the blob clean).
+      pinned: draft.pinned.filter(pinnedId => pinnedId !== `custom:${id}`),
+    })
+  }
+
+  const addCustom = (): void => {
+    commit({
+      ...draft,
+      customEditors: [...draft.customEditors, { id: newCustomEditorId(), name: '', urlTemplate: '', isVscodeFamily: false }],
+    })
+  }
+
+  const hasInvalid = draft.customEditors.some(editor => !isValidCustomEditor(editor))
+
+  return (
+    <div className={css.popupRows}>
+      <div className={css.popupRow}>
+        <span className={css.rowText}>
+          <span className={css.title}>{t('openWithSettingsSshTitle')}</span>
+          <span className={css.desc}>{t('openWithSettingsSshDesc')}</span>
+        </span>
+        <input
+          className={css.typedInput}
+          value={draft.sshHost}
+          placeholder={t('openWithSettingsSshPlaceholder')}
+          spellCheck={false}
+          onChange={(event) => { setSshHost(event.target.value) }}
+        />
+      </div>
+      <div className={css.popupRow}>
+        <span className={css.rowText}>
+          <span className={css.title}>{t('openWithSettingsCustomTitle')}</span>
+          <span className={css.desc}>{t('openWithSettingsCustomDesc')}</span>
+        </span>
+        <span className={css.control}>
+          <button type="button" className={css.done} onClick={addCustom}>
+            {t('openWithSettingsAdd')}
+          </button>
+        </span>
+      </div>
+      {draft.customEditors.map(editor => (
+        <div key={editor.id} className={css.openWithEditorRow}>
+          <input
+            className={css.openWithEditorInput}
+            value={editor.name}
+            placeholder={t('openWithSettingsName')}
+            spellCheck={false}
+            onChange={(event) => { patchCustom(editor.id, { name: event.target.value }) }}
+          />
+          <input
+            className={css.openWithEditorTemplate}
+            value={editor.urlTemplate}
+            placeholder={t('openWithSettingsTemplate')}
+            spellCheck={false}
+            onChange={(event) => { patchCustom(editor.id, { urlTemplate: event.target.value }) }}
+          />
+          <label className={css.openWithFamily} title={t('openWithSettingsFamilyDesc')}>
+            <input
+              type="checkbox"
+              checked={editor.isVscodeFamily}
+              onChange={(event) => { patchCustom(editor.id, { isVscodeFamily: event.currentTarget.checked }) }}
+            />
+            <span>{t('openWithSettingsFamily')}</span>
+          </label>
+          <button
+            type="button"
+            className={css.openWithRemove}
+            aria-label={t('openWithSettingsRemove')}
+            title={t('openWithSettingsRemove')}
+            onClick={() => { removeCustom(editor.id) }}
+          >
+            <IconCloseOutlineRegular size={14} />
+          </button>
+        </div>
+      ))}
+      {hasInvalid && (
+        <div className={css.openWithHint} role="note">
+          {t('openWithSettingsInvalidHint')}
+        </div>
+      )}
+    </div>
+  )
+}
diff --git a/src/client/open-with.ts b/src/client/open-with.ts
new file mode 100644
index 0000000..b255630
--- /dev/null
+++ b/src/client/open-with.ts
@@ -0,0 +1,221 @@
+/**
+ * The file tree's "open with" vocabulary: which external editors / file
+ * managers the context menu can hand a row's path to, how the per-user
+ * configuration (custom editors, SSH host, pinned ids) is parsed out of the
+ * persisted blob, and how the external URL is built (local `file` URLs and
+ * VSCode-family SSH-remote URLs).
+ *
+ * Pure by design (no React / no `api`), so the whole surface is unit-testable
+ * without a DOM or a host route. The menu and the settings panel only consume
+ * the exported types and functions.
+ */
+import type { CopyKey } from './locales.ts'
+
+/** One user-configured editor (persisted in `pluginSettings['editor'].openWith`). */
+export interface CustomEditor {
+  id: string
+  /** Human label shown in the menu (e.g. "Windsurf"). */
+  name: string
+  /** URL template with a `{path}` placeholder (e.g. `cursor://file/{path}`). */
+  urlTemplate: string
+  /** Whether the editor speaks the VSCode URL dialect — the only editors
+   *  with an SSH-remote form (`<scheme>://vscode-remote/ssh-remote+<host>/…`). */
+  isVscodeFamily: boolean
+}
+
+/** The per-user "open with" configuration (one key of the editor blob). */
+export interface OpenWithConfig {
+  /** SSH host (user@host or an ~/.ssh/config alias); '' = local workspace. */
+  sshHost: string
+  /** User-defined editors, appended after the built-ins. */
+  customEditors: CustomEditor[]
+  /** Ids of open-with targets pinned to the menu's top level
+   *  ('explorer' | 'vscode' | 'cursor' | 'zed' | 'custom:<id>'). */
+  pinned: string[]
+}
+
+/** One menu-visible open target (built-in or custom, SSH-filtered). */
+export interface OpenWithTarget {
+  /** Stable id (`explorer` / `vscode` / `cursor` / `zed` / `custom:<id>`). */
+  id: string
+  /** Locale key of a built-in label (custom editors carry `name` instead). */
+  nameKey?: CopyKey
+  /** User-defined label (custom editors only; '' for built-ins). */
+  name: string
+  /** 'reveal' = show in the OS file manager; 'url' = open a URL. */
+  kind: 'reveal' | 'url'
+  /** URL template with `{path}`; undefined for reveal targets. */
+  urlTemplate?: string
+  /** Whether the editor talks the VSCode URL dialect. */
+  isVscodeFamily: boolean
+  /** Hidden in SSH mode (a host-local opener cannot reach a remote path). */
+  localOnly: boolean
+}
+
+/** The default open-with configuration (fresh documents). */
+export const OPEN_WITH_DEFAULTS: OpenWithConfig = {
+  sshHost: '',
+  customEditors: [],
+  pinned: [],
+}
+
+/** The built-in open targets, in menu order. */
+export const OPEN_WITH_BUILTINS: readonly OpenWithTarget[] = [
+  {
+    id: 'explorer',
+    nameKey: 'openWithExplorer',
+    name: '',
+    kind: 'reveal',
+    isVscodeFamily: false,
+    localOnly: true,
+  },
+  {
+    id: 'vscode',
+    nameKey: 'openWithVscode',
+    name: '',
+    kind: 'url',
+    urlTemplate: 'vscode://file/{path}',
+    isVscodeFamily: true,
+    localOnly: false,
+  },
+  {
+    id: 'cursor',
+    nameKey: 'openWithCursor',
+    name: '',
+    kind: 'url',
+    urlTemplate: 'cursor://file/{path}',
+    isVscodeFamily: true,
+    localOnly: false,
+  },
+  {
+    id: 'zed',
+    nameKey: 'openWithZed',
+    name: '',
+    kind: 'url',
+    urlTemplate: 'zed://file/{path}',
+    isVscodeFamily: false,
+    localOnly: true,
+  },
+]
+
+/** Whether a persisted value makes a structurally valid custom-editor row.
+ *  Name/template may be empty — the settings panel edits rows in place and
+ *  an in-progress row must survive the round-trip; the MENU hides rows that
+ *  fail the stricter {@link isValidCustomEditor} check. */
+function isCustomEditor(value: unknown): value is CustomEditor {
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) return false
+  const record = value as Record<string, unknown>
+  return typeof record.id === 'string' && record.id !== ''
+    && typeof record.name === 'string'
+    && typeof record.urlTemplate === 'string'
+    && typeof record.isVscodeFamily === 'boolean'
+}
+
+/**
+ * Parse the persisted `openWith` blob (tolerant): malformed fields fall back
+ * to the defaults, malformed custom-editor rows are dropped, and pinned ids
+ * are kept verbatim (unknown ids are pruned when the targets are resolved —
+ * the menu is the only consumer of the resolved list).
+ */
+export function parseOpenWithConfig(raw: unknown): OpenWithConfig {
+  if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) return { ...OPEN_WITH_DEFAULTS }
+  const record = raw as Record<string, unknown>
+  const sshHost = typeof record.sshHost === 'string' ? record.sshHost : ''
+  const customEditors = Array.isArray(record.customEditors)
+    ? record.customEditors.filter(isCustomEditor)
+    : []
+  const pinned = Array.isArray(record.pinned)
+    ? record.pinned.filter((id): id is string => typeof id === 'string' && id !== '')
+    : []
+  return { sshHost, customEditors, pinned }
+}
+
+/** Whether a custom editor id belongs to this config (id prefix match). */
+function customIdOf(id: string): string {
+  return `custom:${id}`
+}
+
+/**
+ * The menu-visible open targets, in order (built-ins then custom editors).
+ * In SSH mode the local-only targets (the OS file manager, Zed, custom
+ * editors without the VSCode dialect) are dropped — they cannot reach a
+ * remote path. Unknown pinned ids are pruned here too.
+ */
+export function resolveOpenWithTargets(config: OpenWithConfig): OpenWithTarget[] {
+  const ssh = config.sshHost.trim() !== ''
+  const targets: OpenWithTarget[] = [
+    ...OPEN_WITH_BUILTINS,
+    ...config.customEditors
+      .filter(isValidCustomEditor)
+      .map((editor): OpenWithTarget => ({
+        id: customIdOf(editor.id),
+        name: editor.name,
+        kind: 'url',
+        urlTemplate: editor.urlTemplate,
+        isVscodeFamily: editor.isVscodeFamily,
+        localOnly: !editor.isVscodeFamily,
+      })),
+  ]
+  return targets.filter(target => !(ssh && target.localOnly))
+}
+
+/** The SSH hint appended to a target's label in remote mode. */
+export function openWithSshActive(config: OpenWithConfig): boolean {
+  return config.sshHost.trim() !== ''
+}
+
+/**
+ * The URL to open for one resolved target, or undefined when the target has
+ * no URL form (reveal) or the template is malformed. The path is inserted
+ * RAW into the template (browsers percent-encode as needed; VSCode-family
+ * URL parsers consume the absolute path with its leading slash, e.g.
+ * `vscode://file//home/u/f.ts` or `vscode://file/C:/Users/u/f.ts`).
+ */
+export function openWithUrl(target: OpenWithTarget, path: string, config: OpenWithConfig): string | undefined {
+  if (target.kind !== 'url' || target.urlTemplate === undefined) return undefined
+  const normalized = normalizeUrlPath(path)
+  const ssh = openWithSshActive(config)
+  if (ssh && target.isVscodeFamily) {
+    const scheme = schemeOf(target.urlTemplate)
+    if (scheme === undefined) return undefined
+    // `ssh-remote+<host>` owns NO slash of its own: the path keeps its
+    // leading slash, so `/home/u/f.ts` lands as `…+host/home/u/f.ts`.
+    return `${scheme}://vscode-remote/ssh-remote+${config.sshHost.trim()}${normalized}`
+  }
+  if (!target.urlTemplate.includes('{path}') || !hasUrlScheme(target.urlTemplate)) return undefined
+  return target.urlTemplate.replace('{path}', normalized)
+}
+
+/** Whether a template starts with a `scheme://` prefix (the only shape the
+ *  host's external opener accepts and the settings panel suggests). */
+function hasUrlScheme(template: string): boolean {
+  return /^[a-z][a-z0-9+.-]*:\/\//i.test(template)
+}
+
+/** The scheme of a URL template (the part before the first ':'), or undefined. */
+function schemeOf(template: string): string | undefined {
+  const at = template.indexOf(':')
+  if (at <= 0) return undefined
+  const scheme = template.slice(0, at)
+  return /^[a-z][a-z0-9+.-]*$/i.test(scheme) ? scheme : undefined
+}
+
+/** Normalize a filesystem path for embedding in a URL (backslashes → '/'). */
+export function normalizeUrlPath(path: string): string {
+  return path.replace(/\\/g, '/')
+}
+
+/** A fresh custom-editor id (uuid when available, time-based fallback). */
+export function newCustomEditorId(): string {
+  if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+    return crypto.randomUUID()
+  }
+  return `${Date.now().toString(36)}${Math.random().toString(36).slice(2)}`
+}
+
+/** Validate one custom-editor row before the settings panel accepts it. */
+export function isValidCustomEditor(row: { name: string; urlTemplate: string }): boolean {
+  return row.name.trim() !== ''
+    && row.urlTemplate.includes('{path}')
+    && /^[a-z][a-z0-9+.-]*:\/\//i.test(row.urlTemplate.trim())
+}
diff --git a/src/client/plugin-settings.ts b/src/client/plugin-settings.ts
new file mode 100644
index 0000000..db6658f
--- /dev/null
+++ b/src/client/plugin-settings.ts
@@ -0,0 +1,43 @@
+/**
+ * Pending-writes queue for the file tree's open-with config: pin toggles and
+ * (outside the settings popup) config edits land in the sidebar prefs as
+ * `pluginSettings['editor']`. Writes are serialized through one promise chain
+ * so a quick burst of pin clicks can never read a stale pluginSettings map
+ * and drop an earlier toggle; each write pushes the whole open map patch
+ * through the revision-free settings route and adopts the returned document.
+ *
+ * (The settings popup has its own serialized commit — SideCardSection's —
+ * so its rows and this helper rarely race; the shared route's last-write-wins
+ * semantics cover the uncommon overlap.)
+ */
+import { api } from './api.ts'
+import { parsePrefs } from './prefs.ts'
+import type { SidebarStore } from './state.ts'
+
+let queue: Promise<void> = Promise.resolve()
+
+/**
+ * Merge one plugin-owned settings blob of one descriptor and persist it.
+ * @param store - the sidebar store (its prefs are replaced by the write result).
+ * @param descriptorId - the descriptor whose blob is patched ('editor' here).
+ * @param updater - pure patch function; receives a shallow copy of the blob.
+ */
+export function updatePluginSettings(
+  store: SidebarStore,
+  descriptorId: string,
+  updater: (blob: Record<string, unknown>) => Record<string, unknown>,
+): void {
+  queue = queue.then(async () => {
+    const prefs = store.getPrefs()
+    const blob = prefs.pluginSettings[descriptorId] ?? {}
+    const next = updater({ ...blob })
+    const view = await api.settingsUpdate({
+      pluginSettings: { ...prefs.pluginSettings, [descriptorId]: next },
+    })
+    store.setPrefs(parsePrefs(view.value))
+  }).catch((error: unknown) => {
+    // The pin stays visually unchanged (no optimistic flip) and the menu
+    // keeps working — the write failure is logged, not surfaced.
+    console.error('open-with settings write failed', error)
+  })
+}
diff --git a/src/client/sidebar.module.css b/src/client/sidebar.module.css
index 5a17ce4..529dd40 100644
--- a/src/client/sidebar.module.css
+++ b/src/client/sidebar.module.css
@@ -2108,6 +2108,59 @@ body[data-dsh-sidebar-dragging] .bottomPanel {
   }
 }
 
+/* The file tree's plugin "open with" menu rows: the label area is a
+   BLOCK-level flex row that fills the primitives `.itemLabel` span (which is
+   itself `flex: 1` inside the row), so the trailing control — the pushpin on
+   submenu rows, the chevron on the submenu parent — docks at the row's far
+   right, exactly like the trailing check on selected rows of every other
+   menu. */
+.openWithLabel {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  width: 100%;
+  min-width: 0;
+}
+
+.openWithName {
+  flex: 1 1 auto;
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+/* The trailing "expands into a submenu" chevron on the open-with parent row
+   (the primitives Menu renders no arrow for submenu parents). */
+.openWithChevron {
+  flex: none;
+  color: var(--dsw-alias-label-tertiary);
+}
+
+/* The pushpin toggle on an "open with" submenu row: brand ink once the
+   target is pinned to the menu's top level. Sized for the compact menu's
+   26px rows (16px box, 12px glyph) — proportionate without overflowing. */
+.openWithPin {
+  flex: none;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 16px;
+  height: 16px;
+  border-radius: 5px;
+  color: var(--dsw-alias-label-tertiary);
+  cursor: pointer;
+}
+
+.openWithPin:hover {
+  background: var(--dsw-alias-interactive-bg-hover);
+  color: var(--dsw-alias-label-primary);
+}
+
+.openWithPinActive {
+  color: var(--dsw-alias-state-business-primary);
+}
+
 /* ── Markdown preview: raw-HTML runs + table of contents ─────────────────
    The HTML runs lifted out of the markdown source (MarkdownHtml.tsx) render
    as sanitized block leaves; the TOC is a zero-height sticky bar keeping the
diff --git a/src/index.ts b/src/index.ts
index 1e97343..6548e9c 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -37,6 +37,9 @@ import { decodeHtmlUrl } from './html-route.ts'
 import { isTrustedApiRequest } from './trust-fence.ts'
 import { registerBundleRoute } from './bundle-route.ts'
 import { createDirectoryWatchers, type DirectoryWatchers } from './fs-watch.ts'
+import { launchExternal } from './open-external.ts'
+import { archiveNameOf, collectZipEntries } from './archive-route.ts'
+import { buildZip, type ZipEntry } from './zip.ts'
 import * as git from './git.ts'
 import { SettingsConflictError } from '@deepseek-ai/dsh-settings'
 import { AgentOpenRegistry, registerOpenTool, type AgentOpenRequest } from './agent-opens.ts'
@@ -65,6 +68,10 @@ export type {
   FileViewerProps,
   FileFetchStrategy,
 } from './client/service.ts'
+// The archive walk + name sanitizer are exercised directly by tests/zip.spec.ts:
+// their bounds live inside the collector, so the suite needs them observable
+// without creating 10 000 rows first.
+export { archiveNameOf, collectZipEntries } from './archive-route.ts'
 
 /** Plugin identity for cordis.yml rows. */
 export const name = 'dsh-better-sidebar'
@@ -529,6 +536,19 @@ function buildApi(
         throw new SidebarError('settings-rejected', error instanceof Error ? error.message : String(error), 400)
       }
     },
+    // External open for the file tree's "open with" menu: reveal a path in
+    // the OS file manager, or hand a custom-scheme URL (vscode://,
+    // cursor://, zed://, custom editors) to its registered handler. The
+    // client is a browser renderer where raw scheme navigation is
+    // unreliable, so the launch always goes through the host — the same
+    // fence as every other route, argv-only (no shell interpolation).
+    'open.external': (payload) => {
+      const record = payload as { action?: unknown } | null
+      const action = record?.action
+      if (action === 'reveal') return launchExternal('reveal', requireString(payload, 'path'))
+      if (action === 'url') return launchExternal('url', requireString(payload, 'url'))
+      throw new SidebarError('bad-request', 'action must be "reveal" or "url"')
+    },
     // Side Chat: create a side-thread child seeded with the parent's full
     // log up to now, deliver follow-ups (cold-resuming when the thread's
     // agent is gone), abort a running thread, and release a thread's agent.
@@ -897,6 +917,53 @@ export function apply(ctx: Context, config?: SidebarConfig): void {
   // (see bundle-route.ts / src/client/chunk-loader.ts).
   ctx.effect(() => registerBundleRoute(ctx, fence), 'dsh-better-sidebar: /sidebar/bundle chunk route')
 
+  // ── Archive route (zip one selection and download it) ───────────────────
+  // The file tree's "zip and download" action: every `path` is resolved
+  // through the SAME workspace fence as fs.tree / /sidebar/file, directories
+  // are walked recursively (a symlink is recorded as a link, never followed —
+  // no escape and no cycle), and the whole archive is built in memory and
+  // answered in one response. The entry-count/byte bounds live in zip.ts.
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/sidebar/archive',
+    handler: async (req, res) => {
+      if (!fence(req)) {
+        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'forbidden' } })
+        return
+      }
+      if (req.method !== 'GET') {
+        writeJson(res, 405, { ok: false, error: { code: 'method-error', message: 'method not allowed' } })
+        return
+      }
+      try {
+        const url = new URL(req.url ?? '/', 'http://dsh.internal')
+        const sessionId = url.searchParams.get('sessionId')
+        const paths = url.searchParams.getAll('path').filter(value => value !== '')
+        if (sessionId === null || paths.length === 0) {
+          throw new SidebarError('bad-request', 'sessionId and at least one path are required')
+        }
+        const name = archiveNameOf(url.searchParams.get('name'))
+        const cwd = await sessionCwdOf(ctx, sessionId, url.searchParams.get('cwd') ?? undefined)
+        const fenceOn = fenceEnabledOf(() => settingsFace)
+        const entries: ZipEntry[] = []
+        for (const raw of paths) {
+          const absolute = await ensureWorkspacePath(cwd, raw, fenceOn)
+          await collectZipEntries(absolute, basename(absolute), entries)
+        }
+        const body = await buildZip(entries)
+        res.writeHead(200, {
+          'content-type': 'application/zip',
+          'content-disposition': `attachment; filename="${name}"`,
+          'content-length': String(body.byteLength),
+          'cache-control': 'no-cache',
+        })
+        res.end(body)
+      } catch (error) {
+        writeError(res, error)
+      }
+    },
+  }), 'dsh-better-sidebar: /sidebar/archive route')
+
   // ── Media route (images for the editor) ─────────────────────────────────
   ctx.effect(() => ctx.webServer.register({
     kind: 'prefix',
@@ -939,6 +1006,7 @@ export function apply(ctx: Context, config?: SidebarConfig): void {
     },
   }), 'dsh-better-sidebar: /sidebar/file media route')
 
+
   // ── HTML preview route (sandboxed HTML + its relative assets) ───────────
   // Serves files under the session cwd for the built-in HTML previewer. The
   // URL is path-encoded (see html-route.ts) so the previewed page's relative
diff --git a/src/open-external.ts b/src/open-external.ts
new file mode 100644
index 0000000..6a1ef67
--- /dev/null
+++ b/src/open-external.ts
@@ -0,0 +1,89 @@
+/**
+ * External open actions for the file tree's "open with" menu: hand a path to
+ * the OS file manager (reveal/select) or launch a URL scheme's registered
+ * handler (vscode://, cursor://, zed://, custom schemes).
+ *
+ * The client runs in a browser / DSH Desktop renderer where a raw `vscode://`
+ * navigation is unreliable, so both actions fan out through this host route
+ * and spawn the platform opener with an argv array (no shell interpolation).
+ * The command builders are pure — the platform is injectable — so every
+ * per-platform branch is unit-testable without spawning anything.
+ */
+import { spawn } from 'node:child_process'
+import { parentOf, requireAbsolute } from './fs-tree.ts'
+import { SidebarError } from './wire.ts'
+
+/** The two external open actions the route accepts. */
+export type OpenExternalAction = 'reveal' | 'url'
+
+/** One platform opener invocation (argv array — never a shell string). */
+export interface ExternalCommand {
+  command: string
+  args: string[]
+}
+
+/** Reveal/select a path in the OS file manager. On Linux there is no common
+ *  select protocol — the containing directory is opened instead (KISS). */
+export function revealCommand(path: string, platform: NodeJS.Platform = process.platform): ExternalCommand {
+  switch (platform) {
+    case 'darwin':
+      return { command: 'open', args: ['-R', path] }
+    // Explorer expects `/select,<path>` as one argument. Keep the spawn
+    // shell-free: a command shell would reinterpret valid path characters.
+    case 'win32':
+      return { command: 'explorer.exe', args: [`/select,${path}`] }
+    default: {
+      const parent = parentOf(path)
+      return { command: 'xdg-open', args: [parent ?? path] }
+    }
+  }
+}
+
+/** Hand a custom-scheme URL to the OS protocol handler. */
+export function urlCommand(url: string, platform: NodeJS.Platform = process.platform): ExternalCommand {
+  switch (platform) {
+    case 'darwin':
+      return { command: 'open', args: [url] }
+    // url.dll,FileProtocolHandler launches the registered protocol handler;
+    // `cmd /c start "" <url>` is the fallback if rundll32 misbehaves.
+    case 'win32':
+      return { command: 'rundll32.exe', args: ['url.dll,FileProtocolHandler', url] }
+    default:
+      return { command: 'xdg-open', args: [url] }
+  }
+}
+
+/** Validate a URL-scheme open target: a parseable custom-scheme URL (never
+ *  http/https — those would only dump the URL into a browser tab). */
+export function validateExternalUrl(raw: string): string {
+  if (!/^[a-z][a-z0-9+.-]*:\/\//i.test(raw)) {
+    throw new SidebarError('bad-request', 'url must be a custom-scheme URL')
+  }
+  let url: URL
+  try {
+    url = new URL(raw)
+  } catch {
+    throw new SidebarError('bad-request', 'invalid url')
+  }
+  if (url.protocol === 'http:' || url.protocol === 'https:') {
+    throw new SidebarError('bad-request', 'only custom-scheme urls can be opened externally')
+  }
+  return raw
+}
+
+/**
+ * Launch one external open action and return immediately (detached, no
+ * stdio). Spawn failures are reported through the child's 'error' event —
+ * by then the route already returned, so the event is swallowed (the OS
+ * dialog about a missing handler is the user-visible outcome either way).
+ */
+export function launchExternal(action: OpenExternalAction, value: string): { started: true } {
+  const platform = process.platform
+  const spec = action === 'reveal'
+    ? revealCommand(requireAbsolute(value), platform)
+    : urlCommand(validateExternalUrl(value), platform)
+  const child = spawn(spec.command, spec.args, { detached: true, stdio: 'ignore' })
+  child.on('error', () => { /* opener missing/denied: handled by the OS */ })
+  child.unref()
+  return { started: true }
+}
diff --git a/src/zip.ts b/src/zip.ts
new file mode 100644
index 0000000..fcbc522
--- /dev/null
+++ b/src/zip.ts
@@ -0,0 +1,248 @@
+/**
+ * Archive builder for the file tree's "zip and download" action.
+ *
+ * One self-contained ZIP writer: local file headers + central directory +
+ * EOCD, CRC-32 computed locally, `store` (method 0) or `zlib`'s raw DEFLATE
+ * (method 8) picked per entry by whichever is smaller, names written as
+ * UTF-8 (general-purpose bit 11) and DOS timestamps taken from one `Date`
+ * for the whole archive. No third-party dependency, no filesystem walking —
+ * the caller supplies the entries, this module only reads their bytes.
+ *
+ * The entries are bounded by `maxEntries` / `maxBytes` before anything is
+ * read, so a runaway selection fails with a clear error instead of filling
+ * memory with an archive nobody asked for.
+ */
+import { readFile } from 'node:fs/promises'
+import { deflateRaw } from 'node:zlib'
+import { promisify } from 'node:util'
+import { SidebarError } from './wire.ts'
+
+/** One archive member: a file to read, or a directory to record. */
+export interface ZipEntry {
+  /** Absolute filesystem path (source of the bytes). Ignored for a directory
+   *  entry (`isDir: true`), which only contributes its own header row. */
+  path: string
+  /** In-archive name: '/'-separated and relative. A directory name must end
+   *  with '/'. */
+  name: string
+  /** Write a directory entry (zero-length name + trailing '/') instead of
+   *  reading the path as a file. */
+  isDir?: boolean
+}
+
+/** The archive bounds. */
+export interface ZipOptions {
+  /** Total uncompressed byte bound; exceeding it throws fs-error. */
+  maxBytes?: number
+  /** Entry-count bound (directory entries included); exceeding it throws
+   *  fs-error. */
+  maxEntries?: number
+}
+
+/** Default total uncompressed payload bound of one archive (256 MiB). */
+export const ZIP_MAX_BYTES = 256 * 1024 * 1024
+/** Default entry-count bound of one archive. */
+export const ZIP_MAX_ENTRIES = 10_000
+
+/** DOS epoch (1980-01-01) — the smallest representable DOS timestamp. */
+const DOS_YEAR_BASE = 1980
+
+/** CRC-32 (IEEE 802.3, the ZIP polynomial), table built once per process. */
+const CRC_TABLE = ((): Uint32Array => {
+  const table = new Uint32Array(256)
+  for (let i = 0; i < 256; i += 1) {
+    let value = i
+    for (let bit = 0; bit < 8; bit += 1) {
+      value = (value & 1) !== 0 ? (0xEDB88320 ^ (value >>> 1)) : (value >>> 1)
+    }
+    table[i] = value >>> 0
+  }
+  return table
+})()
+
+/** CRC-32 of one buffer. */
+export function crc32(data: Uint8Array): number {
+  let crc = 0xFFFFFFFF
+  for (let i = 0; i < data.length; i += 1) {
+    crc = CRC_TABLE[(crc ^ data[i]!) & 0xFF]! ^ (crc >>> 8)
+  }
+  return (crc ^ 0xFFFFFFFF) >>> 0
+}
+
+/** One prepared member: the bytes to store plus their header fields. */
+interface ZipMember {
+  name: Buffer
+  data: Buffer
+  crc: number
+  method: 0 | 8
+  /** Uncompressed size (the local/central header field). */
+  size: number
+}
+
+const deflateRawAsync = promisify(deflateRaw)
+
+/** DOS date + time words for one instant (clamped to the 1980 epoch). */
+function dosDateTime(date: Date): { time: number; date: number } {
+  const year = Math.max(date.getFullYear(), DOS_YEAR_BASE)
+  const month = date.getMonth() + 1
+  const day = date.getDate()
+  const hours = date.getHours()
+  const minutes = date.getMinutes()
+  const seconds = date.getSeconds()
+  return {
+    time: (hours << 11) | (minutes << 5) | (seconds >> 1),
+    date: ((year - DOS_YEAR_BASE) << 9) | (month << 5) | day,
+  }
+}
+
+/** Normalize an entry name to a '/'-separated relative archive path. */
+function archiveName(raw: string, isDir: boolean): string {
+  const normalized = raw.replace(/\\/g, '/').replace(/^\/+/, '')
+  const segments = normalized.split('/').filter(segment => segment !== '' && segment !== '.')
+  if (segments.length === 0 || segments.includes('..')) {
+    throw new SidebarError('bad-request', `invalid archive entry name "${raw}"`)
+  }
+  const name = segments.join('/')
+  return isDir ? `${name}/` : name
+}
+
+/** The absolute filesystem path shape the builder accepts. */
+function requireSourcePath(raw: string): string {
+  if (raw === '' || raw.includes('\0')) {
+    throw new SidebarError('bad-request', 'archive entry path is required')
+  }
+  return raw
+}
+
+/** Read + compress one member (deflate only when it actually shrinks). */
+async function prepareFile(name: string, path: string): Promise<ZipMember> {
+  let data: Buffer
+  try {
+    data = await readFile(path)
+  } catch (error) {
+    throw new SidebarError('fs-error', `cannot read "${path}": ${error instanceof Error ? error.message : String(error)}`, 400)
+  }
+  const crc = crc32(data)
+  const deflated = await deflateRawAsync(data)
+  const useDeflate = deflated.byteLength < data.byteLength
+  return {
+    name: Buffer.from(name, 'utf8'),
+    data: useDeflate ? deflated : data,
+    crc,
+    method: useDeflate ? 8 : 0,
+    size: data.byteLength,
+  }
+}
+
+/** One directory member (zero payload, name already carries the '/'). */
+function directoryMember(name: string): ZipMember {
+  return { name: Buffer.from(name, 'utf8'), data: Buffer.alloc(0), crc: 0, method: 0, size: 0 }
+}
+
+/** Write one local file header + payload into `out`. */
+function writeLocalHeader(out: Buffer[], member: ZipMember, time: number, date: number): void {
+  const header = Buffer.alloc(30)
+  header.writeUInt32LE(0x04034B50, 0)
+  header.writeUInt16LE(20, 4) // version needed: 2.0 (deflate)
+  header.writeUInt16LE(0x0800, 6) // general purpose: UTF-8 names (bit 11)
+  header.writeUInt16LE(member.method, 8)
+  header.writeUInt16LE(time, 10)
+  header.writeUInt16LE(date, 12)
+  header.writeUInt32LE(member.crc, 14)
+  header.writeUInt32LE(member.data.byteLength, 18)
+  header.writeUInt32LE(member.size, 22)
+  header.writeUInt16LE(member.name.byteLength, 26)
+  header.writeUInt16LE(0, 28) // extra length
+  out.push(header, member.name, member.data)
+}
+
+/**
+ * Build one ZIP archive from the given entries.
+ * @param entries - files to read and/or directory rows to record; a directory
+ *  row contributes its own header, its children are separate entries.
+ * @param opts - entry-count and total-byte bounds ({@link ZipOptions}).
+ * @returns the ZIP bytes.
+ * @throws {SidebarError} bad-request for malformed entry names/paths,
+ *  fs-error when an entry cannot be read or a bound is exceeded.
+ */
+export async function buildZip(entries: readonly ZipEntry[], opts: ZipOptions = {}): Promise<Buffer> {
+  const maxEntries = opts.maxEntries ?? ZIP_MAX_ENTRIES
+  const maxBytes = opts.maxBytes ?? ZIP_MAX_BYTES
+  if (entries.length > maxEntries) {
+    throw new SidebarError('fs-error', `too many entries for one archive (${entries.length} > ${maxEntries})`, 400)
+  }
+  const now = new Date()
+  const stamp = dosDateTime(now)
+
+  const members: ZipMember[] = []
+  /** Total uncompressed payload (the bound is checked against it). */
+  let totalBytes = 0
+  for (const entry of entries) {
+    if (entry.isDir === true) {
+      members.push(directoryMember(archiveName(entry.name, true)))
+      continue
+    }
+    const path = requireSourcePath(entry.path)
+    const member = await prepareFile(archiveName(entry.name, false), path)
+    // The bound is the archive's total UNCOMPRESSED payload: that is what the
+    // reader materializes, and it makes the limit independent of how well the
+    // input happens to compress.
+    totalBytes += member.size
+    if (totalBytes > maxBytes) {
+      throw new SidebarError('fs-error', `archive exceeds the ${maxBytes} byte limit`, 400)
+    }
+    members.push(member)
+  }
+
+  const out: Buffer[] = []
+  const offsets: number[] = []
+  let offset = 0
+  for (const member of members) {
+    offsets.push(offset)
+    writeLocalHeader(out, member, stamp.time, stamp.date)
+    offset += 30 + member.name.byteLength + member.data.byteLength
+  }
+
+  const directoryStart = offset
+  members.forEach((member, index) => {
+    const isDir = member.name.toString('utf8').endsWith('/')
+    const header = Buffer.alloc(46)
+    header.writeUInt32LE(0x02014B50, 0)
+    header.writeUInt16LE(0x031E, 4) // version made by: 3.0 / Unix
+    header.writeUInt16LE(20, 6) // version needed: 2.0
+    header.writeUInt16LE(0x0800, 8) // general purpose: UTF-8 names (bit 11)
+    header.writeUInt16LE(member.method, 10)
+    header.writeUInt16LE(stamp.time, 12)
+    header.writeUInt16LE(stamp.date, 14)
+    header.writeUInt32LE(member.crc, 16)
+    header.writeUInt32LE(member.data.byteLength, 20)
+    header.writeUInt32LE(member.size, 24)
+    header.writeUInt16LE(member.name.byteLength, 28)
+    header.writeUInt16LE(0, 30) // extra length
+    header.writeUInt16LE(0, 32) // comment length
+    header.writeUInt16LE(0, 34) // disk number
+    header.writeUInt16LE(0, 36) // internal attributes
+    // "version made by" says Unix, so the high word is the Unix mode and the
+    // low word carries the MS-DOS attributes. Both halves matter: without the
+    // mode, Info-ZIP extracts every file as mode 000 (unreadable). The mode is
+    // scaled with `* 0x10000` rather than `<< 16`: the shift is a signed int32
+    // operation and `0o100644 << 16` is negative, which writeUInt32LE rejects.
+    const mode = isDir ? 0o40755 : 0o100644
+    header.writeUInt32LE(mode * 0x10000 + (isDir ? 0x10 : 0), 38)
+    header.writeUInt32LE(offsets[index]!, 42)
+    out.push(header, member.name)
+    offset += 46 + member.name.byteLength
+  })
+
+  const eocd = Buffer.alloc(22)
+  eocd.writeUInt32LE(0x06054B50, 0)
+  eocd.writeUInt16LE(0, 4) // this disk
+  eocd.writeUInt16LE(0, 6) // disk with the central directory
+  eocd.writeUInt16LE(members.length, 8)
+  eocd.writeUInt16LE(members.length, 10)
+  eocd.writeUInt32LE(offset - directoryStart, 12)
+  eocd.writeUInt32LE(directoryStart, 16)
+  eocd.writeUInt16LE(0, 20) // comment length
+  out.push(eocd)
+  return Buffer.concat(out)
+}
diff --git a/tests/builtins.spec.ts b/tests/builtins.spec.ts
index f489b9b..777aa00 100644
--- a/tests/builtins.spec.ts
+++ b/tests/builtins.spec.ts
@@ -154,9 +154,9 @@ describe('built-in tab registrations', () => {
     // The workspace fence switch rides the same card as a plain boolean row.
     expect(toggles[1]?.title).toBeDefined()
     expect(toggles[1]?.desc).toBeDefined()
-    // External opening is the host's own open-in-app capability now: the
-    // editor card has no custom settings panel left to render.
-    expect(service.getTab('editor')?.settings?.render).toBeUndefined()
+    // The open-with configuration (SSH host + custom editors) is the custom
+    // panel rendered below the declarative rows.
+    expect(service.getTab('editor')?.settings?.render).toBeDefined()
   })
 
   it('every built-in tab carries the settings-surface icon', () => {
diff --git a/tests/changes-ops.spec.ts b/tests/changes-ops.spec.ts
index 2bb6e5f..b8e43bf 100644
--- a/tests/changes-ops.spec.ts
+++ b/tests/changes-ops.spec.ts
@@ -1,13 +1,16 @@
 /**
- * Changes tab session-lens data layer: event-log folding into file
- * operations, plus a sanity pass over the shared diff/highlight engines
- * (their full behavior suites live in the standalone dsh-file-trace plugin).
+ * Changes tab data layer: event-log folding into file operations, the
+ * directory tree the Git lens renders its groups through, and a sanity pass
+ * over the shared diff/highlight engines (their full behavior suites live in
+ * the standalone dsh-file-trace plugin).
  */
 import { describe, expect, it } from 'vitest'
 import { createToolResultMessage, ToolCallId } from '@deepseek-ai/dsh-llm'
 import { extractFileOps, groupByFile, knownContentBefore, parseReadContent, parseReadLines } from '../src/client/changes/ops.ts'
+import { buildChangeTree, type ChangeNode } from '../src/client/changes/change-tree.ts'
 import { diffLines, buildDiffSegments, coalesceInline, diffInline } from '../src/client/diff/rows.ts'
 import { langOfPath, scanLine } from '../src/client/diff/highlight.ts'
+import type { GitStatusEntry } from '../src/client/api.ts'
 import type { SidebarSessionEvent } from '../src/context-types.ts'
 
 /** One synthetic session event. */
@@ -157,6 +160,108 @@ describe('parseReadLines', () => {
   })
 })
 
+describe('change tree (the Git lens reads its groups through it)', () => {
+  /** One `git status` row from a path and its porcelain code. */
+  const entry = (path: string, xy = ' M'): GitStatusEntry => ({ path, xy })
+
+  /** A compact, assertion-friendly projection of one tree. */
+  const shape = (nodes: readonly ChangeNode[]): unknown[] => nodes.map(node => node.kind === 'dir'
+    ? { dir: node.name, path: node.path, changes: node.changes, children: shape(node.children) }
+    : { file: node.name, path: node.path, letter: node.status.letter, tone: node.status.tone })
+
+  it('keeps a single root-level file as one leaf', () => {
+    expect(shape(buildChangeTree([entry('readme.md')]))).toEqual([
+      { file: 'readme.md', path: 'readme.md', letter: 'M', tone: 'modified' },
+    ])
+  })
+
+  it('nests a deep path and compresses its single-child chain into one row', () => {
+    const tree = buildChangeTree([entry('src/client/changes/a.ts')])
+    expect(shape(tree)).toEqual([
+      {
+        dir: 'src/client/changes',
+        path: 'src/client/changes',
+        changes: 1,
+        children: [{ file: 'a.ts', path: 'src/client/changes/a.ts', letter: 'M', tone: 'modified' }],
+      },
+    ])
+  })
+
+  it('stops compressing where the path branches or a directory holds its own file', () => {
+    // Two child directories: 'src' keeps its own row.
+    expect(shape(buildChangeTree([entry('src/a/x.ts'), entry('src/b/y.ts')]))).toEqual([
+      {
+        dir: 'src',
+        path: 'src',
+        changes: 2,
+        children: [
+          { dir: 'a', path: 'src/a', changes: 1, children: [{ file: 'x.ts', path: 'src/a/x.ts', letter: 'M', tone: 'modified' }] },
+          { dir: 'b', path: 'src/b', changes: 1, children: [{ file: 'y.ts', path: 'src/b/y.ts', letter: 'M', tone: 'modified' }] },
+        ],
+      },
+    ])
+    // A file AT this level: 'a' keeps its own row (and its file leads the child).
+    expect(shape(buildChangeTree([entry('a/x.ts'), entry('a/b/y.ts')]))).toEqual([
+      {
+        dir: 'a',
+        path: 'a',
+        changes: 2,
+        children: [
+          { dir: 'b', path: 'a/b', changes: 1, children: [{ file: 'y.ts', path: 'a/b/y.ts', letter: 'M', tone: 'modified' }] },
+          { file: 'x.ts', path: 'a/x.ts', letter: 'M', tone: 'modified' },
+        ],
+      },
+    ])
+  })
+
+  it('orders directories before files, each by name case-insensitively', () => {
+    const tree = buildChangeTree([
+      entry('Zed.ts'), entry('B.ts'), entry('a.ts'), entry('zdir/f.ts'), entry('Adir/f.ts'),
+    ])
+    expect(shape(tree).map(node => (node as { dir?: string; file?: string }).dir ?? (node as { file: string }).file))
+      .toEqual(['Adir', 'zdir', 'a.ts', 'B.ts', 'Zed.ts'])
+  })
+
+  it('mixes root-level files with nested paths and keeps same-named files apart', () => {
+    expect(shape(buildChangeTree([
+      entry('b/index.ts'), entry('index.ts'), entry('a/index.ts'),
+    ]))).toEqual([
+      { dir: 'a', path: 'a', changes: 1, children: [{ file: 'index.ts', path: 'a/index.ts', letter: 'M', tone: 'modified' }] },
+      { dir: 'b', path: 'b', changes: 1, children: [{ file: 'index.ts', path: 'b/index.ts', letter: 'M', tone: 'modified' }] },
+      { file: 'index.ts', path: 'index.ts', letter: 'M', tone: 'modified' },
+    ])
+  })
+
+  it('carries every file porcelain status and counts the files under each row', () => {
+    const tree = buildChangeTree([
+      entry('src/a.ts', ' M'), entry('src/new.ts', '??'), entry('src/gone.ts', ' D'), entry('src/kept.ts', '  '),
+    ])
+    expect(shape(tree)).toEqual([
+      {
+        dir: 'src',
+        path: 'src',
+        changes: 3,
+        children: [
+          { file: 'a.ts', path: 'src/a.ts', letter: 'M', tone: 'modified' },
+          { file: 'gone.ts', path: 'src/gone.ts', letter: 'D', tone: 'deleted' },
+          { file: 'new.ts', path: 'src/new.ts', letter: 'U', tone: 'untracked' },
+        ],
+      },
+    ])
+  })
+
+  it('returns no nodes for an empty or all-clean list', () => {
+    expect(buildChangeTree([])).toEqual([])
+    expect(buildChangeTree([entry('a.ts', '  '), entry('b.ts', '!!')])).toEqual([])
+  })
+
+  it('counts a repeated path once', () => {
+    expect(shape(buildChangeTree([entry('a.ts'), entry('a.ts', '??')]))).toEqual([
+      { file: 'a.ts', path: 'a.ts', letter: 'M', tone: 'modified' },
+    ])
+  })
+})
+
 describe('ported diff/highlight engines (sanity)', () => {
   it('diffLines pairs a rewrite as mod and folds context into hunks', () => {
     const rows = diffLines('hello world', 'hello dsh')
diff --git a/tests/changes-tab.spec.tsx b/tests/changes-tab.spec.tsx
index 45dd711..20a5a3d 100644
--- a/tests/changes-tab.spec.tsx
+++ b/tests/changes-tab.spec.tsx
@@ -106,11 +106,17 @@ describe('ChangesTab', () => {
       mount(root)
       await flushEffects()
 
-      // Git lens: the changed-file row (badge letter + split name/directory).
+      // Git lens: the change reads as a TREE — the directory row owns the
+      // path segment, the file row its own name, its porcelain letter and the
+      // host's file artwork.
+      const dir = container.querySelector<HTMLButtonElement>('button[data-dir="src"]')
+      expect(dir).not.toBeNull()
+      expect(dir!.getAttribute('aria-expanded')).toBe('true')
       const row = container.querySelector<HTMLButtonElement>('button[data-path="src/a.ts"]')
-      expect(row).toBeDefined()
+      expect(row).not.toBeNull()
       expect(row!.textContent).toContain('a.ts')
-      expect(row!.textContent).toContain('src')
+      expect(row!.textContent).toContain('M')
+      expect(row!.querySelector('svg')).not.toBeNull()
 
       // Clicking the row previews inline (no diff tab minted): the shared
       // renderer draws the added row.
diff --git a/tests/file-tree-archive.spec.tsx b/tests/file-tree-archive.spec.tsx
new file mode 100644
index 0000000..1620293
--- /dev/null
+++ b/tests/file-tree-archive.spec.tsx
@@ -0,0 +1,317 @@
+/**
+ * FileTree "zip and download": the context menu offers an archive row for a
+ * multi-selection (≥2 rows) and for a LONE directory (a lone file is skipped —
+ * the plain download row already covers it).
+ *
+ * The row is NOT a bare anchor any more: the bytes are fetched through
+ * `archiveUrl(scope, paths, name)`, because the archive route reports its caps
+ * and refusals as the plugin's JSON error envelope — an anchor would save that
+ * envelope as a broken `.zip`. So these cases pin:
+ *   - the URL parameters (scope / paths / name) and the appearance gates;
+ *   - success: the response body becomes an object URL, saved through a hidden
+ *     `<a download={name}>`, revoked on the next task;
+ *   - failure: a non-2xx JSON envelope (`{error:{message}}`), a non-JSON body
+ *     (`HTTP <status>`) and a network rejection all land in the error strip
+ *     with the `zipFailed` copy;
+ *   - a click while one request is in flight does not package twice.
+ */
+// @vitest-environment jsdom
+import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
+import { createElement } from 'react'
+import { createRoot, type Root } from 'react-dom/client'
+import { act } from 'react-dom/test-utils'
+import { FileTree } from '../src/client/FileTree.tsx'
+import { createSidebarStore } from '../src/client/state.ts'
+
+import { setupReactAct } from './test-utils.ts'
+setupReactAct()
+
+// vitest 4.1.11+ follows the OS locale; pin en-US so menu copy is English.
+beforeAll(() => {
+  Object.defineProperty(window.navigator, 'language', { value: 'en-US', configurable: true })
+})
+
+const { archiveUrl, fetchMock } = vi.hoisted(() => ({
+  archiveUrl: vi.fn((_scope: unknown, _paths: readonly string[], name: string) => `/sidebar/archive?name=${encodeURIComponent(name)}`),
+  fetchMock: vi.fn(),
+}))
+
+vi.mock('../src/client/api.ts', () => ({
+  api: {
+    fsTree: async () => ({
+      path: '/tmp',
+      entries: [
+        { name: 'sub', path: '/tmp/sub', isDir: true },
+        { name: 'a.ts', path: '/tmp/a.ts', isDir: false },
+        { name: 'b.ts', path: '/tmp/b.ts', isDir: false },
+      ],
+      truncated: false,
+    }),
+    // The tree reads the shared git-status store; a non-repo answer keeps
+    // every row plain (this spec is about the archive row).
+    gitStatus: async () => ({ isRepo: false, entries: [] }),
+  },
+  downloadUrl: () => '/sidebar/file',
+  archiveUrl,
+  isOutsideWorkspaceMessage: () => false,
+}))
+
+/** jsdom implements neither object-URL helper; these ARE the download probe. */
+const createdUrls: Blob[] = []
+const revokedUrls: string[] = []
+beforeAll(() => {
+  Object.defineProperty(URL, 'createObjectURL', {
+    configurable: true,
+    writable: true,
+    value: (blob: Blob) => {
+      createdUrls.push(blob)
+      return `blob:mock-${createdUrls.length}`
+    },
+  })
+  Object.defineProperty(URL, 'revokeObjectURL', {
+    configurable: true,
+    writable: true,
+    value: (url: string) => { revokedUrls.push(url) },
+  })
+})
+
+interface Harness {
+  container: HTMLDivElement
+  unmount: () => void
+}
+
+async function mountTree(): Promise<Harness> {
+  const container = document.createElement('div')
+  document.body.append(container)
+  const root: Root = createRoot(container)
+  await act(async () => {
+    root.render(createElement(FileTree, {
+      sessionId: 's1',
+      cwd: '/tmp',
+      store: createSidebarStore(),
+      expanded: [],
+      revealed: [],
+      onToggle: () => {},
+      onOpenFile: () => {},
+      onReferenceFile: () => {},
+      refreshTick: 0,
+      onUploadRequest: () => {},
+      busy: false,
+    }))
+    await Promise.resolve()
+  })
+  return {
+    container,
+    unmount: () => { act(() => { root.unmount() }); container.remove() },
+  }
+}
+
+/** One tree row by its displayed name (the root row included). */
+function rowByName(container: HTMLElement, name: string): HTMLElement {
+  const row = [...container.querySelectorAll<HTMLElement>('[class*="explorerRow"]')]
+    .find(el => el.querySelector('[class*="explorerName"]')?.textContent === name)
+  if (row === undefined) throw new Error(`row not found: ${name}`)
+  return row
+}
+
+function click(el: Element, init: MouseEventInit = {}): void {
+  act(() => { el.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true, ...init })) })
+}
+
+function rightClick(el: Element): void {
+  act(() => {
+    el.dispatchEvent(new MouseEvent('contextmenu', { bubbles: true, cancelable: true, clientX: 20, clientY: 30 }))
+  })
+}
+
+function menuLabels(): string[] {
+  return [...document.querySelectorAll<HTMLElement>('[role="menuitem"]')].map(item => item.textContent ?? '')
+}
+
+function clickMenuitem(label: string): void {
+  const item = [...document.querySelectorAll<HTMLElement>('[role="menuitem"]')]
+    .find(el => el.textContent === label)
+  if (item === undefined) throw new Error(`menuitem not found: ${label}`)
+  act(() => { item.click() })
+}
+
+/**
+ * Flush the fetch → blob → anchor chain. The chain crosses several async
+ * function boundaries (fetch promise → `await response.blob()` → object URL →
+ * revoke), so a single microtask/timer pair is not enough on a loaded machine:
+ * three macrotask ticks let every hop land, including the revoke `setTimeout`.
+ */
+async function settleDownload(): Promise<void> {
+  await act(async () => {
+    for (let tick = 0; tick < 3; tick += 1) {
+      await Promise.resolve()
+      await new Promise<void>(resolve => { window.setTimeout(resolve, 0) })
+    }
+  })
+}
+
+/** A 200 answer carrying ZIP bytes. */
+function okResponse(bytes = 'zip-bytes'): Response {
+  return {
+    ok: true,
+    status: 200,
+    blob: async () => new Blob([bytes], { type: 'application/zip' }),
+  } as unknown as Response
+}
+
+/** A refused answer carrying the plugin's JSON envelope (or a non-JSON body). */
+function errorResponse(status: number, body?: unknown): Response {
+  return {
+    ok: false,
+    status,
+    json: async () => {
+      if (body === undefined) throw new Error('not json')
+      return body
+    },
+  } as unknown as Response
+}
+
+let harness: Harness
+/** The anchors whose click() ran, as `href|download`. */
+const downloads: string[] = []
+const clickSpy = vi.spyOn(HTMLAnchorElement.prototype, 'click').mockImplementation(function (this: HTMLAnchorElement): void {
+  downloads.push(`${this.getAttribute('href') ?? ''}|${this.download}`)
+})
+
+beforeEach(() => {
+  vi.stubGlobal('fetch', fetchMock)
+  fetchMock.mockReset()
+  fetchMock.mockResolvedValue(okResponse())
+  archiveUrl.mockClear()
+  archiveUrl.mockImplementation((_scope: unknown, _paths: readonly string[], name: string) =>
+    `/sidebar/archive?name=${encodeURIComponent(name)}`)
+})
+
+afterEach(() => {
+  harness.unmount()
+  document.body.innerHTML = ''
+  downloads.length = 0
+  createdUrls.length = 0
+  revokedUrls.length = 0
+  clickSpy.mockClear()
+  vi.unstubAllGlobals()
+})
+
+describe('FileTree zip and download', () => {
+  it('archives a multi-selection through one fetched row', async () => {
+    harness = await mountTree()
+    click(rowByName(harness.container, 'a.ts'), { ctrlKey: true })
+    click(rowByName(harness.container, 'b.ts'), { ctrlKey: true })
+    // Right-clicking a row INSIDE the selection keeps the batch.
+    rightClick(rowByName(harness.container, 'b.ts'))
+    expect(menuLabels()).toContain('Zip and download (2 items)')
+    clickMenuitem('Zip and download (2 items)')
+    await settleDownload()
+    expect(archiveUrl).toHaveBeenCalledWith({ sessionId: 's1', cwd: '/tmp' }, ['/tmp/a.ts', '/tmp/b.ts'], 'archive.zip')
+    expect(fetchMock).toHaveBeenCalledWith('/sidebar/archive?name=archive.zip')
+    // The body became an object URL saved through a hidden anchor…
+    expect(createdUrls).toHaveLength(1)
+    expect(downloads).toEqual(['blob:mock-1|archive.zip'])
+    // …and the object URL is released on the next task.
+    expect(revokedUrls).toEqual(['blob:mock-1'])
+  })
+
+  it('archives a lone directory under its own name', async () => {
+    harness = await mountTree()
+    rightClick(rowByName(harness.container, 'sub'))
+    expect(menuLabels()).toContain('Zip and download')
+    clickMenuitem('Zip and download')
+    await settleDownload()
+    expect(archiveUrl).toHaveBeenCalledWith({ sessionId: 's1', cwd: '/tmp' }, ['/tmp/sub'], 'sub.zip')
+    expect(fetchMock).toHaveBeenCalledWith('/sidebar/archive?name=sub.zip')
+    expect(downloads).toEqual(['blob:mock-1|sub.zip'])
+  })
+
+  it('archives the workspace root row (a lone directory too)', async () => {
+    harness = await mountTree()
+    rightClick(rowByName(harness.container, 'tmp'))
+    clickMenuitem('Zip and download')
+    await settleDownload()
+    expect(archiveUrl).toHaveBeenCalledWith({ sessionId: 's1', cwd: '/tmp' }, ['/tmp'], 'tmp.zip')
+  })
+
+  it('offers nothing for a lone FILE (the download row already covers it)', async () => {
+    harness = await mountTree()
+    rightClick(rowByName(harness.container, 'a.ts'))
+    expect(menuLabels()).toContain('Download')
+    expect(menuLabels().some(label => label.startsWith('Zip and download'))).toBe(false)
+    expect(archiveUrl).not.toHaveBeenCalled()
+    expect(fetchMock).not.toHaveBeenCalled()
+  })
+
+  it('reports a route refusal with the envelope message (caps, fence, bad request)', async () => {
+    fetchMock.mockResolvedValue(errorResponse(413, { ok: false, error: { code: 'bad-request', message: 'archive would exceed 64 MB' } }))
+    harness = await mountTree()
+    rightClick(rowByName(harness.container, 'sub'))
+    clickMenuitem('Zip and download')
+    await settleDownload()
+    expect(harness.container.querySelector('[role="alert"]')?.textContent)
+      .toContain('Archive failed: archive would exceed 64 MB')
+    // Nothing was downloaded, and no object URL leaked.
+    expect(downloads).toEqual([])
+    expect(createdUrls).toEqual([])
+  })
+
+  it('falls back to the status when the refusal carries no JSON body', async () => {
+    fetchMock.mockResolvedValue(errorResponse(500))
+    harness = await mountTree()
+    rightClick(rowByName(harness.container, 'sub'))
+    clickMenuitem('Zip and download')
+    await settleDownload()
+    expect(harness.container.querySelector('[role="alert"]')?.textContent)
+      .toContain('Archive failed: HTTP 500')
+    expect(downloads).toEqual([])
+  })
+
+  it('reports a network failure in the error strip', async () => {
+    fetchMock.mockRejectedValue(new Error('network down'))
+    harness = await mountTree()
+    rightClick(rowByName(harness.container, 'sub'))
+    clickMenuitem('Zip and download')
+    await settleDownload()
+    expect(harness.container.querySelector('[role="alert"]')?.textContent)
+      .toContain('Archive failed: network down')
+    expect(downloads).toEqual([])
+  })
+
+  it('reports a ZIP whose URL cannot be built without fetching', async () => {
+    archiveUrl.mockImplementation(() => { throw new Error('boom: too large') })
+    harness = await mountTree()
+    rightClick(rowByName(harness.container, 'sub'))
+    clickMenuitem('Zip and download')
+    await settleDownload()
+    expect(harness.container.querySelector('[role="alert"]')?.textContent)
+      .toContain('Archive failed: boom: too large')
+    expect(fetchMock).not.toHaveBeenCalled()
+    expect(downloads).toEqual([])
+  })
+
+  it('packages once while a request is in flight (double click guard)', async () => {
+    let release: (response: Response) => void = () => {}
+    fetchMock.mockImplementation(async () => await new Promise<Response>(resolve => { release = resolve }))
+    harness = await mountTree()
+    const pick = (): void => {
+      rightClick(rowByName(harness.container, 'sub'))
+      clickMenuitem('Zip and download')
+    }
+    pick()
+    expect(fetchMock).toHaveBeenCalledTimes(1)
+    // The row is still reachable (the menu closed on selection) and a second
+    // pick must not start a second archive.
+    pick()
+    expect(fetchMock).toHaveBeenCalledTimes(1)
+    await act(async () => { release(okResponse()) })
+    await settleDownload()
+    expect(downloads).toEqual(['blob:mock-1|sub.zip'])
+    // The guard releases once the request settled: another pick fetches again.
+    fetchMock.mockResolvedValue(okResponse())
+    pick()
+    expect(fetchMock).toHaveBeenCalledTimes(2)
+    await settleDownload()
+  })
+})
diff --git a/tests/file-tree-open-in-app.spec.tsx b/tests/file-tree-open-in-app.spec.tsx
index a8eb01e..66d4c30 100644
--- a/tests/file-tree-open-in-app.spec.tsx
+++ b/tests/file-tree-open-in-app.spec.tsx
@@ -16,6 +16,7 @@ import { createRoot, type Root } from 'react-dom/client'
 import { act } from 'react-dom/test-utils'
 import { FileTree } from '../src/client/FileTree.tsx'
 import { createOpenInApp, type OpenInApp, type OpenInAppEntry } from '../src/client/open-in-app.ts'
+import type { OpenWithTarget } from '../src/client/open-with.ts'
 import { createSidebarStore } from '../src/client/state.ts'
 
 import { setupReactAct } from './test-utils.ts'
@@ -83,13 +84,28 @@ function makeHandle(overrides: Partial<OpenInApp> = {}): Handle {
 
 interface Harness {
   container: HTMLDivElement
+  onOpenWith: ReturnType<typeof vi.fn>
+  onToggleOpenWithPin: ReturnType<typeof vi.fn>
   unmount: () => void
 }
 
-async function mountTree(handle?: Handle): Promise<Harness> {
+/** The plugin targets a caller (EditorHost) may hand FileTree alongside the
+ *  host handle; names are distinct from FILE_APPS so assertions are exact. */
+const PLUGIN_TARGETS: OpenWithTarget[] = [
+  { id: 'explorer', nameKey: 'openWithExplorer', name: '', kind: 'reveal', isVscodeFamily: false, localOnly: true },
+  { id: 'custom:w', name: 'Windsurf', kind: 'url', urlTemplate: 'windsurf://file/{path}', isVscodeFamily: false, localOnly: false },
+]
+
+async function mountTree(handle?: Handle, plugin: {
+  targets?: OpenWithTarget[]
+  pinned?: string[]
+  ssh?: boolean
+} = {}): Promise<Harness> {
   const container = document.createElement('div')
   document.body.append(container)
   const root: Root = createRoot(container)
+  const onOpenWith = vi.fn()
+  const onToggleOpenWithPin = vi.fn()
   await act(async () => {
     root.render(createElement(FileTree, {
       sessionId: 's1',
@@ -102,17 +118,26 @@ async function mountTree(handle?: Handle): Promise<Harness> {
       onOpenFileNewTab: () => {},
       onOpenFileSide: () => {},
       ...(handle !== undefined ? { openInApp: handle.openInApp } : {}),
+      ...(plugin.targets !== undefined ? {
+        openWithTargets: plugin.targets,
+        openWithPinned: plugin.pinned ?? [],
+        openWithSsh: plugin.ssh ?? false,
+        onOpenWith,
+        onToggleOpenWithPin,
+      } : {}),
       onReferenceFile: () => {},
       refreshTick: 0,
       onUploadRequest: () => {},
       busy: false,
     }))
-    // Settle the async app listing the row menu triggers.
+    // Settle the async app listing / availability probe the menu triggers.
     await Promise.resolve()
     await Promise.resolve()
   })
   return {
     container,
+    onOpenWith,
+    onToggleOpenWithPin,
     unmount: () => { act(() => { root.unmount() }); container.remove() },
   }
 }
@@ -162,8 +187,13 @@ describe('FileTree open-in-app menu', () => {
     harness = await mountTree(handle)
     await openMenu(harness.container, 'a.ts')
     expect(handle.fileApps).toHaveBeenCalledWith('/tmp/a.ts')
-    // The section heading is a non-interactive label row.
-    expect(document.body.textContent).toContain('Open with')
+    // No heading row any more: the host group is read from the application
+    // names themselves (`openInApp` and `openWithMenu` are near-synonyms, so
+    // two labels in one menu read as a repeated item). A data label entry is
+    // a LEAF `role="presentation"` row inside the menu.
+    const menu = document.querySelector('[role="menuitem"]')!.closest('[role="menu"]')
+    expect([...(menu?.querySelectorAll('[role="presentation"]') ?? [])]
+      .filter(row => row.children.length === 0)).toEqual([])
     expect(menuLabels()).toContain('Open with default app')
     expect(menuLabels()).toContain('VS Code')
     expect(menuLabels()).toContain('Reveal in File Manager')
@@ -289,3 +319,84 @@ describe('FileTree open-in-app menu', () => {
     expect(calls.open).toEqual([{ path: '/tmp/a.ts' }])
   })
 })
+
+describe('FileTree open-in-app + plugin open-with coexistence', () => {
+  let harness: Harness
+  afterEach(() => {
+    harness.unmount()
+    document.body.innerHTML = ''
+  })
+
+  /** The label rows of the single open menu, in DOM order. */
+  function labelsOf(items: string[]): number[] {
+    const labels = menuLabels()
+    return items.map(item => labels.indexOf(item))
+  }
+
+  it('stacks the host rows above the plugin rows and ends with the host reveal', async () => {
+    const handle = makeHandle()
+    harness = await mountTree(handle, { targets: PLUGIN_TARGETS, pinned: ['custom:w'] })
+    await openMenu(harness.container, 'a.ts')
+    const [hostDefault, hostApp, pinnedPlugin, submenu, reveal] = labelsOf([
+      'Open with default app', 'VS Code', 'Windsurf', 'Open with', 'Reveal in File Manager',
+    ])
+    // Every row exists, in the frozen order: host group → plugin group →
+    // reveal.
+    expect([hostDefault, hostApp, pinnedPlugin, submenu, reveal]).not.toContain(-1)
+    expect(hostDefault!).toBeLessThan(hostApp!)
+    expect(hostApp!).toBeLessThan(pinnedPlugin!)
+    expect(pinnedPlugin!).toBeLessThan(submenu!)
+    expect(submenu!).toBeLessThan(reveal!)
+    // The plugin's `explorer` target is replaced by the host reveal row.
+    expect(menuLabels()).not.toContain('File Manager')
+    // Separator rows between each group.
+    expect(document.querySelectorAll('[role="separator"]').length).toBeGreaterThanOrEqual(2)
+  })
+
+  it('keeps the plugin rows — explorer included — when the host cannot open desktop paths', async () => {
+    const handle = makeHandle({ available: () => false })
+    harness = await mountTree(handle, { targets: PLUGIN_TARGETS, pinned: ['custom:w'] })
+    await openMenu(harness.container, 'a.ts')
+    // No host rows at all…
+    expect(menuLabels()).not.toContain('Open with default app')
+    expect(menuLabels()).not.toContain('Reveal in File Manager')
+    // …but the plugin's own reveal target survives, so reveal is never lost.
+    expect(menuLabels()).toContain('Windsurf')
+    const parent = menuItems().find(item => item.getAttribute('aria-haspopup') === 'menu')!
+    act(() => { parent.click() })
+    expect([...document.querySelectorAll<HTMLElement>('[role="menu"] [role="menu"] [role="menuitem"]')]
+      .map(item => item.textContent?.trim())).toEqual(['File Manager', 'Windsurf'])
+  })
+
+  it('keeps the plugin rows when no host handle was injected at all', async () => {
+    harness = await mountTree(undefined, { targets: PLUGIN_TARGETS, pinned: [] })
+    await openMenu(harness.container, 'a.ts')
+    expect(menuLabels()).not.toContain('Reveal in File Manager')
+    expect(menuLabels()).toContain('Open with')
+  })
+
+  it('hands the plugin target id and path to onOpenWith (SSH suffix intact)', async () => {
+    const handle = makeHandle({ available: () => false })
+    harness = await mountTree(handle, { targets: PLUGIN_TARGETS, pinned: [], ssh: true })
+    await openMenu(harness.container, 'a.ts')
+    const parent = menuItems().find(item => item.getAttribute('aria-haspopup') === 'menu')!
+    act(() => { parent.click() })
+    const windsurf = [...document.querySelectorAll<HTMLElement>('[role="menu"] [role="menu"] [role="menuitem"]')]
+      .find(item => item.textContent?.trim() === 'Windsurf (SSH)')!
+    act(() => { windsurf.click() })
+    expect(harness.onOpenWith).toHaveBeenCalledWith('custom:w', '/tmp/a.ts')
+  })
+
+  it('routes a pin click to onToggleOpenWithPin without selecting a row', async () => {
+    const handle = makeHandle({ available: () => false })
+    harness = await mountTree(handle, { targets: PLUGIN_TARGETS, pinned: [] })
+    await openMenu(harness.container, 'a.ts')
+    act(() => { menuItems().find(item => item.getAttribute('aria-haspopup') === 'menu')!.click() })
+    const pin = [...document.querySelectorAll<HTMLElement>('[role="menu"] [role="menu"] [role="menuitem"]')]
+      .find(item => item.textContent?.trim() === 'Windsurf')!
+      .querySelector<HTMLElement>('[class*="openWithPin"]')!
+    act(() => { pin.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true })) })
+    expect(harness.onToggleOpenWithPin).toHaveBeenCalledWith('custom:w')
+    expect(harness.onOpenWith).not.toHaveBeenCalled()
+  })
+})
diff --git a/tests/file-tree-open-with.spec.tsx b/tests/file-tree-open-with.spec.tsx
new file mode 100644
index 0000000..ad95e86
--- /dev/null
+++ b/tests/file-tree-open-with.spec.tsx
@@ -0,0 +1,256 @@
+/**
+ * FileTree's PLUGIN open-with menu (restored in round two, and coexisting with
+ * the host's open-in-app rows — the coexistence cases live in
+ * file-tree-open-in-app.spec.tsx). With no host handle injected, the "打开方式"
+ * section is the plugin's own: the pinned targets as direct rows, the
+ * `openWithMenu` parent row with every target as a nested submenu (per-row
+ * pushpins that toggle without selecting the row), SSH suffixes in remote
+ * mode, and the reveal target kept (nothing else can reveal without the host).
+ */
+// @vitest-environment jsdom
+import { beforeAll, afterEach, describe, expect, it, vi } from 'vitest'
+import { createElement } from 'react'
+import { createRoot, type Root } from 'react-dom/client'
+import { act } from 'react-dom/test-utils'
+import { FileTree } from '../src/client/FileTree.tsx'
+import type { OpenWithTarget } from '../src/client/open-with.ts'
+import { createSidebarStore } from '../src/client/state.ts'
+
+import { setupReactAct } from './test-utils.ts'
+setupReactAct()
+
+// vitest 4.1.11+ follows the OS locale; pin en-US so menu copy is English.
+beforeAll(() => {
+  Object.defineProperty(window.navigator, 'language', { value: 'en-US', configurable: true })
+})
+
+vi.mock('../src/client/api.ts', () => ({
+  api: {
+    fsTree: async () => ({
+      path: '/tmp',
+      entries: [
+        { name: 'sub', path: '/tmp/sub', isDir: true },
+        { name: 'a.ts', path: '/tmp/a.ts', isDir: false },
+      ],
+      truncated: false,
+    }),
+    // The tree reads the shared git-status store; a non-repo answer keeps
+    // every row plain.
+    gitStatus: async () => ({ isRepo: false, entries: [] }),
+  },
+  downloadUrl: () => '/sidebar/file',
+  archiveUrl: () => '/sidebar/archive',
+  isOutsideWorkspaceMessage: () => false,
+}))
+
+/** The resolved target list a caller (EditorHost) would hand FileTree. */
+const targets: OpenWithTarget[] = [
+  { id: 'explorer', nameKey: 'openWithExplorer', name: '', kind: 'reveal', isVscodeFamily: false, localOnly: true },
+  { id: 'vscode', nameKey: 'openWithVscode', name: '', kind: 'url', urlTemplate: 'vscode://file/{path}', isVscodeFamily: true, localOnly: false },
+  { id: 'cursor', nameKey: 'openWithCursor', name: '', kind: 'url', urlTemplate: 'cursor://file/{path}', isVscodeFamily: true, localOnly: false },
+  { id: 'zed', nameKey: 'openWithZed', name: '', kind: 'url', urlTemplate: 'zed://file/{path}', isVscodeFamily: false, localOnly: true },
+  { id: 'custom:w', name: 'Windsurf', kind: 'url', urlTemplate: 'windsurf://file/{path}', isVscodeFamily: false, localOnly: false },
+]
+
+interface Harness {
+  container: HTMLDivElement
+  onOpenWith: ReturnType<typeof vi.fn>
+  onToggleOpenWithPin: ReturnType<typeof vi.fn>
+  unmount: () => void
+}
+
+async function mountTree(overrides: {
+  openWithTargets?: OpenWithTarget[]
+  openWithPinned?: string[]
+  openWithSsh?: boolean
+} = {}): Promise<Harness> {
+  const container = document.createElement('div')
+  document.body.append(container)
+  const root: Root = createRoot(container)
+  const onOpenWith = vi.fn()
+  const onToggleOpenWithPin = vi.fn()
+  // Property-presence semantics: an explicit `openWithTargets: undefined`
+  // must reach FileTree (the section hides) instead of falling back.
+  const has = (key: 'openWithTargets' | 'openWithPinned' | 'openWithSsh'): boolean =>
+    Object.prototype.hasOwnProperty.call(overrides, key)
+  await act(async () => {
+    root.render(createElement(FileTree, {
+      sessionId: 's1',
+      cwd: '/tmp',
+      store: createSidebarStore(),
+      expanded: [],
+      revealed: [],
+      onToggle: () => {},
+      onOpenFile: () => {},
+      onOpenFileNewTab: () => {},
+      onOpenFileSide: () => {},
+      openWithTargets: has('openWithTargets') ? overrides.openWithTargets : targets,
+      openWithPinned: has('openWithPinned') ? overrides.openWithPinned : ['vscode'],
+      openWithSsh: has('openWithSsh') ? overrides.openWithSsh : false,
+      onOpenWith,
+      onToggleOpenWithPin,
+      onReferenceFile: () => {},
+      refreshTick: 0,
+      onUploadRequest: () => {},
+      busy: false,
+    }))
+    await Promise.resolve()
+  })
+  return {
+    container,
+    onOpenWith,
+    onToggleOpenWithPin,
+    unmount: () => { act(() => { root.unmount() }); container.remove() },
+  }
+}
+
+/** The file row of the one-level tree. */
+function fileRow(container: HTMLDivElement): HTMLElement {
+  const row = [...container.querySelectorAll<HTMLElement>('[role="button"]')]
+    .find(el => el.querySelector('[class*="explorerName"]')?.textContent === 'a.ts')
+  if (row === undefined) throw new Error('file row not found')
+  return row
+}
+
+/** Open the row's context menu at a fixed cursor position. */
+function openMenu(container: HTMLDivElement): void {
+  const event = new MouseEvent('contextmenu', { bubbles: true, cancelable: true, clientX: 20, clientY: 30 })
+  act(() => { fileRow(container).dispatchEvent(event) })
+}
+
+function menuItems(): HTMLElement[] {
+  return [...document.querySelectorAll<HTMLElement>('[role="menuitem"]')]
+}
+
+function submenuRows(): HTMLElement[] {
+  return [...document.querySelectorAll<HTMLElement>('[role="menu"] [role="menu"] [role="menuitem"]')]
+}
+
+function submenuParent(): HTMLElement {
+  const parent = menuItems().find(item => item.getAttribute('aria-haspopup') === 'menu')
+  if (parent === undefined) throw new Error('submenu parent not found')
+  return parent
+}
+
+describe('FileTree plugin open-with menu', () => {
+  let harness: Harness
+  afterEach(() => {
+    harness.unmount()
+    document.body.innerHTML = ''
+    document.body.removeAttribute('data-dsh-sidebar-submenu')
+  })
+
+  it('renders the pinned direct row and the submenu parent for a file row', async () => {
+    harness = await mountTree()
+    openMenu(harness.container)
+    // The pinned VS Code sits at the top level (before the submenu parent).
+    expect(menuItems().map(item => item.textContent?.trim())).toContain('VS Code')
+    const parent = submenuParent()
+    expect(parent.textContent).toContain('Open with')
+    // The submenu parent carries the trailing chevron affordance (the
+    // primitives Menu renders no arrow of its own), right-aligned inside a
+    // full-width label row — the same structure the submenu children use.
+    expect(parent.querySelector('[class*="openWithChevron"]')).not.toBeNull()
+    expect(parent.querySelector('[class*="openWithLabel"]')).not.toBeNull()
+  })
+
+  it('opens the submenu on click and lists every target with pin toggles', async () => {
+    harness = await mountTree()
+    openMenu(harness.container)
+    act(() => { submenuParent().click() })
+    expect(submenuRows().map(item => item.textContent?.trim())).toEqual([
+      'File Manager', 'VS Code', 'Cursor', 'Zed', 'Windsurf',
+    ])
+    expect(submenuRows().every(item => item.querySelector('[class*="openWithPin"]') !== null)).toBe(true)
+    // Pinned state is announced per row (and swaps the pushpin glyph).
+    const vscodeRow = submenuRows().find(item => item.textContent?.trim() === 'VS Code')
+    const cursorRow = submenuRows().find(item => item.textContent?.trim() === 'Cursor')
+    expect(vscodeRow?.querySelector('[aria-label="Unpin"]')).not.toBeNull()
+    expect(cursorRow?.querySelector('[aria-label="Pin to menu"]')).not.toBeNull()
+  })
+
+  it('pin click toggles without selecting the row or closing the menu', async () => {
+    harness = await mountTree()
+    openMenu(harness.container)
+    act(() => { submenuParent().click() })
+    const cursorRow = submenuRows().find(item => item.textContent?.trim() === 'Cursor')!
+    const pin = cursorRow.querySelector<HTMLElement>('[class*="openWithPin"]')
+    expect(pin).not.toBeNull()
+    act(() => { pin!.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true })) })
+    expect(harness.onToggleOpenWithPin).toHaveBeenCalledWith('cursor')
+    expect(harness.onOpenWith).not.toHaveBeenCalled()
+    // The menu (and the submenu) stayed open.
+    expect(document.querySelector('[role="menu"] [role="menu"]')).not.toBeNull()
+  })
+
+  it('selecting a submenu child invokes onOpenWith with the row path and closes the menu', async () => {
+    harness = await mountTree()
+    openMenu(harness.container)
+    act(() => { submenuParent().click() })
+    const zedRow = submenuRows().find(item => item.textContent?.trim() === 'Zed')!
+    act(() => { zedRow.click() })
+    expect(harness.onOpenWith).toHaveBeenCalledWith('zed', '/tmp/a.ts')
+    // Selecting closes the row menu entirely.
+    expect(document.querySelector('[role="menu"] [role="menu"]')).toBeNull()
+    expect(menuItems()).toHaveLength(0)
+  })
+
+  it('appends the SSH hint to VSCode-family labels in remote mode', async () => {
+    harness = await mountTree({
+      openWithSsh: true,
+      openWithTargets: targets.filter(target => !target.localOnly),
+      openWithPinned: [],
+    })
+    openMenu(harness.container)
+    act(() => { submenuParent().click() })
+    expect(submenuRows().map(item => item.textContent?.trim())).toEqual([
+      'VS Code (SSH)', 'Cursor (SSH)', 'Windsurf (SSH)',
+    ])
+  })
+
+  it('hides the plugin section when the caller wires no targets', async () => {
+    harness = await mountTree({ openWithTargets: undefined })
+    openMenu(harness.container)
+    expect(menuItems().some(item => item.textContent?.includes('Open with'))).toBe(false)
+    expect(menuItems().some(item => item.getAttribute('aria-haspopup') === 'menu')).toBe(false)
+  })
+})
+
+describe('FileTree plugin open-with menu flip geometry (submenu clamping)', () => {
+  const ATTR = 'data-dsh-sidebar-submenu'
+
+  let harness: Harness
+  afterEach(() => {
+    harness.unmount()
+    document.body.innerHTML = ''
+    document.body.removeAttribute(ATTR)
+  })
+
+  it('publishes "down" for a top-of-tree opening and clears on selection', async () => {
+    harness = await mountTree()
+    // openMenu() right-clicks at (20, 30) — the upper half, plenty of right
+    // room in jsdom's default viewport.
+    openMenu(harness.container)
+    expect(document.body.getAttribute(ATTR)).toBe('down')
+    act(() => { submenuParent().click() })
+    const zedRow = submenuRows().find(item => item.textContent?.trim() === 'Zed')!
+    act(() => { zedRow.click() })
+    expect(menuItems()).toHaveLength(0)
+    expect(document.body.hasAttribute(ATTR)).toBe(false)
+  })
+
+  it('adds "left" when the cursor sits within the right-hand submenu room', async () => {
+    harness = await mountTree()
+    const nearRight = new MouseEvent('contextmenu', { bubbles: true, cancelable: true, clientX: window.innerWidth - 10, clientY: 30 })
+    act(() => { fileRow(harness.container).dispatchEvent(nearRight) })
+    expect(document.body.getAttribute(ATTR)).toBe('down left')
+  })
+
+  it('clears the attribute on unmount with the menu still open', async () => {
+    harness = await mountTree()
+    openMenu(harness.container)
+    expect(document.body.getAttribute(ATTR)).toBe('down')
+    harness.unmount()
+    expect(document.body.hasAttribute(ATTR)).toBe(false)
+  })
+})
diff --git a/tests/git-view-worktree.spec.tsx b/tests/git-view-worktree.spec.tsx
index c19f9c5..97acd4b 100644
--- a/tests/git-view-worktree.spec.tsx
+++ b/tests/git-view-worktree.spec.tsx
@@ -421,3 +421,136 @@ describe('GitLens (changes tab, git lens) linked-worktree consistency', () => {
     }
   })
 })
+
+describe('GitLens (changes tab, git lens) change tree', () => {
+  /** Mount with one changed-file inventory; every test picks its own entries. */
+  async function mountTree(
+    container: HTMLElement,
+    root: Root,
+    entries: Array<{ path: string; xy: string }>,
+  ): Promise<void> {
+    const changes = entries.filter(row => row.xy !== '  ').length
+    vi.spyOn(api, 'gitWorktrees').mockResolvedValue([{ path: MAIN, branch: 'main', current: true, changes }])
+    vi.spyOn(api, 'gitStatus').mockResolvedValue({ isRepo: true, branch: 'main', entries })
+    vi.spyOn(api, 'gitBranch').mockResolvedValue({ current: 'main', names: ['main'] })
+    vi.spyOn(api, 'gitLog').mockResolvedValue([])
+    mountGit(root)
+    await flushEffects()
+  }
+
+  function makeRoot(): { container: HTMLDivElement; root: Root } {
+    const container = document.createElement('div')
+    document.body.append(container)
+    return { container, root: createRoot(container) }
+  }
+
+  it('folds a directory row per group, independently of the same path on the other side', async () => {
+    const { container, root } = makeRoot()
+    try {
+      await mountTree(container, root, [
+        { path: 'src/a.ts', xy: ' M' }, // unstaged side
+        { path: 'src/b.ts', xy: 'M ' }, // staged side
+      ])
+
+      const dirs = () => [...container.querySelectorAll<HTMLButtonElement>('button[data-dir="src"]')]
+      // One 'src' row per group: a path with changes on both sides appears in
+      // both trees.
+      expect(dirs()).toHaveLength(2)
+      expect(dirs()[0]!.getAttribute('aria-expanded')).toBe('true')
+      expect(dirs()[0]!.querySelector('svg')).not.toBeNull()
+      expect(container.querySelector('button[data-path="src/a.ts"]')).not.toBeNull()
+      expect(container.querySelector('button[data-path="src/a.ts"]')!.querySelector('svg')).not.toBeNull()
+
+      await act(async () => { dirs()[0]!.click() })
+      // Folded: the unstaged subtree is gone...
+      expect(dirs()[0]!.getAttribute('aria-expanded')).toBe('false')
+      expect(container.querySelector('button[data-path="src/a.ts"]')).toBeNull()
+      // ...while the staged group's own 'src' row stays open and keeps its file.
+      expect(dirs()[1]!.getAttribute('aria-expanded')).toBe('true')
+      expect(container.querySelector('button[data-path="src/b.ts"]')).not.toBeNull()
+
+      await act(async () => { dirs()[0]!.click() })
+      expect(container.querySelector('button[data-path="src/a.ts"]')).not.toBeNull()
+    } finally {
+      act(() => { root.unmount() })
+      container.remove()
+    }
+  })
+
+  it('compresses a single-child directory chain into one labelled row', async () => {
+    const { container, root } = makeRoot()
+    try {
+      await mountTree(container, root, [
+        { path: 'src/client/changes/a.ts', xy: ' M' },
+        { path: 'src/client/changes/b.ts', xy: ' M' },
+      ])
+
+      // Three levels, one child each: one row, one label, two changes.
+      const row = container.querySelector<HTMLButtonElement>('button[data-dir="src/client/changes"]')
+      expect(row).not.toBeNull()
+      expect(row!.textContent).toContain('src/client/changes')
+      expect(container.querySelector('[data-group="unstaged"] [data-count]')?.textContent).toBe('2')
+      // Both files hang under that one row.
+      expect(container.querySelector('button[data-path="src/client/changes/a.ts"]')).not.toBeNull()
+      expect(container.querySelector('button[data-path="src/client/changes/b.ts"]')).not.toBeNull()
+      // Nothing on the staged side: only the empty band, no tree rows.
+      expect(container.querySelectorAll('[data-group="staged"] [data-path]')).toHaveLength(0)
+    } finally {
+      act(() => { root.unmount() })
+      container.remove()
+    }
+  })
+
+  it('stages a file from a nested tree row and re-reads the shared status', async () => {
+    const { container, root } = makeRoot()
+    try {
+      await mountTree(container, root, [{ path: 'src/deep/a.ts', xy: ' M' }])
+      const stage = vi.spyOn(api, 'gitStage').mockResolvedValue({ ok: true })
+      const statusSpy = vi.mocked(api.gitStatus)
+      const statusCallsBefore = statusSpy.mock.calls.length
+
+      const action = container.querySelector<HTMLButtonElement>(`button[aria-label="${t('stage')}"]`)
+      expect(action).not.toBeNull()
+      await act(async () => { action!.click() })
+      await flushEffects()
+
+      // The auto-selected primary checkout rides along as the worktree target.
+      expect(stage).toHaveBeenCalledWith(expect.objectContaining({ sessionId: 'session' }), 'src/deep/a.ts', MAIN)
+      expect(statusSpy.mock.calls.length).toBeGreaterThan(statusCallsBefore)
+    } finally {
+      act(() => { root.unmount() })
+      container.remove()
+    }
+  })
+
+  it('bands each group with its count and a labelled stage-all action', async () => {
+    const { container, root } = makeRoot()
+    try {
+      await mountTree(container, root, [
+        { path: 'src/a.ts', xy: ' M' },
+        { path: 'docs/b.md', xy: ' M' },
+        { path: 'src/c.ts', xy: 'M ' },
+      ])
+
+      const unstaged = container.querySelector<HTMLElement>('[data-group="unstaged"]')!
+      const staged = container.querySelector<HTMLElement>('[data-group="staged"]')!
+      expect(unstaged.textContent).toContain(t('unstaged'))
+      expect(unstaged.querySelector('[data-count]')?.textContent).toBe('2')
+      expect(staged.querySelector('[data-count]')?.textContent).toBe('1')
+
+      const stageAll = unstaged.querySelector<HTMLButtonElement>(`button[aria-label="${t('stageAll')}"]`)
+      const unstageAll = staged.querySelector<HTMLButtonElement>(`button[aria-label="${t('unstageAll')}"]`)
+      expect(stageAll).not.toBeNull()
+      expect(unstageAll).not.toBeNull()
+
+      const stage = vi.spyOn(api, 'gitStage').mockResolvedValue({ ok: true })
+      await act(async () => { stageAll!.click() })
+      await flushEffects()
+      // "Stage all" stages the whole worktree: no path argument.
+      expect(stage).toHaveBeenCalledWith(expect.objectContaining({ sessionId: 'session' }), undefined, MAIN)
+    } finally {
+      act(() => { root.unmount() })
+      container.remove()
+    }
+  })
+})
diff --git a/tests/menu-flip.spec.tsx b/tests/menu-flip.spec.tsx
new file mode 100644
index 0000000..c9742fc
--- /dev/null
+++ b/tests/menu-flip.spec.tsx
@@ -0,0 +1,122 @@
+/**
+ * The context-menu submenu flip geometry: the pure token computation behind
+ * the body attribute layout.css consumes (see src/client/menu-flip.ts for
+ * the contract) plus the attribute lifecycle of the hook itself.
+ */
+// @vitest-environment jsdom
+import { createElement, useState } from 'react'
+import { readFileSync } from 'node:fs'
+import { act } from 'react-dom/test-utils'
+import { describe, expect, it } from 'vitest'
+import { renderRoot, setupReactAct } from './test-utils.ts'
+import { SUBMENU_FLIP_ATTR, submenuFlipTokens, useSubmenuFlip } from '../src/client/menu-flip.ts'
+
+setupReactAct()
+
+describe('layout.css contract', () => {
+  it('consumes the exact attribute name menu-flip.ts publishes', () => {
+    // The two halves of the flip mechanism can drift silently: renaming the
+    // attribute here would leave layout.css matching nothing (submenus revert
+    // to overflowing) with every test still green. Tie them together. Specs
+    // run from the repo root (chunk-artifact.spec.ts reads lib/ the same way).
+    const css = readFileSync('src/client/layout.css', 'utf8')
+    expect(css).toContain(`body[${SUBMENU_FLIP_ATTR}~="down"] div[role="menu"] div[role="menu"]`)
+    expect(css).toContain(`body[${SUBMENU_FLIP_ATTR}~="left"] div[role="menu"] div[role="menu"]`)
+    expect(css).toContain(`body[${SUBMENU_FLIP_ATTR}~="left"] div[role="menu"] div[role="menu"]::before`)
+  })
+
+  it('keeps the submenu visual tether rules (parent highlight + tight gap)', () => {
+    // Part 1 keeps the parent row lit while its submenu is open (the Menu
+    // marks it aria-expanded); part 2 tightens the card gap to 4px with the
+    // hover corridor narrowed to match. Losing either sends the submenu back
+    // to reading as an unrelated floating card.
+    const css = readFileSync('src/client/layout.css', 'utf8')
+    expect(css).toContain(`body[${SUBMENU_FLIP_ATTR}] div[role="menu"] button[aria-expanded="true"]`)
+    expect(css).toContain('left: calc(100% + 4px)')
+    expect(css).toContain('right: calc(100% + 4px)')
+    expect(css).toContain('width: 4px')
+  })
+})
+
+describe('submenuFlipTokens', () => {
+  // Default geometry (1024x768): the panel is docked right, so the
+  // interesting split is the right-hand 400px strip and the vertical half.
+  it('flips down for a cursor in the upper half, keeps primitive defaults below', () => {
+    expect(submenuFlipTokens(500, 20, 1024, 768)).toBe('down')
+    expect(submenuFlipTokens(500, 700, 1024, 768)).toBe('')
+  })
+
+  it('flips left when the right-hand room cannot fit card + submenu', () => {
+    // 700 + 400 > 1024 → left; the cursor is low, so no down token.
+    expect(submenuFlipTokens(700, 700, 1024, 768)).toBe('left')
+    // Both tokens compose for a top-right opening.
+    expect(submenuFlipTokens(700, 20, 1024, 768)).toBe('down left')
+  })
+
+  it('uses the exact boundary inclusively (midpoint and width-minus-room still flip)', () => {
+    expect(submenuFlipTokens(500, 384, 1024, 768)).toBe('')
+    expect(submenuFlipTokens(500, 383, 1024, 768)).toBe('down')
+    expect(submenuFlipTokens(624, 700, 1024, 768)).toBe('')
+    expect(submenuFlipTokens(625, 700, 1024, 768)).toBe('left')
+  })
+
+  it('flips left throughout a narrow viewport', () => {
+    // A 600px window: any cursor past x=200 flips; the left strip cannot
+    // fit a right-growing submenu beside the 218px card either way.
+    expect(submenuFlipTokens(300, 100, 600, 800)).toBe('down left')
+    expect(submenuFlipTokens(500, 700, 600, 800)).toBe('left')
+  })
+})
+
+describe('useSubmenuFlip', () => {
+  const ATTR = 'data-dsh-sidebar-submenu'
+
+  /** Mount a probe whose menu state the spec drives via the returned setter. */
+  function mountFlipProbe(initial: { x: number; y: number } | null): { setMenu: (next: { x: number; y: number } | null) => void, unmount: () => void } {
+    let applyMenu: (next: { x: number; y: number } | null) => void = () => {}
+    function Probe(): React.ReactElement {
+      const [menu, setMenu] = useState<{ x: number; y: number } | null>(initial)
+      applyMenu = setMenu
+      useSubmenuFlip(menu)
+      return <div />
+    }
+    const rendered = renderRoot(createElement(Probe))
+    return {
+      setMenu: (next) => { act(() => { applyMenu(next) }) },
+      unmount: rendered.unmount,
+    }
+  }
+
+  it('publishes tokens while the menu is open and clears on close', () => {
+    const probe = mountFlipProbe({ x: 700, y: 20 })
+    try {
+      expect(document.body.getAttribute(ATTR)).toBe('down left')
+      probe.setMenu(null)
+      expect(document.body.hasAttribute(ATTR)).toBe(false)
+    } finally {
+      probe.unmount()
+    }
+  })
+
+  it('tracks the position across consecutive openings', () => {
+    const probe = mountFlipProbe({ x: 100, y: 20 })
+    try {
+      expect(document.body.getAttribute(ATTR)).toBe('down')
+      // Still open, now lower-left: the attribute stays (menu lifetime) but
+      // carries no token, so the primitive's own geometry applies.
+      probe.setMenu({ x: 100, y: 700 })
+      expect(document.body.getAttribute(ATTR)).toBe('')
+      probe.setMenu({ x: 700, y: 700 })
+      expect(document.body.getAttribute(ATTR)).toBe('left')
+    } finally {
+      probe.unmount()
+    }
+  })
+
+  it('clears the attribute when the owner unmounts with the menu still open', () => {
+    const probe = mountFlipProbe({ x: 100, y: 20 })
+    expect(document.body.getAttribute(ATTR)).toBe('down')
+    probe.unmount()
+    expect(document.body.hasAttribute(ATTR)).toBe(false)
+  })
+})
diff --git a/tests/open-external-client.spec.ts b/tests/open-external-client.spec.ts
new file mode 100644
index 0000000..714233f
--- /dev/null
+++ b/tests/open-external-client.spec.ts
@@ -0,0 +1,98 @@
+/**
+ * Client/host routing for the file tree's external-open action. Remote
+ * VSCode-family SSH URLs must launch on the browser machine, while local
+ * editor URLs and reveal actions keep using the DSH host opener.
+ */
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { api } from '../src/client/api.ts'
+
+afterEach(() => {
+  vi.unstubAllGlobals()
+})
+
+function hostOk(): ReturnType<typeof vi.fn> {
+  return vi.fn(async () => ({
+    ok: true,
+    status: 200,
+    json: async () => ({ ok: true, value: { started: true } }),
+  }))
+}
+
+describe('api.openExternal', () => {
+  it('launches an SSH remote-editor URL on the client without calling the host', async () => {
+    const assign = vi.fn()
+    const fetchMock = hostOk()
+    vi.stubGlobal('window', { location: { assign } })
+    vi.stubGlobal('fetch', fetchMock)
+    const url = 'vscode://vscode-remote/ssh-remote+dev/home/u/f.ts'
+
+    await expect(api.openExternal({ action: 'url', url })).resolves.toEqual({ started: true })
+    expect(assign).toHaveBeenCalledOnce()
+    expect(assign).toHaveBeenCalledWith(url)
+    expect(fetchMock).not.toHaveBeenCalled()
+  })
+
+  it('launches Cursor/custom VSCode-family SSH URLs on the client too', async () => {
+    const assign = vi.fn()
+    const fetchMock = hostOk()
+    vi.stubGlobal('window', { location: { assign } })
+    vi.stubGlobal('fetch', fetchMock)
+
+    await api.openExternal({
+      action: 'url',
+      url: 'cursor://vscode-remote/ssh-remote+dev/home/u/f.ts',
+    })
+    await api.openExternal({
+      action: 'url',
+      url: 'myfork://vscode-remote/ssh-remote+dev/home/u/f.ts',
+    })
+
+    expect(assign).toHaveBeenCalledTimes(2)
+    expect(fetchMock).not.toHaveBeenCalled()
+  })
+
+  it('keeps local editor URLs on the host opener', async () => {
+    const assign = vi.fn()
+    const fetchMock = hostOk()
+    vi.stubGlobal('window', { location: { assign } })
+    vi.stubGlobal('fetch', fetchMock)
+
+    await expect(api.openExternal({
+      action: 'url',
+      url: 'vscode://file//tmp/a.ts',
+    })).resolves.toEqual({ started: true })
+
+    expect(assign).not.toHaveBeenCalled()
+    expect(fetchMock).toHaveBeenCalledOnce()
+    expect(fetchMock.mock.calls[0]?.[0]).toBe('/sidebar/api/open.external')
+  })
+
+  it('keeps reveal actions and http(s) lookalikes on the host opener', async () => {
+    const assign = vi.fn()
+    const fetchMock = hostOk()
+    vi.stubGlobal('window', { location: { assign } })
+    vi.stubGlobal('fetch', fetchMock)
+
+    await api.openExternal({ action: 'reveal', path: '/tmp/a.ts' })
+    await api.openExternal({
+      action: 'url',
+      url: 'https://vscode-remote/ssh-remote+dev/home/u/f.ts',
+    })
+
+    expect(assign).not.toHaveBeenCalled()
+    expect(fetchMock).toHaveBeenCalledTimes(2)
+  })
+
+  it('returns a rejected promise when client navigation throws', async () => {
+    const error = new Error('navigation failed')
+    const fetchMock = hostOk()
+    vi.stubGlobal('window', { location: { assign: vi.fn(() => { throw error }) } })
+    vi.stubGlobal('fetch', fetchMock)
+
+    await expect(api.openExternal({
+      action: 'url',
+      url: 'vscode://vscode-remote/ssh-remote+dev/home/u/f.ts',
+    })).rejects.toBe(error)
+    expect(fetchMock).not.toHaveBeenCalled()
+  })
+})
diff --git a/tests/open-external.spec.ts b/tests/open-external.spec.ts
new file mode 100644
index 0000000..d83477c
--- /dev/null
+++ b/tests/open-external.spec.ts
@@ -0,0 +1,73 @@
+/**
+ * Host external-open helpers: per-platform opener commands (pure, injected
+ * platform) and the URL validation that guards the spawn route. The actual
+ * spawns are not exercised — the route runs in the DSH host process and the
+ * OS outcome is not testable here.
+ */
+import { describe, expect, it } from 'vitest'
+import { launchExternal, revealCommand, urlCommand, validateExternalUrl } from '../src/open-external.ts'
+import { SidebarError } from '../src/wire.ts'
+
+describe('revealCommand', () => {
+  it('darwin: `open -R <path>` selects the file in Finder', () => {
+    expect(revealCommand('/a/b.txt', 'darwin')).toEqual({ command: 'open', args: ['-R', '/a/b.txt'] })
+  })
+
+  it('win32: passes /select,<path> as one shell-free Explorer argument', () => {
+    expect(revealCommand('C:\\work\\two words\\a.txt', 'win32')).toEqual({
+      command: 'explorer.exe',
+      args: ['/select,C:\\work\\two words\\a.txt'],
+    })
+  })
+
+  it('linux: `xdg-open` opens the containing directory (no common select protocol)', () => {
+    expect(revealCommand('/a/b.txt', 'linux')).toEqual({ command: 'xdg-open', args: ['/a'] })
+    expect(revealCommand('/', 'linux')).toEqual({ command: 'xdg-open', args: ['/'] })
+  })
+})
+
+describe('urlCommand', () => {
+  it('darwin: `open <url>` launches the registered protocol handler', () => {
+    expect(urlCommand('vscode://file/x', 'darwin')).toEqual({ command: 'open', args: ['vscode://file/x'] })
+  })
+
+  it('win32: rundll32 url.dll,FileProtocolHandler <url>', () => {
+    expect(urlCommand('cursor://file/x', 'win32')).toEqual({
+      command: 'rundll32.exe',
+      args: ['url.dll,FileProtocolHandler', 'cursor://file/x'],
+    })
+  })
+
+  it('linux: `xdg-open <url>` launches the registered protocol handler', () => {
+    expect(urlCommand('zed://file/x', 'linux')).toEqual({ command: 'xdg-open', args: ['zed://file/x'] })
+  })
+})
+
+describe('validateExternalUrl', () => {
+  it('accepts custom-scheme URLs (incl. the SSH-remote form)', () => {
+    expect(validateExternalUrl('vscode://vscode-remote/ssh-remote+dev/home/u/f.ts'))
+      .toBe('vscode://vscode-remote/ssh-remote+dev/home/u/f.ts')
+    expect(validateExternalUrl('myapp://file/{path}')).toBe('myapp://file/{path}')
+  })
+
+  it('rejects http/https (only custom schemes make sense here)', () => {
+    expect(() => validateExternalUrl('https://example.com')).toThrow(SidebarError)
+    expect(() => validateExternalUrl('http://example.com')).toThrow(SidebarError)
+  })
+
+  it('rejects non-URL / non-`scheme://` strings', () => {
+    expect(() => validateExternalUrl('/home/u/f.ts')).toThrow(SidebarError)
+    expect(() => validateExternalUrl('a:file/x')).toThrow(SidebarError)
+    expect(() => validateExternalUrl('')).toThrow(SidebarError)
+  })
+})
+
+describe('launchExternal validation (pre-spawn)', () => {
+  it('rejects relative reveal paths before anything is spawned', () => {
+    expect(() => launchExternal('reveal', 'relative/path')).toThrow(SidebarError)
+  })
+
+  it('rejects invalid URLs before anything is spawned', () => {
+    expect(() => launchExternal('url', 'https://example.com')).toThrow(SidebarError)
+  })
+})
diff --git a/tests/open-with-settings.spec.tsx b/tests/open-with-settings.spec.tsx
new file mode 100644
index 0000000..7faf7c1
--- /dev/null
+++ b/tests/open-with-settings.spec.tsx
@@ -0,0 +1,112 @@
+/**
+ * The editor's "open with" settings panel: the SSH host row and the custom
+ * editor list (name + URL template + VSCode-family flag, add/remove). Every
+ * edit commits the whole `openWith` blob through the popup's
+ * updatePluginSetting; removing an editor also prunes its pinned id.
+ */
+// @vitest-environment jsdom
+import { beforeAll, afterEach, describe, expect, it, vi } from 'vitest'
+import { createElement } from 'react'
+import { createRoot, type Root } from 'react-dom/client'
+import { act } from 'react-dom/test-utils'
+import { OpenWithSettings } from '../src/client/open-with-settings.tsx'
+
+import { setupReactAct } from './test-utils.ts'
+setupReactAct()
+
+beforeAll(() => {
+  Object.defineProperty(window.navigator, 'language', { value: 'en-US', configurable: true })
+})
+
+interface Harness {
+  container: HTMLDivElement
+  update: ReturnType<typeof vi.fn>
+  unmount: () => void
+}
+
+function mountSettings(rawOpenWith: unknown): Harness {
+  const container = document.createElement('div')
+  document.body.append(container)
+  const root: Root = createRoot(container)
+  const update = vi.fn()
+  act(() => {
+    root.render(createElement(OpenWithSettings, {
+      pluginSettings: { openWith: rawOpenWith },
+      updatePluginSetting: update,
+    }))
+  })
+  return {
+    container,
+    update,
+    unmount: () => { act(() => { root.unmount() }) },
+  }
+}
+
+const baseConfig = {
+  sshHost: 'dev',
+  customEditors: [
+    { id: 'a', name: 'Windsurf', urlTemplate: 'windsurf://file/{path}', isVscodeFamily: false },
+  ],
+  pinned: ['vscode', 'custom:a'],
+}
+
+describe('OpenWithSettings', () => {
+  let harness: Harness
+  afterEach(() => {
+    harness.unmount()
+    document.body.innerHTML = ''
+  })
+
+  it('seeds the SSH host input from the persisted blob and commits edits', () => {
+    harness = mountSettings(baseConfig)
+    const input = harness.container.querySelector<HTMLInputElement>('input:not([type])')
+    expect(input?.value).toBe('dev')
+    // The native value setter (React's value tracker must see the change).
+    const setter = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value')!.set!
+    act(() => {
+      setter.call(input, 'prod')
+      input!.dispatchEvent(new Event('input', { bubbles: true }))
+    })
+    expect(harness.update.mock.calls[0]?.[0]).toBe('openWith')
+    expect(harness.update.mock.calls[0]?.[1]).toMatchObject({ sshHost: 'prod' })
+  })
+
+  it('adds a custom editor row and commits the extended list', () => {
+    harness = mountSettings(baseConfig)
+    const add = [...harness.container.querySelectorAll<HTMLButtonElement>('button')]
+      .find(button => button.textContent?.trim() === 'Add')
+    expect(add).toBeDefined()
+    act(() => { add!.click() })
+    const blob = harness.update.mock.calls[0]?.[1] as { customEditors: unknown[]; pinned: string[] }
+    expect(blob.customEditors).toHaveLength(2)
+    expect(blob.pinned).toEqual(['vscode', 'custom:a'])
+  })
+
+  it('removes an editor and prunes its pinned id', () => {
+    harness = mountSettings(baseConfig)
+    const remove = harness.container.querySelector<HTMLButtonElement>('button[aria-label="Remove"]')
+    expect(remove).toBeDefined()
+    act(() => { remove!.click() })
+    const blob = harness.update.mock.calls[0]?.[1] as { customEditors: unknown[]; pinned: string[] }
+    expect(blob.customEditors).toHaveLength(0)
+    expect(blob.pinned).toEqual(['vscode'])
+  })
+
+  it('shows the validity hint when a row is incomplete', () => {
+    harness = mountSettings({
+      sshHost: '',
+      customEditors: [{ id: 'x', name: 'Bad', urlTemplate: 'x://file/x', isVscodeFamily: true }],
+      pinned: [],
+    })
+    expect(harness.container.textContent).toContain('are not shown in the menu')
+  })
+
+  it('edits the VSCode-family flag of one row', () => {
+    harness = mountSettings(baseConfig)
+    const checkbox = harness.container.querySelector<HTMLInputElement>('input[type="checkbox"]')
+    expect(checkbox?.checked).toBe(false)
+    act(() => { checkbox!.click() })
+    const blob = harness.update.mock.calls[0]?.[1] as { customEditors: { isVscodeFamily: boolean }[] }
+    expect(blob.customEditors[0]?.isVscodeFamily).toBe(true)
+  })
+})
diff --git a/tests/open-with.spec.ts b/tests/open-with.spec.ts
new file mode 100644
index 0000000..beb3d76
--- /dev/null
+++ b/tests/open-with.spec.ts
@@ -0,0 +1,150 @@
+/**
+ * The file tree "open with" pure logic: config parsing (tolerant), target
+ * resolution (built-ins + custom, SSH filtering), URL building (local file
+ * URLs and VSCode-family SSH-remote URLs) and the custom-editor validators.
+ */
+import { describe, expect, it } from 'vitest'
+import {
+  isValidCustomEditor,
+  newCustomEditorId,
+  normalizeUrlPath,
+  openWithSshActive,
+  openWithUrl,
+  parseOpenWithConfig,
+  resolveOpenWithTargets,
+  type CustomEditor,
+  type OpenWithTarget,
+} from '../src/client/open-with.ts'
+
+describe('parseOpenWithConfig', () => {
+  it('returns the defaults for null / non-object / array values', () => {
+    expect(parseOpenWithConfig(null)).toEqual({ sshHost: '', customEditors: [], pinned: [] })
+    expect(parseOpenWithConfig('junk')).toEqual({ sshHost: '', customEditors: [], pinned: [] })
+    expect(parseOpenWithConfig([])).toEqual({ sshHost: '', customEditors: [], pinned: [] })
+  })
+
+  it('keeps structurally valid custom editors (incl. in-progress rows) and drops junk', () => {
+    const config = parseOpenWithConfig({
+      sshHost: 'dev',
+      customEditors: [
+        { id: 'a', name: 'Windsurf', urlTemplate: 'windsurf://file/{path}', isVscodeFamily: false },
+        { id: 'b', name: '', urlTemplate: 'b://file/{path}', isVscodeFamily: true },
+        { id: 'c', name: 'Trae', urlTemplate: 'trae://file/{path}', isVscodeFamily: true },
+        'junk',
+        null,
+        42,
+      ],
+      pinned: ['vscode', 'custom:a', 42, '', 'custom:c'],
+    })
+    expect(config.sshHost).toBe('dev')
+    expect(config.customEditors.map(editor => editor.id)).toEqual(['a', 'b', 'c'])
+    expect(config.pinned).toEqual(['vscode', 'custom:a', 'custom:c'])
+  })
+})
+
+describe('resolveOpenWithTargets', () => {
+  const localCustom: CustomEditor = { id: 'e1', name: 'Windsurf', urlTemplate: 'windsurf://file/{path}', isVscodeFamily: false }
+  const familyCustom: CustomEditor = { id: 'e2', name: 'Zed-like fork', urlTemplate: 'x-zed://file/{path}', isVscodeFamily: true }
+
+  it('lists built-ins first, then custom editors (local mode)', () => {
+    const targets = resolveOpenWithTargets(parseOpenWithConfig({ customEditors: [localCustom] }))
+    expect(targets.map(target => target.id)).toEqual(['explorer', 'vscode', 'cursor', 'zed', 'custom:e1'])
+    expect(targets[0]?.kind).toBe('reveal')
+    expect(targets[1]?.urlTemplate).toBe('vscode://file/{path}')
+  })
+
+  it('excludes incomplete custom-editor rows from the menu (they stay in the blob)', () => {
+    const targets = resolveOpenWithTargets(parseOpenWithConfig({
+      customEditors: [
+        { id: 'e1', name: 'Windsurf', urlTemplate: 'windsurf://file/{path}', isVscodeFamily: false },
+        { id: 'e2', name: '', urlTemplate: 'incomplete://file/{path}', isVscodeFamily: true },
+      ],
+    }))
+    expect(targets.map(target => target.id)).toEqual(['explorer', 'vscode', 'cursor', 'zed', 'custom:e1'])
+  })
+
+  it('drops local-only targets in SSH mode (file manager, Zed, non-VSCode custom)', () => {
+    const config = parseOpenWithConfig({ sshHost: 'dev', customEditors: [localCustom, familyCustom] })
+    const targets = resolveOpenWithTargets(config)
+    expect(targets.map(target => target.id)).toEqual(['vscode', 'cursor', 'custom:e2'])
+  })
+
+  it('prunes unknown pinned ids only when resolving (the parse keeps them)', () => {
+    const config = parseOpenWithConfig({ pinned: ['ghost'] })
+    expect(config.pinned).toEqual(['ghost'])
+    expect(resolveOpenWithTargets(config).map(target => target.id)).toContain('vscode')
+  })
+})
+
+describe('openWithUrl', () => {
+  const targets = resolveOpenWithTargets(parseOpenWithConfig({}))
+  const byId = (id: string): OpenWithTarget => {
+    const target = targets.find(item => item.id === id)
+    if (target === undefined) throw new Error(`no target ${id}`)
+    return target
+  }
+
+  it('builds local file URLs with the raw path (backslashes normalized)', () => {
+    expect(openWithUrl(byId('vscode'), '/home/u/f.ts', parseOpenWithConfig({}))).toBe('vscode://file//home/u/f.ts')
+    expect(openWithUrl(byId('vscode'), 'C:\\Users\\u\\f.ts', parseOpenWithConfig({}))).toBe('vscode://file/C:/Users/u/f.ts')
+    expect(openWithUrl(byId('zed'), '/x/y', parseOpenWithConfig({}))).toBe('zed://file//x/y')
+  })
+
+  it('builds SSH-remote URLs for VSCode-family targets in SSH mode', () => {
+    const config = parseOpenWithConfig({ sshHost: 'dev' })
+    expect(openWithUrl(byId('vscode'), '/home/u/f.ts', config))
+      .toBe('vscode://vscode-remote/ssh-remote+dev/home/u/f.ts')
+    expect(openWithUrl(byId('cursor'), '/home/u/f.ts', config))
+      .toBe('cursor://vscode-remote/ssh-remote+dev/home/u/f.ts')
+  })
+
+  it('keeps the local URL form for non-VSCode-family targets even in SSH mode', () => {
+    // (Such targets are hidden from the SSH menu; the URL builder stays honest.)
+    expect(openWithUrl(byId('zed'), '/x', parseOpenWithConfig({ sshHost: 'dev' }))).toBe('zed://file//x')
+  })
+
+  it('returns undefined for reveal targets and malformed templates', () => {
+    expect(openWithUrl(byId('explorer'), '/x', parseOpenWithConfig({}))).toBeUndefined()
+    const noScheme: OpenWithTarget = { id: 'x', name: '', kind: 'url', urlTemplate: 'not-a-url {path}', isVscodeFamily: false, localOnly: false }
+    expect(openWithUrl(noScheme, '/x', parseOpenWithConfig({}))).toBeUndefined()
+    const noSlash: OpenWithTarget = { id: 'y', name: '', kind: 'url', urlTemplate: 'a:file/{path}', isVscodeFamily: false, localOnly: false }
+    expect(openWithUrl(noSlash, '/x', parseOpenWithConfig({}))).toBeUndefined()
+  })
+
+  it('uses the custom template scheme for SSH URLs of VSCode-family custom editors', () => {
+    const config = parseOpenWithConfig({
+      sshHost: 'dev',
+      customEditors: [
+        { id: 'e', name: 'Fork', urlTemplate: 'myfork://file/{path}', isVscodeFamily: true },
+      ],
+    })
+    const targets = resolveOpenWithTargets(config)
+    expect(openWithUrl(targets[targets.length - 1]!, '/r/f.ts', config))
+      .toBe('myfork://vscode-remote/ssh-remote+dev/r/f.ts')
+  })
+})
+
+describe('helpers', () => {
+  it('normalizeUrlPath converts backslashes to slashes', () => {
+    expect(normalizeUrlPath('a\\b\\c')).toBe('a/b/c')
+  })
+
+  it('openWithSshActive trims the host', () => {
+    expect(openWithSshActive(parseOpenWithConfig({ sshHost: '  ' }))).toBe(false)
+    expect(openWithSshActive(parseOpenWithConfig({ sshHost: ' dev ' }))).toBe(true)
+  })
+
+  it('isValidCustomEditor requires a name, a {path} placeholder and a scheme:// prefix', () => {
+    expect(isValidCustomEditor({ name: 'A', urlTemplate: 'a://file/{path}' })).toBe(true)
+    expect(isValidCustomEditor({ name: '', urlTemplate: 'a://file/{path}' })).toBe(false)
+    expect(isValidCustomEditor({ name: 'A', urlTemplate: 'a://file/x' })).toBe(false)
+    expect(isValidCustomEditor({ name: 'A', urlTemplate: 'a:file/{path}' })).toBe(false)
+  })
+
+  it('newCustomEditorId yields unique non-empty ids', () => {
+    const first = newCustomEditorId()
+    const second = newCustomEditorId()
+    expect(first).not.toBe(second)
+    expect(first.length).toBeGreaterThan(0)
+  })
+})
diff --git a/tests/smoke.spec.ts b/tests/smoke.spec.ts
index c838947..2827ea4 100644
--- a/tests/smoke.spec.ts
+++ b/tests/smoke.spec.ts
@@ -84,6 +84,7 @@ describe('host plugin smoke', () => {
       '/sidebar/api',
       '/sidebar/upload',
       '/sidebar/bundle',
+      '/sidebar/archive',
       '/sidebar/file',
       '/sidebar/html',
     ])
@@ -738,6 +739,25 @@ const mountWithSettings = (settings?: unknown, home?: string): SidebarWebRoute =
   return routes.find(route => route.path === '/sidebar/api')!
 }
 
+describe('open.external route', () => {
+  it('rejects an unknown action with bad-request (before anything spawns)', async () => {
+    const route = mountWithSettings()
+    const result = await invoke(route, 'open.external', { action: 'open-ish', path: '/tmp/a.txt' })
+    expect(result).toMatchObject({ ok: false, error: { code: 'bad-request' } })
+  })
+
+  it('rejects http(s) URLs and relative reveal paths before spawning', async () => {
+    const route = mountWithSettings()
+    const https = await invoke(route, 'open.external', { action: 'url', url: 'https://example.com' })
+    expect(https).toMatchObject({ ok: false, error: { code: 'bad-request' } })
+    const relative = await invoke(route, 'open.external', { action: 'reveal', path: 'relative/path' })
+    expect(relative).toMatchObject({ ok: false, error: { code: 'fs-error' } })
+    // A missing field never reaches launchExternal either.
+    const empty = await invoke(route, 'open.external', { action: 'url' })
+    expect(empty).toMatchObject({ ok: false, error: { code: 'bad-request' } })
+  })
+})
+
 describe('side card settings routes', () => {
   it('serves the schema defaults when the settings service is absent', async () => {
     const route = mountWithSettings(undefined)
diff --git a/tests/zip.spec.ts b/tests/zip.spec.ts
new file mode 100644
index 0000000..b1a780d
--- /dev/null
+++ b/tests/zip.spec.ts
@@ -0,0 +1,436 @@
+/**
+ * ZIP builder + /sidebar/archive route.
+ *
+ * Two layers, no third-party ZIP dependency in either direction:
+ *  - `buildZip` is checked by a minimal reader written HERE (EOCD → central
+ *    directory → local header → inflate), so the test proves the bytes on the
+ *    wire, not the writer's own bookkeeping. `unzip -t` is an extra check when
+ *    the binary happens to exist (CI runners do not ship it).
+ *  - the route is mounted against a fake cordis context (the same shape
+ *    smoke.spec.ts uses) and answers a real request over a real temp
+ *    workspace, covering the fence, the parameter guards and a full
+ *    directory walk.
+ */
+import { afterEach, describe, expect, it } from 'vitest'
+import { spawnSync } from 'node:child_process'
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, statSync, symlinkSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { inflateRawSync } from 'node:zlib'
+import { apply } from '../src/index.ts'
+import { archiveUrl } from '../src/client/api.ts'
+import { archiveNameOf, collectZipEntries } from '../src/archive-route.ts'
+import { crc32, buildZip, type ZipEntry } from '../src/zip.ts'
+import { SidebarError } from '../src/wire.ts'
+import type { SidebarWebRoute, SidebarWebUpgradeRoute } from '../src/context-types.ts'
+
+/** One parsed central-directory row + its local payload. */
+interface ParsedEntry {
+  name: string
+  method: number
+  crc: number
+  compressedSize: number
+  size: number
+  flags: number
+  externalAttributes: number
+  isDirectory: boolean
+  data: Buffer
+}
+
+/**
+ * Minimal ZIP reader: locate the EOCD from the tail, walk the central
+ * directory, then read each local header's payload. Enough to verify names
+ * (UTF-8), methods, CRCs, sizes and both compression branches.
+ */
+function readZip(archive: Buffer): ParsedEntry[] {
+  const eocdAt = archive.lastIndexOf(Buffer.from([0x50, 0x4B, 0x05, 0x06]))
+  if (eocdAt < 0) throw new Error('no EOCD')
+  if (eocdAt + 22 !== archive.length) throw new Error('EOCD is not the last record')
+  const count = archive.readUInt16LE(eocdAt + 10)
+  const directorySize = archive.readUInt32LE(eocdAt + 12)
+  const directoryAt = archive.readUInt32LE(eocdAt + 16)
+  if (count > 0 && archive.readUInt32LE(directoryAt) !== 0x02014B50) throw new Error('bad central directory signature')
+  if (directoryAt + directorySize > eocdAt) throw new Error('central directory overruns the EOCD')
+
+  const entries: ParsedEntry[] = []
+  let cursor = directoryAt
+  for (let index = 0; index < count; index += 1) {
+    if (archive.readUInt32LE(cursor) !== 0x02014B50) throw new Error(`bad central header ${index}`)
+    const flags = archive.readUInt16LE(cursor + 8)
+    const method = archive.readUInt16LE(cursor + 10)
+    const crc = archive.readUInt32LE(cursor + 16)
+    const compressedSize = archive.readUInt32LE(cursor + 20)
+    const size = archive.readUInt32LE(cursor + 24)
+    const nameLength = archive.readUInt16LE(cursor + 28)
+    const extraLength = archive.readUInt16LE(cursor + 30)
+    const commentLength = archive.readUInt16LE(cursor + 32)
+    const externalAttributes = archive.readUInt32LE(cursor + 38)
+    const localAt = archive.readUInt32LE(cursor + 42)
+    const name = archive.subarray(cursor + 46, cursor + 46 + nameLength).toString('utf8')
+
+    if (archive.readUInt32LE(localAt) !== 0x04034B50) throw new Error(`bad local header for ${name}`)
+    const localNameLength = archive.readUInt16LE(localAt + 26)
+    const localExtraLength = archive.readUInt16LE(localAt + 28)
+    if (archive.readUInt32LE(localAt + 14) !== crc) throw new Error(`local CRC mismatch for ${name}`)
+    if (archive.readUInt32LE(localAt + 18) !== compressedSize) throw new Error(`local compressed size mismatch for ${name}`)
+    if (archive.readUInt32LE(localAt + 22) !== size) throw new Error(`local size mismatch for ${name}`)
+    const payloadAt = localAt + 30 + localNameLength + localExtraLength
+    const payload = archive.subarray(payloadAt, payloadAt + compressedSize)
+    entries.push({
+      name,
+      method,
+      crc,
+      compressedSize,
+      size,
+      flags,
+      externalAttributes,
+      isDirectory: name.endsWith('/'),
+      data: method === 8 ? inflateRawSync(payload) : Buffer.from(payload),
+    })
+    cursor += 46 + nameLength + extraLength + commentLength
+  }
+  return entries
+}
+
+/** /sidebar/archive mounted against a fake context, as the host runs it. */
+function mountArchive(): SidebarWebRoute {
+  const routes: SidebarWebRoute[] = []
+  const ctx = {
+    webRuntime: { trustedHosts: [] },
+    webServer: {
+      register: (route: SidebarWebRoute) => { routes.push(route); return () => {} },
+      registerUpgrade: (route: SidebarWebUpgradeRoute) => { void route; return () => {} },
+    },
+    sessions: { get: () => undefined },
+    tools: { register: () => () => {} },
+    effect: (fn: () => void | (() => void)) => { fn() },
+    inject: () => () => {},
+    on: () => () => {},
+    get: () => undefined,
+  }
+  apply(ctx as never)
+  const route = routes.find(candidate => candidate.path === '/sidebar/archive')
+  if (route === undefined) throw new Error('test setup: /sidebar/archive route not registered')
+  return route
+}
+
+/** One GET against a mounted route, collecting raw bytes. */
+async function get(route: SidebarWebRoute, url: string): Promise<{ status: number; headers: Record<string, string>; body: Buffer }> {
+  const out: { status: number; headers: Record<string, string>; chunks: Buffer[] } = { status: 200, headers: {}, chunks: [] }
+  const req = { method: 'GET', url, headers: { host: '127.0.0.1:3080' } } as never
+  const res = {
+    writeHead: (status: number, headers: Record<string, string> = {}) => { out.status = status; out.headers = headers },
+    end: (chunk?: Buffer | string) => { if (chunk !== undefined) out.chunks.push(Buffer.from(chunk)) },
+  } as never
+  await route.handler(req, res)
+  return { status: out.status, headers: out.headers, body: Buffer.concat(out.chunks) }
+}
+
+/** A temp workspace (plus an outside sibling) removed after each test. */
+const roots: string[] = []
+function tempRoot(): string {
+  const root = mkdtempSync(join(tmpdir(), 'dsh-sidebar-zip-'))
+  roots.push(root)
+  return root
+}
+afterEach(() => {
+  while (roots.length > 0) rmSync(roots.pop()!, { recursive: true, force: true })
+})
+
+describe('buildZip', () => {
+  it('round-trips a deflated file: name, content and CRC-32', async () => {
+    const root = tempRoot()
+    const path = join(root, 'hello.txt')
+    const content = 'hello zip\n'.repeat(200)
+    writeFileSync(path, content)
+    const archive = await buildZip([{ path, name: 'hello.txt' }])
+    const entries = readZip(archive)
+    expect(entries).toHaveLength(1)
+    const entry = entries[0]!
+    expect(entry.name).toBe('hello.txt')
+    expect(entry.method).toBe(8)
+    expect(entry.data.toString('utf8')).toBe(content)
+    expect(entry.crc).toBe(crc32(Buffer.from(content)))
+    expect(entry.size).toBe(Buffer.byteLength(content))
+    expect(entry.isDirectory).toBe(false)
+  })
+
+  it('stores incompressible data (method 0) and marks UTF-8 names (bit 11)', async () => {
+    const root = tempRoot()
+    const path = join(root, 'random.bin')
+    // High-entropy bytes: deflateRaw expands them (4096 → ~4100), so the
+    // writer must fall back to `store`. Generated from a fixed seed so the
+    // case stays deterministic.
+    const random = Buffer.alloc(4096)
+    let state = 0x9E3779B9
+    for (let i = 0; i < random.length; i += 1) {
+      state = (Math.imul(state, 1664525) + 1013904223) >>> 0
+      random[i] = (state >>> 16) & 0xFF
+    }
+    writeFileSync(path, random)
+    const archive = await buildZip([{ path, name: '数据/随机.bin' }])
+    const entries = readZip(archive)
+    expect(entries).toHaveLength(1)
+    const entry = entries[0]!
+    expect(entry.method).toBe(0)
+    expect(entry.name).toBe('数据/随机.bin')
+    expect((entry.flags & 0x0800) !== 0).toBe(true)
+    expect(entry.data.equals(random)).toBe(true)
+    expect(entry.crc).toBe(crc32(random))
+  })
+
+  it('writes directory rows with a trailing slash, zero payload and the dir attribute', async () => {
+    const root = tempRoot()
+    mkdirSync(join(root, 'nested'))
+    writeFileSync(join(root, 'nested', 'a.txt'), 'a')
+    const archive = await buildZip([
+      { path: join(root, 'nested'), name: 'nested', isDir: true },
+      { path: join(root, 'nested', 'a.txt'), name: 'nested/a.txt' },
+    ])
+    const entries = readZip(archive)
+    expect(entries.map(entry => entry.name)).toEqual(['nested/', 'nested/a.txt'])
+    const dir = entries[0]!
+    expect(dir.isDirectory).toBe(true)
+    expect(dir.size).toBe(0)
+    expect(dir.crc).toBe(0)
+    // The external-attributes word carries the Unix mode in the high half and
+    // the MS-DOS directory bit in the low half: without the mode Info-ZIP
+    // extracts every member as mode 000.
+    expect(dir.externalAttributes & 0x10).toBe(0x10)
+    expect(dir.externalAttributes >>> 16).toBe(0o40755)
+    expect(entries[1]!.externalAttributes & 0x10).toBe(0)
+    expect(entries[1]!.externalAttributes >>> 16).toBe(0o100644)
+  })
+
+  it('accepts an empty directory set and produces a valid empty archive', async () => {
+    const archive = await buildZip([])
+    expect(readZip(archive)).toEqual([])
+    expect(archive.readUInt32LE(archive.length - 22)).toBe(0x06054B50)
+  })
+
+  it('rejects an over-limit entry count before reading anything', async () => {
+    const root = tempRoot()
+    const path = join(root, 'a.txt')
+    writeFileSync(path, 'a')
+    await expect(buildZip([{ path, name: 'a.txt' }], { maxEntries: 0 })).rejects.toThrow(SidebarError)
+    await expect(buildZip([{ path, name: 'a.txt' }], { maxEntries: 0 })).rejects.toMatchObject({ code: 'fs-error' })
+  })
+
+  it('rejects an over-limit payload with fs-error', async () => {
+    const root = tempRoot()
+    const path = join(root, 'big.txt')
+    writeFileSync(path, 'x'.repeat(4096))
+    await expect(buildZip([{ path, name: 'big.txt' }], { maxBytes: 1024 }))
+      .rejects.toMatchObject({ code: 'fs-error' })
+  })
+
+  it('reports an unreadable source as fs-error and refuses traversal names', async () => {
+    const root = tempRoot()
+    await expect(buildZip([{ path: join(root, 'missing.txt'), name: 'missing.txt' }]))
+      .rejects.toMatchObject({ code: 'fs-error' })
+    await expect(buildZip([{ path: join(root, 'x'), name: '../escape.txt' }]))
+      .rejects.toMatchObject({ code: 'bad-request' })
+  })
+
+  it('passes `unzip -t` when the binary exists (skipped otherwise)', async () => {
+    const probe = spawnSync('unzip', ['-v'], { encoding: 'utf8' })
+    if (probe.error !== undefined || probe.status !== 0) return
+    const root = tempRoot()
+    const content = 'unzip parity\n'.repeat(100)
+    writeFileSync(join(root, 'a.txt'), content)
+    mkdirSync(join(root, 'dir'))
+    writeFileSync(join(root, 'dir', 'b.txt'), content)
+    const archive = await buildZip([
+      { path: join(root, 'a.txt'), name: 'a.txt' },
+      { path: join(root, 'dir'), name: 'dir', isDir: true },
+      { path: join(root, 'dir', 'b.txt'), name: 'dir/b.txt' },
+    ])
+    const file = join(root, 'out.zip')
+    writeFileSync(file, archive)
+    const result = spawnSync('unzip', ['-t', file], { encoding: 'utf8' })
+    expect(result.status, result.stderr).toBe(0)
+    expect(result.stdout).toContain('No errors detected')
+    // `-t` only checks CRCs; extract too, so a broken external-attributes word
+    // (Info-ZIP writes mode 000 files) cannot pass unnoticed.
+    const extracted = join(root, 'out')
+    const unpack = spawnSync('unzip', ['-o', file, '-d', extracted], { encoding: 'utf8' })
+    expect(unpack.status, unpack.stderr).toBe(0)
+    const inMode = statSync(join(root, 'a.txt')).mode & 0o777
+    const outMode = statSync(join(extracted, 'a.txt')).mode & 0o777
+    expect(outMode).toBe(inMode & 0o644)
+    expect(readFileSync(join(extracted, 'a.txt'), 'utf8')).toBe(content)
+    expect(readFileSync(join(extracted, 'dir', 'b.txt'), 'utf8')).toBe(content)
+  })
+})
+
+describe('collectZipEntries', () => {
+  it('walks directories depth-first in name order and bounds the row count', async () => {
+    const root = tempRoot()
+    mkdirSync(join(root, 'd'))
+    writeFileSync(join(root, 'a.txt'), 'a')
+    writeFileSync(join(root, 'd', 'b.txt'), 'b')
+    const entries: ZipEntry[] = []
+    await collectZipEntries(root, 'root', entries)
+    expect(entries.map(entry => entry.name)).toEqual(['root', 'root/a.txt', 'root/d', 'root/d/b.txt'])
+    expect(entries[0]!.isDir).toBe(true)
+
+    const bounded: ZipEntry[] = []
+    await expect(collectZipEntries(root, 'root', bounded, 2))
+      .rejects.toMatchObject({ code: 'fs-error' })
+    // The bound stops the walk early instead of filling the list first.
+    expect(bounded.length).toBeLessThanOrEqual(2)
+  })
+
+  it('treats an unreadable row as fs-error', async () => {
+    const root = tempRoot()
+    const entries: ZipEntry[] = []
+    await expect(collectZipEntries(join(root, 'missing'), 'missing', entries))
+      .rejects.toMatchObject({ code: 'fs-error' })
+  })
+})
+
+describe('archiveNameOf', () => {
+  it('strips separators / quotes / control chars and applies the .zip suffix once', () => {
+    expect(archiveNameOf(null)).toBe('archive.zip')
+    expect(archiveNameOf('')).toBe('archive.zip')
+    expect(archiveNameOf('   ')).toBe('archive.zip')
+    expect(archiveNameOf('docs')).toBe('docs.zip')
+    expect(archiveNameOf('docs.zip')).toBe('docs.zip')
+    expect(archiveNameOf('DOCS.ZIP')).toBe('DOCS.ZIP')
+    // Path separators, traversal dots and quotes never survive.
+    expect(archiveNameOf('../../etc/passwd')).toBe('etcpasswd.zip')
+    expect(archiveNameOf('a\\b".zip')).toBe('ab.zip')
+    expect(archiveNameOf('bad\u0000name\u001F.zip')).toBe('badname.zip')
+    // Length is capped, and a bare ".zip" input falls back to the default.
+    expect(archiveNameOf(`${'x'.repeat(300)}.zip`).length).toBe(124)
+    expect(archiveNameOf('.zip')).toBe('archive.zip')
+  })
+})
+
+describe('/sidebar/archive route', () => {
+  it('archiveUrl builds the GET URL the route parses (repeated path, encoded)', () => {
+    const url = archiveUrl({ sessionId: 's-1', cwd: '/work tree' }, ['/work tree/a b.txt', '/work tree/子目录'], 'my zip.zip')
+    const parsed = new URL(url, 'http://dsh.internal')
+    expect(parsed.pathname).toBe('/sidebar/archive')
+    expect(parsed.searchParams.get('sessionId')).toBe('s-1')
+    expect(parsed.searchParams.get('cwd')).toBe('/work tree')
+    expect(parsed.searchParams.get('name')).toBe('my zip.zip')
+    expect(parsed.searchParams.getAll('path')).toEqual(['/work tree/a b.txt', '/work tree/子目录'])
+    // A scope without a cwd omits the parameter entirely (same as downloadUrl).
+    expect(archiveUrl({ sessionId: 's-2' }, ['/a'], 'x.zip')).toBe('/sidebar/archive?sessionId=s-2&name=x.zip&path=%2Fa')
+  })
+
+  it('zips a selected file and a selected directory, walking it recursively', async () => {
+    const root = tempRoot()
+    const workspace = join(root, 'workspace')
+    mkdirSync(join(workspace, 'src', 'deep'), { recursive: true })
+    writeFileSync(join(workspace, 'src', 'index.ts'), 'export {}\n')
+    writeFileSync(join(workspace, 'src', 'deep', 'nested.ts'), 'nested\n')
+    writeFileSync(join(workspace, 'notes.md'), '# notes\n')
+    const route = mountArchive()
+    const url = `/sidebar/archive?sessionId=s-zip&cwd=${encodeURIComponent(workspace)}`
+      + `&name=${encodeURIComponent('我的打包.zip')}`
+      + `&path=${encodeURIComponent(join(workspace, 'src'))}`
+      + `&path=${encodeURIComponent(join(workspace, 'notes.md'))}`
+    const response = await get(route, url)
+    expect(response.status).toBe(200)
+    expect(response.headers['content-type']).toBe('application/zip')
+    expect(response.headers['content-disposition']).toBe('attachment; filename="我的打包.zip"')
+    expect(Number(response.headers['content-length'])).toBe(response.body.byteLength)
+    const entries = readZip(response.body)
+    expect(entries.map(entry => entry.name)).toEqual([
+      'src/',
+      'src/deep/',
+      'src/deep/nested.ts',
+      'src/index.ts',
+      'notes.md',
+    ])
+    const byName = new Map(entries.map(entry => [entry.name, entry]))
+    expect(byName.get('src/index.ts')!.data.toString('utf8')).toBe('export {}\n')
+    expect(byName.get('notes.md')!.data.toString('utf8')).toBe('# notes\n')
+  })
+
+  it('never follows a symlink out of the workspace', async () => {
+    const root = tempRoot()
+    const workspace = join(root, 'workspace')
+    const outside = join(root, 'outside')
+    mkdirSync(workspace)
+    mkdirSync(outside)
+    writeFileSync(join(outside, 'secret.txt'), 'secret')
+    try {
+      symlinkSync(outside, join(workspace, 'link'))
+      // A file INSIDE the workspace, so the archive itself is readable.
+      writeFileSync(join(workspace, 'keep.txt'), 'keep')
+    } catch {
+      return // symlink creation needs privileges on Windows
+    }
+    const route = mountArchive()
+    const scope = `sessionId=s-zip&cwd=${encodeURIComponent(workspace)}`
+    // Selecting the escaping link refuses at the workspace fence (the route
+    // canonicalizes before walking), so its target is never read…
+    const linked = await get(route, `/sidebar/archive?${scope}&path=${encodeURIComponent(join(workspace, 'link'))}`)
+    expect(linked.status).toBe(403)
+    // …and walking the containing directory reports the link as an entry-less
+    // row instead of descending into it.
+    const walked = await get(route, `/sidebar/archive?${scope}&path=${encodeURIComponent(workspace)}`)
+    expect(walked.status).toBe(200)
+    const entries = readZip(walked.body)
+    expect(entries.map(entry => entry.name)).toEqual(['workspace/', 'workspace/keep.txt'])
+    expect(entries.some(entry => entry.data.toString('utf8').includes('secret'))).toBe(false)
+  })
+
+  it('refuses a path outside the workspace with 403', async () => {
+    const root = tempRoot()
+    const workspace = join(root, 'workspace')
+    const outside = join(root, 'outside')
+    mkdirSync(workspace)
+    mkdirSync(outside)
+    writeFileSync(join(outside, 'secret.txt'), 'secret')
+    const route = mountArchive()
+    const url = `/sidebar/archive?sessionId=s-zip&cwd=${encodeURIComponent(workspace)}`
+      + `&path=${encodeURIComponent(join(outside, 'secret.txt'))}`
+    const response = await get(route, url)
+    expect(response.status).toBe(403)
+    expect(JSON.parse(response.body.toString('utf8'))).toMatchObject({ ok: false, error: { code: 'forbidden' } })
+  })
+
+  it('rejects a missing path (and a missing sessionId) with 400', async () => {
+    const root = tempRoot()
+    const workspace = join(root, 'workspace')
+    mkdirSync(workspace)
+    const route = mountArchive()
+    const noPath = await get(route, `/sidebar/archive?sessionId=s-zip&cwd=${encodeURIComponent(workspace)}`)
+    expect(noPath.status).toBe(400)
+    expect(JSON.parse(noPath.body.toString('utf8'))).toMatchObject({ ok: false, error: { code: 'bad-request' } })
+    const noSession = await get(route, `/sidebar/archive?cwd=${encodeURIComponent(workspace)}&path=${encodeURIComponent(workspace)}`)
+    expect(noSession.status).toBe(400)
+  })
+
+  it('sanitizes the download name (separators stripped, default and suffix applied)', async () => {
+    const root = tempRoot()
+    const workspace = join(root, 'workspace')
+    mkdirSync(workspace)
+    writeFileSync(join(workspace, 'a.txt'), 'a')
+    const route = mountArchive()
+    const path = encodeURIComponent(join(workspace, 'a.txt'))
+    const scope = `sessionId=s-zip&cwd=${encodeURIComponent(workspace)}&path=${path}`
+    const traversal = await get(route, `/sidebar/archive?${scope}&name=${encodeURIComponent('../evil")b.zip')}`)
+    expect(traversal.headers['content-disposition']).toBe('attachment; filename="evil)b.zip"')
+    const bare = await get(route, `/sidebar/archive?${scope}&name=docs`)
+    expect(bare.headers['content-disposition']).toBe('attachment; filename="docs.zip"')
+    const fallback = await get(route, `/sidebar/archive?${scope}`)
+    expect(fallback.headers['content-disposition']).toBe('attachment; filename="archive.zip"')
+  })
+
+  it('rejects a non-GET method', async () => {
+    const route = mountArchive()
+    const out: { status: number; body: string } = { status: 200, body: '' }
+    const req = { method: 'POST', url: '/sidebar/archive?sessionId=s&path=/x', headers: { host: '127.0.0.1:3080' } } as never
+    const res = {
+      writeHead: (status: number) => { out.status = status },
+      end: (chunk?: string) => { out.body += String(chunk ?? '') },
+    } as never
+    await route.handler(req, res)
+    expect(out.status).toBe(405)
+  })
+})