@dsh-electron/dsh-plugin-multi-root-workspace 0.1.5 → 0.1.7

package/lib/client.js

@@ -11,6 +11,15 @@ window.__ModuleLoader__.load({
 		var __getOwnPropNames = Object.getOwnPropertyNames;
 		var __getProtoOf = Object.getPrototypeOf;
 		var __hasOwnProp = Object.prototype.hasOwnProperty;
+		var __exportAll = (all, no_symbols) => {
+			let target = {};
+			for (var name in all) __defProp(target, name, {
+				get: all[name],
+				enumerable: true
+			});
+			if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+			return target;
+		};
 		var __copyProps = (to, from, except, desc) => {
 			if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
 				key = keys[i];
@@ -27,8 +36,11 @@ window.__ModuleLoader__.load({
 		}) : target, mod));
 		//#endregion
 		let react = require("react");
+		let react_dom = require("react-dom");
 		let _deepseek_ai_dsh_client_ui_primitives = require("@deepseek-ai/dsh-client-ui-primitives");
 		_deepseek_ai_dsh_client_ui_primitives = __toESM(_deepseek_ai_dsh_client_ui_primitives, 1);
+		require("@deepseek-ai/cordis");
+		let _deepseek_ai_dsh_client_store = require("@deepseek-ai/dsh-client-store");
 		let react_jsx_runtime = require("react/jsx-runtime");
 		//#region src/compat/client-session.ts
 		/**
@@ -44,6 +56,12 @@ window.__ModuleLoader__.load({
 			if (typeof current === "string" && current !== "") return current;
 			return mainViewSessionId(snapshot.byId);
 		}
+		/** Observe native catalog changes when this surface provides a subscribable store. */
+		function subscribeSessions(sessions, listener) {
+			if (sessions === null || typeof sessions !== "object") return () => {};
+			const list = sessions.list;
+			return typeof list?.subscribe === "function" ? list.subscribe(listener) : () => {};
+		}
 		/**
 		* The list snapshot, when the service actually exposes one.
 		*
@@ -1111,6 +1129,7 @@ window.__ModuleLoader__.load({
 		}
 		const anyString = /^[\s\S]{0,}$/;
 		const number$1 = /^-?\d+(?:\.\d+)?$/;
+		const boolean$1 = /^(?:true|false)$/i;
 		const lowercase = /^[^A-Z]*$/;
 		const uppercase = /^[^a-z]*$/;
 		//#endregion
@@ -1898,6 +1917,24 @@ window.__ModuleLoader__.load({
 			$ZodCheckNumberFormat.init(inst, def);
 			$ZodNumber.init(inst, def);
 		});
+		const $ZodBoolean = /*@__PURE__*/ $constructor("$ZodBoolean", (inst, def) => {
+			$ZodType.init(inst, def);
+			inst._zod.pattern = boolean$1;
+			inst._zod.parse = (payload, _ctx) => {
+				if (def.coerce) try {
+					payload.value = Boolean(payload.value);
+				} catch (_) {}
+				const input = payload.value;
+				if (typeof input === "boolean") return payload;
+				payload.issues.push({
+					expected: "boolean",
+					code: "invalid_type",
+					input,
+					inst
+				});
+				return payload;
+			};
+		});
 		const $ZodUnknown = /*@__PURE__*/ $constructor("$ZodUnknown", (inst, def) => {
 			$ZodType.init(inst, def);
 			inst._zod.parse = (payload) => payload;
@@ -3340,6 +3377,13 @@ window.__ModuleLoader__.load({
 			});
 		}
 		// @__NO_SIDE_EFFECTS__
+		function _boolean(Class, params) {
+			return new Class({
+				type: "boolean",
+				...normalizeParams(params)
+			});
+		}
+		// @__NO_SIDE_EFFECTS__
 		function _unknown(Class) {
 			return new Class({ type: "unknown" });
 		}
@@ -4118,6 +4162,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				if (rest.length) json.allOf = [...json.allOf ?? [], ...rest.map((m) => ({ multipleOf: m }))];
 			}
 		};
+		const booleanProcessor = (_schema, _ctx, json, _params) => {
+			json.type = "boolean";
+		};
 		const neverProcessor = (_schema, _ctx, json, _params) => {
 			json.not = {};
 		};
@@ -4865,6 +4912,14 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		function int(params) {
 			return /* @__PURE__ */ _int(ZodNumberFormat, params);
 		}
+		const ZodBoolean = /*@__PURE__*/ $constructor("ZodBoolean", (inst, def) => {
+			$ZodBoolean.init(inst, def);
+			ZodType.init(inst, def);
+			inst._zod.processJSONSchema = (ctx, json, params) => booleanProcessor(inst, ctx, json, params);
+		});
+		function boolean(params) {
+			return /* @__PURE__ */ _boolean(ZodBoolean, params);
+		}
 		const ZodUnknown = /*@__PURE__*/ $constructor("ZodUnknown", (inst, def) => {
 			$ZodUnknown.init(inst, def);
 			ZodType.init(inst, def);
@@ -5208,8 +5263,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		* - **One shape per endpoint.** {@link PanelResponseMap} is the single mapping
 		*   from endpoint to response type, so the panel cannot silently decode one
 		*   endpoint's answer as another's. `reveal` answers with
-		*   {@link RevealedView}; every other endpoint answers with a whole
-		*   {@link RootsView}. The host builds those answers in `command.ts` and the
+		*   {@link RevealedView}; root-management endpoints answer with
+		*   {@link RootsView}.
+		*   The host builds those answers in `command.ts` and the
 		*   panel parses them here — one definition, two consumers.
 		* - **Runtime validation at the boundary.** The payload arrives from a browser
 		*   and the answer arrives from the host; neither is trusted to match the
@@ -5236,6 +5292,11 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			id: string().optional(),
 			path: string().optional(),
 			alias: string().optional(),
+			access: _enum([
+				"inherit",
+				"read-write",
+				"read-only"
+			]).optional(),
 			beforeEntry: object({
 				ordinal: number().int().positive(),
 				id: string(),
@@ -5261,12 +5322,33 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				"redirected",
 				"invalid"
 			]),
-			detail: string().optional()
+			access: _enum([
+				"inherit",
+				"read-write",
+				"read-only"
+			]).optional(),
+			detail: string().optional(),
+			effectiveAccess: _enum([
+				"read-only",
+				"read-write",
+				"full-access",
+				"unavailable"
+			]).optional()
 		});
 		const rootsViewSchema = object({
 			primaryRoot: string(),
 			primaryName: string().optional(),
+			effectiveCwd: string().optional(),
+			mode: _enum([
+				"read-only",
+				"workspace-write",
+				"danger-full-access"
+			]).optional(),
+			cappedTools: array(string()).optional(),
+			toolAccessInvalid: boolean().optional(),
 			roots: array(rootViewSchema),
+			limit: number().int().nonnegative().optional(),
+			count: number().int().nonnegative().optional(),
 			unavailable: string().optional()
 		});
 		const revealedViewSchema = object({ revealed: string() });
@@ -5292,7 +5374,13 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				value: {
 					primaryRoot: view.primaryRoot,
 					...view.primaryName === void 0 ? {} : { primaryName: view.primaryName },
+					...view.effectiveCwd === void 0 ? {} : { effectiveCwd: view.effectiveCwd },
+					...view.mode === void 0 ? {} : { mode: view.mode },
+					...view.cappedTools === void 0 ? {} : { cappedTools: view.cappedTools },
+					...view.toolAccessInvalid === void 0 ? {} : { toolAccessInvalid: view.toolAccessInvalid },
 					roots: view.roots.map(narrowRootView),
+					limit: view.limit ?? Number.MAX_SAFE_INTEGER,
+					count: view.count ?? view.roots.length,
 					...view.unavailable === void 0 ? {} : { unavailable: view.unavailable }
 				}
 			};
@@ -5334,6 +5422,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				path: value.path,
 				addedAt: value.addedAt,
 				state: value.state,
+				access: value.access ?? "inherit",
+				...value.effectiveAccess === void 0 ? {} : { effectiveAccess: value.effectiveAccess },
 				...value.alias === void 0 ? {} : { alias: value.alias },
 				...value.detail === void 0 ? {} : { detail: value.detail }
 			};
@@ -5357,18 +5447,33 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		* @module @dsh-electron/dsh-plugin-multi-root-workspace/client/locales
 		*/
 		/** The locale namespace this plugin owns. */
-		const NS = "multiRootWorkspace";
+		const NS$2 = "multiRootWorkspace";
 		/** Chinese copy (the canonical shape). */
 		const zh = {
+			"panel.mode": "当前会话权限：",
+			"panel.effectiveAccess": "当前有效：",
+			"panel.toolCaps": "工具 {tools} 对附属根始终只读。",
+			"panel.invalidCap": "工具权限配置无效，附属根写入全部被拒绝。",
+			"mode.read-only": "只读",
+			"mode.workspace-write": "读写",
+			"mode.danger-full-access": "完全权限（Full-access）",
+			"effective.read-only": "只读",
+			"effective.read-write": "读写",
+			"effective.full-access": "完全权限（Full-access）",
+			"effective.unavailable": "不可用",
 			"action.label": "工作区目录",
 			"action.title": "管理本会话的附属工作目录",
+			"switcher.manage": "管理工作区目录…",
 			"panel.title": "工作区目录",
-			"panel.subtitle": "主目录和附加目录遵循当前沙箱模式；workspace-write 可写，read-only 下都不可写。",
-			"panel.primary": "主工作目录",
-			"panel.primaryNote": "当前工作区主工作目录，不可移除",
+			"panel.subtitle": "主目录与「跟随会话」的附加目录遵循当前沙箱模式；目录也可固定为只读或读写。",
+			"panel.primary": "主根",
+			"panel.primaryNote": "会话原始项目，不可移除",
+			"panel.cwd": "当前执行目录",
+			"panel.cwdNote": "切换目录不会增加授权",
 			"panel.additional": "附属工作目录",
+			"panel.limitReached": "已达到附加目录数量上限，请先移除一个再添加。",
 			"panel.empty": "还没有附属工作目录。",
-			"panel.emptyHint": "添加后，Agent 可在同一会话中读写该目录；macOS/Linux 的受限 bash 同步生效，Windows 当前仅覆盖 fs 写路径。",
+			"panel.emptyHint": "添加后，Agent 可在同一会话中读写该目录，受限 shell 和终端同步生效。",
 			"panel.noSession": "当前没有活动会话",
 			"panel.loading": "正在读取…",
 			"panel.retry": "重试",
@@ -5386,9 +5491,20 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			"panel.copyPath": "复制路径",
 			"panel.copied": "已复制",
 			"panel.reveal": "在文件管理器中显示",
+			"panel.reRegister": "重新登记（保留原访问级别）",
 			"panel.moveUp": "上移",
 			"panel.moveDown": "下移",
-			"state.available": "可写",
+			"access.inherit": "跟随会话",
+			"access.readWrite": "固定读写",
+			"access.readOnly": "只读",
+			"panel.accessLabel": "访问权限",
+			"panel.accessInherit": "设为跟随会话",
+			"panel.accessReadOnly": "设为只读",
+			"panel.accessReadWrite": "设为固定读写",
+			"panel.accessUpgradeConfirm": "将该目录的权限改为「{access}」？在某些沙箱模式下，这将允许 Agent 修改其中的文件。",
+			"panel.accessUpgradeTitle": "扩大访问权限",
+			"panel.accessUpgradeDo": "修改",
+			"state.available": "已授予",
 			"state.missing": "目录不存在，暂不授予",
 			"state.redirected": "登记目录已被替换（现在指向别处），暂不授予",
 			"state.invalid": "登记无效",
@@ -5404,23 +5520,42 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			"error.invalid-ref": "请求缺少必要的标识。",
 			"error.storage-unavailable": "根目录登记的存储不可用，请检查 $DSH_HOME/storages 下的文件。",
 			"error.registry-contended": "根目录登记正由另一个 DSH 进程占用；本进程不会授予附加根。关闭另一个进程后点重试。",
+			"error.root-limit-reached": "已达到附加目录数量上限，请先移除一个再添加。",
+			"error.config-invalid": "根目录登记的配置无效；本进程不会授予附加根，请修正配置后重启。",
+			"error.root-unavailable": "该目录当前不可用，只能设为只读；请先恢复目录再调整权限。",
 			"error.reveal-unavailable": "无法打开系统的文件管理器；登记项不受影响，路径仍可复制。",
 			"error.unavailable": "无法连接到 dsh 主进程。",
 			"error.copy-failed": "无法写入剪贴板，请检查浏览器的剪贴板权限。",
 			"error.session-not-found": "找不到该会话；请先打开一个工作区会话。",
+			"error.unsupported-path": "该路径是网络或设备路径，Windows ACL 隔离无法覆盖它。",
 			"error.fallback": "操作失败。"
 		};
 		/** English copy, pinned to the Chinese key set. */
 		const en = {
+			"panel.mode": "Current session access:",
+			"panel.effectiveAccess": "Effective:",
+			"panel.toolCaps": "The tools {tools} always have read-only access to additional roots.",
+			"panel.invalidCap": "Invalid tool access configuration refuses all additional-root writes.",
+			"mode.read-only": "Read-only",
+			"mode.workspace-write": "Read-write",
+			"mode.danger-full-access": "Full-access",
+			"effective.read-only": "Read-only",
+			"effective.read-write": "Read-write",
+			"effective.full-access": "Full-access",
+			"effective.unavailable": "Unavailable",
 			"action.label": "Folders",
 			"action.title": "Manage this session's secondary working directories",
+			"switcher.manage": "Manage workspace folders…",
 			"panel.title": "Workspace folders",
-			"panel.subtitle": "The primary and additional folders follow the current sandbox mode: writable in workspace-write and read-only in read-only.",
-			"panel.primary": "Primary working directory",
-			"panel.primaryNote": "This workspace's primary working directory; it cannot be removed",
+			"panel.subtitle": "The primary root and inherit folders follow the current sandbox mode; a folder can also be pinned read-only or read-write.",
+			"panel.primary": "Primary root",
+			"panel.primaryNote": "The session's original project; it cannot be removed",
+			"panel.cwd": "Current working directory",
+			"panel.cwdNote": "Changing directory does not grant access",
 			"panel.additional": "Secondary working directories",
+			"panel.limitReached": "The additional-folder limit is reached; remove one before adding another.",
 			"panel.empty": "No secondary working directories yet.",
-			"panel.emptyHint": "Once added, the agent can use the folder in this session; confined bash follows on macOS/Linux, while Windows currently covers fs writes only.",
+			"panel.emptyHint": "Once added, the agent can use the folder in this session, including confined shells and terminals.",
 			"panel.noSession": "No active session",
 			"panel.loading": "Loading…",
 			"panel.retry": "Retry",
@@ -5438,9 +5573,20 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			"panel.copyPath": "Copy path",
 			"panel.copied": "Copied",
 			"panel.reveal": "Reveal in file manager",
+			"panel.reRegister": "Re-register (keeps its access level)",
 			"panel.moveUp": "Move up",
 			"panel.moveDown": "Move down",
-			"state.available": "Writable",
+			"access.inherit": "Inherit",
+			"access.readWrite": "Read-write",
+			"access.readOnly": "Read-only",
+			"panel.accessLabel": "Access",
+			"panel.accessInherit": "Make inherit",
+			"panel.accessReadOnly": "Make read-only",
+			"panel.accessReadWrite": "Make read-write",
+			"panel.accessUpgradeConfirm": "Change this folder's access to \"{access}\"? Under some sandbox modes this lets the agent modify files in it.",
+			"panel.accessUpgradeTitle": "Widen access",
+			"panel.accessUpgradeDo": "Change",
+			"state.available": "Granted",
 			"state.missing": "Directory is absent; not granted",
 			"state.redirected": "Registration was replaced (it now points elsewhere); not granted",
 			"state.invalid": "Registration is unusable",
@@ -5456,10 +5602,14 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			"error.invalid-ref": "The request is missing a required identity.",
 			"error.storage-unavailable": "The root registry store is unavailable; check the files under $DSH_HOME/storages.",
 			"error.registry-contended": "The root registry is owned by another DSH process; this process grants no additional roots. Close the other process, then retry.",
+			"error.root-limit-reached": "The additional-root limit is reached; remove one before adding another.",
+			"error.config-invalid": "The root registry configuration is invalid; this process grants no additional roots. Fix the configuration and restart.",
+			"error.root-unavailable": "That folder is not available right now and cannot be made writable; restore the directory first.",
 			"error.reveal-unavailable": "Could not open the system file manager; the registration is untouched, and the path can still be copied.",
 			"error.unavailable": "Could not reach the dsh host process.",
 			"error.copy-failed": "Could not write to the clipboard; check the browser's clipboard permission.",
 			"error.session-not-found": "That session is not active; open a workspace session first.",
+			"error.unsupported-path": "That is a network or device path, which Windows ACL confinement cannot cover.",
 			"error.fallback": "The operation failed."
 		};
 		//#endregion
@@ -5493,10 +5643,10 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		* @returns the client, with every transport failure normalized to a `PanelError`.
 		*/
 		function createPanelClient(connection) {
-			return { async call(endpoint, payload) {
+			return { async call(endpoint, payload, signal) {
 				let result;
 				try {
-					result = await connection.rpc.call(PANEL_CHANNEL, endpoint, payload);
+					result = await connection.rpc.call(PANEL_CHANNEL, endpoint, payload, signal);
 				} catch (error) {
 					throw new PanelError("unavailable", error instanceof Error ? error.message : String(error));
 				}
@@ -5604,6 +5754,367 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   justify-content: center;
 }
 
+/* Icon-only launcher inside the upstream Files tab header. Upstream's
+   FilesBody renders .header as one flat flex row — PathLabel, then the
+   reload button, then the files.actions slot occupants — and each of those
+   children carries a stable data-files-* attribute on the flex item itself
+   (data-files-root on the pane, data-files-path, data-files-reload).
+   A registration order sorts only INSIDE the actions slot and can never
+   overtake the reload button, so the launcher is moved with the flex order
+   property instead: this wrapper is the slot's root element and therefore a
+   direct flex item of .header, and order: -1 puts it ahead of every
+   order-0 sibling while the :has() rule below keeps the path first. */
+.mrfw-fileLauncher {
+  order: -1;
+  flex: none;
+  display: flex;
+  align-items: center;
+}
+
+/* Pin the upstream path label ahead of the launcher — but only while this
+   plugin is in the row: the :has() guard keeps a rule that names an
+   upstream element inert whenever the launcher is absent. The
+   :not([data-files-entry]) qualifier is load-bearing, not decorative:
+   upstream puts data-files-path on EVERY tree row too (the row's own
+   absolute path), so an unqualified selector would match the whole tree,
+   not just the header's PathLabel. Both selectors depend on upstream's DOM
+   shape, which is not part of the slot contract; if it changes, the rules
+   simply stop matching and the launcher falls back to its in-slot position —
+   a silent degradation, never a broken header. */
+[data-files-root]:has(.mrfw-fileLauncher) [data-files-path]:not([data-files-entry]) {
+  order: -2;
+}
+
+/* The root switcher is the launcher's grown-up form on runtimes whose
+   files.actions owner carries absolutePath. It takes the path label's flex
+   position and stretch: order: -1 ahead of every order-0 sibling, and a
+   growing min-width:0 item so both the trigger label and the PathLabel
+   inside it can ellipsize instead of pushing the header controls out. */
+.mrfw-rootSwitcher {
+  order: -1;
+  flex: 1 1 auto;
+  min-width: 0;
+  display: flex;
+  align-items: center;
+  /* Same 4px the upstream .header puts between its own flex items, so the
+     takeover controls (reload, open-in-app fork) sit at the same offsets the
+     hidden native ones did — no drift between primary and additional state. */
+  gap: 4px;
+}
+
+/* While the switcher exists it hides the upstream path label — the
+   :has() guard again keeps the upstream-naming rule inert unless this
+   plugin is actually in the row. The switcher draws its own PathLabel of
+   the selected root next to the trigger (className mrfw-switcherPath, no
+   data-files-* attributes), so the header keeps a path in the same spot.
+   :not([data-files-entry]) is what confines this rule to the header:
+   every tree row carries data-files-path with its own path as the value,
+   and only the PathLabel carries it bare. Without the qualifier this
+   display:none would blank the entire native tree. */
+[data-files-root]:has(.mrfw-rootSwitcher) [data-files-path]:not([data-files-entry]) {
+  display: none;
+}
+
+/* While the switcher names an additional root, the native tree body and its
+   reload hide: the reload refreshes the very tree that is no longer
+   visible, and the plugin's forked tree is portaled in as the body's sibling.
+   The header still offers a reload — the switcher's own .mrfw-switcherReload
+   calls the forked face's refresh. The native tree keeps watching in the
+   background, so switching back to the primary root restores it instantly. */
+[data-files-root]:has(.mrfw-rootSwitcher[data-root-kind="additional"]) [data-files-body],
+[data-files-root]:has(.mrfw-rootSwitcher[data-root-kind="additional"]) [data-files-reload] {
+  display: none;
+}
+
+/* While the switcher names an additional root, the native open-in-app split
+   button hides too: its slot props carry the pane's primary root, so it
+   would always open the primary root no matter what the switcher selected.
+   The header gets the plugin's own fork of that same control instead (the
+   open-in-app directory), wired to the selected root.
+
+   The slot's render site is wrapped in the renderer's own anchor —
+   <div data-slot="sidebar.right.tab.files.actions" style="display:contents">
+   — so the header's flex items inside it are the occupants themselves, and
+   the native item is the ui-primitives Menu anchor span wrapping the marked
+   .split. The first selector hides that occupant item through the data-slot
+   anchor: hiding only the inner control would leave the empty anchor span
+   as a zero-width flex item whose header gap pushes the fork 4px left of
+   the native position. The wrapper itself can never be the target — its
+   inline display:contents beats any stylesheet rule, and hiding it would
+   take the switcher with it. The second selector is the fallback for an
+   upstream that moves the attribute off the item. The fork survives both:
+   the only data-open-target inside .mrfw-rootSwitcher is its own
+   .mrfw-openSplit, which :not() excludes. */
+[data-files-root]:has(.mrfw-rootSwitcher[data-root-kind="additional"]) [data-slot="sidebar.right.tab.files.actions"] > *:has([data-open-target="directory"]:not(.mrfw-openSplit)),
+[data-files-root]:has(.mrfw-rootSwitcher[data-root-kind="additional"]) [data-open-target="directory"]:not(.mrfw-openSplit) {
+  display: none;
+}
+
+/* The trigger borrows the path label's look: quiet text with a folder
+   glyph, the hover of the neighboring header buttons, and the overflow
+   behavior PathLabel itself uses in a narrow header. It may shrink but
+   never grows — the PathLabel after it owns the free header space. */
+.mrfw-rootSwitchBtn {
+  flex: 0 1 auto;
+  min-width: 0;
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  height: 28px;
+  margin: 0;
+  padding: 0 4px;
+  border: none;
+  border-radius: 8px;
+  background: transparent;
+  color: var(--dsw-alias-label-primary);
+  font-family: inherit;
+  font-size: inherit;
+  line-height: 20px;
+  text-align: left;
+  cursor: pointer;
+  transition: background-color var(--ds-transition-duration-fast) var(--ds-ease-in-out);
+}
+
+.mrfw-rootSwitchBtn:hover {
+  background: var(--dsw-alias-interactive-bg-hover);
+}
+
+.mrfw-rootSwitchBtn .mrfw-triggerIcon {
+  color: var(--dsw-alias-label-secondary);
+}
+
+.mrfw-rootSwitchLabel {
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.mrfw-rootSwitchChevron {
+  margin-left: auto;
+  color: var(--dsw-alias-label-tertiary);
+}
+
+/* The selected root's full path sits between the trigger and the reload —
+   the very PathLabel upstream draws there, so it brings its own grow,
+   left-clip and hover-title behavior; only the gutters are ours. The right
+   margin plus the container gap reproduces upstream's .path margin-right
+   12px + header gap 4px; the left gutter comes from the same container gap. */
+.mrfw-switcherPath {
+  margin: 0 12px 0 0;
+}
+
+/* The takeover's own reload, standing exactly where the hidden native one
+   did: the upstream .tool recipe verbatim (28px hit area, 15px glyph,
+   secondary voice, hover fills). It calls the forked face's refresh — an
+   in-place re-list, not a remount. */
+.mrfw-switcherReload {
+  flex: none;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 28px;
+  height: 28px;
+  padding: 6px;
+  border: none;
+  border-radius: var(--dsw-radius-sm);
+  background: transparent;
+  color: var(--dsw-alias-label-secondary);
+  line-height: 1;
+  cursor: pointer;
+}
+
+.mrfw-switcherReload:hover {
+  color: var(--dsw-alias-label-primary);
+  background: var(--dsw-alias-interactive-bg-hover);
+}
+
+/* ── files-tree fork (verbatim rules, renamed classes) ─────────────────────
+   Copied from upstream's FilesBody.module.css (ui-sidebar-files @
+   0.2.1-alpha.2) with local names mapped to mrfw-ft* so the rules cannot
+   collide with host DOM — and so the fork's own body (which must NOT carry
+   data-files-body) stays visible while the rules above hide the native one.
+   The header-only rules (root/header/path/tool/status/statusLine/titleIcon)
+   belong to the upstream shell this fork drops and are not mapped. Fork sync
+   re-diffs the upstream file and re-applies the rename — see
+   src/client/files-tree/FORK.md. */
+
+/* The pane's own .root already supplies the flex column, color, and font;
+   the fork's body takes the same stretch item the hidden native body held,
+   including the workspace list's 2px scrollbar offset and stable gutter. */
+.mrfw-ftBody {
+  flex: 1 1 auto;
+  min-height: 0;
+  margin-right: 2px;
+  padding: 8px 0 8px 8px;
+  overflow: auto;
+  scrollbar-gutter: stable;
+}
+
+.mrfw-ftBody::-webkit-scrollbar-track {
+  margin: 2px;
+}
+
+.mrfw-ftLevel {
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+
+.mrfw-ftLevel .mrfw-ftLevel {
+  padding-left: 18px;
+}
+
+.mrfw-ftItem {
+  margin: 0;
+  padding: 0;
+}
+
+/* Rows abut, so the hover fill is the whole row; the tree's air is this
+   inset, not a gap between rows. */
+.mrfw-ftRow {
+  display: flex;
+  gap: 6px;
+  align-items: center;
+  width: 100%;
+  min-width: 0;
+  padding: 5px 10px;
+  color: inherit;
+  font: inherit;
+  text-align: left;
+  background: transparent;
+  border: 0;
+  border-radius: var(--dsw-radius-md);
+  cursor: pointer;
+}
+
+.mrfw-ftRow:hover {
+  background: var(--dsw-alias-interactive-bg-hover);
+}
+
+/* The folder glyph rides the tertiary ink, as the workspace tree's does. */
+.mrfw-ftIcon {
+  flex: 0 0 auto;
+  color: var(--dsw-alias-label-tertiary);
+}
+
+/* The type's coloured sheet at the folder glyph's 16px; its colour is its own. */
+.mrfw-ftFileIcon {
+  flex: 0 0 auto;
+}
+
+.mrfw-ftName {
+  min-width: 0;
+  overflow: hidden;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+}
+
+/* Neither a file nor a directory: shown so the directory is reported whole,
+   greyed so nobody tries to open it. */
+.mrfw-ftOther {
+  color: var(--dsw-alias-label-tertiary);
+  cursor: default;
+}
+
+.mrfw-ftOther:hover {
+  background: transparent;
+}
+
+.mrfw-ftNote {
+  margin: 0;
+  padding: 3px 10px;
+  color: var(--dsw-alias-label-tertiary);
+  font-size: 12px;
+}
+
+/* ── open-in-app fork (verbatim rules, renamed classes) ───────────────────
+   Copied from upstream's OpenTargetButton.module.css
+   (dsh-client-ui-open-in-app @ 0.2.1-alpha.2) with local names mapped to
+   mrfw-open* so the rules cannot collide with host DOM. Fork sync re-diffs
+   the upstream file and re-applies the rename — see
+   src/client/open-in-app/FORK.md. */
+
+/* Sized to sit in the document header's 24px control row beside its round
+   icon buttons: a hairline pill with a 12px label and a narrow chevron half. */
+.mrfw-openMenuAnchor {
+  display: inline-flex;
+  flex: none;
+  align-self: center;
+}
+
+.mrfw-openSplit {
+  display: inline-flex;
+  align-items: stretch;
+  box-sizing: border-box;
+  height: 24px;
+  overflow: hidden;
+  border: 0.5px solid var(--dsw-alias-border-l4);
+  border-radius: var(--dsw-radius-sm);
+  font-family: var(--dsw-font-family);
+}
+
+.mrfw-openMain,
+.mrfw-openChevron {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  border: 0;
+  background: none;
+  color: var(--dsw-alias-label-primary);
+  font-size: 11px;
+  line-height: 16px;
+  white-space: nowrap;
+  cursor: pointer;
+}
+
+.mrfw-openMain {
+  gap: 4px;
+  padding: 3px 5px;
+}
+
+.mrfw-openChevron {
+  padding: 3px 4px 3px 3px;
+  border-left: 0.5px solid var(--dsw-alias-border-l4);
+  color: var(--dsw-alias-label-secondary);
+}
+
+.mrfw-openMain:hover:not(:disabled),
+.mrfw-openMain:focus-visible,
+.mrfw-openChevron:hover:not(:disabled),
+.mrfw-openChevron:focus-visible {
+  background: var(--dsw-alias-interactive-bg-hover);
+}
+
+/* Pending disables clicks without a restyle; only hover feedback pauses. */
+.mrfw-openMain:disabled,
+.mrfw-openChevron:disabled {
+  cursor: default;
+}
+
+.mrfw-openAppIcon {
+  object-fit: contain;
+}
+
+/* The unavailable preview emphasizes the same actions with a labeled button. */
+.mrfw-openSplit[data-size='large'] {
+  height: 36px;
+  border-radius: var(--dsw-radius-md);
+  border-color: var(--dsw-alias-border-l2);
+}
+
+.mrfw-openSplit[data-size='large'] .mrfw-openMain {
+  gap: 6px;
+  padding: 6px 14px;
+  font-size: 14px;
+}
+
+.mrfw-openSplit[data-size='large'] .mrfw-openChevron {
+  padding: 6px 10px;
+}
+
+.mrfw-openSkeleton { display: inline-block; flex: none; border-radius: var(--dsw-radius-xs); background: var(--dsw-alias-interactive-bg-hover); }
+
 .mrfw-overlay {
   position: fixed;
   inset: 0;
@@ -5748,16 +6259,27 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   min-width: 0;
 }
 
+/* The name line is a flex row: the truncating name text first, the access
+   badge beside it never shrinking — baseline-aligned so the badge's smaller
+   voice sits on the name's baseline rather than its middle. */
 .mrfw-rootName {
+  display: flex;
+  align-items: baseline;
+  gap: 6px;
+  min-width: 0;
   overflow: hidden;
-  text-overflow: ellipsis;
-  white-space: nowrap;
   font-size: 14px;
   line-height: 20px;
   font-weight: 500;
   color: var(--dsw-alias-label-primary);
 }
 
+.mrfw-rootNameText {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
 .mrfw-rootPath {
   font-family: var(--ds-font-family-code);
   font-size: 12px;
@@ -5766,6 +6288,35 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   color: var(--dsw-alias-label-tertiary);
 }
 
+/* The path doubles as the copy control: an unstyled button that keeps the
+   text recipe and makes the whole string clickable — the whole region, not
+   just the icon, copies on click. */
+.mrfw-pathCopy {
+  display: block;
+  width: 100%;
+  padding: 0;
+  border: 0;
+  background: transparent;
+  text-align: left;
+  cursor: pointer;
+}
+
+/* The trailing icon stays in flow but invisible until the path is hovered
+   or focused: appearing never re-wraps the text, and the icon inherits the
+   path's own tertiary ink. */
+.mrfw-pathCopyIcon {
+  display: inline-flex;
+  margin-left: 4px;
+  vertical-align: -2px;
+  opacity: 0;
+  transition: opacity var(--ds-transition-duration-fast) var(--ds-ease-in-out);
+}
+
+.mrfw-pathCopy:hover .mrfw-pathCopyIcon,
+.mrfw-pathCopy:focus-visible .mrfw-pathCopyIcon {
+  opacity: 1;
+}
+
 .mrfw-note {
   margin: 0;
   font-size: 12px;
@@ -5811,8 +6362,19 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   background: var(--dsw-alias-interactive-bg-active);
 }
 
+/* The solid destructive action of the capsule family: the upgrade confirm's
+   red button. state-error-primary is the error ink upstream also uses as a
+   fill (StateDot); the hover mixes in the host's primary label token to
+   follow its theme and contrast choices. Neither color is a guessed token:
+   an undefined var() would fall back
+   to transparent and white-out the whole button. */
+.mrfw-btnDanger {
+  background: var(--dsw-alias-state-error-primary);
+  color: var(--dsw-alias-label-primary-foreground);
+}
+
 .mrfw-btnDanger:hover:not(:disabled) {
-  background: var(--dsw-alias-interactive-bg-hover-danger);
+  background: color-mix(in srgb, var(--dsw-alias-state-error-primary) 85%, var(--dsw-alias-label-primary));
 }
 
 .mrfw-btnOutline {
@@ -5870,6 +6432,24 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   flex: 1 1 auto;
 }
 
+.mrfw-accessSelect {
+  flex: 0 0 auto;
+}
+
+/* The access dropdown's capsule trigger: the Menu anchor wrapper is the flex
+   item, the button inside keeps the control row's 32px capsule recipe. */
+.mrfw-accessTrigger {
+  padding: 0 12px;
+}
+
+.mrfw-accessBadge,
+.mrfw-effectiveAccess {
+  flex: none;
+  font-size: 12px;
+  line-height: 18px;
+  color: var(--dsw-alias-label-tertiary);
+}
+
 .mrfw-aliasEditor {
   display: flex;
   flex-wrap: wrap;
@@ -5905,7 +6485,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		* Named imports cannot spell both releases: each name is absent from the
 		* other release's declaration, so the compiler is told once, here.
 		*/
-		const installed = _deepseek_ai_dsh_client_ui_primitives;
+		const installed$1 = _deepseek_ai_dsh_client_ui_primitives;
 		/**
 		* Pick the first export name this release actually provides.
 		* @param module - the icon module to read.
@@ -5921,9 +6501,29 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			}
 			throw new Error(`multi-root workspace: @deepseek-ai/dsh-client-ui-primitives exports none of ${names.join(", ")}; the workspace-folders panel cannot render its icons. Adapt src/compat/client-icons.ts to the installed release.`);
 		}
+		/**
+		* The same by-name probe for a decorative glyph a release may simply not
+		* carry: absence degrades to no icon, not to a boot error. Required icons go
+		* through `selectIcon` and fail loud; optional ones go through here.
+		*/
+		function maybeIcon(names) {
+			for (const name of names) {
+				const found = installed$1[name];
+				if (found !== void 0) return found;
+			}
+		}
+		/**
+		* The same by-name probe for a whole component a release may not carry:
+		* `PathLabel` arrived in `0.1.7-alpha.1`, so pixel-era runtimes degrade to a
+		* plain span where the header invites one. Absence degrades to no component,
+		* not to a boot error.
+		*/
+		function maybeComponent(names) {
+			return maybeIcon(names);
+		}
 		/** Resolved once, against the installed module. */
 		function icon(pixelName, regularName) {
-			return selectIcon(installed, [pixelName, regularName]);
+			return selectIcon(installed$1, [pixelName, regularName]);
 		}
 		const IconChevronDown = icon("IconChevronDownOutline14", "IconChevronDownOutlineRegular");
 		const IconChevronUp = icon("IconChevronUpOutline14", "IconChevronUpOutlineRegular");
@@ -5933,34 +6533,1537 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		const IconFolderClose = icon("IconFolderClose16", "IconFolderCloseRegular");
 		const IconFolderOpen = icon("IconFolderOpenOutline16", "IconFolderOpenOutlineRegular");
 		const IconPlus = icon("IconPlusOutline16", "IconPlusOutlineRegular");
+		const IconRefresh = icon("IconRefreshOutline16", "IconRefreshOutlineRegular");
+		const IconSettings = icon("IconSettingsOutline16", "IconSettingsOutlineRegular");
 		const IconTrash = icon("IconTrashOutline16", "IconTrashOutlineRegular");
+		const IconAccessReadWrite = maybeIcon(["IconWorkspaceWriteRegular"]);
+		const IconAccessReadOnly = maybeIcon(["IconReadOnlyRegular"]);
+		const IconAccessInherit = maybeIcon(["IconWorkspaceTreeOutline16", "IconWorkspaceTreeOutlineRegular"]);
 		//#endregion
-		//#region src/client/WorkspaceFoldersAction.tsx
+		//#region node_modules/.pnpm/@deepseek-ai+dsh-typert-protocol@0.2.1-rc.2_@deepseek-ai+cordis@4.0.5/node_modules/@deepseek-ai/dsh-typert-protocol/lib/index.js
+		/** The one Remote failure class shared by owners, the Gateway, and consumers. */
 		/**
-		* The Workspace Folders panel: one sidebar footer action that opens a dialog
-		* listing this session's workspace root and the additional roots registered for
-		* it, with the actions the milestone requires — Add (through the composed
-		* directory picker), Remove, Alias, Copy Path, Reveal, and reordering.
-		*
-		* Why a footer action and its own dialog, instead of a first-class panel: the
-		* slots that can host a full panel (`sidebar.panellist` + the keyed `main`
-		* panel) exist only in the pinned 0.1.5 surface, while `sidebar.footer.action`
-		* exists in both supported runtimes — and `sidebar.workspaces` is a single slot
-		* already owned by the workspace browser, so it cannot be extended in place.
-		*
-		* Styling is the host's, not this file's: the elements carry `mrfw-*` classes
-		* resolved by the stylesheet the client entry injects (`styles.ts`), and every
-		* color in that sheet is a host `--dsw-*` token, so the panel inherits the
-		* native look — sidebar trigger, modal card, capsule buttons — in both themes
-		* without naming a single color here (see ADR-0006).
-		*
-		* @module @dsh-electron/dsh-plugin-multi-root-workspace/client/WorkspaceFoldersAction
+		* One Remote call failure: a real Error carrying its stable code and typed
+		* details. Owners throw it at the failure point; the Host Gateway encodes it
+		* onto the wire unchanged; the Client face rebuilds an instance for the
+		* `RemoteResult` error branch, so `throw result.error` keeps throw semantics.
+		* Discrimination is always by `code`, never by instanceof.
 		*/
-		const VARIANT_CLASS = {
-			ghost: "mrfw-btnGhost",
-			outline: "mrfw-btnOutline",
-			primary: "mrfw-btnPrimary",
-			danger: "mrfw-btnDanger"
+		var RemoteError = class extends Error {
+			code;
+			details;
+			/** Structural marker: cross-realm/bundle identification never uses instanceof. */
+			isDSHRemoteError = true;
+			/**
+			* @param code - stable failure code declared in {@link RemoteErrorDetailsMap}.
+			* @param message - human diagnostic carried across the wire.
+			* @param details - structured payload typed by the code.
+			* @param options - standard Error options (`cause` survives in-process only).
+			*/
+			constructor(code, message, details, options) {
+				super(message, options);
+				this.code = code;
+				this.details = details;
+				this.name = "RemoteError";
+			}
+		};
+		//#endregion
+		//#region src/client/files-tree/directory-node.ts
+		/** One open directory and its active child nodes; cached view preferences live in the store. */
+		var DirectoryNode = class DirectoryNode {
+			path;
+			load;
+			watch;
+			failed;
+			restore;
+			/** Open direct-child directories, keyed by absolute path. */
+			children = /* @__PURE__ */ new Map();
+			controller = new AbortController();
+			signal;
+			task;
+			reading;
+			dirty = false;
+			initialized = false;
+			automatic = true;
+			constructor(path, load, watch, failed, lifetime, restore = []) {
+				this.path = path;
+				this.load = load;
+				this.watch = watch;
+				this.failed = failed;
+				this.restore = restore;
+				this.signal = AbortSignal.any([lifetime, this.controller.signal]);
+			}
+			/**
+			* Start observation once; readiness triggers the initial listing.
+			* @returns this node.
+			*/
+			open() {
+				this.task ??= this.follow();
+				return this;
+			}
+			/**
+			* Find an active node in this subtree.
+			* @param path - absolute directory path.
+			* @returns the matching node, or undefined when that directory is closed.
+			*/
+			find(path) {
+				if (path === this.path) return this;
+				for (const child of this.children.values()) {
+					const found = child.find(path);
+					if (found !== void 0) return found;
+				}
+			}
+			/**
+			* Update the expansion preferences used by pending directory listings.
+			* @param expanded - latest expansion preferences from the store.
+			*/
+			setExpanded(expanded) {
+				this.restore = expanded;
+				for (const child of this.children.values()) child.setExpanded(expanded);
+			}
+			/**
+			* Open a direct child using this node's lifetime and automatic-refresh setting.
+			* @param path - absolute direct-child directory path.
+			* @param restore - descendant expansion preferences to restore after listing.
+			* @returns the active child, or undefined after cancellation.
+			*/
+			expand(path, restore = []) {
+				if (this.signal.aborted) return void 0;
+				let child = this.children.get(path);
+				if (child === void 0) {
+					child = new DirectoryNode(path, this.load, this.watch, this.failed, this.signal, restore);
+					child.automatic = this.automatic;
+					this.children.set(path, child);
+				}
+				return child.open();
+			}
+			/**
+			* Remove a child and its pending restoration preferences.
+			* @param path - absolute direct-child directory path.
+			* @returns once the child subtree's reads and watches have ended.
+			*/
+			async collapse(path) {
+				this.restore = this.restore.filter((value) => value !== path && !value.startsWith(`${path}/`));
+				const child = this.children.get(path);
+				this.children.delete(path);
+				await child?.close();
+			}
+			/**
+			* Control subtree rereads without ending subscriptions.
+			* @param enabled - refresh dirty nodes automatically.
+			*/
+			setAutomatic(enabled) {
+				this.automatic = enabled;
+				if (enabled && this.dirty) this.refresh();
+				for (const child of this.children.values()) child.setAutomatic(enabled);
+			}
+			/** Queue a reread, coalescing with active work. @returns completion of the active read and its coalesced rereads. */
+			refresh() {
+				this.dirty = true;
+				this.reading ??= this.read();
+				return this.reading;
+			}
+			/** Refresh this node and its open descendants. @returns once their listings settle. */
+			async refreshTree() {
+				await this.refresh();
+				await Promise.all([...this.children.values()].map((child) => child.refreshTree()));
+			}
+			/** Cancel the active subtree. @returns once all owned reads and watches have ended. */
+			async close() {
+				this.controller.abort();
+				await Promise.all([
+					this.task,
+					this.reading,
+					...[...this.children.values()].map((child) => child.close())
+				]);
+				this.children.clear();
+			}
+			async follow() {
+				try {
+					for await (const _event of this.watch(this.path, this.signal)) {
+						this.dirty = true;
+						if (!this.initialized || this.automatic) this.refresh();
+					}
+				} catch (error) {
+					if (!this.signal.aborted) {
+						if (!this.initialized) await this.refresh();
+						if (!(typeof error === "object" && error !== null && "code" in error && error.code === "workspace-file/watch-unsupported")) this.failed(this.path, error);
+					}
+				}
+			}
+			async read() {
+				const readAgain = () => this.dirty && this.automatic && !this.signal.aborted;
+				try {
+					do {
+						this.dirty = false;
+						const level = await this.load(this.path, this.signal);
+						if (this.signal.aborted || level === void 0) return;
+						this.initialized = true;
+						const directories = new Set(level.entries.filter((entry) => entry.type === "directory").map((entry) => `${this.path.replace(/[/\\]+$/, "")}/${entry.name}`));
+						for (const path of this.children.keys()) if (!directories.has(path)) await this.collapse(path);
+						for (const path of directories) if (this.restore.includes(path)) this.expand(path, this.restore);
+						this.restore = [];
+					} while (readAgain());
+				} finally {
+					this.reading = void 0;
+				}
+			}
+		};
+		//#endregion
+		//#region src/client/files-tree/face.ts
+		/**
+		* Bind directory observation to the Remote stream supervisor.
+		* @param remote - Client Remote with workspace file streams.
+		* @returns a watcher that awaits stream disposal when its node ends.
+		*/
+		function createWatch(remote) {
+			return async function* (sessionId, path, signal) {
+				const aborted = () => signal.aborted;
+				if (aborted()) return;
+				const stream = remote.$stream({
+					name: `directory ${path}`,
+					open: (lifetime) => remote.workspaceFiles.changes(sessionId, path, lifetime),
+					ended: () => /* @__PURE__ */ new Error(`Directory watch ended: ${path}`)
+				});
+				const abort = () => {
+					stream.dispose();
+				};
+				signal.addEventListener("abort", abort, { once: true });
+				try {
+					for await (const item of stream) {
+						if (aborted()) return;
+						if (item.value.kind === "ready") item.accept();
+						yield item.value.kind;
+					}
+				} finally {
+					signal.removeEventListener("abort", abort);
+					await stream.dispose();
+				}
+			};
+		}
+		/**
+		* Bind the listing to one Remote face, keeping only what the tree stores.
+		* @param remote - the Client Remote face carrying the `workspaceFiles` namespace.
+		* @returns the listing the tree's face performs.
+		*/
+		function createList(remote) {
+			return async (sessionId, path, signal) => {
+				const result = await remote.workspaceFiles.list(sessionId, path, signal);
+				if (!result.ok) return result;
+				return {
+					ok: true,
+					value: {
+						entries: result.value.entries,
+						truncated: result.value.truncated
+					}
+				};
+			};
+		}
+		/**
+		* The absolute path of one child entry.
+		*
+		* Joined with `/` whatever the parent's separators: the Host resolves mixed
+		* separators, and the tree only needs a stable key.
+		* @param parent - absolute path of the listed directory.
+		* @param name - the entry's basename.
+		* @returns the child's absolute path.
+		*/
+		function childPath(parent, name) {
+			return `${parent.replace(/[/\\]+$/, "")}/${name}`;
+		}
+		/**
+		* Bind the tree's face to one directory listing.
+		* @param list - the bound `workspaceFiles.list` call.
+		* @param watch - target-scoped directory observation.
+		* @returns the Slot `inject` factory: session and bound actions in, face out.
+		*/
+		function filesFace(list, watch) {
+			return (sessionId, actions) => {
+				/** Per tab, per absolute path: the listing generation a settlement must match; the latest request wins. */
+				const generations = /* @__PURE__ */ new Map();
+				const roots = /* @__PURE__ */ new Map();
+				const nextGeneration = (tabId, path) => {
+					const byPath = generations.get(tabId) ?? /* @__PURE__ */ new Map();
+					generations.set(tabId, byPath);
+					const generation = (byPath.get(path) ?? 0) + 1;
+					byPath.set(path, generation);
+					return generation;
+				};
+				const load = async (tabId, path, signal) => {
+					if (signal.aborted) return;
+					const generation = nextGeneration(tabId, path);
+					actions.loading(tabId, path);
+					return list(sessionId, path, signal).then((result) => {
+						if (signal.aborted || generations.get(tabId)?.get(path) !== generation) return;
+						if (result.ok) actions.loaded(tabId, path, result.value);
+						else actions.failed(tabId, path, result.error);
+						return result.ok ? result.value : void 0;
+					});
+				};
+				return {
+					refresh: (tabId) => {
+						roots.get(tabId)?.refreshTree();
+					},
+					setAutoRefresh: (tabId, enabled) => {
+						actions.autoRefresh(tabId, enabled);
+						roots.get(tabId)?.setAutomatic(enabled);
+					},
+					start(tabId, root, signal) {
+						actions.start(tabId, root);
+						signal.addEventListener("abort", () => {
+							roots.get(tabId)?.close();
+							roots.delete(tabId);
+							generations.delete(tabId);
+							actions.forget(tabId);
+						}, { once: true });
+						roots.set(tabId, new DirectoryNode(root, (path, lifetime) => load(tabId, path, lifetime), (path, lifetime) => watch(sessionId, path, lifetime), (path, error) => {
+							if (!signal.aborted) actions.failed(tabId, path, new RemoteError("gateway/internal", error instanceof Error ? error.message : String(error), {}));
+						}, signal).open());
+					},
+					load: (tabId, path, signal) => {
+						load(tabId, path, signal);
+					},
+					toggle(tabId, parentPath, path, expanded, signal) {
+						if (signal.aborted) return;
+						const root = roots.get(tabId);
+						if (root === void 0) return;
+						const parent = root.find(parentPath);
+						if (parent === void 0 && !expanded.includes(parentPath)) return;
+						const collapsing = expanded.includes(path);
+						const next = collapsing ? expanded.filter((value) => value !== path) : [...expanded, path];
+						root.setExpanded(next);
+						if (collapsing) parent?.collapse(path);
+						else parent?.expand(path, next);
+						actions.toggled(tabId, path);
+					}
+				};
+			};
+		}
+		//#endregion
+		//#region src/client/files-tree/store.ts
+		/**
+		* The file tree's view state: which directories are expanded, what each
+		* loaded level contains, and where the body is scrolled to.
+		*
+		* The tree is not one resource. A directory listing per level, expanded lazily,
+		* is state the type owns — so it lives in a Slot-standard exclusive store
+		* (one instance per session), bucketed by tab id because two tabs of this kind
+		* in one session expand independently.
+		*
+		* Writers run between `start` and `forget`: the owner's `signal` is what ends a
+		* bucket's life, and the face stops dispatching once it aborts.
+		*/
+		/**
+		* One tab's bucket, which every writer after `start` relies on: the face only
+		* dispatches while the record's signal is live, and `forget` runs on its abort.
+		* @param state - the draft.
+		* @param tabId - the tab being written.
+		* @returns the tab's tree.
+		*/
+		function bucket(state, tabId) {
+			const tree = state.byTab[tabId];
+			if (tree === void 0) throw new Error(`ui-sidebar-files: no tree for tab "${tabId}"`);
+			return tree;
+		}
+		/**
+		* Declare the file tree's store.
+		*
+		* A factory rather than a shared handle: the registration declares it as an
+		* exclusive store, so the framework mints one instance per session.
+		* @returns the store handle to declare on the registration.
+		*/
+		function createFilesStore() {
+			return (0, _deepseek_ai_dsh_client_store.defineStore)({
+				init: () => ({ byTab: {} }),
+				actions: {
+					autoRefresh: (d, tabId, enabled) => {
+						bucket(d, tabId).autoRefresh = enabled;
+					},
+					/**
+					* Seed one tab's tree at its workspace root, with the root expanded.
+					* @param d - draft state.
+					* @param tabId - the tab being drawn.
+					* @param root - absolute path of the workspace root.
+					*/
+					start: (d, tabId, root) => {
+						d.byTab[tabId] = {
+							root,
+							levels: {},
+							expanded: [root],
+							scrollTop: 0,
+							autoRefresh: true
+						};
+					},
+					/**
+					* Mark one directory as being listed.
+					* @param d - draft state.
+					* @param tabId - the tab being drawn.
+					* @param path - absolute directory path.
+					*/
+					loading: (d, tabId, path) => {
+						const state = bucket(d, tabId);
+						if (state.levels[path]?.kind !== "ready") state.levels[path] = { kind: "loading" };
+					},
+					/**
+					* Record one directory's contents.
+					* @param d - draft state.
+					* @param tabId - the tab being drawn.
+					* @param path - absolute directory path.
+					* @param level - the listing to show under it.
+					*/
+					loaded: (d, tabId, path, level) => {
+						const state = bucket(d, tabId);
+						const previous = state.levels[path];
+						if (previous?.kind === "ready") {
+							const directories = new Set(level.entries.filter((entry) => entry.type === "directory").map((entry) => entry.name));
+							for (const entry of previous.level.entries) {
+								if (entry.type !== "directory" || directories.has(entry.name)) continue;
+								const removed = `${path.replace(/[/\\]+$/, "")}/${entry.name}`;
+								state.expanded = state.expanded.filter((value) => value !== removed && !value.startsWith(`${removed}/`));
+								state.levels = Object.fromEntries(Object.entries(state.levels).filter(([key]) => key !== removed && !key.startsWith(`${removed}/`)));
+							}
+						}
+						state.levels[path] = {
+							kind: "ready",
+							level
+						};
+					},
+					/**
+					* Record why one directory could not be listed.
+					* @param d - draft state.
+					* @param tabId - the tab being drawn.
+					* @param path - absolute directory path.
+					* @param failure - the settled Remote failure.
+					*/
+					failed: (d, tabId, path, failure) => {
+						const level = bucket(d, tabId).levels[path];
+						bucket(d, tabId).levels[path] = level?.kind === "ready" ? {
+							...level,
+							failure
+						} : {
+							kind: "failed",
+							failure
+						};
+					},
+					/**
+					* Open a collapsed directory, or collapse an open one.
+					*
+					* A collapsed level keeps what it loaded, so reopening it draws at once.
+					* @param d - draft state.
+					* @param tabId - the tab being drawn.
+					* @param path - absolute directory path.
+					*/
+					toggled: (d, tabId, path) => {
+						const state = bucket(d, tabId);
+						const at = state.expanded.indexOf(path);
+						if (at >= 0) state.expanded.splice(at, 1);
+						else state.expanded.push(path);
+					},
+					/**
+					* Record where one tab's body is scrolled to.
+					* @param d - draft state.
+					* @param tabId - the tab being drawn.
+					* @param scrollTop - the body's scroll offset, in px.
+					*/
+					scrolled: (d, tabId, scrollTop) => {
+						bucket(d, tabId).scrollTop = scrollTop;
+					},
+					/**
+					* Drop every loaded level, keeping what is expanded.
+					*
+					* This is the reload gesture's first half: the expanded set says which
+					* levels to fetch again.
+					* @param d - draft state.
+					* @param tabId - the tab being drawn.
+					*/
+					reset: (d, tabId) => {
+						bucket(d, tabId).levels = {};
+					},
+					/**
+					* Forget one tab's tree, for a tab record that is gone.
+					* @param d - draft state.
+					* @param tabId - the tab that went away.
+					*/
+					forget: (d, tabId) => {
+						d.byTab = Object.fromEntries(Object.entries(d.byTab).filter(([id]) => id !== tabId));
+					}
+				}
+			});
+		}
+		//#endregion
+		//#region src/client/files-tree/primitives.ts
+		/**
+		* Runtime probes for the `@deepseek-ai/dsh-client-ui-primitives` exports the
+		* verbatim Files-tree files spell.
+		*
+		* The upstream imports name the `*Regular` glyph family (0.1.7+; the pixel
+		* names are kept as fallbacks for the same reason `compat/client-icons`
+		* dual-names them) plus `FileTypeIcon` and `classifyFileType`, which every
+		* supported release carries. A named import cannot spell two release eras at
+		* once, so the resolution goes through `maybeIcon`/`maybeComponent` — the
+		* same probe the open-in-app fork uses.
+		*
+		* The exported bindings are typed definite because the adapter mounts the
+		* tree only after {@link filesTreeSurfaceSupported} passes; reaching for a
+		* binding on a composition that failed the gate is a caller bug, and the
+		* gate — not this module — is what a missing export degrades into.
+		*
+		* @module @dsh-electron/dsh-plugin-multi-root-workspace/client/files-tree/primitives
+		*/
+		/** Exports the fork's row rendering needs, keyed by their upstream names. */
+		const probed = {
+			folderClose: maybeIcon(["IconFolderCloseRegular", "IconFolderClose16"]),
+			folderOpen: maybeIcon(["IconFolderOpenRegular", "IconFolderOpen16"]),
+			fileTypeIcon: maybeComponent(["FileTypeIcon"]),
+			classifyFileType: maybeComponent(["classifyFileType"])
+		};
+		/**
+		* Whether this composition's primitives carry everything the forked rows
+		* spell. The adapter consults this once: `false` means the additional-root
+		* menu stays menu-only and no fork mount is attempted — the same absence
+		* upstream's own no-such-export state would produce.
+		*/
+		function filesTreeSurfaceSupported() {
+			return probed.folderClose !== void 0 && probed.folderOpen !== void 0 && probed.fileTypeIcon !== void 0 && probed.classifyFileType !== void 0;
+		}
+		const IconFolderCloseRegular = probed.folderClose;
+		const IconFolderOpenRegular = probed.folderOpen;
+		const FileTypeIcon = probed.fileTypeIcon;
+		const classifyFileType = probed.classifyFileType;
+		//#endregion
+		//#region src/client/files-tree/locales.ts
+		/** Dictionary namespace owned by upstream's plugin (verbatim). */
+		const NS$1 = "sidebarFiles";
+		//#endregion
+		//#region node_modules/.pnpm/clsx@2.1.1/node_modules/clsx/dist/clsx.mjs
+		function r(e) {
+			var t, f, n = "";
+			if ("string" == typeof e || "number" == typeof e) n += e;
+			else if ("object" == typeof e) if (Array.isArray(e)) {
+				var o = e.length;
+				for (t = 0; t < o; t++) e[t] && (f = r(e[t])) && (n && (n += " "), n += f);
+			} else for (f in e) e[f] && (n && (n += " "), n += f);
+			return n;
+		}
+		function clsx() {
+			for (var e, t, f = 0, n = "", o = arguments.length; f < o; f++) (e = arguments[f]) && (t = r(e)) && (n && (n += " "), n += t);
+			return n;
+		}
+		//#endregion
+		//#region node_modules/.pnpm/@deepseek-ai+dsh-util-workspace-path@0.2.1-rc.2_@deepseek-ai+cordis@4.0.5/node_modules/@deepseek-ai/dsh-util-workspace-path/lib/index.js
+		/**
+		* The `dsh-resource://file/…` address grammar: how a file is named across the
+		* Sidebar and the resource model, built and parsed without touching a
+		* filesystem.
+		* @module
+		*/
+		/** The scheme and type every file address opens with. */
+		const FILE_ADDRESS_PREFIX = "dsh-resource://file/";
+		/** Component-encode one id or path segment, keeping `:` literal for drive letters. */
+		function encodeSegment(segment) {
+			return encodeURIComponent(segment).replace(/%3A/gi, ":");
+		}
+		/** Encode a `/`-separated path segment by segment. */
+		function encodePath(path) {
+			return path.split("/").map(encodeSegment).join("/");
+		}
+		/**
+		* Build the address of a file read through one Session.
+		* @param sessionId - the Session whose Host workspace resolves the path.
+		* @param path - absolute or workspace-relative path; backslashes are normalized to `/`, and leading `./` prefixes are dropped.
+		* @returns the `dsh-resource://file/session/<sessionId>/<path>` address.
+		*/
+		function sessionFileAddress(sessionId, path) {
+			const normalized = path.replace(/\\/g, "/").replace(/^(?:\.\/)+/, "");
+			return `${FILE_ADDRESS_PREFIX}session/${encodeSegment(sessionId)}/${encodePath(normalized)}`;
+		}
+		/**
+		* Browser-safe Workspace path and display helpers.
+		* @module @deepseek-ai/dsh-util-workspace-path
+		*/
+		/** Whether a path uses a Windows drive or UNC prefix. */
+		function isWindowsStylePath(value) {
+			return /^[A-Za-z]:[/\\]/.test(value) || value.startsWith("\\\\");
+		}
+		/**
+		* Whether a path is absolute in either spelling the Host accepts: POSIX (`/a/b`) or Windows drive or UNC.
+		* @param path - the path to classify.
+		* @returns `true` for an absolute path; `false` for a Workspace-relative one.
+		*/
+		function isAbsoluteWorkspacePath(path) {
+			return path.startsWith("/") || isWindowsStylePath(path);
+		}
+		/**
+		* The address for a path as a caller holds it: a relative path, or an absolute
+		* path inside the Session's workspace, becomes a `session`-scoped address; an
+		* absolute path outside it, or one whose workspace root is unknown, keeps its
+		* absolute path in that Session's address.
+		* @param sessionId - the Session the path is read in.
+		* @param cwd - that Session's workspace root, when known.
+		* @param path - absolute or workspace-relative path, in either separator spelling.
+		* @returns the `dsh-resource://file/…` address.
+		*/
+		function fileAddressFor(sessionId, cwd, path) {
+			const normalized = path.replace(/\\/g, "/");
+			if (!isAbsoluteWorkspacePath(normalized)) return sessionFileAddress(sessionId, normalized);
+			const root = cwd === void 0 ? "" : cwd.replace(/\\/g, "/").replace(/\/+$/, "");
+			if (root !== "" && normalized === root) return sessionFileAddress(sessionId, "");
+			if (root !== "" && normalized.startsWith(`${root}/`)) return sessionFileAddress(sessionId, normalized.slice(root.length + 1));
+			return sessionFileAddress(sessionId, normalized);
+		}
+		//#endregion
+		//#region src/client/files-tree/FilesBody.module.css.ts
+		/**
+		* Shim for the CSS-module virtual module `./FilesBody.module.css`.
+		*
+		* This toolchain resolves real files, not CSS-module virtual modules — so
+		* the forked body imports this file instead (the one-line specifier delta
+		* recorded in FORK.md). It exports the same `css.<name>` map, pointed at the
+		* plugin-prefixed `mrfw-ft*` classes whose rules live in `styles.ts`; the
+		* upstream `FilesBody.module.css` sits beside it verbatim as the diffable
+		* source. Only the names the fork's JSX actually reads are mapped — the
+		* header-only entries (`root`, `header`, `path`, `tool`, `status`,
+		* `statusLine`, `titleIcon`) belong to the shell this fork drops.
+		*/
+		const css$1 = {
+			body: "mrfw-ftBody",
+			level: "mrfw-ftLevel",
+			item: "mrfw-ftItem",
+			row: "mrfw-ftRow",
+			icon: "mrfw-ftIcon",
+			fileIcon: "mrfw-ftFileIcon",
+			name: "mrfw-ftName",
+			other: "mrfw-ftOther",
+			note: "mrfw-ftNote"
+		};
+		//#endregion
+		//#region src/client/files-tree/FilesTree.tsx
+		/**
+		* The file tree's body, forked to a caller-supplied root: one additional
+		* workspace root, listed one level at a time.
+		*
+		* Everything the tree keeps lives in its store, keyed by tab; everything it
+		* asks for goes through its injected face. The component itself only decides
+		* what to draw for each absolute path and what a click means: a directory
+		* toggles, a file opens through the owner's open callback for a `file:`
+		* viewer to claim, and anything else is shown but refuses to open.
+		*
+		* The rows below the exported shell are byte-identical to upstream's
+		* `FilesBody.tsx`; the shell is the adaptation — upstream's version derives
+		* the root from the session's `cwd`, takes its tab identity and lifetime from
+		* `useTabInfo()`, opens resources through `tab.actions.openResource`, and
+		* draws the header (PathLabel, auto-refresh, reload, actions slot) that this
+		* plugin's switcher already owns. This fork takes all four as props and
+		* draws only the body. See FORK.md.
+		*/
+		/** Natural, case-insensitive name order, so `file2` precedes `file10`. */
+		const byName = new Intl.Collator(void 0, {
+			numeric: true,
+			sensitivity: "base"
+		});
+		/**
+		* Order one level's entries for display: directories first, then everything
+		* else, each group by name. The endpoint's order is a listing fact; this is the
+		* reader's.
+		* @param entries - the listing as the endpoint returned it.
+		* @returns a new array, directories first, then by name within each group.
+		*/
+		function orderEntries(entries) {
+			return [...entries].sort((left, right) => {
+				const group = Number(right.type === "directory") - Number(left.type === "directory");
+				return group !== 0 ? group : byName.compare(left.name, right.name);
+			});
+		}
+		/**
+		* Say why a directory could not be listed, in terms of the directory.
+		* @param t - namespace-bound translate.
+		* @param failure - the settled Remote failure.
+		* @returns the line to show under the directory.
+		*/
+		function failureLine(t, failure) {
+			switch (failure.code) {
+				case "workspace-file/not-found": return t("error.notFound");
+				case "workspace-file/outside-workspace": return t("error.outsideWorkspace");
+				case "workspace-file/not-directory": return t("error.notDirectory");
+				default: return t("error.unavailable", { message: failure.message });
+			}
+		}
+		/** One entry's row, and its children when it is an expanded directory. */
+		function Entry({ parent, entry, tree }) {
+			const path = childPath(parent, entry.name);
+			if (entry.type === "directory") {
+				const expanded = tree.state.expanded.includes(path);
+				return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("li", {
+					className: css$1.item,
+					"data-files-entry": "directory",
+					"data-files-path": path,
+					children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("button", {
+						type: "button",
+						className: css$1.row,
+						"aria-expanded": expanded,
+						onClick: () => {
+							tree.onToggle(parent, path);
+						},
+						children: [expanded ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconFolderOpenRegular, { className: css$1.icon }) : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconFolderCloseRegular, { className: css$1.icon }), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							className: css$1.name,
+							children: entry.name
+						})]
+					}), expanded && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("ul", {
+						className: css$1.level,
+						children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Level, {
+							path,
+							tree
+						})
+					})]
+				});
+			}
+			if (entry.type === "file") return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("li", {
+				className: css$1.item,
+				"data-files-entry": "file",
+				"data-files-path": path,
+				children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("button", {
+					type: "button",
+					className: css$1.row,
+					onClick: () => {
+						tree.onOpen(path);
+					},
+					children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(FileTypeIcon, {
+						kind: classifyFileType(entry.name),
+						size: 16,
+						className: css$1.fileIcon
+					}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+						className: css$1.name,
+						children: entry.name
+					})]
+				})
+			});
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("li", {
+				className: css$1.item,
+				"data-files-entry": "other",
+				"data-files-path": path,
+				children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+					className: clsx(css$1.row, css$1.other),
+					"aria-disabled": "true",
+					title: tree.t("entry.other"),
+					children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+						className: css$1.name,
+						children: entry.name
+					})
+				})
+			});
+		}
+		/** One directory's rows: its state while listing, its entries once listed. */
+		function Level({ path, tree }) {
+			const { state, t } = tree;
+			const level = state.levels[path];
+			if (level === void 0 || level.kind === "loading") return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("li", {
+				className: css$1.note,
+				"data-files-row": "loading",
+				children: t("loading")
+			});
+			if (level.kind === "failed") return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("li", {
+				className: css$1.note,
+				"data-files-row": "failed",
+				"data-files-code": level.failure.code,
+				children: failureLine(t, level.failure)
+			});
+			const entries = orderEntries(level.level.entries);
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [
+				level.failure !== void 0 && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("li", {
+					className: css$1.note,
+					"data-files-row": "failed",
+					children: failureLine(t, level.failure)
+				}),
+				entries.length === 0 && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("li", {
+					className: css$1.note,
+					"data-files-row": "empty",
+					children: t("empty")
+				}),
+				entries.map((entry) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Entry, {
+					parent: path,
+					entry,
+					tree
+				}, entry.name)),
+				level.level.truncated && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("li", {
+					className: css$1.note,
+					"data-files-row": "truncated",
+					children: t("truncated")
+				})
+			] });
+		}
+		/**
+		* The additional-root tree's body: the selected root and whatever the reader
+		* has opened under it — the upstream body's scroll, seed, and render logic
+		* verbatim, with the root arriving as a prop instead of `useSessions(cwd)`.
+		*/
+		function FilesTree({ tabId, sessionId, root, signal, useStore, actions, start, toggle, onOpen, t }) {
+			const state = useStore((store) => store.byTab[tabId]);
+			const bodyRef = (0, react.useRef)(null);
+			const scrollTopRef = (0, react.useRef)(0);
+			const seeded = state !== void 0;
+			(0, react.useLayoutEffect)(() => {
+				const body = bodyRef.current;
+				if (seeded && body !== null) {
+					body.scrollTop = state.scrollTop;
+					scrollTopRef.current = body.scrollTop;
+				}
+			}, [seeded]);
+			(0, react.useEffect)(() => () => {
+				if (seeded && !signal.aborted) actions.scrolled(tabId, scrollTopRef.current);
+			}, [
+				seeded,
+				signal,
+				tabId,
+				actions
+			]);
+			(0, react.useEffect)(() => {
+				if (state !== void 0 || signal.aborted) return;
+				start(tabId, root, signal);
+			}, [
+				state,
+				root,
+				tabId,
+				signal,
+				start
+			]);
+			if (state === void 0) return null;
+			const tree = {
+				state,
+				onToggle: (parent, path) => {
+					toggle(tabId, parent, path, state.expanded, signal);
+				},
+				onOpen: (path) => {
+					onOpen(fileAddressFor(sessionId, void 0, path));
+				},
+				t
+			};
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+				ref: bodyRef,
+				className: css$1.body,
+				onScroll: (event) => {
+					scrollTopRef.current = event.currentTarget.scrollTop;
+				},
+				children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("ul", {
+					className: css$1.level,
+					children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Level, {
+						path: state.root,
+						tree
+					})
+				})
+			});
+		}
+		//#endregion
+		//#region src/client/files-tree/adapter.tsx
+		/** The failure every lazy-remote path reports when the carrier is absent. */
+		const unavailable = () => new RemoteError("gateway/internal", "the remote service is not available in this composition", {});
+		/**
+		* Fold an unexpected exception into the Remote failure a dead carrier would
+		* produce. A generated Remote call cannot reject — but the lazy indirection
+		* can (a `remote` whose `workspaceFiles` namespace is not mounted leaves
+		* `.list` throwing a TypeError). The verbatim `load` awaits `list` through
+		* `.then` without `.catch`, so an escaped rejection would die inside
+		* `DirectoryNode.task` and pin the level at `loading` forever; folding it
+		* here keeps the failure a settled Remote result — the visible failure row.
+		*/
+		const failureOf = (error) => typeof error === "object" && error !== null && "code" in error ? error : new RemoteError("gateway/internal", error instanceof Error ? error.message : String(error), {});
+		/** An AsyncIterable whose first read throws the absent-carrier failure. */
+		const deadStream = (error = unavailable()) => ({
+			[Symbol.asyncIterator]: () => ({ next: () => Promise.reject(failureOf(error)) }),
+			dispose: () => Promise.resolve()
+		});
+		/**
+		* A `ClientRemote` stand-in that resolves the real service per call.
+		*
+		* The verbatim `createList`/`createWatch` hold one remote face for the
+		* session's life; resolving lazily keeps the fork correct on compositions
+		* that acquire `remote` after this plugin activates, and a composition that
+		* never acquires it still answers every call — with the same failure kind a
+		* dead carrier returns — instead of crashing the slot. Every method upholds
+		* the Remote contract the face relies on: `list` resolves a `RemoteResult`
+		* and never rejects; `changes`/`$stream` surface synchronous lookup failures
+		* through the stream's own failure path.
+		*/
+		function lazyFilesRemote(ctx) {
+			const get = (name) => ctx.get(name);
+			const namespace = () => get("remote.workspaceFiles");
+			return {
+				workspaceFiles: {
+					list: (sessionId, path, signal) => {
+						try {
+							const ns = namespace();
+							if (ns === void 0) return Promise.resolve({
+								ok: false,
+								error: unavailable()
+							});
+							return Promise.resolve(ns.list(sessionId, path, signal)).catch((error) => ({
+								ok: false,
+								error: failureOf(error)
+							}));
+						} catch (error) {
+							return Promise.resolve({
+								ok: false,
+								error: failureOf(error)
+							});
+						}
+					},
+					changes: (sessionId, path, signal) => {
+						try {
+							const ns = namespace();
+							return ns === void 0 ? deadStream() : ns.changes(sessionId, path, signal);
+						} catch (error) {
+							return deadStream(error);
+						}
+					}
+				},
+				$stream: ((options) => {
+					try {
+						const remote = get("remote");
+						return remote === void 0 ? deadStream() : remote.$stream(options);
+					} catch (error) {
+						return deadStream(error);
+					}
+				})
+			};
+		}
+		/**
+		* The registration's `store`/`inject` declarations, built once in `apply`.
+		*
+		* The inject face nests the verbatim files face under `face` and adds the
+		* session-bound `openFile` — keeping `FilesInjected` untouched means the
+		* fork's call sites and the sync diff stay upstream-shaped.
+		* @param ctx - the client root context (the remote/sidebarRight lookups).
+		* @returns the store handle and the inject factory for `register`.
+		*/
+		function createFilesTreeSeats(ctx) {
+			const store = createFilesStore();
+			const remote = lazyFilesRemote(ctx);
+			const face = filesFace(createList(remote), createWatch(remote));
+			const inject = (sessionId, actions) => ({
+				face: face(sessionId, actions),
+				openFile: (address) => {
+					ctx.get("sidebarRight")?.openResourceIn?.(sessionId, address);
+				}
+			});
+			return {
+				store,
+				inject
+			};
+		}
+		/**
+		* Assemble the props `RootSwitcher` portals into `FilesTree`, or `undefined`
+		* when this composition cannot render the fork — the caller then keeps the
+		* additional-root rows out of the menu entirely, which is the same absence
+		* upstream produces when its own tree cannot draw.
+		* @param props - the occupant's composed props (store, inject, session shares).
+		* @param t - the `sidebarFiles`-bound translate.
+		* @returns the stable surface, or `undefined` when the fork cannot mount.
+		*/
+		function createFilesTreeSurface(props, t) {
+			if (!filesTreeSurfaceSupported()) return void 0;
+			const { sessionId, useStore, actions, face, openFile } = props;
+			if (face === void 0 || openFile === void 0 || useStore === void 0 || actions === void 0) return void 0;
+			return {
+				sessionId,
+				useStore,
+				actions,
+				face,
+				openFile,
+				t
+			};
+		}
+		//#endregion
+		//#region node_modules/.pnpm/@deepseek-ai+dsh-host-open-in-app@0.2.1-rc.2_@deepseek-ai+cordis@4.0.5_@deepseek-ai+dsh_90dfa79a7f5aae0c8b5a66b41d5c318b/node_modules/@deepseek-ai/dsh-host-open-in-app/lib/types/shared.js
+		var shared_exports = /* @__PURE__ */ __exportAll({
+			OPEN_IN_APP_APPS_PATH: () => OPEN_IN_APP_APPS_PATH,
+			OPEN_IN_APP_APPS_ROUTE: () => OPEN_IN_APP_APPS_ROUTE,
+			OPEN_IN_APP_ICON_PREFIX_PATH: () => OPEN_IN_APP_ICON_PREFIX_PATH,
+			OPEN_IN_APP_ICON_PREFIX_ROUTE: () => OPEN_IN_APP_ICON_PREFIX_ROUTE,
+			OPEN_IN_APP_OPEN_PATH: () => OPEN_IN_APP_OPEN_PATH,
+			OPEN_IN_APP_OPEN_ROUTE: () => OPEN_IN_APP_OPEN_ROUTE
+		});
+		/**
+		* Route paths and wire payloads shared verbatim by the host routes and the
+		* browser package (`@deepseek-ai/dsh-client-ui-open-in-app`), published as
+		* the `./shared` subpath. Browser-safe: constants and types only. Each route
+		* carries the absolute pathname the Host registers beside the
+		* document-relative form the browser addresses; see
+		* .agents/notes/implemented/architecture/2026-09-14-web-document-relative-app-routes.md.
+		*/
+		/** GET route path serving the probed application ids. */
+		const OPEN_IN_APP_APPS_PATH = "/open-in-app/apps";
+		/** Browser-relative form of {@link OPEN_IN_APP_APPS_PATH}. */
+		const OPEN_IN_APP_APPS_ROUTE = OPEN_IN_APP_APPS_PATH.slice(1);
+		/** GET prefix path serving one PNG bundle icon per application id. */
+		const OPEN_IN_APP_ICON_PREFIX_PATH = "/open-in-app/icon";
+		/** Browser-relative form of {@link OPEN_IN_APP_ICON_PREFIX_PATH}. */
+		const OPEN_IN_APP_ICON_PREFIX_ROUTE = OPEN_IN_APP_ICON_PREFIX_PATH.slice(1);
+		/** POST route path launching one application on one workspace directory. */
+		const OPEN_IN_APP_OPEN_PATH = "/open-in-app/open";
+		/** Browser-relative form of {@link OPEN_IN_APP_OPEN_PATH}. */
+		const OPEN_IN_APP_OPEN_ROUTE = OPEN_IN_APP_OPEN_PATH.slice(1);
+		//#endregion
+		//#region src/compat/open-in-app-routes.ts
+		/**
+		* Compatibility adapter for the route constants of
+		* `@deepseek-ai/dsh-host-open-in-app/shared`.
+		*
+		* ```text
+		* 0.1.5-rc.2 / 0.1.6   OPEN_IN_APP_ICON_PREFIX = '/open-in-app/icon'       (absolute pathname)
+		* 0.1.7-alpha.1 +      OPEN_IN_APP_ICON_PREFIX_ROUTE = 'open-in-app/icon'  (document-relative)
+		* ```
+		*
+		* `0.1.7-alpha.1` split every shared route constant into a `*_PATH` spelling
+		* the Host registers and a `*_ROUTE` spelling the browser addresses, retiring
+		* the old names. The fork's `iconUrl` needs the browser-facing form — which a
+		* pixel-era release spells without the `_ROUTE` suffix, so a named import of
+		* the new name does not even BUILD against those manifests (MISSING_EXPORT at
+		* bundle time, not a runtime undefined). The lookup is by export name, not by
+		* release string.
+		*
+		* @module @dsh-electron/dsh-plugin-multi-root-workspace/compat/open-in-app-routes
+		*/
+		/**
+		* The installed shared module, addressed by export name.
+		*
+		* Named imports cannot spell both eras: each name is absent from the other
+		* era's declaration, so the compiler is told once, here.
+		*/
+		const installed = shared_exports;
+		/**
+		* Pick the first export name this release actually provides.
+		* @param module - the shared module to read.
+		* @param names - candidate export names, preferred first.
+		* @returns the route string.
+		* @throws {Error} when none of the names is exported. That is a compatibility
+		*   break to adapt here, not a missing optional peer.
+		*/
+		function selectSharedRoute(module, names) {
+			for (const name of names) {
+				const found = module[name];
+				if (found !== void 0) return found;
+			}
+			throw new Error(`multi-root workspace: @deepseek-ai/dsh-host-open-in-app/shared exports none of ${names.join(", ")}; the open-in-app fork cannot address its icon route. Adapt src/compat/open-in-app-routes.ts to the installed release.`);
+		}
+		/**
+		* The browser-facing icon-prefix route, whichever spelling this release
+		* exports. Resolved once at module load: the fork's adapter only reaches
+		* `iconUrl` on runtimes whose glyph gate already passed, and on the pixel era
+		* the absolute form is exactly what upstream's own client fetched.
+		*/
+		const OPEN_IN_APP_ICON_URL_PREFIX = selectSharedRoute(installed, ["OPEN_IN_APP_ICON_PREFIX_ROUTE", "OPEN_IN_APP_ICON_PREFIX"]);
+		//#endregion
+		//#region src/client/open-in-app/applications.ts
+		/** Label keys for applications supported by this client. */
+		const APP_LABEL_KEY = {
+			finder: "app.finder",
+			explorer: "app.explorer",
+			filemanager: "app.filemanager",
+			cursor: "app.cursor",
+			vscode: "app.vscode",
+			vscodeinsiders: "app.vscodeinsiders",
+			windsurf: "app.windsurf",
+			zed: "app.zed",
+			sublimetext: "app.sublimetext",
+			xcode: "app.xcode",
+			androidstudio: "app.androidstudio",
+			intellij: "app.intellij",
+			pycharm: "app.pycharm",
+			webstorm: "app.webstorm",
+			phpstorm: "app.phpstorm",
+			goland: "app.goland",
+			rider: "app.rider",
+			rustrover: "app.rustrover",
+			fork: "app.fork",
+			sourcetree: "app.sourcetree",
+			github: "app.github",
+			tower: "app.tower",
+			gitkraken: "app.gitkraken",
+			smartgit: "app.smartgit",
+			sublimemerge: "app.sublimemerge",
+			ghostty: "app.ghostty",
+			warp: "app.warp",
+			iterm: "app.iterm",
+			kitty: "app.kitty",
+			terminal: "app.terminal",
+			windowsterminal: "app.windowsterminal",
+			gitbash: "app.gitbash",
+			gnometerminal: "app.gnometerminal",
+			konsole: "app.konsole"
+		};
+		//#endregion
+		//#region src/client/open-in-app/controller.ts
+		/** Browser availability/choice state and the launch carrier for the split button. */
+		/**
+		* Owns the once-per-page availability read, the persisted last choice, and
+		* the launch POST. Availability and choice publish through uSES-safe sources
+		* so every Session header shares one truth.
+		*/
+		var OpenInAppController = class {
+			fetcher;
+			/** Installed app ids in host menu order; null until the host answered. */
+			apps = (0, _deepseek_ai_dsh_client_store.createSnapshotStore)(null);
+			/** Last chosen app id, or empty before the first choice, shared across sessions and browser restarts. */
+			choice = (0, _deepseek_ai_dsh_client_store.createSnapshotStore)("", { persist: { name: "dsh.open-in-app.choice" } });
+			/** Current launch, shared by pointer and keyboard gestures. */
+			operation = (0, _deepseek_ai_dsh_client_store.createSnapshotStore)({
+				phase: "idle",
+				path: null
+			});
+			/**
+			* Resolve the remembered nameable installed application, with the button's first-app fallback.
+			* @returns the installed app id, or undefined while unavailable.
+			*/
+			currentApp() {
+				const apps = (this.apps.getSnapshot() ?? []).filter((id) => APP_LABEL_KEY[id] !== void 0);
+				const choice = this.choice.getSnapshot();
+				return apps.includes(choice) ? choice : apps[0];
+			}
+			loading;
+			/**
+			* @param fetcher - HTTP carrier for the apps read and the launch POST.
+			*/
+			constructor(fetcher = (input, init) => fetch(input, init)) {
+				this.fetcher = fetcher;
+			}
+			/**
+			* Read availability once per controller life; concurrent calls share the read.
+			* A failed read publishes an empty list, which renders no button at all.
+			* @returns after availability is published.
+			*/
+			load() {
+				this.loading ??= this.run();
+				return this.loading;
+			}
+			/**
+			* Remember one picked app id.
+			* @param appId - catalog id from the availability list.
+			*/
+			choose(appId) {
+				if (this.operation.getSnapshot().phase !== "busy") this.choice.set(appId);
+			}
+			/**
+			* Launch one installed app on a workspace directory.
+			* @param appId - catalog id from the availability list.
+			* @param path - the session's absolute workspace directory.
+			* Concurrent gestures are ignored until the current Host request settles.
+			* @returns after the host acknowledged the launch; rejects on any failure.
+			*/
+			async launch(appId, path) {
+				if (this.operation.getSnapshot().phase === "busy") return;
+				this.operation.set({
+					phase: "busy",
+					path
+				});
+				const body = {
+					app: appId,
+					path
+				};
+				try {
+					const response = await this.fetcher(OPEN_IN_APP_OPEN_ROUTE, {
+						method: "POST",
+						headers: { "content-type": "application/json" },
+						body: JSON.stringify(body)
+					});
+					if (!response.ok) throw new Error(`open failed: HTTP ${String(response.status)}`);
+					this.operation.set({
+						phase: "idle",
+						path
+					});
+				} catch (error) {
+					this.operation.set({
+						phase: "error",
+						path
+					});
+					throw error;
+				}
+			}
+			async run() {
+				let apps = [];
+				try {
+					const response = await this.fetcher(OPEN_IN_APP_APPS_ROUTE, { headers: { accept: "application/json" } });
+					if (response.ok) {
+						const payload = await response.json();
+						if (Array.isArray(payload.apps)) apps = payload.apps.filter((id) => typeof id === "string");
+					}
+				} catch {}
+				this.apps.set(apps);
+			}
+		};
+		//#endregion
+		//#region src/client/open-in-app/locales.ts
+		/** Dictionary namespace owned by upstream's plugin (verbatim). */
+		const NS = "open-in-app";
+		//#endregion
+		//#region src/client/open-in-app/open-failure-toast.tsx
+		/** Per-control failure banner for path gestures. */
+		/**
+		* Transient failure banner owned by the control that initiated the gesture,
+		* so one failed request announces once, from the control the user pressed.
+		* @returns `toast` owned by the control and `show` to announce one
+		* failure with resolved copy; announcing again replays the banner.
+		*/
+		function useOpenFailureToast() {
+			const seq = (0, react.useRef)(0);
+			const [banner, setBanner] = (0, react.useState)(null);
+			const dismiss = (0, react.useCallback)(() => {
+				setBanner(null);
+			}, []);
+			return {
+				toast: banner === null ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Toast, {
+					text: banner.text,
+					icon: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.IconWarningOutlineRegular, {}),
+					onDone: dismiss
+				}, banner.seq),
+				show: (text) => {
+					seq.current += 1;
+					setBanner({
+						seq: seq.current,
+						text
+					});
+				}
+			};
+		}
+		//#endregion
+		//#region src/client/open-in-app/OpenTargetButton.module.css.ts
+		/**
+		* Fork-facing shim for upstream `OpenTargetButton.module.css`.
+		*
+		* This plugin's bundle has no CSS-module pipeline: the `<style>` element it
+		* installs carries one flat sheet (`src/client/styles.ts`). The upstream
+		* component reads `css.<name>` so the forked file needs one importable
+		* module exporting that same key map — this file, reached through the
+		* verbatim `./OpenTargetButton.module.css.ts` specifier (the one sanctioned
+		* fork edit: the specifier gains the `.ts` this toolchain resolves
+		* everywhere — tsc, tsdown, vitest). The specifier text is spelled without
+		* its `import` clause on purpose: the packed-artifact check scans every
+		* bundle comment too, and quoting the full statement would read as a
+		* relative import the tarball does not carry.
+		*
+		* Each upstream local class maps to an `mrfw-open*` name so the copied
+		* rules cannot collide with host DOM; the rules themselves live in
+		* styles.ts verbatim apart from that rename. `data-open-target` and the
+		* other data attributes are literals in the component and stay byte-exact.
+		* See FORK.md.
+		*/
+		const css = {
+			menuAnchor: "mrfw-openMenuAnchor",
+			split: "mrfw-openSplit",
+			main: "mrfw-openMain",
+			chevron: "mrfw-openChevron",
+			appIcon: "mrfw-openAppIcon",
+			skeleton: "mrfw-openSkeleton"
+		};
+		//#endregion
+		//#region src/client/open-in-app/OpenTargetButton.tsx
+		/** Shared file and directory opener: one default action, application menu, and per-gesture feedback. */
+		/**
+		* Serialize gestures and announce their failures through the initiating control's toast.
+		* @param execute - target adapter that returns the failure to announce, or null.
+		* @param t - localized control copy.
+		* @returns the pending state, feedback, and guarded action callback.
+		*/
+		function useOpenTargetGesture(execute, t) {
+			const [pending, setPending] = (0, react.useState)(false);
+			const inFlight = (0, react.useRef)(false);
+			const { toast, show } = useOpenFailureToast();
+			return {
+				pending,
+				toast,
+				act: (operation) => {
+					if (inFlight.current) return;
+					inFlight.current = true;
+					setPending(true);
+					execute(operation).then((failure) => {
+						if (failure !== null) show(t(`path.${failure}`));
+					}).finally(() => {
+						inFlight.current = false;
+						setPending(false);
+					});
+				}
+			};
+		}
+		/** One application image with a per-image fallback, shared by main and menu buttons. */
+		function ApplicationIcon({ source, size = 14 }) {
+			const [failed, setFailed] = (0, react.useState)(false);
+			return source === null || failed ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.IconRightUpOutlineRegular, { size }) : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("img", {
+				src: source,
+				width: size,
+				height: size,
+				className: css.appIcon,
+				alt: "",
+				draggable: false,
+				onError: () => {
+					setFailed(true);
+				}
+			});
+		}
+		/**
+		* Render identical split buttons for files and directories. File reveal always
+		* stays last; it is the default only when no application is registered.
+		* @param props - target applications, default selection, and operations.
+		* @returns the control and its transient failure feedback.
+		*/
+		function OpenTargetButton(props) {
+			const { applications, defaultId, kind, t } = props;
+			const [menuOpen, setMenuOpen] = (0, react.useState)(false);
+			const { pending, toast, act } = useOpenTargetGesture(props.execute, t);
+			const preferred = kind === "file" ? applications.find((app) => app.id === defaultId) ?? applications[0] : applications.find((app) => app.id === defaultId);
+			const disabled = pending || props.busy === true || props.loading === true;
+			const hasMenu = props.loading === true || props.failed || applications.length + (kind === "file" ? 1 : 0) > 1;
+			const revealDefault = kind === "file" && preferred === void 0 && props.loading !== true;
+			const primaryLabel = preferred === void 0 ? t("path.reveal") : t("open.title", { app: preferred.name });
+			const run = (operation) => {
+				setMenuOpen(false);
+				act(operation);
+			};
+			const primary = () => {
+				if (revealDefault) {
+					run({ kind: "reveal" });
+					return;
+				}
+				if (preferred !== void 0 && preferred.id !== defaultId) {
+					run({
+						kind: "application",
+						id: preferred.id
+					});
+					return;
+				}
+				run({ kind: "default" });
+			};
+			const icon = props.loading === true && preferred === void 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+				className: css.skeleton,
+				"data-open-target-skeleton": true,
+				"aria-hidden": "true",
+				style: {
+					width: props.prominent ? 18 : 13,
+					height: props.prominent ? 18 : 13
+				}
+			}) : revealDefault ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.IconFolderOpenOutlineRegular, { size: props.prominent ? 18 : 13 }) : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ApplicationIcon, {
+				source: preferred?.icon ?? null,
+				size: props.prominent ? 18 : 13
+			}, preferred?.icon);
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Menu, {
+				className: css.menuAnchor,
+				open: menuOpen && !disabled && hasMenu,
+				autoFocus: true,
+				portal: true,
+				dense: true,
+				align: "end",
+				onClose: () => {
+					setMenuOpen(false);
+				},
+				items: [...applications.map((app) => ({
+					id: `app:${app.id}`,
+					icon: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ApplicationIcon, { source: app.icon }, app.icon),
+					label: app.id === preferred?.id ? t("path.appDefault", { app: app.name }) : app.name
+				})), ...props.failed ? [{
+					id: "unavailable",
+					label: t("path.appsError"),
+					disabled: true
+				}] : []],
+				footer: kind === "file" ? [{
+					id: "reveal",
+					icon: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.IconFolderOpenOutlineRegular, {}),
+					label: revealDefault ? t("path.appDefault", { app: t("path.reveal") }) : t("path.reveal")
+				}] : [],
+				onSelect: (id) => {
+					run(id === "reveal" ? { kind: "reveal" } : {
+						kind: "application",
+						id: id.slice(4)
+					});
+				},
+				anchor: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+					className: css.split,
+					"data-open-target": kind,
+					"data-size": props.prominent ? "large" : "compact",
+					"data-open-path": kind === "file" && !props.prominent ? "" : void 0,
+					"data-state": disabled ? "busy" : "idle",
+					children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Tooltip, {
+						portal: true,
+						label: primaryLabel,
+						shortcutKeys: props.shortcut?.keys,
+						side: "bottom",
+						delayMs: 500,
+						children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("button", {
+							type: "button",
+							className: css.main,
+							disabled,
+							"aria-label": props.prominent ? void 0 : primaryLabel,
+							"aria-keyshortcuts": props.shortcut?.aria,
+							"data-open-path-open": kind === "file" && !props.prominent ? "" : void 0,
+							"data-open-path-unpreviewable": props.prominent ? "" : void 0,
+							onClick: primary,
+							children: [icon, props.prominent && (revealDefault ? t("path.reveal") : t("path.open"))]
+						})
+					}), hasMenu && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+						type: "button",
+						className: css.chevron,
+						disabled,
+						"aria-haspopup": "menu",
+						"aria-expanded": menuOpen && !disabled,
+						"aria-label": t("path.more"),
+						"data-open-path-more": kind === "file" && !props.prominent ? "" : void 0,
+						onClick: () => {
+							if (!menuOpen) props.refresh?.();
+							setMenuOpen((value) => !value);
+						},
+						children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.IconChevronDownOutlineRegular, { size: props.prominent ? 14 : 10 })
+					})]
+				})
+			}), toast] });
+		}
+		//#endregion
+		//#region src/client/open-in-app/OpenInAppAction.tsx
+		/**
+		* Adapt the installed directory catalog to the shared opening control.
+		* @param props - displayed directory, installed catalog, and launch operations.
+		* @returns the shared control, or null without an eligible application.
+		*/
+		function OpenInAppAction(props) {
+			const { absolutePath, useOpenInAppApps, useOpenInAppChoice, t } = props;
+			const available = useOpenInAppApps((apps) => apps);
+			const choice = useOpenInAppChoice((id) => id);
+			const operation = props.useOpenInAppLaunch((value) => value);
+			const shortcut = props.useShortcuts((rows) => rows.find((row) => row.id === "workspace.openLocal"));
+			const apps = (available ?? []).flatMap((id) => {
+				const key = APP_LABEL_KEY[id];
+				return key === void 0 ? [] : [{
+					id,
+					name: t(key),
+					icon: props.iconUrl(id)
+				}];
+			});
+			const preferred = apps.find((app) => app.id === choice) ?? apps[0];
+			if (preferred === void 0) return null;
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(OpenTargetButton, {
+				kind: "directory",
+				applications: apps,
+				defaultId: preferred.id,
+				failed: false,
+				t,
+				busy: operation.phase === "busy",
+				shortcut,
+				execute: async (operation) => {
+					const id = operation.kind === "application" ? operation.id : preferred.id;
+					try {
+						await props.launch(id, absolutePath);
+					} catch (_error) {
+						return "openError";
+					}
+					if (operation.kind === "application") props.choose(id);
+					return null;
+				}
+			}, absolutePath);
+		}
+		//#endregion
+		//#region src/client/open-in-app/adapter.tsx
+		/**
+		* The plugin-owned wiring around the verbatim open-in-app fork.
+		*
+		* Upstream builds the same props in its `apply` (`directoryInjected`): one
+		* controller per page, its SnapshotStores bound by the slot renderer into
+		* `use*` props, and a `t` bound to the `open-in-app` namespace. This module
+		* reproduces exactly that — minus slot machinery the fork never sees —
+		* plus the two degradations only a fork needs:
+		*
+		* - the glyph set the fork spells is the `*Regular` family (0.1.7+); a
+		*   pixel-name runtime (0.1.5/0.1.6) leaves the adapter undefined, so the
+		*   header simply keeps the native button, mirroring upstream's own
+		*   "no apps → no button" absence;
+		* - `ctx.locale.bind('open-in-app')` consumes upstream's registered
+		*   dictionary verbatim — same strings, upstream's updates included;
+		* - the icon route comes through `compat/open-in-app-routes`: the `*_ROUTE`
+		*   spelling is another 0.1.7+ name, so the constant is probed by export
+		*   name rather than imported (a pixel-era manifest lacks it entirely —
+		*   a named import would fail the bundle's own build).
+		*
+		* Everything here is ours; nothing in this file needs upstream sync.
+		*
+		* @module @dsh-electron/dsh-plugin-multi-root-workspace/client/open-in-app/adapter
+		*/
+		/**
+		* Turn one observable into the renderer-bound `use*` prop shape:
+		* `useSyncExternalStore` under the hood, exactly like the slot renderer's
+		* own binding. Built once per store so `subscribe` stays referentially
+		* stable across renders.
+		* @param source - the observable to bind.
+		* @returns the bound selector hook.
+		*/
+		function bindSnapshot(source) {
+			const subscribe = (listener) => source.subscribe(listener);
+			const getSnapshot = () => source.getSnapshot();
+			return function useBound(selector) {
+				return (0, react.useSyncExternalStore)(subscribe, () => selector(getSnapshot()));
+			};
+		}
+		/** Glyphs the forked components spell verbatim — all `*Regular`, all probed. */
+		const REQUIRED_GLYPHS = [
+			"IconChevronDownOutlineRegular",
+			"IconRightUpOutlineRegular",
+			"IconFolderOpenOutlineRegular",
+			"IconWarningOutlineRegular"
+		];
+		/** The empty catalog stand-in when the composition carries no shortcuts service. */
+		const NO_SHORTCUTS = {
+			getSnapshot: () => [],
+			subscribe: () => () => {}
+		};
+		/**
+		* Build the open-in-app props upstream hands its own registration.
+		* @param deps - the namespace-bound translate for `open-in-app`, and the
+		*   composition's shortcuts catalog when it exists.
+		* @returns the adapter, or `undefined` when this runtime cannot render the
+		*   fork (pixel-era icon names — the forked files would crash on missing
+		*   exports, so absence mirrors upstream's own no-button path).
+		*/
+		function createOpenInAppAdapter(deps) {
+			if (!REQUIRED_GLYPHS.every((name) => maybeIcon([name]) !== void 0)) return void 0;
+			const controller = new OpenInAppController();
+			controller.load();
+			return {
+				useOpenInAppApps: bindSnapshot(controller.apps),
+				useOpenInAppChoice: bindSnapshot(controller.choice),
+				useOpenInAppLaunch: bindSnapshot(controller.operation),
+				useShortcuts: bindSnapshot(deps.shortcuts ?? NO_SHORTCUTS),
+				launch: (appId, path) => controller.launch(appId, path),
+				choose: (appId) => {
+					controller.choose(appId);
+				},
+				iconUrl: (appId) => `${OPEN_IN_APP_ICON_URL_PREFIX}/${appId}`,
+				t: deps.t
+			};
+		}
+		//#endregion
+		//#region src/client/WorkspaceFoldersAction.tsx
+		/**
+		* The Workspace Folders panel: one sidebar footer action that opens a dialog
+		* listing this session's workspace root and the additional roots registered for
+		* it, with the actions the milestone requires — Add (through the composed
+		* directory picker), Remove, Alias, Copy Path, Reveal, and reordering.
+		*
+		* Why a footer action and its own dialog, instead of a first-class panel: the
+		* slots that can host a full panel (`sidebar.panellist` + the keyed `main`
+		* panel) exist only in the pinned 0.1.5 surface, while `sidebar.footer.action`
+		* exists in both supported runtimes — and `sidebar.workspaces` is a single slot
+		* already owned by the workspace browser, so it cannot be extended in place.
+		*
+		* Styling is the host's, not this file's: the elements carry `mrfw-*` classes
+		* resolved by the stylesheet the client entry injects (`styles.ts`), and every
+		* color in that sheet is a host `--dsw-*` token, so the panel inherits the
+		* native look — sidebar trigger, modal card, capsule buttons — in both themes
+		* without naming a single color here (see ADR-0006).
+		*
+		* The dialog itself is also exported: the Files-tab root switcher opens the
+		* same manager through its trailing menu item instead of carrying a second
+		* dialog.
+		*
+		* @module @dsh-electron/dsh-plugin-multi-root-workspace/client/WorkspaceFoldersAction
+		*/
+		const VARIANT_CLASS = {
+			ghost: "mrfw-btnGhost",
+			outline: "mrfw-btnOutline",
+			primary: "mrfw-btnPrimary",
+			danger: "mrfw-btnDanger"
 		};
 		/** One small capsule button matching the panel's own styling. */
 		function Action(props) {
@@ -6003,6 +8106,27 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("path", { d: "M4 4l8 8M12 4l-8 8" })
 			});
 		}
+		/**
+		* One path that copies itself: text that paints like the surrounding copy
+		* and reveals a trailing icon on hover — clicking the text or the icon
+		* copies the same canonical path. The accessible name swaps to "copied"
+		* for the feedback window, the icon button's old recipe. Shared by the
+		* primary row, the current-directory line, and every additional root.
+		*/
+		function PathCopy(props) {
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("button", {
+				type: "button",
+				className: "mrfw-rootPath mrfw-pathCopy",
+				title: props.path,
+				"aria-label": props.copied ? props.t("panel.copied") : props.t("panel.copyPath"),
+				onClick: props.onCopy,
+				children: [props.path, /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+					className: "mrfw-pathCopyIcon",
+					"aria-hidden": "true",
+					children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconCopy, { size: 14 })
+				})]
+			});
+		}
 		/** The locale key for one reported root state. */
 		function stateKey(state) {
 			switch (state) {
@@ -6012,6 +8136,25 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				case "invalid": return "state.invalid";
 			}
 		}
+		/** The locale key for one registration's access level. */
+		function accessKey(access) {
+			switch (access) {
+				case "inherit": return "access.inherit";
+				case "read-only": return "access.readOnly";
+				case "read-write": return "access.readWrite";
+			}
+		}
+		/**
+		* Whether moving FROM `from` TO `to` could widen the agent's write authority
+		* under some session mode. The three levels are not a total order — `inherit`
+		* is weaker than `read-write` under a read-only session but never weaker
+		* under the others — so the check is spelled out per pair rather than
+		* computed from a rank. Only a widening change asks for confirmation.
+		*/
+		function widensAccess(from, to) {
+			if (from === "read-only") return to !== "read-only";
+			return from === "inherit" && to === "read-write" || from === "read-write" && to === "inherit";
+		}
 		/** The final segment of an absolute path, on either platform separator. */
 		function basename(path) {
 			const segments = path.split(/[\\/]/).filter((segment) => segment !== "");
@@ -6029,11 +8172,12 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			const [open, setOpen] = (0, react.useState)(false);
 			const rail = props.wide === false;
 			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
-				className: rail ? "mrfw-triggerRow mrfw-railRow" : "mrfw-triggerRow",
+				className: props.compact ? "mrfw-fileLauncher" : rail ? "mrfw-triggerRow mrfw-railRow" : "mrfw-triggerRow",
 				children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("button", {
 					type: "button",
-					className: rail ? "mrfw-trigger mrfw-triggerRail" : "mrfw-trigger",
+					className: props.compact ? "mrfw-btn mrfw-btnGhost mrfw-iconBtn" : rail ? "mrfw-trigger mrfw-triggerRail" : "mrfw-trigger",
 					title: props.t("action.title"),
+					"aria-label": props.compact === true ? props.t("action.title") : void 0,
 					"aria-haspopup": "dialog",
 					"aria-expanded": open,
 					onClick: () => {
@@ -6042,8 +8186,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 					children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
 						className: "mrfw-triggerIcon",
 						"aria-hidden": "true",
-						children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconFolderClose, { size: rail ? 18 : 16 })
-					}), rail ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+						children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconSettings, { size: rail ? 18 : 16 })
+					}), rail || props.compact === true ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
 						className: "mrfw-triggerLabel",
 						children: props.t("action.label")
 					})]
@@ -6055,6 +8199,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				}
 			}) : null] });
 		}
+		/** The exact row reference the browsing endpoints and mutations carry. */
 		function entryOf(root) {
 			return {
 				ordinal: root.ordinal,
@@ -6084,6 +8229,18 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				noSession: false
 			});
 			const [manualPath, setManualPath] = (0, react.useState)("");
+			/** The access the Add controls register new roots with; `inherit` is the default. */
+			const [addAccess, setAddAccess] = (0, react.useState)("inherit");
+			/**
+			* Whether the operator actually picked a level. The select shows its default
+			* before they do, and sending that default would be an explicit value the
+			* operator never named: on a revive the registry upgrades a read-only record
+			* to it. Only a chosen level may travel in the request.
+			*/
+			const [accessChosen, setAccessChosen] = (0, react.useState)(false);
+			const [accessMenuOpen, setAccessMenuOpen] = (0, react.useState)(false);
+			/** The widening access change waiting on the confirmation's red button. */
+			const [upgradeFor, setUpgradeFor] = (0, react.useState)(void 0);
 			const [aliasFor, setAliasFor] = (0, react.useState)(void 0);
 			const [aliasDraft, setAliasDraft] = (0, react.useState)("");
 			const [copiedId, setCopiedId] = (0, react.useState)(void 0);
@@ -6091,9 +8248,12 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			const dialogRef = (0, react.useRef)(null);
 			const requestEpoch = (0, react.useRef)(0);
 			const mounted = (0, react.useRef)(true);
-			(0, react.useEffect)(() => () => {
-				mounted.current = false;
-				requestEpoch.current += 1;
+			(0, react.useEffect)(() => {
+				mounted.current = true;
+				return () => {
+					mounted.current = false;
+					requestEpoch.current += 1;
+				};
 			}, []);
 			const requestBase = (0, react.useCallback)(() => {
 				const current = props.sessionId?.();
@@ -6104,15 +8264,16 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			}, []);
 			const onDialogKeyDown = (event) => {
 				if (event.key === "Escape") {
-					if (menuFor !== void 0) return;
+					if (menuFor !== void 0 || accessMenuOpen || upgradeFor !== void 0) return;
 					event.stopPropagation();
 					props.onClose();
 					return;
 				}
 				if (event.key !== "Tab") return;
+				if (upgradeFor !== void 0) return;
 				const dialog = dialogRef.current;
 				if (dialog === null) return;
-				const focusable = Array.from(dialog.querySelectorAll("button, input, [href], [tabindex]:not([tabindex=\"-1\"])")).filter((element) => !element.hasAttribute("disabled"));
+				const focusable = Array.from(dialog.querySelectorAll("button, input, select, [href], [tabindex]:not([tabindex=\"-1\"])")).filter((element) => !element.hasAttribute("disabled"));
 				if (focusable.length === 0) {
 					event.preventDefault();
 					return;
@@ -6156,7 +8317,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				}));
 				try {
 					const view = await panel.call("list", base);
-					if (!mounted.current || epoch !== requestEpoch.current) return;
+					if (!mounted.current || epoch !== requestEpoch.current || props.sessionId?.() !== base.sessionId) return;
 					setState({
 						view,
 						error: void 0,
@@ -6164,7 +8325,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 						noSession: false
 					});
 				} catch (error) {
-					if (!mounted.current || epoch !== requestEpoch.current) return;
+					if (!mounted.current || epoch !== requestEpoch.current || props.sessionId?.() !== base.sessionId) return;
 					setState({
 						view: void 0,
 						error: asPanelError(error),
@@ -6176,6 +8337,28 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			(0, react.useEffect)(() => {
 				refresh();
 			}, [refresh]);
+			(0, react.useEffect)(() => {
+				let previous = props.sessionId?.();
+				return props.subscribeSession?.(() => {
+					const current = props.sessionId?.();
+					if (current === previous) return;
+					previous = current;
+					requestEpoch.current += 1;
+					setState({
+						view: void 0,
+						error: void 0,
+						busy: false,
+						noSession: current === void 0
+					});
+					setMenuFor(void 0);
+					setAliasFor(void 0);
+					refresh();
+				});
+			}, [
+				props.subscribeSession,
+				props.sessionId,
+				refresh
+			]);
 			/**
 			* Submit one change to the host and adopt the view it answers with.
 			* @returns whether the host accepted it (the caller decides whether to clear
@@ -6204,7 +8387,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 						...base,
 						...payload
 					});
-					if (!mounted.current || epoch !== requestEpoch.current) return false;
+					if (!mounted.current || epoch !== requestEpoch.current || props.sessionId?.() !== base.sessionId) return false;
 					setState({
 						view,
 						error: void 0,
@@ -6213,7 +8396,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 					});
 					return true;
 				} catch (error) {
-					if (!mounted.current || epoch !== requestEpoch.current) return false;
+					if (!mounted.current || epoch !== requestEpoch.current || props.sessionId?.() !== base.sessionId) return false;
 					setState((previous) => ({
 						...previous,
 						error: asPanelError(error),
@@ -6241,8 +8424,16 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 					return;
 				}
 				if (picked === null || picked.trim() === "") return;
-				await mutate("add", { path: picked });
-			}, [mutate, props]);
+				await mutate("add", {
+					path: picked,
+					...accessChosen ? { access: addAccess } : {}
+				});
+			}, [
+				mutate,
+				props,
+				addAccess,
+				accessChosen
+			]);
 			/**
 			* Add the path in the manual field — the one the operator typed. The picker
 			* plays no part here: this is the entry point the confirm button and the
@@ -6251,8 +8442,27 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			const addManualPath = (0, react.useCallback)(async () => {
 				const path = manualPath.trim();
 				if (path === "") return;
-				if (await mutate("add", { path })) setManualPath("");
-			}, [manualPath, mutate]);
+				if (await mutate("add", {
+					path,
+					...accessChosen ? { access: addAccess } : {}
+				})) setManualPath("");
+			}, [
+				manualPath,
+				mutate,
+				addAccess,
+				accessChosen
+			]);
+			/**
+			* Re-register one withheld or unusable root in place. The request carries
+			* the stored path and deliberately NO access: `registry.add` treats the call
+			* as a revive — it keeps the record's access, alias, and identity instead of
+			* creating a new registration — which is also why the root limit must not
+			* gate this button: a revive consumes no slot, and it is the panel's only
+			* repair route for a redirected entry.
+			*/
+			const reRegister = (0, react.useCallback)(async (root) => {
+				await mutate("add", { path: root.path });
+			}, [mutate]);
 			/** Reveal one root: the answer is the revealed path, not a new view. */
 			const reveal = (0, react.useCallback)(async (root) => {
 				if (panel === void 0) return;
@@ -6277,14 +8487,14 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 						...base,
 						entry: entryOf(root)
 					});
-					if (!mounted.current || epoch !== requestEpoch.current) return;
+					if (!mounted.current || epoch !== requestEpoch.current || props.sessionId?.() !== base.sessionId) return;
 					setState((previous) => ({
 						...previous,
 						error: void 0,
 						busy: false
 					}));
 				} catch (error) {
-					if (!mounted.current || epoch !== requestEpoch.current) return;
+					if (!mounted.current || epoch !== requestEpoch.current || props.sessionId?.() !== base.sessionId) return;
 					setState((previous) => ({
 						...previous,
 						error: asPanelError(error),
@@ -6292,10 +8502,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 					}));
 				}
 			}, [panel, requestBase]);
-			const copyPath = (0, react.useCallback)(async (root) => {
+			const copyPath = (0, react.useCallback)(async (key, path) => {
 				try {
-					await navigator.clipboard.writeText(root.path);
-					const key = rowKey(root);
+					await navigator.clipboard.writeText(path);
 					setCopiedId(key);
 					setState((previous) => ({
 						...previous,
@@ -6319,7 +8528,11 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				});
 			}, [mutate]);
 			const roots = state.view?.roots ?? [];
-			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+			const atLimit = state.view !== void 0 && state.view.count >= state.view.limit;
+			const IconAccessTrigger = addAccess === "read-only" ? IconAccessReadOnly : addAccess === "read-write" ? IconAccessReadWrite : IconAccessInherit;
+			const primaryPath = state.view?.primaryRoot;
+			const cwdPath = state.view?.effectiveCwd;
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
 				className: "mrfw-overlay",
 				role: "presentation",
 				children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
@@ -6359,6 +8572,21 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 								className: "mrfw-description",
 								children: t("panel.subtitle")
 							}),
+							state.view?.mode === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("p", {
+								className: "mrfw-note",
+								children: [
+									t("panel.mode"),
+									" ",
+									t(`mode.${state.view.mode}`)
+								]
+							}),
+							state.view?.toolAccessInvalid ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+								className: "mrfw-note",
+								children: t("panel.invalidCap")
+							}) : (state.view?.cappedTools?.length ?? 0) > 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+								className: "mrfw-note",
+								children: t("panel.toolCaps", { tools: state.view.cappedTools.join(", ") })
+							}) : null,
 							state.error === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("p", {
 								role: "alert",
 								className: "mrfw-alert",
@@ -6386,14 +8614,44 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 										className: "mrfw-rootText",
 										children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
 											className: "mrfw-rootName",
-											children: state.view === void 0 ? "…" : state.view.primaryName ?? basename(state.view.primaryRoot)
-										}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+											children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+												className: "mrfw-rootNameText",
+												children: state.view === void 0 ? "…" : state.view.primaryName ?? basename(state.view.primaryRoot)
+											})
+										}), primaryPath === void 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
 											className: "mrfw-rootPath",
-											children: state.view?.primaryRoot ?? "…"
+											children: "…"
+										}) : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(PathCopy, {
+											path: primaryPath,
+											copied: copiedId === "primary",
+											onCopy: () => {
+												copyPath("primary", primaryPath);
+											},
+											t
 										})]
 									})
 								})]
 							}),
+							cwdPath !== void 0 && /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("section", {
+								className: "mrfw-section",
+								children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+									className: "mrfw-sectionTitleRow",
+									children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+										className: "mrfw-sectionTitle",
+										children: t("panel.cwd")
+									}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+										className: "mrfw-sectionNote",
+										children: t("panel.cwdNote")
+									})]
+								}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(PathCopy, {
+									path: cwdPath,
+									copied: copiedId === "cwd",
+									onCopy: () => {
+										copyPath("cwd", cwdPath);
+									},
+									t
+								})]
+							}),
 							/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("section", {
 								className: "mrfw-section",
 								children: [
@@ -6423,12 +8681,33 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 											children: [
 												/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
 													className: "mrfw-rootText",
-													children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+													children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
 														className: "mrfw-rootName",
-														children: displayNameOf(root)
-													}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
-														className: "mrfw-rootPath",
-														children: root.path
+														children: [
+															/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+																className: "mrfw-rootNameText",
+																children: displayNameOf(root)
+															}),
+															/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+																className: "mrfw-accessBadge",
+																children: t(accessKey(root.access))
+															}),
+															root.effectiveAccess === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
+																className: "mrfw-effectiveAccess",
+																children: [
+																	t("panel.effectiveAccess"),
+																	" ",
+																	t(`effective.${root.effectiveAccess}`)
+																]
+															})
+														]
+													}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(PathCopy, {
+														path: root.path,
+														copied: copiedId === key,
+														onCopy: () => {
+															copyPath(key, root.path);
+														},
+														t
 													})]
 												}),
 												root.state === "available" ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
@@ -6436,12 +8715,13 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 													className: "mrfw-stateWarn",
 													children: t(stateKey(root.state))
 												}),
-												/* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconButton, {
+												root.state === "available" ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconButton, {
+													disabled: state.busy,
 													onClick: () => {
-														copyPath(root);
+														reRegister(root);
 													},
-													icon: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconCopy, {}),
-													label: copiedId === key ? t("panel.copied") : t("panel.copyPath")
+													icon: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconRefresh, {}),
+													label: t("panel.reRegister")
 												}),
 												/* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconButton, {
 													disabled: state.busy,
@@ -6472,23 +8752,55 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 													onClose: () => {
 														setMenuFor(void 0);
 													},
-													items: [{
-														id: "rename",
-														label: t("panel.rename"),
-														icon: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconEdit, {})
-													}, {
-														id: "remove",
-														label: t("panel.remove"),
-														icon: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconTrash, {}),
-														danger: true,
-														disabled: state.busy
-													}],
+													items: [
+														{
+															id: "rename",
+															label: t("panel.rename"),
+															icon: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconEdit, {})
+														},
+														{
+															id: "access:inherit",
+															label: t("panel.accessInherit"),
+															disabled: state.busy || root.access === "inherit"
+														},
+														{
+															id: "access:read-only",
+															label: t("panel.accessReadOnly"),
+															disabled: state.busy || root.access === "read-only"
+														},
+														{
+															id: "access:read-write",
+															label: t("panel.accessReadWrite"),
+															disabled: state.busy || root.access === "read-write"
+														},
+														{
+															id: "remove",
+															label: t("panel.remove"),
+															icon: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconTrash, {}),
+															danger: true,
+															disabled: state.busy
+														}
+													],
 													onSelect: (id) => {
 														setMenuFor(void 0);
 														if (id === "rename") {
 															setAliasFor(key);
 															setAliasDraft(root.alias ?? "");
 														}
+														if (id.startsWith("access:")) {
+															const access = id.slice(7);
+															if (widensAccess(root.access, access)) {
+																setUpgradeFor({
+																	root,
+																	access
+																});
+																return;
+															}
+															mutate("setAccess", {
+																entry: entryOf(root),
+																access
+															});
+														}
 														if (id === "remove") mutate("remove", { entry: entryOf(root) });
 													},
 													portal: true,
@@ -6544,31 +8856,92 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 							children: [
 								state.noSession || props.pickDirectory === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconButton, {
 									variant: "outline",
-									disabled: state.busy,
+									disabled: state.busy || atLimit,
 									onClick: () => {
 										addViaPicker();
 									},
 									icon: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconPlus, {}),
-									label: t("panel.add")
+									label: atLimit ? t("panel.limitReached") : t("panel.add")
 								}),
-								state.noSession ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
-									className: "mrfw-input",
-									value: manualPath,
-									placeholder: t("panel.addManual"),
-									onChange: (event) => {
-										setManualPath(event.target.value);
-									},
-									onKeyDown: (event) => {
-										if (event.key === "Enter") addManualPath();
-									}
-								}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Action, {
-									onClick: () => {
-										addManualPath();
-									},
-									disabled: state.busy || manualPath.trim() === "",
-									variant: "primary",
-									children: t("panel.addConfirm")
-								})] }),
+								state.noSession ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [
+									/* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
+										className: "mrfw-input",
+										value: manualPath,
+										placeholder: t("panel.addManual"),
+										disabled: atLimit,
+										onChange: (event) => {
+											setManualPath(event.target.value);
+										},
+										onKeyDown: (event) => {
+											if (event.key === "Enter") addManualPath();
+										}
+									}),
+									/* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Menu, {
+										open: accessMenuOpen,
+										onClose: () => {
+											setAccessMenuOpen(false);
+										},
+										className: "mrfw-accessSelect",
+										items: [
+											{
+												id: "inherit",
+												label: t("access.inherit"),
+												icon: IconAccessInherit === void 0 ? void 0 : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconAccessInherit, {})
+											},
+											{
+												id: "read-write",
+												label: t("access.readWrite"),
+												icon: IconAccessReadWrite === void 0 ? void 0 : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconAccessReadWrite, {})
+											},
+											{
+												id: "read-only",
+												label: t("access.readOnly"),
+												icon: IconAccessReadOnly === void 0 ? void 0 : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconAccessReadOnly, {})
+											}
+										],
+										selectedId: addAccess,
+										onSelect: (id) => {
+											setAccessMenuOpen(false);
+											if (id === "inherit" || id === "read-write" || id === "read-only") {
+												setAccessChosen(true);
+												setAddAccess(id);
+											}
+										},
+										portal: true,
+										side: "top",
+										align: "end",
+										closeOnPointerLeave: true,
+										anchor: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("button", {
+											type: "button",
+											className: "mrfw-btn mrfw-btnOutline mrfw-accessTrigger",
+											title: t("panel.accessLabel"),
+											"aria-label": t("panel.accessLabel"),
+											"aria-haspopup": "menu",
+											"aria-expanded": accessMenuOpen,
+											disabled: state.busy || atLimit,
+											onClick: () => {
+												setAccessMenuOpen((open) => !open);
+											},
+											children: [
+												IconAccessTrigger === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconAccessTrigger, {}),
+												t(accessKey(addAccess)),
+												accessMenuOpen ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconChevronUp, { size: 14 }) : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconChevronDown, { size: 14 })
+											]
+										})
+									}),
+									/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Action, {
+										onClick: () => {
+											addManualPath();
+										},
+										disabled: state.busy || atLimit || manualPath.trim() === "",
+										variant: "primary",
+										children: t("panel.addConfirm")
+									})
+								] }),
+								atLimit ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+									className: "mrfw-note",
+									children: t("panel.limitReached")
+								}) : null,
 								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Action, {
 									onClick: () => {
 										refresh();
@@ -6581,7 +8954,33 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 						})]
 					})]
 				})]
-			});
+			}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Modal, {
+				open: upgradeFor !== void 0,
+				onClose: () => {
+					setUpgradeFor(void 0);
+				},
+				title: t("panel.accessUpgradeTitle"),
+				description: upgradeFor === void 0 ? "" : t("panel.accessUpgradeConfirm", { access: t(accessKey(upgradeFor.access)) }),
+				closeLabel: t("panel.close"),
+				footer: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Action, {
+					onClick: () => {
+						setUpgradeFor(void 0);
+					},
+					children: t("panel.aliasCancel")
+				}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Action, {
+					variant: "danger",
+					disabled: state.busy,
+					onClick: () => {
+						const pending = upgradeFor;
+						setUpgradeFor(void 0);
+						if (pending !== void 0) mutate("setAccess", {
+							entry: entryOf(pending.root),
+							access: pending.access
+						});
+					},
+					children: t("panel.accessUpgradeDo")
+				})] })
+			})] });
 		}
 		/** Normalize any thrown value into a `PanelError` the dialog can render. */
 		function asPanelError(error) {
@@ -6589,6 +8988,275 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			return new PanelError("fallback", error instanceof Error ? error.message : String(error));
 		}
 		//#endregion
+		//#region src/client/RootSwitcher.tsx
+		/**
+		* The Files-tab root switcher — the entry that took over the header position
+		* the P1 gear launcher first claimed. It poses as the pane's path label: a
+		* trigger that opens a menu of this session's roots (primary first, the
+		* registered additional roots next, and the Workspace Folders manager last),
+		* followed by a `PathLabel` of the selected root's full path — the same
+		* component upstream draws in that spot, so both primary and additional
+		* selections read exactly like the native header. While an additional root
+		* is selected it also lends the pane's body area to this plugin's verbatim
+		* fork of the native Files tree (`files-tree/`), so an additional root reads
+		* and behaves exactly like the primary one.
+		*
+		* Two upstream DOM hooks make the takeover work, and both degrade silently:
+		*
+		* - The stylesheet rules: while `.mrfw-rootSwitcher` exists inside a
+		*   `[data-files-root]` pane the upstream `data-files-path` is hidden and the
+		*   switcher takes its flex position; while the switcher carries
+		*   `data-root-kind="additional"` the native `data-files-body`,
+		*   `data-files-reload`, and `data-open-target="directory"` split button
+		*   hide too (the reload refreshes the very tree that is no longer
+		*   visible, and the native open-in-app button only ever receives the
+		*   primary root through its slot props — the header gets a
+		*   `.mrfw-switcherReload` replacement and the plugin's verbatim fork of
+		*   the open-in-app control, pointed at the selected root). Upstream
+		*   changing that DOM shape simply stops the selectors from matching — the
+		*   native header keeps working and the switcher is just another actions
+		*   occupant.
+		* - `closest('[data-files-root]')` from the switcher's own element locates
+		*   the pane the forked Files tree is portaled into, as a sibling of
+		*   `data-files-body`. No match → no portal: the component keeps working as
+		*   a menu and the native tree keeps its area. The tree's tab id comes from
+		*   the same element's `closest('[data-dockkit-content]')` — the dockkit
+		*   tabHost section — with a generated fallback where the hook is absent.
+		*
+		* The selected root is component state on purpose: every tab render
+		* occurrence gets its own, and reopening the pane resets to the primary
+		* root. There is no cross-tab or persisted selection.
+		*
+		* @module @dsh-electron/dsh-plugin-multi-root-workspace/client/RootSwitcher
+		*/
+		/**
+		* The subdued full-path label upstream's Files header draws — it exists from
+		* `0.1.7-alpha.1` on. A pixel-era runtime has no such export, so the probe
+		* returns `undefined` and the header falls back to a plain titled span: the
+		* path stays readable and hoverable, only the dir/file typography differs.
+		*/
+		const PathLabel = maybeComponent(["PathLabel"]);
+		/** The Files-header switcher: root menu, dialog entry, and the portal tree. */
+		function RootSwitcher(props) {
+			const { panel, t, primaryPath, filesTree } = props;
+			const [menuOpen, setMenuOpen] = (0, react.useState)(false);
+			const [dialogOpen, setDialogOpen] = (0, react.useState)(false);
+			const [view, setView] = (0, react.useState)(void 0);
+			const [selected, setSelected] = (0, react.useState)("primary");
+			const [takeover, setTakeover] = (0, react.useState)(null);
+			const wrapperRef = (0, react.useRef)(null);
+			const fallbackTabId = (0, react.useRef)(void 0);
+			const [pane, setPane] = (0, react.useState)(null);
+			const mounted = (0, react.useRef)(true);
+			const requestEpoch = (0, react.useRef)(0);
+			(0, react.useEffect)(() => {
+				mounted.current = true;
+				return () => {
+					mounted.current = false;
+					requestEpoch.current += 1;
+				};
+			}, []);
+			(0, react.useEffect)(() => {
+				setPane(wrapperRef.current?.closest("[data-files-root]") ?? null);
+			}, []);
+			const refresh = (0, react.useCallback)(async () => {
+				if (panel === void 0) {
+					setView(void 0);
+					return;
+				}
+				const session = props.sessionId?.();
+				if (session === void 0 || session === "") {
+					setView(void 0);
+					return;
+				}
+				const epoch = ++requestEpoch.current;
+				try {
+					const next = await panel.call("list", { sessionId: session });
+					if (!mounted.current || epoch !== requestEpoch.current || props.sessionId?.() !== session) return;
+					setView(next);
+				} catch {
+					if (!mounted.current || epoch !== requestEpoch.current || props.sessionId?.() !== session) return;
+					setView(void 0);
+				}
+			}, [panel, props.sessionId]);
+			(0, react.useEffect)(() => {
+				refresh();
+			}, [refresh]);
+			(0, react.useEffect)(() => {
+				let previous = props.sessionId?.();
+				return props.subscribeSession?.(() => {
+					const current = props.sessionId?.();
+					if (current === previous) return;
+					previous = current;
+					requestEpoch.current += 1;
+					setSelected("primary");
+					setView(void 0);
+					refresh();
+				});
+			}, [
+				props.subscribeSession,
+				props.sessionId,
+				refresh
+			]);
+			(0, react.useEffect)(() => {
+				if (selected === "primary") return;
+				const current = view?.roots.find((root) => root.id === selected.id);
+				if (current === void 0 || current.state !== "available") {
+					setSelected("primary");
+					return;
+				}
+				if (current !== selected) setSelected(current);
+			}, [view, selected]);
+			const roots = (0, react.useMemo)(() => view?.roots ?? [], [view]);
+			const primaryLabel = view?.primaryName ?? basename(view?.primaryRoot ?? primaryPath);
+			const triggerLabel = selected === "primary" ? primaryLabel : displayNameOf(selected);
+			const triggerPath = selected === "primary" ? view?.primaryRoot ?? primaryPath : selected.path;
+			const treeVisible = selected !== "primary" && panel !== void 0 && pane !== null && filesTree !== void 0;
+			const selectedPath = selected === "primary" ? void 0 : selected.path;
+			(0, react.useEffect)(() => {
+				if (!treeVisible || selectedPath === void 0) {
+					setTakeover(null);
+					return;
+				}
+				const controller = new AbortController();
+				const tabId = (wrapperRef.current?.closest("[data-dockkit-content]")?.dataset.dockkitContent ?? "") || (fallbackTabId.current ??= `mrfw-${Math.random().toString(36).slice(2)}`);
+				setTakeover({
+					signal: controller.signal,
+					tabId,
+					root: selectedPath
+				});
+				return () => {
+					controller.abort();
+				};
+			}, [treeVisible, selectedPath]);
+			const items = (0, react.useMemo)(() => [{
+				id: "primary",
+				label: `${primaryLabel} · ${t("panel.primary")}`,
+				icon: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconFolderOpen, {})
+			}, ...(filesTree === void 0 ? [] : roots).map((root) => ({
+				id: `root:${root.id}`,
+				label: root.state === "available" ? displayNameOf(root) : `${displayNameOf(root)} · ${t(stateKey(root.state))}`,
+				icon: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconFolderClose, {}),
+				disabled: root.state !== "available"
+			}))], [
+				roots,
+				primaryLabel,
+				t,
+				filesTree
+			]);
+			const onSelect = (id) => {
+				setMenuOpen(false);
+				if (id === "manage") {
+					setDialogOpen(true);
+					return;
+				}
+				if (id === "primary") {
+					setSelected("primary");
+					return;
+				}
+				const root = roots.find((candidate) => `root:${candidate.id}` === id);
+				if (root !== void 0) setSelected(root);
+			};
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [
+				/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
+					ref: wrapperRef,
+					className: "mrfw-rootSwitcher",
+					"data-root-kind": treeVisible ? "additional" : "primary",
+					children: [
+						/* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Menu, {
+							open: menuOpen,
+							onClose: () => {
+								setMenuOpen(false);
+							},
+							items,
+							footer: [{
+								id: "manage",
+								label: t("switcher.manage"),
+								icon: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconSettings, {})
+							}],
+							selectedId: selected === "primary" ? "primary" : `root:${selected.id}`,
+							onSelect,
+							portal: true,
+							align: "start",
+							anchor: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("button", {
+								type: "button",
+								className: "mrfw-rootSwitchBtn",
+								title: triggerPath,
+								"aria-haspopup": "menu",
+								"aria-expanded": menuOpen,
+								onClick: () => {
+									const opening = !menuOpen;
+									setMenuOpen(opening);
+									if (opening) refresh();
+								},
+								children: [
+									/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+										className: "mrfw-triggerIcon",
+										"aria-hidden": "true",
+										children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconFolderClose, { size: 16 })
+									}),
+									/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+										className: "mrfw-rootSwitchLabel",
+										children: triggerLabel
+									}),
+									/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+										className: "mrfw-triggerIcon mrfw-rootSwitchChevron",
+										"aria-hidden": "true",
+										children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconChevronDown, { size: 14 })
+									})
+								]
+							})
+						}),
+						PathLabel === void 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							className: "mrfw-switcherPath",
+							title: triggerPath,
+							children: triggerPath
+						}) : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(PathLabel, {
+							path: triggerPath,
+							className: "mrfw-switcherPath"
+						}),
+						treeVisible && filesTree !== void 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+							type: "button",
+							className: "mrfw-switcherReload",
+							"aria-label": filesTree.t("reload"),
+							title: filesTree.t("reload"),
+							onClick: () => {
+								if (takeover !== null) filesTree.face.refresh(takeover.tabId);
+							},
+							children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(IconRefresh, { size: 15 })
+						}) : null,
+						treeVisible && props.openInApp !== void 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(OpenInAppAction, {
+							...props.openInApp,
+							absolutePath: triggerPath
+						}) : null
+					]
+				}),
+				treeVisible && takeover !== null && filesTree !== void 0 ? (0, react_dom.createPortal)(/* @__PURE__ */ (0, react_jsx_runtime.jsx)(FilesTree, {
+					tabId: takeover.tabId,
+					sessionId: filesTree.sessionId,
+					root: takeover.root,
+					signal: takeover.signal,
+					useStore: filesTree.useStore,
+					actions: filesTree.actions,
+					start: filesTree.face.start,
+					toggle: filesTree.face.toggle,
+					onOpen: filesTree.openFile,
+					t: filesTree.t
+				}), pane) : null,
+				dialogOpen ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(WorkspaceFoldersDialog, {
+					panel: props.panel,
+					pickDirectory: props.pickDirectory,
+					...props.sessionId === void 0 ? {} : { sessionId: props.sessionId },
+					...props.subscribeSession === void 0 ? {} : { subscribeSession: props.subscribeSession },
+					t,
+					onClose: () => {
+						setDialogOpen(false);
+						refresh();
+					}
+				}) : null
+			] });
+		}
+		//#endregion
 		//#region src/client/index.ts
 		/** The footer-action cell this plugin owns. */
 		const SLOT_ID = "multi-root-folders";
@@ -6605,7 +9273,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		* @param ctx - the client root context.
 		*/
 		function apply(ctx) {
-			ctx.effect(() => ctx.locale.register(NS, {
+			ctx.effect(() => ctx.locale.register(NS$2, {
 				zh,
 				en
 			}), "multi-root-workspace: dictionaries");
@@ -6631,23 +9299,59 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				return await workspace.pickDirectory();
 			};
 			const sessionId = () => currentSessionIdOf(readService(ctx, "sessions"));
-			const t = ctx.locale.bind(NS);
+			const subscribeSession = (listener) => subscribeSessions(readService(ctx, "sessions"), listener);
+			const t = ctx.locale.bind(NS$2);
+			const openInApp = createOpenInAppAdapter({
+				t: ctx.locale.bind(NS),
+				shortcuts: readService(ctx, "shortcuts")?.catalog
+			});
+			const filesTreeSeats = createFilesTreeSeats(ctx);
+			const filesTreeT = ctx.locale.bind(NS$1);
 			ctx.slots.inject("sidebar.footer.action", () => ctx.slots.register({
 				name: "sidebar.footer.action",
 				id: SLOT_ID,
 				order: 50,
 				label: () => t("action.label"),
-				locale: NS
+				locale: NS$2
 			}, (owner) => {
 				const wide = owner?.wide;
 				return (0, react.createElement)(WorkspaceFoldersAction, {
 					panel,
 					pickDirectory,
 					sessionId,
+					subscribeSession,
 					t,
 					...wide === void 0 ? {} : { wide }
 				});
 			}));
+			ctx.slots.inject("sidebar.right.tab.files.actions", () => ctx.slots.register({
+				name: "sidebar.right.tab.files.actions",
+				id: SLOT_ID,
+				order: 50,
+				store: filesTreeSeats.store,
+				inject: filesTreeSeats.inject
+			}, function FilesActionsOccupant(props) {
+				const absolutePath = props?.absolutePath;
+				const paneSessionId = () => props?.sessionId ?? sessionId();
+				const filesTree = createFilesTreeSurface(props, filesTreeT);
+				return absolutePath === void 0 ? (0, react.createElement)(WorkspaceFoldersAction, {
+					panel,
+					pickDirectory,
+					sessionId: paneSessionId,
+					subscribeSession,
+					t,
+					compact: true
+				}) : (0, react.createElement)(RootSwitcher, {
+					primaryPath: absolutePath,
+					panel,
+					pickDirectory,
+					sessionId: paneSessionId,
+					subscribeSession,
+					t,
+					openInApp,
+					filesTree
+				});
+			}));
 		}
 		/**
 		* Read one optional service by name.