@qilin-agent/client-ui-workspace 0.0.0-stage → 3.1.3

package/lib/client.js

@@ -0,0 +1,3698 @@
+window.__ModuleLoader__.load({
+	id: "@qilin-agent/client-ui-workspace",
+	factory: (require) => {
+		var module = { exports: {} };
+		var exports = module.exports;
+		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+		let _qilin_agent_client_store = require("@qilin-agent/client-store");
+		let _qilin_agent_kylin = require("@qilin-agent/kylin");
+		let react_jsx_runtime = require("react/jsx-runtime");
+		let react = require("react");
+		let _qilin_agent_client_ui_primitives = require("@qilin-agent/client-ui-primitives");
+		//#region lib/types/client/shortcuts.js
+		/**
+		* Create the private browser request source shared by commands and controls.
+		* @returns observable state and its complete mutation callbacks.
+		*/
+		function createWorkspaceShortcutControls() {
+			const state = (0, _qilin_agent_client_store.createSnapshotStore)({
+				searchRequest: 0,
+				addRequested: false,
+				directoryBusy: false,
+				renameTarget: null
+			});
+			return {
+				state,
+				search: () => {
+					state.set({
+						...state.getSnapshot(),
+						searchRequest: state.getSnapshot().searchRequest + 1
+					});
+				},
+				add: () => {
+					state.set(state.getSnapshot().directoryBusy ? state.getSnapshot() : {
+						...state.getSnapshot(),
+						addRequested: true
+					});
+				},
+				closeAdd: () => {
+					state.set({
+						...state.getSnapshot(),
+						addRequested: false
+					});
+				},
+				directoryBusy: (busy) => {
+					state.set({
+						...state.getSnapshot(),
+						directoryBusy: busy
+					});
+				},
+				rename: (sessionId, currentTitle) => {
+					state.set({
+						...state.getSnapshot(),
+						renameTarget: {
+							sessionId,
+							currentTitle
+						}
+					});
+				},
+				closeRename: () => {
+					state.set({
+						...state.getSnapshot(),
+						renameTarget: null
+					});
+				}
+			};
+		}
+		/**
+		* Register navigation commands against the existing workspace owner.
+		* @param ctx - plugin context with the shortcut, locale, and model services.
+		* @param navigation - session creation and forking from the pointer controls' navigation service.
+		* @param controls - browser-owned opening requests.
+		* @param archiveSession - shared archive action, including running-work confirmation and notices.
+		*/
+		function installWorkspaceShortcuts(ctx, navigation, controls, archiveSession) {
+			const t = ctx.locale.bind("workspace");
+			const current = () => Object.values(ctx.sessions.list.getSnapshot().byId).find((row) => (row.retainedBy.mainView ?? 0) > 0);
+			const addReason = () => ctx.slots.entries("sidebar.workspaces.directoryFlow").length === 0 ? t("shortcut.noPicker") : controls.state.getSnapshot().directoryBusy ? t("shortcut.directoryBusy") : null;
+			const register = (id, label, aliases, code, modifiers, webModifiers, resolve) => {
+				ctx.effect(() => ctx.shortcuts.register({
+					id,
+					label,
+					aliases,
+					defaults: {
+						"desktop:macos": {
+							code,
+							modifiers
+						},
+						"desktop:windows": {
+							code,
+							modifiers
+						},
+						"desktop:linux": {
+							code,
+							modifiers
+						},
+						"web:macos": {
+							code,
+							modifiers: webModifiers
+						},
+						"web:windows": {
+							code,
+							modifiers: webModifiers
+						}
+					},
+					regions: ["page", "editable"],
+					modals: [],
+					resolve
+				}), `ui-workspace: ${id}`);
+			};
+			register("session.new", () => t("session.new"), ["new session", "new chat"], "KeyN", ["primary"], ["primary", "alt"], () => ({
+				status: "handled",
+				run: () => {
+					navigation.startSession();
+				}
+			}));
+			register("session.search", () => t("search.sessions.aria"), ["search sessions"], "KeyK", ["primary"], ["primary", "alt"], () => ({
+				status: "handled",
+				run: controls.search
+			}));
+			register("workspace.add", () => t("workspace.add"), ["add workspace", "open folder"], "KeyO", ["primary"], ["primary", "alt"], () => {
+				const reason = addReason();
+				return reason === null ? {
+					status: "handled",
+					run: controls.add
+				} : {
+					status: "blocked",
+					reason
+				};
+			});
+			register("session.rename", () => t("rename.session.title"), ["rename session"], "KeyR", ["primary", "alt"], ["primary", "shift"], () => {
+				const target = current();
+				return target === void 0 ? {
+					status: "blocked",
+					reason: t("shortcut.noSession")
+				} : {
+					status: "handled",
+					run: () => {
+						controls.rename(target.id, target.displayTitle);
+					}
+				};
+			});
+			register("session.fork", () => t("menu.fork"), ["fork session"], "KeyF", ["primary", "alt"], ["primary", "shift"], () => {
+				const target = current();
+				if (target === void 0) return {
+					status: "blocked",
+					reason: t("shortcut.noSession")
+				};
+				if (target.blank) return {
+					status: "blocked",
+					reason: t("shortcut.noCompletedTurn")
+				};
+				return {
+					status: "handled",
+					run: () => {
+						navigation.forkSession(target.id).catch((error) => {
+							if (!(error instanceof Error && error.name === "SessionForkError" && error.rpcError.code === "session/fork-unavailable")) console.warn("session fork rejected:", error);
+						});
+					}
+				};
+			});
+			register("session.archive", () => t("menu.archiveSession"), ["archive session"], "KeyA", ["primary", "shift"], ["primary", "alt"], () => {
+				const target = current();
+				return target === void 0 ? {
+					status: "blocked",
+					reason: t("shortcut.noSession")
+				} : {
+					status: "handled",
+					run: () => {
+						archiveSession(target.id);
+					}
+				};
+			});
+		}
+		//#endregion
+		//#region ../../util/workspace-path/src/index.ts
+		/** Whether a path uses a Windows drive or UNC prefix. */
+		function isWindowsStylePath(value) {
+			return /^[A-Za-z]:[/\\]/.test(value) || value.startsWith("\\\\");
+		}
+		/**
+		* Abbreviate a POSIX home directory for display.
+		* @param path - Absolute or already-short display path.
+		* @param home - Host account home; absent skips abbreviation.
+		* @returns `~` or `~/…` for the POSIX home and its descendants, otherwise `path`.
+		*/
+		function abbreviateHomePath(path, home) {
+			if (home === void 0 || home === "") return path;
+			if (isWindowsStylePath(path) || isWindowsStylePath(home)) return path;
+			const root = home.replace(/\/+$/, "");
+			if (root === "" || root === "/") return path;
+			if (path.replace(/\/+$/, "") === root) return "~";
+			if (path.startsWith(`${root}/`)) return `~${path.slice(root.length)}`;
+			return path;
+		}
+		/**
+		* Read the final non-empty segment of a Workspace path for display.
+		* Workspace-label surfaces use this helper instead of deriving another basename.
+		* @param path - Workspace directory path using POSIX or Windows separators.
+		* @returns the final segment, or an empty string for a separator-only path.
+		*/
+		function workspaceTitleOf(path) {
+			const trimmed = path.replace(/[/\\]+$/, "");
+			const separator = Math.max(trimmed.lastIndexOf("/"), trimmed.lastIndexOf("\\"));
+			return trimmed.slice(separator + 1);
+		}
+		//#endregion
+		//#region lib/types/client/subagent-lineage.js
+		/** UI Workspace-owned projection of descendant counts from Session summaries. */
+		/**
+		* Index uninterrupted subagent descendants under each ancestor.
+		* @param summaries - Session summaries keyed by id.
+		* @returns descendant totals keyed by possible parent id.
+		*/
+		function indexSubagentDescendants(summaries) {
+			const indexed = /* @__PURE__ */ new Map();
+			for (const descendant of Object.values(summaries)) {
+				if (descendant.origin !== "subagent") continue;
+				const seen = /* @__PURE__ */ new Set();
+				let current = descendant;
+				while (current?.origin === "subagent" && current.parentId !== void 0 && !seen.has(current.id)) {
+					seen.add(current.id);
+					const aggregate = indexed.get(current.parentId);
+					if (aggregate === void 0) indexed.set(current.parentId, {
+						count: 1,
+						runningCount: descendant.running ? 1 : 0
+					});
+					else {
+						aggregate.count += 1;
+						if (descendant.running) aggregate.runningCount += 1;
+					}
+					current = summaries[current.parentId];
+				}
+			}
+			return indexed;
+		}
+		/**
+		* Resolve the Workspace browser group that owns one Session.
+		* @param workspaces - authoritative Workspace membership.
+		* @param sessionId - Session whose browser group is required.
+		* @returns owning Workspace id, or {@link UNGROUPED_KEY} when no Workspace accounts for it.
+		*/
+		function owningGroupKey(workspaces, sessionId) {
+			return workspaces.find((workspace) => workspace.sessionIds.includes(sessionId))?.workspaceId ?? "";
+		}
+		function mainSessionId(list) {
+			return Object.values(list.byId).find((session) => (session.retainedBy.mainView ?? 0) > 0)?.id;
+		}
+		/**
+		* Directory display label: basename of the path (both separators accepted).
+		* Ungrouped-bucket fallback for surfaces without a workspace title.
+		* @param cwd - directory path, or undefined for the ungrouped bucket.
+		* @returns basename, the raw cwd when it has no basename, or an empty ungrouped marker.
+		*/
+		function workspaceLabel(cwd) {
+			if (cwd === void 0 || cwd === "") return "";
+			const base = workspaceTitleOf(cwd);
+			return base !== "" ? base : cwd;
+		}
+		/**
+		* Project known account members by current Session recency.
+		* @param sessionIds - authoritative account membership.
+		* @param summaries - current Session summaries; members without a summary are omitted until it arrives.
+		* @returns known members newest first, with Session identity as the deterministic tie-break.
+		*/
+		function orderByRecency(sessionIds, summaries) {
+			return sessionIds.flatMap((id) => {
+				const summary = summaries[id];
+				return summary === void 0 ? [] : [{
+					id,
+					updatedAt: summary.updatedAt
+				}];
+			}).sort((a, b) => {
+				if (a.updatedAt !== b.updatedAt) return b.updatedAt - a.updatedAt;
+				return a.id < b.id ? -1 : 1;
+			}).map((member) => member.id);
+		}
+		/**
+		* Reconcile a browser-local manual order with current account membership.
+		* @param memberIds - authoritative account membership.
+		* @param savedOrder - previously saved browser-local order.
+		* @param summaries - current Session summaries used to append newly known members by recency.
+		* @returns retained saved slots followed by newly known members; departed members and unknown new members are omitted.
+		*/
+		function reconcileManualOrder(memberIds, savedOrder, summaries) {
+			const members = new Map(memberIds.map((id) => [id, id]));
+			const included = /* @__PURE__ */ new Set();
+			const ordered = [];
+			for (const key of savedOrder ?? []) {
+				const id = members.get(key);
+				if (id === void 0 || included.has(key)) continue;
+				ordered.push(id);
+				included.add(key);
+			}
+			for (const id of orderByRecency(memberIds, summaries)) {
+				if (included.has(id)) continue;
+				ordered.push(id);
+				included.add(id);
+			}
+			return ordered;
+		}
+		/**
+		* Keep the selected provisional New Session ahead of either base order.
+		* @param order - recency or reconciled manual order.
+		* @param currentBlank - selected blank Session in this account, when present.
+		* @returns a copy with the selected blank first and no duplicate slot.
+		*/
+		function pinCurrentBlank(order, currentBlank) {
+			if (currentBlank === void 0) return [...order];
+			return [currentBlank, ...order.filter((id) => id !== currentBlank)];
+		}
+		/**
+		* Ordinary sessions are visible; among blank sessions, only the current one
+		* is visible. Subagent children use their parent header catalog; archived
+		* sessions are visible nowhere, while their accounting slots remain so
+		* unarchiving restores position.
+		*/
+		function sessionVisible(session, current, archived) {
+			return session.origin !== "subagent" && !archived.has(session.id) && (!session.blank || session.id === current);
+		}
+		/**
+		* A blank session is the selected Workspace's provisional New Session row;
+		* its canonical title never enters search (blank rows are query-excluded)
+		* and the renderer localizes its display label.
+		*/
+		function sessionTitle(session) {
+			return session.blank ? "" : session.displayTitle;
+		}
+		/** Build one group without projecting session lineage into presentation. */
+		function buildGroup(key, workspaceId, cwd, createdAt, label, members) {
+			return {
+				key,
+				workspaceId,
+				cwd,
+				createdAt,
+				label,
+				sessions: [...members]
+			};
+		}
+		/** Apply a stored Ungrouped order and append newly loose Sessions by recency. */
+		function orderedUngrouped(members, stored, summaries) {
+			const byId = new Map(members.map((session) => [session.id, session]));
+			return (stored === void 0 ? orderByRecency(members.map((session) => session.id), summaries) : reconcileManualOrder(members.map((session) => session.id), stored, summaries)).flatMap((id) => {
+				const session = byId.get(id);
+				/* v8 ignore next -- ids are projected exclusively from the members used to build byId. */
+				return session === void 0 ? [] : [session];
+			});
+		}
+		/**
+		* Group Sessions by Workspace: one group per caller-ordered entity, with
+		* members resolved from caller-ordered sessionIds. Sessions outside every
+		* Workspace trail in the browser-local Ungrouped order, which falls back to
+		* recency before that order is initialized.
+		*/
+		function groupByWorkspace(list, workspaces, archived, ungroupedOrder) {
+			const current = mainSessionId(list);
+			const groups = [];
+			const accounted = /* @__PURE__ */ new Set();
+			for (const workspace of workspaces) {
+				const members = [];
+				for (const id of workspace.sessionIds) {
+					const summary = list.byId[id];
+					if (summary === void 0) continue;
+					accounted.add(id);
+					if (!sessionVisible(summary, current, archived)) continue;
+					members.push(summary);
+				}
+				groups.push(buildGroup(workspace.workspaceId, workspace.workspaceId, workspace.path, Date.parse(workspace.createdAt), workspace.title, members));
+			}
+			const stray = list.ids.map((id) => list.byId[id]).filter((s) => s !== void 0 && !accounted.has(s.id) && sessionVisible(s, current, archived));
+			if (stray.length > 0) groups.push(buildGroup("", void 0, void 0, void 0, "", orderedUngrouped(stray, ungroupedOrder, list.byId)));
+			return groups;
+		}
+		/** Keep navigation presentation independent from domain-owned interaction objects. */
+		function visiblePendingKind(kind) {
+			switch (kind) {
+				case "approval":
+				case "plan-review":
+				case "question": return kind;
+				default: return;
+			}
+		}
+		function sessionNode(s, descendants, statuses, pinned) {
+			const status = statuses.get(s.id);
+			const pendingInteraction = visiblePendingKind(status?.pendingInteraction?.kind);
+			return {
+				id: s.id,
+				title: sessionTitle(s),
+				blank: s.blank,
+				running: status?.running ?? s.running,
+				runningSubagentCount: descendants.get(s.id)?.runningCount ?? 0,
+				completed: status?.completionUnread === true,
+				updatedAt: s.updatedAt,
+				pinned: pinned.has(s.id),
+				...pendingInteraction === void 0 ? {} : { pendingInteraction }
+			};
+		}
+		/**
+		* Front pinned rows without changing either partition's caller order, so the
+		* provisional New Session placeholder's own position is untouched.
+		* @param members - caller-ordered rows.
+		* @param pinned - registry-global pin set.
+		* @returns pinned rows first, then the rest.
+		*/
+		function sectionMembers(members, pinned) {
+			const leading = [];
+			const rest = [];
+			for (const member of members) if (pinned.has(member.id)) leading.push(member);
+			else rest.push(member);
+			return [...leading, ...rest];
+		}
+		/**
+		* Derive the workspace browser groups with every session as a top-level row.
+		*
+		* Every group shows; sessions populate under expanded groups in the selected
+		* local order. Blank sessions are excluded except for the selected
+		* provisional New Session row; archived sessions are excluded everywhere.
+		* Content search lives outside this derivation
+		* (see {@link deriveSearchResults}).
+		* @param list - sessions list snapshot (`mainView` retention feeds containsCurrent).
+		* @param workspaces - real Workspaces in Host group order with caller-projected Session order.
+		* @param rowState - registry-global pin and archive membership.
+		* @param statuses - unified UI status by Session.
+		* @param view - local expansion arrays.
+		* @returns group sections in render order.
+		*/
+		function deriveGroups(list, workspaces, rowState, statuses, view) {
+			const archived = new Set(rowState.archivedSessionIds);
+			const pinned = new Set(rowState.pinnedSessionIds);
+			const expandedGroups = new Set(view.expandedGroups);
+			const descendants = indexSubagentDescendants(list.byId);
+			const current = mainSessionId(list);
+			const currentGroup = current === void 0 ? void 0 : owningGroupKey(workspaces, current);
+			const groups = [];
+			for (const g of groupByWorkspace(list, workspaces, archived, view.ungroupedOrder)) {
+				const expanded = expandedGroups.has(g.key);
+				groups.push({
+					key: g.key,
+					workspaceId: g.workspaceId,
+					cwd: g.cwd,
+					createdAt: g.createdAt,
+					label: g.label,
+					sessionCount: g.sessions.length,
+					expanded,
+					containsCurrent: g.key === currentGroup,
+					sessions: expanded ? sectionMembers(g.sessions, pinned).map((session) => sessionNode(session, descendants, statuses, pinned)) : []
+				});
+			}
+			return groups;
+		}
+		/**
+		* Select flat-list members without deriving row presentation or ordering.
+		* @param list - sessions list snapshot.
+		* @param rowState - registry-global pin and archive membership.
+		* @returns known visible Session ids in list order, including ordinary forks and only the current blank.
+		*/
+		function visibleSessionIds(list, rowState) {
+			return memberIds(list, new Set(rowState.archivedSessionIds));
+		}
+		/**
+		* Select complete flat-list membership, independently of archive visibility.
+		* The pin write-back reconciles this account, so an archived Session keeps its
+		* slot and no pin silently drops it.
+		* @param list - sessions list snapshot.
+		* @returns known ordinary Session ids, including archived ones.
+		*/
+		function sessionMemberIds(list) {
+			return memberIds(list, /* @__PURE__ */ new Set());
+		}
+		function memberIds(list, archived) {
+			const current = mainSessionId(list);
+			return list.ids.filter((id) => {
+				const s = list.byId[id];
+				return s !== void 0 && sessionVisible(s, current, archived);
+			});
+		}
+		/**
+		* Derive flat rows from the browser's ordered visible Session ids.
+		* @param list - sessions list snapshot used to select the ids.
+		* @param sessionIds - known visible members in caller order, including any pinned blank.
+		* @param pinnedSessionIds - registry-global pin set; pinned rows lead after the blank.
+		* @param statuses - unified UI status by Session.
+		* @returns flat rows with pinned rows fronted and current status indicators.
+		*/
+		function deriveFlat(list, sessionIds, pinnedSessionIds, statuses) {
+			const descendants = indexSubagentDescendants(list.byId);
+			const pinned = new Set(pinnedSessionIds);
+			return sectionMembers(sessionIds.map((id) => list.byId[id]), pinned).map((session) => sessionNode(session, descendants, statuses, pinned));
+		}
+		/**
+		* Merge immediate title/Workspace substring matches with ranked Host content
+		* matches. Local rows lead newest-first, content-only rows retain backend
+		* order, and duplicate sessions receive the backend snippet in place.
+		* @param list - session metadata authority.
+		* @param workspaces - Workspace membership and display labels.
+		* @param query - caller text; surrounding whitespace is ignored.
+		* @param rowState - registry-global archive membership (members never match).
+		* @param statuses - unified UI status by Session.
+		* @param content - ranked Host content-search page.
+		* @param limit - protocol-owned maximum merged row count.
+		* @returns bounded deduplicated flat rows and a refine-query hint bit.
+		*/
+		function deriveSearchResults(list, workspaces, query, rowState, statuses, content, limit) {
+			const q = query.trim().toLowerCase();
+			if (q === "") return {
+				items: [],
+				hasMore: false
+			};
+			const archived = new Set(rowState.archivedSessionIds);
+			const descendants = indexSubagentDescendants(list.byId);
+			const current = mainSessionId(list);
+			const workspaceBySession = /* @__PURE__ */ new Map();
+			for (const workspace of workspaces) for (const sessionId of workspace.sessionIds) if (!workspaceBySession.has(sessionId)) workspaceBySession.set(sessionId, workspace.title);
+			const labelOf = (summary) => workspaceBySession.get(summary.id) ?? workspaceLabel(summary.cwd);
+			const contentBySession = /* @__PURE__ */ new Map();
+			for (const item of content.items) if (!contentBySession.has(item.sessionId)) contentBySession.set(item.sessionId, item);
+			const local = [];
+			for (const id of list.ids) {
+				const summary = list.byId[id];
+				if (summary === void 0 || summary.blank || !sessionVisible(summary, current, archived)) continue;
+				if (sessionTitle(summary).toLowerCase().includes(q) || labelOf(summary).toLowerCase().includes(q)) local.push(summary);
+			}
+			const localById = new Map(local.map((summary) => [summary.id, summary]));
+			const orderedLocal = orderByRecency(local.map((summary) => summary.id), list.byId).map((id) => localById.get(id));
+			const ordered = [];
+			const included = /* @__PURE__ */ new Set();
+			const include = (summary) => {
+				if (included.has(summary.id)) return;
+				included.add(summary.id);
+				ordered.push(summary);
+			};
+			for (const summary of orderedLocal) include(summary);
+			for (const item of content.items) {
+				const summary = list.byId[item.sessionId];
+				if (summary !== void 0 && !summary.blank && sessionVisible(summary, current, archived)) include(summary);
+			}
+			return {
+				items: ordered.slice(0, limit).map((summary) => {
+					const match = contentBySession.get(summary.id);
+					const status = statuses.get(summary.id);
+					const pendingInteraction = visiblePendingKind(status?.pendingInteraction?.kind);
+					return {
+						id: summary.id,
+						title: sessionTitle(summary),
+						workspace: labelOf(summary),
+						running: status?.running ?? summary.running,
+						runningSubagentCount: descendants.get(summary.id)?.runningCount ?? 0,
+						...pendingInteraction === void 0 ? {} : { pendingInteraction },
+						completed: status?.completionUnread === true,
+						...match === void 0 ? {} : { snippet: match.snippet }
+					};
+				}),
+				hasMore: content.hasMore || ordered.length > limit
+			};
+		}
+		/** Normalize separators for comparison without interpreting POSIX backslashes as separators. */
+		function folderPath(path) {
+			return (/^[A-Za-z]:[/\\]/.test(path) || path.startsWith("\\\\") ? path.replaceAll("\\", "/") : path).replace(/\/+$/, "");
+		}
+		/**
+		* Find the nearest registered ancestor, excluding the Workspace directory itself.
+		* Paths use Host spelling; matching is case-sensitive, like Workspace identity.
+		* @param path - Workspace directory.
+		* @param parents - registered Workspace directory paths.
+		* @returns the owning parent path, or undefined when no parent contains the Workspace.
+		*/
+		function owningParentFolder(path, parents) {
+			const child = folderPath(path);
+			let owner;
+			let length = -1;
+			for (const parent of parents) {
+				const root = folderPath(parent);
+				if (root.length > length && child !== root && child.startsWith(`${root}/`)) {
+					owner = parent;
+					length = root.length;
+				}
+			}
+			return owner;
+		}
+		//#endregion
+		//#region lib/types/client/stores.js
+		/**
+		* The workspace browser's viewing store: the session-list grouping mode,
+		* persisted across reloads. Module level exports the factory only (a
+		* module-level handle would pin the store identity across plugin reloads);
+		* register() receives the factory and the browser derives its PropsStore
+		* share from the return type.
+		*/
+		/** Browser-local order account for the hierarchy-free flat Session list. */
+		const FLAT_SESSION_ORDER_KEY = "__flat_session_order__";
+		/** Copy read-only projections into the persisted mutable store representation. */
+		function copySessionOrders(orders) {
+			return Object.fromEntries(Object.entries(orders).map(([key, order]) => [key, [...order]]));
+		}
+		/**
+		* Create the workspace browser viewing store handle.
+		* @returns the store handle (spec + type + identity + factory in one).
+		*/
+		function createWorkspaceViewStore() {
+			return (0, _qilin_agent_client_store.defineStore)({
+				init: () => ({
+					groupBy: "workspace",
+					orderBy: "updated",
+					groupExpansion: {},
+					sessionOrderByAccount: {}
+				}),
+				persist: "qilin.workspace.view.v5",
+				actions: {
+					setGroupBy: (d, mode) => {
+						d.groupBy = mode;
+					},
+					setOrderBy: (d, mode, initialOrders) => {
+						if (mode === d.orderBy) return;
+						d.sessionOrderByAccount = mode === "manual" ? copySessionOrders(initialOrders) : {};
+						d.orderBy = mode;
+					},
+					setGroupExpanded: (d, key, expanded) => {
+						d.groupExpansion[key] = expanded;
+					},
+					retainAccountKeys: (d, workspaceKeys) => {
+						const retained = new Set(workspaceKeys);
+						d.groupExpansion = Object.fromEntries(Object.entries(d.groupExpansion).filter(([key]) => retained.has(key)));
+						d.sessionOrderByAccount = Object.fromEntries(Object.entries(d.sessionOrderByAccount).filter(([key]) => retained.has(key)));
+						delete d.sessionUpdatedAtByAccount;
+					},
+					syncSessionOrders: (d, orders) => {
+						if (d.orderBy !== "manual") return;
+						Object.assign(d.sessionOrderByAccount, copySessionOrders(orders));
+					},
+					setSessionOrder: (d, accountKey, order, initialOrders) => {
+						if (d.orderBy === "updated") d.sessionOrderByAccount = copySessionOrders(initialOrders);
+						d.orderBy = "manual";
+						d.sessionOrderByAccount[accountKey] = [...order];
+					},
+					pinSessionOrder: (d, sessionId, accountKeys, source) => {
+						const selected = new Set(accountKeys);
+						d.sessionOrderByAccount = Object.fromEntries(Object.entries(source.members).map(([key, members]) => {
+							const order = reconcileManualOrder(members, d.sessionOrderByAccount[key], source.summaries);
+							return [key, selected.has(key) ? [sessionId, ...order.filter((id) => id !== sessionId)] : order];
+						}));
+					}
+				}
+			});
+		}
+		//#endregion
+		//#region lib/types/client/pin-order.js
+		/**
+		* Every account's complete membership: each Workspace, Ungrouped, and the flat list.
+		* @param workspaces - current Host Workspaces.
+		* @param list - current Session list snapshot.
+		* @returns membership per account key plus the summaries a reconciliation orders by.
+		*/
+		function pinOrderSource(workspaces, list) {
+			const accounted = new Set(workspaces.flatMap((workspace) => workspace.sessionIds));
+			return {
+				members: Object.fromEntries([
+					...workspaces.map((workspace) => [workspace.workspaceId, workspace.sessionIds]),
+					["", list.ids.filter((id) => list.byId[id] !== void 0 && !accounted.has(id))],
+					[FLAT_SESSION_ORDER_KEY, sessionMemberIds(list)]
+				]),
+				summaries: list.byId
+			};
+		}
+		/**
+		* The accounts a pinned Session leads: its group (or Ungrouped) and the flat list.
+		* @param workspaces - current Host Workspaces.
+		* @param sessionId - the Session being pinned.
+		* @returns the account keys a pin write fronts.
+		*/
+		function pinOrderAccounts(workspaces, sessionId) {
+			return [owningGroupKey(workspaces, sessionId), FLAT_SESSION_ORDER_KEY];
+		}
+		//#endregion
+		//#region lib/types/client/navigation.js
+		/** Workspace archive and directory UI capability. */
+		/** Structured directory failure exposed to directory UI consumers. */
+		var DirectoryBrowseError = class extends Error {
+			rpcError;
+			name = "DirectoryBrowseError";
+			/** @param rpcError - Host directory business failure. */
+			constructor(rpcError) {
+				super(`directory browse failed: ${rpcError.code}: ${rpcError.message}`);
+				this.rpcError = rpcError;
+			}
+		};
+		/** Implements Workspace archive and directory UI operations. */
+		var UiWorkspaceService = class extends _qilin_agent_kylin.Service {
+			directoryPicker;
+			agentPresets;
+			workbench;
+			workspaces;
+			sessions;
+			view;
+			connecting = /* @__PURE__ */ new Map();
+			lifetime = new AbortController();
+			/**
+			* The persisted main-pane selection. Published as the `mainSelection` root
+			* standard source, because the Session Controller owns the catalog and leaves
+			* view selection to navigation.
+			*/
+			selection = (0, _qilin_agent_client_store.createSnapshotStore)({}, { persist: { name: "qilin.sessions.current" } });
+			mainReference;
+			/**
+			* @param ctx - Client root Context.
+			* @param directoryPicker - the directory-picking Remote namespace.
+			* @param agentPresets - the preset-switch caller, for the blank-session
+			* tag rebind (D3: a blank session may switch presets; a started one may not).
+			* @param workbench - the tag state owner, supplying each new task's preset
+			* and the visibility fold the reuse rule checks.
+			* @param workspaces - pure Workspace Controller.
+			* @param sessions - pure Session Controller.
+			* @param view - the browser's viewing-store write set, which owns saved Session order.
+			*/
+			constructor(ctx, directoryPicker, agentPresets, workbench, workspaces, sessions, view) {
+				super(ctx, "uiWorkspace");
+				this.directoryPicker = directoryPicker;
+				this.agentPresets = agentPresets;
+				this.workbench = workbench;
+				this.workspaces = workspaces;
+				this.sessions = sessions;
+				this.view = view;
+				ctx.effect(() => {
+					const stop = this.watchNavigation();
+					return () => {
+						stop();
+						this.lifetime.abort();
+						const reference = this.mainReference;
+						this.mainReference = void 0;
+						reference?.release();
+					};
+				}, "ui-workspace: Workspace navigation policy");
+			}
+			async connectWorkspace(workspaceId) {
+				const workspace = this.workspaces.list.getSnapshot().items.find((item) => item.workspaceId === workspaceId);
+				if (workspace === void 0) throw new Error(`uiWorkspace.connectWorkspace: unknown workspace ${workspaceId}`);
+				const inflight = this.connecting.get(workspaceId);
+				if (inflight !== void 0) return inflight;
+				const archived = this.workspaces.list.getSnapshot().archivedSessionIds;
+				const sessions = this.sessions.list.getSnapshot();
+				for (const id of sessions.ids) {
+					const summary = sessions.byId[id];
+					if (summary !== void 0 && summary.blank && summary.cwd === workspace.path && workspace.sessionIds.includes(summary.id) && !archived.includes(summary.id)) {
+						this.rebindBlankToActiveTag(id);
+						return summary.id;
+					}
+				}
+				const attempt = this.sessions.create({
+					workspaceId,
+					agentPreset: this.workbench.presetFor(this.workbench.state.getSnapshot().active)
+				}).finally(() => {
+					this.connecting.delete(workspaceId);
+				});
+				this.connecting.set(workspaceId, attempt);
+				return attempt;
+			}
+			/**
+			* Rebind every blank session of the current Workspace to the now-active
+			* tag's preset. Blank sessions carried over from the other tag would
+			* otherwise sit hidden in this tag's filtered list; a non-blank session
+			* stays exactly as it is (the Host refuses non-blank switches anyway).
+			*/
+			rebindBlanksAfterTagSwitch() {
+				const current = this.mainReference?.sessionId;
+				const workspace = current === void 0 ? void 0 : this.workspaces.list.getSnapshot().items.find((item) => item.sessionIds.includes(current));
+				if (workspace === void 0) return;
+				for (const id of workspace.sessionIds) if (this.sessions.list.getSnapshot().byId[id]?.blank === true) this.rebindBlankToActiveTag(id);
+			}
+			/**
+			* Switch one blank session to the active tag's preset when the preset it
+			* was created under does not show under this tag. Fire-and-forget: the
+			* session stays usable either way, and a `locked` verdict means it engaged
+			* mid-rebind, so its own preset stands.
+			* @param id - the blank session to align.
+			*/
+			rebindBlankToActiveTag(id) {
+				const summary = this.sessions.list.getSnapshot().byId[id];
+				if (summary === void 0) return;
+				const tag = this.workbench.state.getSnapshot().active;
+				if (this.workbench.shows(summary.projectionValues?.agentPreset, tag)) return;
+				this.agentPresets.select(id, this.workbench.presetFor(tag)).catch((reason) => {
+					console.warn(`blank session ${id} kept its own preset:`, reason);
+				});
+			}
+			adoptBlankSessionPreset(presetId) {
+				const current = this.mainReference?.sessionId;
+				if (current === void 0) return;
+				if (this.sessions.list.getSnapshot().byId[current]?.blank !== true) return;
+				this.agentPresets.select(current, presetId).catch((reason) => {
+					console.warn(`blank session ${current} kept its own preset:`, reason);
+				});
+			}
+			openSession(target) {
+				this.replaceMain(target, this.lifetime.signal);
+			}
+			async openWorkspace(workspaceId, beforeOpen) {
+				const navigation = AbortSignal.any([this.ctx.layout.beginNavigation(), this.lifetime.signal]);
+				const sessionId = await this.connectWorkspace(workspaceId);
+				if (navigation.aborted) return;
+				this.replaceMain(sessionId, navigation, beforeOpen);
+			}
+			async forkSession(sessionId) {
+				const navigation = AbortSignal.any([this.ctx.layout.beginNavigation(), this.lifetime.signal]);
+				const childId = await this.sessions.fork({
+					sessionId,
+					increaseTitle: true
+				});
+				if (!navigation.aborted) this.replaceMain(childId, navigation);
+			}
+			startSession(workspaceId) {
+				const workspace = this.workspaces.list.getSnapshot();
+				const sessions = this.sessions.list.getSnapshot();
+				const current = this.mainReference?.sessionId;
+				const currentWorkspaceId = current === void 0 ? void 0 : workspace.items.find((item) => item.sessionIds.includes(current))?.workspaceId;
+				const recent = workspace.phase === "ready" && sessions.phase === "ready" ? recentWorkspace(workspace.items, sessions.byId) : void 0;
+				const target = workspaceId ?? currentWorkspaceId ?? recent;
+				if (target === void 0) {
+					this.clearMain();
+					return;
+				}
+				this.openWorkspace(target).catch((reason) => {
+					console.warn("new session failed:", reason);
+				});
+			}
+			async archiveSession(sessionId) {
+				await this.workspaces.archiveSession(sessionId);
+				if (this.mainReference?.sessionId === sessionId) this.clearMain();
+			}
+			async unarchiveSession(sessionId) {
+				await this.workspaces.unarchiveSession(sessionId);
+			}
+			async pinSession(sessionId) {
+				await this.workspaces.pinSession(sessionId);
+				const { items } = this.workspaces.list.getSnapshot();
+				this.view.pinSessionOrder(sessionId, pinOrderAccounts(items, sessionId), pinOrderSource(items, this.sessions.list.getSnapshot()));
+			}
+			async unpinSession(sessionId) {
+				await this.workspaces.unpinSession(sessionId);
+			}
+			async pickDirectory() {
+				const result = await this.directoryPicker.pick();
+				if (!result.ok) throw new Error(`directory picker failed: ${result.error.message}`);
+				return result.value;
+			}
+			async listDirectory(path, signal) {
+				const result = await this.directoryPicker.list(path, signal);
+				if (!result.ok) throw new DirectoryBrowseError(result.error);
+				return result.value;
+			}
+			async createDirectory(path, name) {
+				const result = await this.directoryPicker.createDirectory(path, name);
+				if (!result.ok) throw new DirectoryBrowseError(result.error);
+				return result.value;
+			}
+			watchNavigation() {
+				let initial = "waiting";
+				const reconcile = () => {
+					if (this.lifetime.signal.aborted) return;
+					if (this.clearArchivedCurrent()) return;
+					if (initial !== "waiting") return;
+					const workspace = this.workspaces.list.getSnapshot();
+					const sessions = this.sessions.list.getSnapshot();
+					if (workspace.phase !== "ready" || sessions.phase !== "ready") return;
+					if (this.mainReference !== void 0) {
+						initial = "done";
+						return;
+					}
+					const saved = this.selection.getSnapshot();
+					const savedTarget = saved.subagentAddress ?? (saved.sessionId !== void 0 && sessions.byId[saved.sessionId] !== void 0 ? saved.sessionId : void 0);
+					if (savedTarget !== void 0) {
+						initial = "connecting";
+						try {
+							if (saved.subagentAddress !== void 0) this.sessions.refreshProjections(saved.subagentAddress.parentSessionId);
+							this.openSession(savedTarget);
+							initial = "done";
+						} catch (reason) {
+							initial = "waiting";
+							console.warn("initial Session restoration failed:", reason);
+						}
+						return;
+					}
+					const target = recentWorkspace(workspace.items, sessions.byId);
+					if (target === void 0) {
+						initial = "done";
+						return;
+					}
+					initial = "connecting";
+					this.connectWorkspace(target).then((sessionId) => {
+						if (this.mainReference === void 0) this.openSession(sessionId);
+					}).then(() => {
+						initial = "done";
+					}, (reason) => {
+						if (this.lifetime.signal.aborted) return;
+						initial = "waiting";
+						console.warn("initial workspace selection failed:", reason);
+					});
+				};
+				const disposeWorkspaces = this.workspaces.list.subscribe(reconcile);
+				const disposeSessions = this.sessions.list.subscribe(reconcile);
+				reconcile();
+				return () => {
+					this.lifetime.abort();
+					disposeSessions();
+					disposeWorkspaces();
+				};
+			}
+			/** @returns true when an archived current selection was cleared. */
+			clearArchivedCurrent() {
+				const current = this.mainReference?.sessionId;
+				if (current === void 0 || !this.workspaces.list.getSnapshot().archivedSessionIds.includes(current)) return false;
+				this.clearMain();
+				return true;
+			}
+			clearMain() {
+				const previous = this.mainReference;
+				this.mainReference = void 0;
+				this.selection.set({});
+				previous?.release();
+				this.ctx.layout.selectPanel(null);
+			}
+			replaceMain(target, signal, beforeOpen) {
+				signal.throwIfAborted();
+				const reference = this.sessions.retain(target, { source: "mainView" });
+				try {
+					signal.throwIfAborted();
+					beforeOpen?.(reference.sessionId);
+					if (signal.aborted) {
+						reference.release();
+						return;
+					}
+					const subagentAddress = typeof target === "string" ? this.sessions.subagentAddress(reference.sessionId) : target;
+					this.selection.set({
+						sessionId: reference.sessionId,
+						...subagentAddress === void 0 ? {} : { subagentAddress }
+					});
+				} catch (error) {
+					reference.release();
+					throw error;
+				}
+				const previous = this.mainReference;
+				this.mainReference = reference;
+				previous?.release();
+				this.sessions.refreshProjections(reference.sessionId);
+				this.ctx.layout.selectPanel(null);
+			}
+		};
+		/** Stable tie-breaking follows Host Workspace order. */
+		function recentWorkspace(workspaces, sessions) {
+			let selected;
+			let selectedTime = Number.NEGATIVE_INFINITY;
+			for (const workspace of workspaces) {
+				let latest = Number.NEGATIVE_INFINITY;
+				for (const sessionId of workspace.sessionIds) {
+					const session = sessions[sessionId];
+					if (session !== void 0) latest = Math.max(latest, session.updatedAt);
+				}
+				if (latest === Number.NEGATIVE_INFINITY) latest = Date.parse(workspace.createdAt);
+				if (selected === void 0 || latest > selectedTime) {
+					selected = workspace.workspaceId;
+					selectedTime = latest;
+				}
+			}
+			return selected;
+		}
+		//#endregion
+		//#region \0qilin-css:/home/runner/work/QiLin/QiLin/packages/client/ui-workspace/src/client/AgentPresetChip.module.css.mjs
+		const css$5 = "._2_v9Qa_chip{max-width:min(100%,360px);min-height:28px;color:var(--qilin-alias-label-primary);cursor:pointer;background:0 0;border:none;border-radius:16px;align-items:center;gap:4px;padding:0 8px;font-size:13px;font-weight:500;line-height:20px;display:inline-flex}._2_v9Qa_chip:hover,._2_v9Qa_chip[aria-expanded=true]{background:var(--qilin-alias-interactive-bg-hover)}._2_v9Qa_icon{color:var(--qilin-alias-label-primary);flex:none}._2_v9Qa_label{text-overflow:ellipsis;white-space:nowrap;min-width:0;overflow:hidden}._2_v9Qa_chevron{color:var(--qilin-alias-label-caption);flex:none}._2_v9Qa_item{flex-direction:column;gap:2px;min-width:0;display:flex}._2_v9Qa_itemName{font-weight:500}._2_v9Qa_itemDesc{color:var(--qilin-alias-label-secondary);text-overflow:ellipsis;white-space:nowrap;font-size:12px;line-height:18px;overflow:hidden}._2_v9Qa_menuAnchor{z-index:10}";
+		const tagId$5 = "@qilin-agent/client-ui-workspace/AgentPresetChip.module.css";
+		if (typeof document !== "undefined" && document.querySelector("style[data-plugin-css=" + JSON.stringify(tagId$5) + "]") === null) {
+			const tag = document.createElement("style");
+			tag.dataset.plugin = "@qilin-agent/client-ui-workspace";
+			tag.dataset.pluginCss = tagId$5;
+			tag.textContent = css$5;
+			document.head.appendChild(tag);
+		}
+		var AgentPresetChip_module_css_default = {
+			"chevron": "_2_v9Qa_chevron",
+			"chip": "_2_v9Qa_chip",
+			"icon": "_2_v9Qa_icon",
+			"item": "_2_v9Qa_item",
+			"itemDesc": "_2_v9Qa_itemDesc",
+			"itemName": "_2_v9Qa_itemName",
+			"label": "_2_v9Qa_label",
+			"menuAnchor": "_2_v9Qa_menuAnchor"
+		};
+		//#endregion
+		//#region lib/types/client/AgentPresetChip.js
+		/**
+		* The hero run-mode chip, beside the workspace picker on the new-task screen:
+		* which preset the next task in this workbench tag composes from (D3). The
+		* general and coding tags carry their own defaults (standard / ptc); the chip
+		* exists so the creator preset stays one pick away. The choice is remembered
+		* per tag through the workbench state, and the on-screen blank session is
+		* rebound immediately so the staged task already carries it.
+		*
+		* The chip hides while the roster is unavailable, failed, or offers fewer
+		* than two choices for the tag — a selector over one entry is noise.
+		*/
+		/**
+		* Render the run-mode chip.
+		* @param props - the bound workbench and roster selector hooks, the tag
+		*   vocabulary and pick actions, and the locale seat.
+		* @returns the chip, or null when there is nothing to choose.
+		*/
+		function AgentPresetChip({ useWorkbench, useRoster, tagChoices, pick, t }) {
+			const workbench = useWorkbench((snapshot) => snapshot);
+			const roster = useRoster((snapshot) => snapshot);
+			const [open, setOpen] = (0, react.useState)(false);
+			const tag = workbench.active;
+			const options = (0, react.useMemo)(() => {
+				const byId = new Map(roster.presets.map((preset) => [preset.id, preset]));
+				const shipped = tagChoices(tag).map((id) => byId.get(id)).filter((preset) => preset !== void 0);
+				const known = new Set([...tagChoices("general"), ...tagChoices("coding")]);
+				const custom = roster.presets.filter((preset) => !known.has(preset.id));
+				return [...shipped, ...custom];
+			}, [
+				roster.presets,
+				tag,
+				tagChoices
+			]);
+			if (roster.status !== "ready" || options.length < 2) return null;
+			const currentId = workbench.presets[tag];
+			const currentName = options.find((option) => option.id === currentId)?.name ?? currentId;
+			return (0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.Menu, {
+				open,
+				onClose: () => {
+					setOpen(false);
+				},
+				items: options.map((option) => ({
+					id: option.id,
+					label: (0, react_jsx_runtime.jsxs)("span", {
+						className: AgentPresetChip_module_css_default.item,
+						children: [(0, react_jsx_runtime.jsx)("span", {
+							className: AgentPresetChip_module_css_default.itemName,
+							children: option.name ?? option.id
+						}), option.description !== void 0 && (0, react_jsx_runtime.jsx)("span", {
+							className: AgentPresetChip_module_css_default.itemDesc,
+							children: option.description
+						})]
+					})
+				})),
+				selectedId: currentId,
+				onSelect: (id) => {
+					setOpen(false);
+					pick(id);
+				},
+				align: "start",
+				portal: true,
+				className: AgentPresetChip_module_css_default.menuAnchor,
+				anchor: (0, react_jsx_runtime.jsxs)("button", {
+					type: "button",
+					className: AgentPresetChip_module_css_default.chip,
+					"aria-label": t("preset.aria"),
+					"aria-haspopup": "menu",
+					"aria-expanded": open,
+					title: t("preset.hint"),
+					onClick: () => {
+						setOpen((value) => !value);
+					},
+					children: [
+						(0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.IconAgentPresetOutline16, { className: AgentPresetChip_module_css_default.icon }),
+						(0, react_jsx_runtime.jsx)("span", {
+							className: AgentPresetChip_module_css_default.label,
+							children: currentName
+						}),
+						(0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.IconChevronDownOutline14, { className: AgentPresetChip_module_css_default.chevron })
+					]
+				})
+			});
+		}
+		//#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 \0qilin-css:/home/runner/work/QiLin/QiLin/packages/client/ui-workspace/src/client/rows/WorkbenchSwitch.module.css.mjs
+		const css$4 = ".n6Fpha_switch{align-items:center;gap:6px;display:inline-flex}.n6Fpha_tab{height:28px;color:var(--qilin-alias-label-secondary);font-size:var(--dsh-content-font-size-secondary,13px);corner-shape:round;cursor:pointer;transition:background var(--ds-transition-duration-fast) var(--ds-ease-in-out);background:0 0;border:1px solid #0000;border-radius:999px;flex:none;justify-content:center;align-items:center;gap:5px;padding:0 8px;line-height:1;display:inline-flex}.n6Fpha_tab:hover{background:var(--qilin-alias-interactive-bg-hover)}.n6Fpha_activePill{color:var(--qilin-alias-brand-primary-new-colorprimary-new-color);border-color:currentColor;padding:0 11px}.n6Fpha_inactiveIcon{width:28px;padding:0}.n6Fpha_label{white-space:nowrap}";
+		const tagId$4 = "@qilin-agent/client-ui-workspace/WorkbenchSwitch.module.css";
+		if (typeof document !== "undefined" && document.querySelector("style[data-plugin-css=" + JSON.stringify(tagId$4) + "]") === null) {
+			const tag = document.createElement("style");
+			tag.dataset.plugin = "@qilin-agent/client-ui-workspace";
+			tag.dataset.pluginCss = tagId$4;
+			tag.textContent = css$4;
+			document.head.appendChild(tag);
+		}
+		var WorkbenchSwitch_module_css_default = {
+			"activePill": "n6Fpha_activePill",
+			"inactiveIcon": "n6Fpha_inactiveIcon",
+			"label": "n6Fpha_label",
+			"switch": "n6Fpha_switch",
+			"tab": "n6Fpha_tab"
+		};
+		//#endregion
+		//#region lib/types/client/rows/WorkbenchSwitch.js
+		/** Constant visual order: coding first (left), general second (right). */
+		const ENTRIES = ["coding", "general"];
+		/**
+		* Render the two-tag switch. Both tags stay mounted and reachable — only the
+		* label of the inactive one is hidden — so the tab semantics of the previous
+		* segmented control carry over: roving tab stop on the selected tag,
+		* Left/Right to move selection.
+		* @param props.value - the active tag.
+		* @param props.onChange - selection requested by click or Left/Right.
+		* @param props.labels - localized tag names, keyed by tag; the inactive
+		* button's accessible name (its label is hidden).
+		* @param props.ariaLabel - localized accessible name for the tab list.
+		* @param props.panelId - DOM id of the panel the tabs control.
+		* @returns the tab list, without its panel.
+		*/
+		function WorkbenchSwitch({ value, onChange, labels, ariaLabel, panelId }) {
+			const onKeyDown = (event, index) => {
+				let next;
+				switch (event.key) {
+					case "ArrowLeft":
+						next = (index + ENTRIES.length - 1) % ENTRIES.length;
+						break;
+					case "ArrowRight":
+						next = (index + 1) % ENTRIES.length;
+						break;
+					default: return;
+				}
+				event.preventDefault();
+				event.stopPropagation();
+				const tablist = event.currentTarget.parentElement;
+				const nextTag = ENTRIES[next];
+				/* v8 ignore next -- the event comes from a mounted direct child and next is bounded by the fixed pair. */
+				if (tablist === null || nextTag === void 0) return;
+				tablist.querySelectorAll("[role=\"tab\"]").item(next).focus();
+				onChange(nextTag);
+			};
+			return (0, react_jsx_runtime.jsx)("div", {
+				role: "tablist",
+				"aria-label": ariaLabel,
+				className: WorkbenchSwitch_module_css_default.switch,
+				children: ENTRIES.map((tag, index) => {
+					const active = value === tag;
+					return (0, react_jsx_runtime.jsxs)("button", {
+						type: "button",
+						role: "tab",
+						id: `workbench-tab-${tag}`,
+						"aria-selected": active,
+						"aria-controls": panelId,
+						"aria-label": labels[tag],
+						tabIndex: active ? 0 : -1,
+						title: labels[tag],
+						className: clsx(WorkbenchSwitch_module_css_default.tab, active ? WorkbenchSwitch_module_css_default.activePill : WorkbenchSwitch_module_css_default.inactiveIcon),
+						onClick: () => {
+							onChange(tag);
+						},
+						onKeyDown: (event) => {
+							onKeyDown(event, index);
+						},
+						children: [tag === "coding" ? (0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.IconTerminalOutline16, { size: 14 }) : (0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.IconSparkle16, { size: 14 }), active && (0, react_jsx_runtime.jsx)("span", {
+							className: WorkbenchSwitch_module_css_default.label,
+							children: labels[tag]
+						})]
+					}, tag);
+				})
+			});
+		}
+		//#endregion
+		//#region \0qilin-css:/home/runner/work/QiLin/QiLin/packages/client/ui-workspace/src/client/WorkbenchSwitchSeat.module.css.mjs
+		const css$3 = ".ASIh6a_seat{flex:none;padding:0 12px 8px}";
+		const tagId$3 = "@qilin-agent/client-ui-workspace/WorkbenchSwitchSeat.module.css";
+		if (typeof document !== "undefined" && document.querySelector("style[data-plugin-css=" + JSON.stringify(tagId$3) + "]") === null) {
+			const tag = document.createElement("style");
+			tag.dataset.plugin = "@qilin-agent/client-ui-workspace";
+			tag.dataset.pluginCss = tagId$3;
+			tag.textContent = css$3;
+			document.head.appendChild(tag);
+		}
+		var WorkbenchSwitchSeat_module_css_default = { "seat": "ASIh6a_seat" };
+		//#endregion
+		//#region lib/types/client/WorkbenchSwitchSeat.js
+		/**
+		* Render the switch seat.
+		* @param props - shell owner share (wide), the bound workbench selector hook,
+		*   the switch callback, and the locale seat.
+		* @returns the switch row, or null on the rail.
+		*/
+		function WorkbenchSwitchSeat({ wide, useWorkbench, onWorkbenchSwitch, t }) {
+			const workbench = useWorkbench((state) => state);
+			if (!wide) return null;
+			return (0, react_jsx_runtime.jsx)("div", {
+				className: WorkbenchSwitchSeat_module_css_default.seat,
+				children: (0, react_jsx_runtime.jsx)(WorkbenchSwitch, {
+					value: workbench.active,
+					onChange: onWorkbenchSwitch,
+					labels: {
+						general: t("workbench.general"),
+						coding: t("workbench.coding")
+					},
+					ariaLabel: t("workbench.tabs.aria"),
+					panelId: "workbench-list-panel"
+				})
+			});
+		}
+		//#endregion
+		//#region \0qilin-css:/home/runner/work/QiLin/QiLin/packages/client/ui-workspace/src/client/rows/Rows.module.css.mjs
+		const css$2 = ".RrwzeW_projectRow,.RrwzeW_sessionRow{padding:0 8px;cursor:pointer;user-select:none;color:var(--qilin-alias-label-primary);border-radius:8px;align-items:center;gap:6px;padding-inline-start:calc(8px + var(--dsh-workspace-indent,0px));display:flex}.RrwzeW_projectRow:hover,.RrwzeW_sessionRow:hover,.RrwzeW_sessionRow.RrwzeW_selected{background:var(--qilin-alias-interactive-bg-hover)}.RrwzeW_searchResultRow{box-sizing:border-box;cursor:pointer;text-align:left;width:100%;min-height:48px;color:var(--qilin-alias-label-primary);background:0 0;border:none;border-radius:8px;flex-direction:column;align-items:stretch;padding:4px 8px;display:flex}.RrwzeW_searchResultRow:hover,.RrwzeW_searchResultRow.RrwzeW_selected{background:var(--qilin-alias-interactive-bg-hover)}.RrwzeW_searchResultHeading{align-items:center;min-width:0;display:flex}.RrwzeW_searchResultTitle{text-overflow:ellipsis;white-space:nowrap;flex:0 auto;min-width:0;margin-left:4px;font-size:14px;line-height:20px;overflow:hidden}.RrwzeW_searchResultMeta{align-items:center;gap:6px;min-width:0;margin-left:20px;display:flex}.RrwzeW_searchResultWorkspace,.RrwzeW_searchResultSnippet{text-overflow:ellipsis;white-space:nowrap;font-size:12px;line-height:17px;overflow:hidden}.RrwzeW_searchResultWorkspace{max-width:40%;color:var(--qilin-alias-label-tertiary);flex:none}.RrwzeW_searchResultSnippet{min-width:0;color:var(--qilin-alias-label-secondary);flex:1}.RrwzeW_projectRow{box-sizing:border-box;align-items:center;height:34px}.RrwzeW_projectRow .RrwzeW_rowActions{height:20px}.RrwzeW_sessionRow{height:32px;animation:RrwzeW_row-in .15s var(--ds-ease-in-out);gap:0}.RrwzeW_sessionRow .RrwzeW_title{margin:0 6px 0 4px}@keyframes RrwzeW_row-in{0%{opacity:0}}.RrwzeW_slot{width:16px;height:20px;color:var(--qilin-alias-label-tertiary);flex:none;justify-content:center;align-items:center;display:inline-flex}.RrwzeW_visuallyHidden{clip:rect(0 0 0 0);white-space:nowrap;width:1px;height:1px;position:absolute;overflow:hidden}.RrwzeW_folderActive{color:var(--qilin-alias-state-business-primary)}.RrwzeW_projectRow .RrwzeW_chevron{display:none}.RrwzeW_projectRow:hover .RrwzeW_chevron{display:inline-flex}.RrwzeW_projectRow:hover .RrwzeW_folder{display:none}.RrwzeW_arrow{transition:transform .15s var(--ds-ease-in-out)}.RrwzeW_arrowOpen{transform:rotate(90deg)}.RrwzeW_projectText{flex-direction:column;flex:1;gap:2px;min-width:0;display:flex}.RrwzeW_title{text-overflow:ellipsis;white-space:nowrap;min-width:0;font-size:14px;line-height:20px;overflow:hidden}.RrwzeW_renameInput{border:.5px solid var(--qilin-alias-border-l4);background:var(--qilin-alias-button-elevated-fill);min-width:0;color:inherit;border-radius:4px;outline:none;padding:0 2px;font-size:14px;line-height:20px}.RrwzeW_sessionRow .RrwzeW_title{scroll-behavior:smooth;flex:1}@media (hover:hover){.RrwzeW_sessionRow:hover .RrwzeW_title{text-overflow:clip}}.RrwzeW_meta{text-overflow:ellipsis;white-space:nowrap;color:var(--qilin-alias-label-tertiary);font-size:12px;line-height:20px;overflow:hidden}.RrwzeW_time{color:var(--qilin-alias-label-tertiary);flex:none;font-size:12px;line-height:20px}.RrwzeW_dot{flex:none}.RrwzeW_pinIndicator{width:16px;height:20px;color:var(--qilin-alias-label-caption);flex:none;justify-content:center;align-items:center;margin-left:6px;display:inline-flex}.RrwzeW_sessionRow:hover .RrwzeW_pinIndicator,.RrwzeW_sessionRow.RrwzeW_menuOpen .RrwzeW_pinIndicator{display:none}.RrwzeW_rowActions{flex:none;align-items:center;gap:12px;display:none}.RrwzeW_projectRow:hover .RrwzeW_rowActions,.RrwzeW_sessionRow:hover .RrwzeW_rowActions,.RrwzeW_projectRow.RrwzeW_menuOpen .RrwzeW_rowActions,.RrwzeW_sessionRow.RrwzeW_menuOpen .RrwzeW_rowActions{display:inline-flex}.RrwzeW_sessionRow:hover .RrwzeW_time,.RrwzeW_sessionRow.RrwzeW_menuOpen .RrwzeW_time{display:none}.RrwzeW_projectRow.RrwzeW_menuOpen,.RrwzeW_sessionRow.RrwzeW_menuOpen{background:var(--qilin-alias-interactive-bg-hover)}.RrwzeW_sessionRow.RrwzeW_dropBefore,.RrwzeW_sessionRow.RrwzeW_dropAfter{position:relative}.RrwzeW_sessionRow.RrwzeW_dropBefore:before,.RrwzeW_sessionRow.RrwzeW_dropAfter:after{content:\"\";z-index:1;background:linear-gradient(55deg, transparent calc(50% - 1px), var(--qilin-alias-state-business-primary) calc(50% - 1px) calc(50% + 1px), transparent calc(50% + 1px)) 0 0 / 5px 7px no-repeat, linear-gradient(125deg, transparent calc(50% - 1px), var(--qilin-alias-state-business-primary) calc(50% - 1px) calc(50% + 1px), transparent calc(50% + 1px)) 0 5px / 5px 7px no-repeat, linear-gradient(var(--qilin-alias-state-business-primary) 0 0) 4px 5px / calc(100% - 4px) 2px no-repeat;pointer-events:none;height:12px;position:absolute;left:0;right:4px}.RrwzeW_sessionRow.RrwzeW_dropBefore:before{top:-7px}.RrwzeW_sessionRow.RrwzeW_dropAfter:after{bottom:-7px}.RrwzeW_hoverContent{flex-direction:column;gap:8px;display:flex}.RrwzeW_hoverTitle{color:#fff;overflow-wrap:break-word;font-size:14px;line-height:20px}.RrwzeW_hoverPath{color:#cfd3d6;word-break:break-all;font-size:12px;line-height:16px}.RrwzeW_hoverTime{color:#cfd3d6;font-size:12px;line-height:16px}.RrwzeW_hoverStatus{color:#adb2b8;align-items:center;gap:8px;font-size:12px;line-height:20px;display:flex}.RrwzeW_iconButton{cursor:pointer;width:16px;height:16px;color:var(--qilin-alias-label-tertiary);background:0 0;border:none;border-radius:4px;flex:none;justify-content:center;align-items:center;padding:0;display:inline-flex}.RrwzeW_iconButton:hover{color:var(--qilin-alias-label-primary)}.RrwzeW_chevron{color:var(--qilin-alias-label-caption)}@media (prefers-reduced-motion:reduce){.RrwzeW_sessionRow,.RrwzeW_arrow{transition:none;animation:none}.RrwzeW_sessionRow .RrwzeW_title{scroll-behavior:auto}}";
+		const tagId$2 = "@qilin-agent/client-ui-workspace/Rows.module.css";
+		if (typeof document !== "undefined" && document.querySelector("style[data-plugin-css=" + JSON.stringify(tagId$2) + "]") === null) {
+			const tag = document.createElement("style");
+			tag.dataset.plugin = "@qilin-agent/client-ui-workspace";
+			tag.dataset.pluginCss = tagId$2;
+			tag.textContent = css$2;
+			document.head.appendChild(tag);
+		}
+		var Rows_module_css_default = {
+			"arrow": "RrwzeW_arrow",
+			"arrowOpen": "RrwzeW_arrowOpen",
+			"chevron": "RrwzeW_chevron",
+			"dot": "RrwzeW_dot",
+			"dropAfter": "RrwzeW_dropAfter",
+			"dropBefore": "RrwzeW_dropBefore",
+			"folder": "RrwzeW_folder",
+			"folderActive": "RrwzeW_folderActive",
+			"hoverContent": "RrwzeW_hoverContent",
+			"hoverPath": "RrwzeW_hoverPath",
+			"hoverStatus": "RrwzeW_hoverStatus",
+			"hoverTime": "RrwzeW_hoverTime",
+			"hoverTitle": "RrwzeW_hoverTitle",
+			"iconButton": "RrwzeW_iconButton",
+			"menuOpen": "RrwzeW_menuOpen",
+			"meta": "RrwzeW_meta",
+			"pinIndicator": "RrwzeW_pinIndicator",
+			"projectRow": "RrwzeW_projectRow",
+			"projectText": "RrwzeW_projectText",
+			"renameInput": "RrwzeW_renameInput",
+			"row-in": "RrwzeW_row-in",
+			"rowActions": "RrwzeW_rowActions",
+			"searchResultHeading": "RrwzeW_searchResultHeading",
+			"searchResultMeta": "RrwzeW_searchResultMeta",
+			"searchResultRow": "RrwzeW_searchResultRow",
+			"searchResultSnippet": "RrwzeW_searchResultSnippet",
+			"searchResultTitle": "RrwzeW_searchResultTitle",
+			"searchResultWorkspace": "RrwzeW_searchResultWorkspace",
+			"selected": "RrwzeW_selected",
+			"sessionRow": "RrwzeW_sessionRow",
+			"slot": "RrwzeW_slot",
+			"time": "RrwzeW_time",
+			"title": "RrwzeW_title",
+			"visuallyHidden": "RrwzeW_visuallyHidden"
+		};
+		//#endregion
+		//#region lib/types/client/rows/Rows.js
+		/**
+		* Workspace browser tree row components (figma Cell set 14:3080): pure presentational —
+		* all data and callbacks arrive via props. Hover swaps (folder->chevron,
+		* time->ellipsis, action buttons) are CSS-only, and a session row's clipped
+		* title is scrolled programmatically while the row is hovered. Row ... menus are
+		* visual-only except workspace Rename/Delete and session Rename/Fork/Archive; the
+		* session and workspace hover cards are suppressed while a menu is open.
+		*/
+		/** Row display title: blank rows show the localized New Session label. */
+		function displayTitle(node, t) {
+			return node.blank ? t("session.new") : node.title || t("session.untitled");
+		}
+		/**
+		* Reveal a title wider than its one-line cell while its row is hovered: the
+		* title clips its own text, so the far edge (a fork's incremented title, for
+		* example) is reachable by scrolling the element to its end. Leaving returns it
+		* to the start in one step, because the resting ellipsis and the narrowed cell
+		* would otherwise meet the text while it travelled back. A title that fits has
+		* no scroll range to move, and the stylesheet decides whether either move
+		* glides or jumps.
+		* @param title - the row's clipping title element.
+		* @param revealed - whether the pointer is on the row.
+		*/
+		function revealClippedTitle(title, revealed) {
+			/* v8 ignore next -- defensive: the title span renders unconditionally. */
+			if (title === null) return;
+			if (revealed) {
+				title.scrollLeft = title.scrollWidth - title.clientWidth;
+				return;
+			}
+			if (typeof title.scrollTo === "function") title.scrollTo({
+				left: 0,
+				behavior: "instant"
+			});
+			else title.scrollLeft = 0;
+		}
+		/** Localized compact relative time ("刚刚"/"5分钟" in zh, "now"/"5min" in en). */
+		function timeLabel(updatedAt, now, t) {
+			const { unit, n } = (0, _qilin_agent_client_ui_primitives.relativeTime)(updatedAt, now);
+			return unit === "now" ? t("time.now") : t(`time.${unit}`, { n });
+		}
+		/** Hover-card variant: distances wrap in the ago template; the now bucket stays bare (no "now ago"). */
+		function hoverTimeLabel(updatedAt, now, t) {
+			const { unit, n } = (0, _qilin_agent_client_ui_primitives.relativeTime)(updatedAt, now);
+			return unit === "now" ? t("time.now") : t("time.ago", { t: t(`time.${unit}`, { n }) });
+		}
+		/**
+		* Absolute creation time through the dictionary's date template (the message
+		* clock pattern): `toLocaleString` would follow the browser language, not the
+		* app locale, and produce mixed-language text after a switch.
+		*/
+		function createdLabel(createdAt, t) {
+			const d = new Date(createdAt);
+			const pad2 = (v) => String(v).padStart(2, "0");
+			return t("hover.created", { time: `${t("date.ymd", {
+				y: d.getFullYear(),
+				m: d.getMonth() + 1,
+				d: d.getDate()
+			})} ${pad2(d.getHours())}:${pad2(d.getMinutes())}` });
+		}
+		/** Hover-card body: workspace title, display directory path, absolute creation time. */
+		function WorkspaceHoverContent({ label, cwd, createdAt, t }) {
+			return (0, react_jsx_runtime.jsxs)("div", {
+				className: Rows_module_css_default.hoverContent,
+				children: [
+					(0, react_jsx_runtime.jsx)("div", {
+						className: Rows_module_css_default.hoverTitle,
+						children: label
+					}),
+					(0, react_jsx_runtime.jsx)("div", {
+						className: Rows_module_css_default.hoverPath,
+						children: cwd
+					}),
+					(0, react_jsx_runtime.jsx)("div", {
+						className: Rows_module_css_default.hoverTime,
+						children: createdLabel(createdAt, t)
+					})
+				]
+			});
+		}
+		/** Pointer-position half of a row (insert line above or below). */
+		function rowHalf(e) {
+			const rect = e.currentTarget.getBoundingClientRect();
+			return e.clientY < rect.top + rect.height / 2 ? "before" : "after";
+		}
+		/**
+		* Project (workspace) header row: folder + title;
+		* hover reveals the chevron and create button, and dwelling on a real
+		* Workspace shows its hover card (the ungrouped bucket has none).
+		* `containsCurrent` arrives on the node (derivation fact, no renderer scan).
+		* @param props.group - derived group node.
+		* @param props.containsCurrentDescendant - highlight an ancestor even when its subtree is collapsed.
+		* @param props.onToggle - expand/collapse the group.
+		* @param props.onCreate - start a frontend Session inside this Workspace.
+		* @param props.drag - optional workspace-row drag wiring.
+		* @param props.home - host account home for POSIX hover-path abbreviation.
+		* @param props.t - the browser root's locale seat.
+		* @returns the row element.
+		*/
+		function ProjectRowItem({ group, containsCurrentDescendant = false, onToggle, onCreate, actions, drag, home, t }) {
+			const row = group;
+			const label = row.workspaceId === void 0 ? t("group.ungrouped") : row.label;
+			const active = containsCurrentDescendant || group.expanded && group.containsCurrent;
+			const [menuOpen, setMenuOpen] = (0, react.useState)(false);
+			const workspaceMenuItems = [{
+				id: "rename",
+				label: t("rename"),
+				icon: (0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.IconEditOutline16, {})
+			}, {
+				id: "delete",
+				label: t("delete.workspace"),
+				icon: (0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.IconTrashOutline16, {}),
+				danger: true
+			}];
+			const ownRow = (0, react_jsx_runtime.jsxs)("div", {
+				className: clsx(Rows_module_css_default.projectRow, menuOpen && Rows_module_css_default.menuOpen),
+				role: "treeitem",
+				"aria-expanded": row.expanded,
+				onClick: onToggle,
+				draggable: drag !== void 0,
+				onDragStart: drag === void 0 ? void 0 : (e) => {
+					e.dataTransfer.effectAllowed = "move";
+					e.dataTransfer.setData("text/plain", row.key);
+					drag.start();
+				},
+				onDragEnd: drag?.end,
+				children: [
+					(0, react_jsx_runtime.jsx)("span", {
+						className: clsx(Rows_module_css_default.slot, Rows_module_css_default.folder, active && Rows_module_css_default.folderActive),
+						children: row.expanded ? (0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.IconFolderOpen16, {}) : (0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.IconFolderClose16, {})
+					}),
+					(0, react_jsx_runtime.jsx)("span", {
+						className: clsx(Rows_module_css_default.slot, Rows_module_css_default.chevron),
+						children: (0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.IconTriangleRightFill14, { className: clsx(Rows_module_css_default.arrow, row.expanded && Rows_module_css_default.arrowOpen) })
+					}),
+					(0, react_jsx_runtime.jsx)("span", {
+						className: Rows_module_css_default.projectText,
+						children: (0, react_jsx_runtime.jsx)("span", {
+							className: Rows_module_css_default.title,
+							children: label
+						})
+					}),
+					(0, react_jsx_runtime.jsxs)("span", {
+						className: Rows_module_css_default.rowActions,
+						children: [actions !== void 0 && (0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.Menu, {
+							open: menuOpen,
+							onClose: () => {
+								setMenuOpen(false);
+							},
+							items: workspaceMenuItems,
+							onSelect: (id) => {
+								setMenuOpen(false);
+								/* v8 ignore next -- Menu can emit only the rename and delete rows supplied above. */
+								if (id !== "rename" && id !== "delete") return;
+								if (id === "rename") actions.rename();
+								else actions.delete();
+							},
+							portal: true,
+							closeOnPointerLeave: true,
+							anchor: (0, react_jsx_runtime.jsx)("button", {
+								type: "button",
+								className: Rows_module_css_default.iconButton,
+								"aria-label": t("actions.workspace.aria", { name: label }),
+								onClick: (e) => {
+									e.stopPropagation();
+									setMenuOpen((v) => !v);
+								},
+								children: (0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.IconEllipsisOutline16, {})
+							})
+						}), (0, react_jsx_runtime.jsx)("button", {
+							type: "button",
+							className: Rows_module_css_default.iconButton,
+							"aria-label": t("actions.newSession.aria", { name: label }),
+							onClick: (e) => {
+								e.stopPropagation();
+								onCreate();
+							},
+							children: (0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.IconPlusOutline16, {})
+						})]
+					})
+				]
+			});
+			if (row.createdAt === void 0) return ownRow;
+			return (0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.HoverCard, {
+				anchor: ownRow,
+				content: (0, react_jsx_runtime.jsx)(WorkspaceHoverContent, {
+					label: row.label,
+					cwd: row.cwd === void 0 ? void 0 : abbreviateHomePath(row.cwd, home),
+					createdAt: row.createdAt,
+					t
+				}),
+				disabled: menuOpen,
+				copyText: row.cwd,
+				copyLabel: t("copy"),
+				copiedLabel: t("hover.copied")
+			});
+		}
+		/* v8 ignore next 3 -- closed-union backstop; only reached if the status is forged */
+		function assertNever(value) {
+			throw new Error(`unknown pending interaction: ${String(value)}`);
+		}
+		/**
+		* Session status presentation; pending interaction is primary and live activity
+		* outranks completion reminders.
+		*/
+		function sessionStatuses(node, t) {
+			const subagents = node.runningSubagentCount === 0 ? void 0 : {
+				state: "ongoing",
+				label: t(node.runningSubagentCount === 1 ? "status.subagentsRunning.one" : "status.subagentsRunning.other", { n: node.runningSubagentCount })
+			};
+			let pending;
+			switch (node.pendingInteraction) {
+				case "approval":
+					pending = {
+						state: "warning",
+						label: t("status.waitingApproval")
+					};
+					break;
+				case "plan-review":
+					pending = {
+						state: "warning",
+						label: t("status.planReview")
+					};
+					break;
+				case "question":
+					pending = {
+						state: "warning",
+						label: t("status.waitingAnswer")
+					};
+					break;
+				case void 0: break;
+				/* v8 ignore next -- closed PendingInteractionStatus union */
+				default: return assertNever(node.pendingInteraction);
+			}
+			if (pending !== void 0) return subagents === void 0 ? [pending] : [pending, subagents];
+			if (node.running) {
+				const primary = {
+					state: "ongoing",
+					label: t("status.running")
+				};
+				return subagents === void 0 ? [primary] : [primary, subagents];
+			}
+			if (subagents !== void 0) return [subagents];
+			if (node.completed) return [{
+				state: "done",
+				label: t("status.completed")
+			}];
+			return [{
+				state: "done",
+				label: t("status.idle")
+			}];
+		}
+		/** Primary status dot plus every status's screen-reader label, shared by the search and session rows. */
+		function SessionStatusDots({ statuses }) {
+			return (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [(0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.StateDot, { state: statuses[0].state }), statuses.map((status) => (0, react_jsx_runtime.jsx)("span", {
+				className: Rows_module_css_default.visuallyHidden,
+				children: status.label
+			}, status.label))] });
+		}
+		/** Non-interactive pinned-row marker; the enclosing row remains the only action. */
+		function PinnedIndicator({ t }) {
+			const label = t("row.pinned");
+			return (0, react_jsx_runtime.jsx)("span", {
+				className: Rows_module_css_default.pinIndicator,
+				role: "img",
+				"aria-label": label,
+				title: label,
+				children: (0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.IconPinFillRegular, { size: 14 })
+			});
+		}
+		/**
+		* Hover-card body: full title, relative time, the Session's own scheduled-task
+		* section, and every relevant live status. The seat section sits above the
+		* status lines so they stay the card's trailing status line.
+		*/
+		function SessionHoverContent({ node, now, renderSlot, t }) {
+			const statuses = sessionStatuses(node, t);
+			return (0, react_jsx_runtime.jsxs)("div", {
+				className: Rows_module_css_default.hoverContent,
+				children: [
+					(0, react_jsx_runtime.jsx)("div", {
+						className: Rows_module_css_default.hoverTitle,
+						children: displayTitle(node, t)
+					}),
+					!node.blank && (0, react_jsx_runtime.jsx)("div", {
+						className: Rows_module_css_default.hoverTime,
+						children: hoverTimeLabel(node.updatedAt, now, t)
+					}),
+					renderSlot("sidebar.session.row.hover", { sessionId: node.id }),
+					statuses.map((status) => (0, react_jsx_runtime.jsxs)("div", {
+						className: Rows_module_css_default.hoverStatus,
+						children: [(0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.StateDot, { state: status.state }), (0, react_jsx_runtime.jsx)("span", { children: status.label })]
+					}, status.label))
+				]
+			});
+		}
+		/**
+		* One flat search result: title, Workspace context, and optional content
+		* excerpt. Search navigation opens the session only; it does not address an
+		* event inside the conversation.
+		* @param props.result - merged local/content search row.
+		* @param props.currentId - selected session id.
+		* @param props.onOpen - open the selected session.
+		* @param props.t - Workspace-browser translation seat.
+		* @returns the result button.
+		*/
+		function SearchResultItem({ result, currentId, onOpen, t }) {
+			const selected = result.id === currentId;
+			const statuses = sessionStatuses(result, t);
+			const primaryStatus = statuses[0];
+			return (0, react_jsx_runtime.jsxs)("button", {
+				type: "button",
+				className: clsx(Rows_module_css_default.searchResultRow, selected && Rows_module_css_default.selected),
+				role: "treeitem",
+				"aria-selected": selected,
+				onClick: () => {
+					onOpen(result.id);
+				},
+				children: [(0, react_jsx_runtime.jsxs)("span", {
+					className: Rows_module_css_default.searchResultHeading,
+					children: [(0, react_jsx_runtime.jsx)("span", {
+						className: Rows_module_css_default.slot,
+						children: (primaryStatus.state !== "done" || result.completed) && (0, react_jsx_runtime.jsx)(SessionStatusDots, { statuses })
+					}), (0, react_jsx_runtime.jsx)("span", {
+						className: Rows_module_css_default.searchResultTitle,
+						children: result.title || t("session.untitled")
+					})]
+				}), (0, react_jsx_runtime.jsxs)("span", {
+					className: Rows_module_css_default.searchResultMeta,
+					children: [(0, react_jsx_runtime.jsx)("span", {
+						className: Rows_module_css_default.searchResultWorkspace,
+						children: result.workspace || t("group.ungrouped")
+					}), result.snippet !== void 0 && (0, react_jsx_runtime.jsx)("span", {
+						className: Rows_module_css_default.searchResultSnippet,
+						children: result.snippet
+					})]
+				})]
+			});
+		}
+		/**
+		* One top-level 34px session row: status dot (pending user interaction outranks
+		* own or descendant activity), title, relative time, and the row actions menu.
+		* @param props.node - derived session node.
+		* @param props.currentId - selected session id (row highlight).
+		* @param props.now - epoch ms for relative-time formatting.
+		* @param props.onOpen - open a session by id.
+		* @param props.onRename - open the session rename dialog (id + current title).
+		* @param props.onFork - fork a session at its last completed turn.
+		* @param props.onArchive - archive a session by id.
+		* @param props.onPin - pin a session by id (leading its group and the flat list).
+		* @param props.onUnpin - drop a session's pin.
+		* @param props.onReveal - scroll this row into view after search navigation, then acknowledge it.
+		* @param props.drag - optional row-drag target wiring; blank rows cannot start a drag.
+		* @param props.t - the browser root's locale seat.
+		* @returns the session row.
+		*/
+		function SessionNodeItem({ node, currentId, now, onOpen, onRename, onFork, onArchive, onPin, onUnpin, onReveal, drag, renderSlot, t }) {
+			const row = node;
+			const title = displayTitle(node, t);
+			const selected = node.id === currentId;
+			const statuses = sessionStatuses(node, t);
+			const showStatus = statuses[0].state !== "done" || row.completed;
+			const draggable = drag !== void 0 && !row.blank;
+			const [menuOpen, setMenuOpen] = (0, react.useState)(false);
+			const rowRef = (0, react.useRef)(null);
+			const titleRef = (0, react.useRef)(null);
+			(0, react.useEffect)(() => {
+				if (onReveal === void 0) return;
+				rowRef.current?.scrollIntoView({ block: "nearest" });
+				onReveal();
+			}, [onReveal]);
+			const sessionMenuItems = [
+				{
+					id: "pin",
+					label: t(row.pinned ? "menu.unpinSession" : "menu.pinSession"),
+					icon: row.pinned ? (0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.IconPinFillRegular, {}) : (0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.IconPinOutlineRegular, {})
+				},
+				{
+					id: "rename",
+					label: t("rename"),
+					icon: (0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.IconEditOutline16, {})
+				},
+				{
+					id: "fork",
+					label: t("menu.fork"),
+					icon: (0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.IconBranchOutline16, {})
+				},
+				{
+					id: "archive",
+					label: t("menu.archiveSession"),
+					icon: (0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.IconArchiveOutline20, { size: 16 })
+				}
+			];
+			return (0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.HoverCard, {
+				anchor: (0, react_jsx_runtime.jsxs)("div", {
+					ref: rowRef,
+					className: clsx(Rows_module_css_default.sessionRow, selected && Rows_module_css_default.selected, menuOpen && Rows_module_css_default.menuOpen, drag?.marker === "before" && Rows_module_css_default.dropBefore, drag?.marker === "after" && Rows_module_css_default.dropAfter),
+					role: "treeitem",
+					"aria-selected": selected,
+					onClick: () => {
+						onOpen(node.id);
+					},
+					onPointerEnter: () => {
+						revealClippedTitle(titleRef.current, true);
+					},
+					onPointerLeave: () => {
+						revealClippedTitle(titleRef.current, false);
+					},
+					draggable,
+					onDragStart: drag === void 0 || row.blank ? void 0 : (e) => {
+						e.dataTransfer.effectAllowed = "move";
+						e.dataTransfer.setData("text/plain", node.id);
+						drag.start();
+					},
+					onDragEnd: drag === void 0 || row.blank ? void 0 : drag.end,
+					onDragOver: drag === void 0 ? void 0 : (e) => {
+						if (!drag.active) return;
+						e.preventDefault();
+						e.dataTransfer.dropEffect = "move";
+						drag.hover(rowHalf(e));
+					},
+					onDrop: drag === void 0 ? void 0 : (e) => {
+						if (!drag.active) return;
+						e.preventDefault();
+						drag.drop(rowHalf(e));
+					},
+					children: [
+						(0, react_jsx_runtime.jsx)("span", {
+							className: Rows_module_css_default.slot,
+							children: !row.blank && (showStatus ? (0, react_jsx_runtime.jsx)(SessionStatusDots, { statuses }) : renderSlot("sidebar.session.row.leading", { sessionId: node.id }))
+						}),
+						(0, react_jsx_runtime.jsx)("span", {
+							ref: titleRef,
+							className: Rows_module_css_default.title,
+							children: title
+						}),
+						!row.blank && (0, react_jsx_runtime.jsx)("span", {
+							className: Rows_module_css_default.time,
+							children: timeLabel(row.updatedAt, now, t)
+						}),
+						row.pinned && !row.blank && (0, react_jsx_runtime.jsx)(PinnedIndicator, { t }),
+						!row.blank && (0, react_jsx_runtime.jsxs)("span", {
+							className: Rows_module_css_default.rowActions,
+							children: [(0, react_jsx_runtime.jsx)("button", {
+								type: "button",
+								className: Rows_module_css_default.iconButton,
+								"aria-label": t(row.pinned ? "actions.unpin" : "actions.pin"),
+								onClick: (e) => {
+									e.stopPropagation();
+									(row.pinned ? onUnpin : onPin)(node.id);
+								},
+								children: row.pinned ? (0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.IconPinFillRegular, { size: 14 }) : (0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.IconPinOutlineRegular, { size: 14 })
+							}), (0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.Menu, {
+								open: menuOpen,
+								onClose: () => {
+									setMenuOpen(false);
+								},
+								items: sessionMenuItems,
+								onSelect: (id) => {
+									setMenuOpen(false);
+									if (id === "pin") (row.pinned ? onUnpin : onPin)(node.id);
+									if (id === "rename") onRename(node.id, row.title);
+									if (id === "fork") onFork(node.id);
+									if (id === "archive") onArchive(node.id);
+								},
+								portal: true,
+								closeOnPointerLeave: true,
+								anchor: (0, react_jsx_runtime.jsx)("button", {
+									type: "button",
+									className: Rows_module_css_default.iconButton,
+									"aria-label": t("actions.session.aria", { name: title }),
+									onClick: (e) => {
+										e.stopPropagation();
+										setMenuOpen((v) => !v);
+									},
+									children: (0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.IconEllipsisOutline16, {})
+								})
+							})]
+						})
+					]
+				}),
+				content: (0, react_jsx_runtime.jsx)(SessionHoverContent, {
+					node,
+					now,
+					renderSlot,
+					t
+				}),
+				disabled: menuOpen || drag?.active === true,
+				copyText: row.blank || row.title === "" ? void 0 : row.title,
+				copyLabel: t("copy"),
+				copiedLabel: t("hover.copied")
+			});
+		}
+		//#endregion
+		//#region \0qilin-css:/home/runner/work/QiLin/QiLin/packages/client/ui-workspace/src/client/WorkspacePicker.module.css.mjs
+		const css$1 = ".QOlntq_modalAction{min-width:72px}.QOlntq_modalError,.QOlntq_menuStatus{margin-top:8px;font-size:12px;line-height:18px}.QOlntq_modalError{color:var(--qilin-alias-state-error-primary)}.QOlntq_menuStatus{color:var(--qilin-alias-label-secondary)}";
+		const tagId$1 = "@qilin-agent/client-ui-workspace/WorkspacePicker.module.css";
+		if (typeof document !== "undefined" && document.querySelector("style[data-plugin-css=" + JSON.stringify(tagId$1) + "]") === null) {
+			const tag = document.createElement("style");
+			tag.dataset.plugin = "@qilin-agent/client-ui-workspace";
+			tag.dataset.pluginCss = tagId$1;
+			tag.textContent = css$1;
+			document.head.appendChild(tag);
+		}
+		var WorkspacePicker_module_css_default = {
+			"menuStatus": "QOlntq_menuStatus",
+			"modalAction": "QOlntq_modalAction",
+			"modalError": "QOlntq_modalError"
+		};
+		//#endregion
+		//#region lib/types/client/WorkspacePicker.js
+		const ADD_WORKSPACE = "::add-workspace";
+		/**
+		* Render the pick menu plus the adoption error dialog.
+		* @param props - owner-controlled flow props.
+		* @returns menu + dialog elements.
+		*/
+		function WorkspacePickFlow({ t, open, anchorRef, useWorkspaces, createWorkspace, useDirectoryFlow, renderDirectoryFlow, onPick, onClose, addOnly = false, side = "bottom", selectedId }) {
+			const workspaceSnapshot = useWorkspaces((state) => state);
+			const workspaces = workspaceSnapshot.items;
+			const getAnchorRect = (0, react.useCallback)(() => anchorRef?.current?.getBoundingClientRect() ?? null, [anchorRef]);
+			const [errorOpen, setErrorOpen] = (0, react.useState)(false);
+			const [modalError, setModalError] = (0, react.useState)(null);
+			const [flowOpen, setFlowOpen] = (0, react.useState)(false);
+			const [pickingFolder, setPickingFolder] = (0, react.useState)(false);
+			const flowBusy = flowOpen || pickingFolder;
+			const flowAvailable = useDirectoryFlow((occupied) => occupied);
+			(0, react.useEffect)(() => {
+				if (flowOpen && !flowAvailable) setFlowOpen(false);
+			}, [flowOpen, flowAvailable]);
+			const addEntries = flowAvailable ? [{
+				id: ADD_WORKSPACE,
+				label: t("menu.addWorkspace"),
+				icon: (0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.IconPlusOutline16, { size: 16 }),
+				disabled: flowBusy
+			}] : [];
+			const pinAdd = !addOnly && workspaces.length > 0;
+			const items = pinAdd ? workspaces.map((workspace) => ({
+				id: workspace.workspaceId,
+				label: workspace.title,
+				icon: (0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.IconFolderClose16, { size: 16 }),
+				disabled: flowBusy
+			})) : addEntries;
+			const menuIsEmpty = items.length === 0;
+			const closeModal = () => {
+				setErrorOpen(false);
+				setModalError(null);
+			};
+			/** Adopt a picked directory; failures land in the folder-error dialog (Choose again reopens the flow). */
+			const adoptDirectory = (path) => createWorkspace({ path }).then((workspace) => {
+				setFlowOpen(false);
+				onPick(workspace.workspaceId);
+			}).catch((reason) => {
+				setModalError(reason instanceof Error ? reason.message : String(reason));
+				setFlowOpen(false);
+				setErrorOpen(true);
+			});
+			const openDirectoryFlow = (0, react.useCallback)(() => {
+				onClose();
+				setErrorOpen(false);
+				setModalError(null);
+				setFlowOpen(true);
+			}, [onClose]);
+			const listSettled = addOnly || workspaceSnapshot.phase === "ready";
+			const addIsTheOnlyEntry = !pinAdd && listSettled && addEntries.length === 1;
+			(0, react.useEffect)(() => {
+				if (open && addIsTheOnlyEntry && !flowBusy) openDirectoryFlow();
+			}, [
+				open,
+				addIsTheOnlyEntry,
+				flowBusy,
+				openDirectoryFlow
+			]);
+			/** Owner side of the flow conversation: adopt keeps the flow open (busy) until the Host answers. */
+			const flowOwner = {
+				open: flowOpen,
+				busy: pickingFolder,
+				onPicked: (path) => {
+					setPickingFolder(true);
+					adoptDirectory(path).finally(() => {
+						setPickingFolder(false);
+					});
+				},
+				onCancel: () => {
+					setFlowOpen(false);
+				},
+				onError: (message) => {
+					setFlowOpen(false);
+					setModalError(message);
+					setErrorOpen(true);
+				}
+			};
+			const handleSelect = (id) => {
+				if (id === ADD_WORKSPACE) {
+					openDirectoryFlow();
+					return;
+				}
+				onPick(id);
+			};
+			return (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [
+				(0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.Menu, {
+					open: open && !addIsTheOnlyEntry && !menuIsEmpty,
+					anchor: null,
+					items,
+					...pinAdd ? { footer: addEntries } : {},
+					selectedId,
+					onSelect: handleSelect,
+					onClose,
+					side,
+					portal: true,
+					getAnchorRect
+				}),
+				open && !addIsTheOnlyEntry && !menuIsEmpty && workspaceSnapshot.phase === "pending" && (0, react_jsx_runtime.jsx)("div", {
+					className: WorkspacePicker_module_css_default.menuStatus,
+					role: "status",
+					children: t("picker.loading")
+				}),
+				renderDirectoryFlow(flowOwner),
+				(0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.Modal, {
+					open: errorOpen,
+					onClose: closeModal,
+					closeLabel: t("close"),
+					title: t("folderError.title"),
+					footer: (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [(0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.Button, {
+						variant: "outline",
+						className: WorkspacePicker_module_css_default.modalAction,
+						onClick: closeModal,
+						children: t("cancel")
+					}), (0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.Button, {
+						variant: "primary",
+						className: WorkspacePicker_module_css_default.modalAction,
+						disabled: !flowAvailable,
+						onClick: openDirectoryFlow,
+						children: t("folderError.retry")
+					})] }),
+					children: (0, react_jsx_runtime.jsx)("div", {
+						className: WorkspacePicker_module_css_default.modalError,
+						role: "alert",
+						children: modalError
+					})
+				})
+			] });
+		}
+		/**
+		* The conversation empty-state registration: adapts the owner share to the
+		* core flow (all state and semantics live in the flow / the owner).
+		* @param props - empty-state slot props (owner share + injected creation callback).
+		* @returns the flow element.
+		*/
+		function WorkspacePicker({ open, anchorRef, useWorkspaces, selectedId, onPick, onClose, createWorkspace, useDirectoryFlow, renderSlot, t }) {
+			return (0, react_jsx_runtime.jsx)(WorkspacePickFlow, {
+				t,
+				open,
+				anchorRef,
+				useWorkspaces,
+				createWorkspace,
+				useDirectoryFlow,
+				renderDirectoryFlow: (owner) => renderSlot("conversation.hero.workspace.directoryFlow", owner),
+				selectedId,
+				onPick,
+				onClose
+			});
+		}
+		//#endregion
+		//#region \0qilin-css:/home/runner/work/QiLin/QiLin/packages/client/ui-workspace/src/client/rows/WorkspaceBrowser.module.css.mjs
+		const css = ".CO5s3G_root{--qilin-session-list-edge-inset:var(--qilin-sidebar-inline-padding);--qilin-session-list-scrollbar-width:8px;--qilin-session-list-scrollbar-offset:2px;box-sizing:border-box;min-height:0;padding-right:var(--qilin-session-list-edge-inset);flex-direction:column;flex:1;display:flex}.CO5s3G_root.CO5s3G_rail{padding-right:0}.CO5s3G_iconButton{corner-shape:round;cursor:pointer;width:28px;height:28px;color:var(--qilin-alias-label-secondary);background:0 0;border:none;border-radius:50%;flex:none;justify-content:center;align-items:center;padding:0;display:inline-flex}.CO5s3G_iconButton:focus-visible,.CO5s3G_searchButton:focus-visible,.CO5s3G_clearButton:focus-visible{outline:var(--qilin-focus-ring-width) solid var(--qilin-focus-ring-color,var(--qilin-alias-state-business-primary));outline-offset:-2px}.CO5s3G_iconButton:hover{background:var(--qilin-alias-interactive-bg-hover)}.CO5s3G_sectionHeader{box-sizing:border-box;height:36px;color:var(--qilin-alias-label-tertiary);border-radius:12px;flex:none;justify-content:flex-end;align-items:center;gap:4px;margin-bottom:4px;padding-left:4px;display:flex;overflow:hidden}.CO5s3G_root:not(.CO5s3G_rail) .CO5s3G_sectionHeader{margin-top:2px;margin-right:-4px}.CO5s3G_sectionLabel{white-space:nowrap;opacity:1;visibility:visible;min-width:0;max-width:45%;transition:max-width .18s var(--ds-ease-in-out), margin-right .18s var(--ds-ease-in-out), opacity .12s var(--ds-ease-in-out), transform .18s var(--ds-ease-in-out), visibility 0s linear;flex:none;line-height:20px;overflow:hidden}.CO5s3G_sectionLabelHidden{opacity:0;visibility:hidden;max-width:0;margin-right:-4px;transition-delay:0s,0s,0s,0s,.18s;transform:translate(-4px)}.CO5s3G_searchSlot{box-sizing:border-box;min-width:0;max-width:28px;transition:max-width .18s var(--ds-ease-in-out), padding-left .18s var(--ds-ease-in-out);flex:1;align-items:center;margin-left:auto;padding-left:0;display:flex}.CO5s3G_searchSlotExpanded{max-width:100%;padding-left:0}.CO5s3G_headerActions{opacity:1;visibility:visible;max-width:60px;transition:max-width .18s var(--ds-ease-in-out), opacity .12s var(--ds-ease-in-out), transform .18s var(--ds-ease-in-out), visibility 0s linear;flex:none;align-items:center;gap:4px;display:flex;overflow:hidden}.CO5s3G_headerActionsHidden{opacity:0;visibility:hidden;pointer-events:none;max-width:0;transition-delay:0s,0s,0s,.18s;transform:translate(4px)}.CO5s3G_search{box-sizing:border-box;corner-shape:round;cursor:text;width:100%;height:28px;color:var(--qilin-alias-label-secondary);transition:width .18s var(--ds-ease-in-out), padding .18s var(--ds-ease-in-out), border-color .18s var(--ds-ease-in-out), background-color .18s var(--ds-ease-in-out);background:0 0;border:none;border-radius:50%;flex:none;align-items:center;gap:0;margin:0;padding:0;display:flex;overflow:hidden}.CO5s3G_searchExpanded{border:.5px solid var(--qilin-alias-border-l4);width:calc(100% + 4px);height:30px;color:var(--qilin-alias-label-caption);background:0 0;border-radius:10px;margin-inline:-2px;padding:0 4px 0 0}.CO5s3G_searchButton{corner-shape:round;cursor:pointer;width:28px;height:28px;color:inherit;background:0 0;border:none;border-radius:50%;flex:none;justify-content:center;align-items:center;padding:0;display:inline-flex}.CO5s3G_searchExpanded .CO5s3G_searchButton{width:28px;height:30px}.CO5s3G_searchButton:hover{background:var(--qilin-alias-interactive-bg-hover)}.CO5s3G_searchExpanded .CO5s3G_searchButton:hover{background:0 0}.CO5s3G_searchInput{opacity:0;pointer-events:none;width:0;min-width:0;color:var(--qilin-alias-label-primary);transition:opacity .12s var(--ds-ease-in-out);background:0 0;border:none;outline:none;flex:1;font-size:13px;line-height:18px}.CO5s3G_searchExpanded .CO5s3G_searchInput{opacity:1;pointer-events:auto;margin-left:-2px}.CO5s3G_searchInput::placeholder{color:var(--qilin-alias-label-tertiary)}.CO5s3G_clearButton{corner-shape:round;cursor:pointer;width:24px;height:24px;color:var(--qilin-alias-label-secondary);background:0 0;border:none;border-radius:50%;flex:none;justify-content:center;align-items:center;padding:0;display:inline-flex}.CO5s3G_clearButton:hover{background:var(--qilin-alias-interactive-bg-hover)}.CO5s3G_rail .CO5s3G_sectionHeader{justify-content:flex-start;gap:0;margin-bottom:12px;padding-left:0}.CO5s3G_listArea{min-height:0;margin-left:-4px;margin-right:calc(-1 * var(--qilin-session-list-edge-inset));flex-direction:column;flex:1;padding-left:4px;display:flex;overflow:visible}.CO5s3G_rail .CO5s3G_listArea{margin-left:0;margin-right:0;padding-left:0}.CO5s3G_treeBody{flex-direction:column;flex:1;min-height:0;display:flex;position:relative}.CO5s3G_fade{left:0;right:var(--qilin-session-list-edge-inset);background:linear-gradient(to bottom, transparent, var(--qilin-specific-sidebar-fill));pointer-events:none;height:24px;position:absolute;bottom:0}[data-platform=darwin] .CO5s3G_fade{display:none}.CO5s3G_wide{animation:CO5s3G_wide-in .2s var(--ds-ease-in-out)}@keyframes CO5s3G_wide-in{0%{opacity:0}}.CO5s3G_list{min-height:0;margin-left:-4px;margin-right:var(--qilin-session-list-scrollbar-offset);padding-left:4px;padding-right:calc(var(--qilin-session-list-edge-inset) - var(--qilin-session-list-scrollbar-width) - var(--qilin-session-list-scrollbar-offset));scrollbar-gutter:stable;flex:1;padding-bottom:16px;overflow-y:auto}.CO5s3G_flatList>*+*,.CO5s3G_searchTree>[role=treeitem]+[role=treeitem],.CO5s3G_groupSection>*+*{margin-top:2px}.CO5s3G_searchStatus,.CO5s3G_searchWarning{color:var(--qilin-alias-label-tertiary);padding:10px 12px;font-size:12px;line-height:18px}.CO5s3G_searchWarning{color:var(--qilin-alias-label-secondary)}.CO5s3G_groupSection{position:relative}.CO5s3G_groupSection+.CO5s3G_groupSection{margin-top:4px}.CO5s3G_listTopDropIndicator,.CO5s3G_workspaceDropBefore:before,.CO5s3G_workspaceDropAfter:after{content:\"\";z-index:1;background:linear-gradient(55deg, transparent calc(50% - 1px), var(--qilin-alias-state-business-primary) calc(50% - 1px) calc(50% + 1px), transparent calc(50% + 1px)) 0 0 / 5px 7px no-repeat, linear-gradient(125deg, transparent calc(50% - 1px), var(--qilin-alias-state-business-primary) calc(50% - 1px) calc(50% + 1px), transparent calc(50% + 1px)) 0 5px / 5px 7px no-repeat, linear-gradient(var(--qilin-alias-state-business-primary) 0 0) 4px 5px / calc(100% - 4px) 2px no-repeat;pointer-events:none;height:12px;position:absolute;left:0;right:0}.CO5s3G_listTopDropIndicator{top:-8px;left:0;right:var(--qilin-session-list-edge-inset)}.CO5s3G_listTopDropActive>.CO5s3G_workspaceDropBefore:first-child:before{display:none}.CO5s3G_workspaceDropBefore:before{top:-8px}.CO5s3G_workspaceDropAfter:after{bottom:-8px}.CO5s3G_sessionOverflowButton{width:100%;height:28px;padding:0 12px 0 calc(28px + var(--qilin-workspace-indent,0px));cursor:pointer;text-align:left;color:var(--qilin-alias-label-tertiary);background:0 0;border:none;border-radius:8px;font-size:12px}.CO5s3G_groupSection>.CO5s3G_sessionOverflowButton{margin-top:0}.CO5s3G_sessionOverflowButton:hover{color:var(--qilin-alias-label-secondary);background:0 0}.CO5s3G_empty{color:var(--qilin-alias-label-tertiary);padding:16px 12px;font-size:13px}.CO5s3G_renameInput{box-sizing:border-box;border:.5px solid var(--qilin-alias-border-l4);width:100%;height:44px;color:var(--qilin-alias-label-primary);background:0 0;border-radius:22px;outline:none;padding:7px 14px;font-size:14px;font-weight:400;line-height:22px}.CO5s3G_renameInput:disabled{color:var(--qilin-alias-label-dimmed)}.CO5s3G_renameError{color:var(--qilin-alias-state-error-primary);margin-top:8px;font-size:12px;line-height:18px}.CO5s3G_deleteAction:not(:disabled){color:var(--qilin-alias-state-error-primary)}.CO5s3G_deleteStatus{color:var(--qilin-alias-label-secondary);font-size:12px;line-height:18px}@media (prefers-reduced-motion:reduce){.CO5s3G_wide{animation:none}.CO5s3G_search,.CO5s3G_sectionLabel,.CO5s3G_searchSlot,.CO5s3G_searchInput,.CO5s3G_headerActions{transition:none}}";
+		const tagId = "@qilin-agent/client-ui-workspace/WorkspaceBrowser.module.css";
+		if (typeof document !== "undefined" && document.querySelector("style[data-plugin-css=" + JSON.stringify(tagId) + "]") === null) {
+			const tag = document.createElement("style");
+			tag.dataset.plugin = "@qilin-agent/client-ui-workspace";
+			tag.dataset.pluginCss = tagId;
+			tag.textContent = css;
+			document.head.appendChild(tag);
+		}
+		var WorkspaceBrowser_module_css_default = {
+			"clearButton": "CO5s3G_clearButton",
+			"deleteAction": "CO5s3G_deleteAction",
+			"deleteStatus": "CO5s3G_deleteStatus",
+			"empty": "CO5s3G_empty",
+			"fade": "CO5s3G_fade",
+			"flatList": "CO5s3G_flatList",
+			"groupSection": "CO5s3G_groupSection",
+			"headerActions": "CO5s3G_headerActions",
+			"headerActionsHidden": "CO5s3G_headerActionsHidden",
+			"iconButton": "CO5s3G_iconButton",
+			"list": "CO5s3G_list",
+			"listArea": "CO5s3G_listArea",
+			"listTopDropActive": "CO5s3G_listTopDropActive",
+			"listTopDropIndicator": "CO5s3G_listTopDropIndicator",
+			"rail": "CO5s3G_rail",
+			"renameError": "CO5s3G_renameError",
+			"renameInput": "CO5s3G_renameInput",
+			"root": "CO5s3G_root",
+			"search": "CO5s3G_search",
+			"searchButton": "CO5s3G_searchButton",
+			"searchExpanded": "CO5s3G_searchExpanded",
+			"searchInput": "CO5s3G_searchInput",
+			"searchSlot": "CO5s3G_searchSlot",
+			"searchSlotExpanded": "CO5s3G_searchSlotExpanded",
+			"searchStatus": "CO5s3G_searchStatus",
+			"searchTree": "CO5s3G_searchTree",
+			"searchWarning": "CO5s3G_searchWarning",
+			"sectionHeader": "CO5s3G_sectionHeader",
+			"sectionLabel": "CO5s3G_sectionLabel",
+			"sectionLabelHidden": "CO5s3G_sectionLabelHidden",
+			"sessionOverflowButton": "CO5s3G_sessionOverflowButton",
+			"treeBody": "CO5s3G_treeBody",
+			"wide": "CO5s3G_wide",
+			"wide-in": "CO5s3G_wide-in",
+			"workspaceDropAfter": "CO5s3G_workspaceDropAfter",
+			"workspaceDropBefore": "CO5s3G_workspaceDropBefore"
+		};
+		//#endregion
+		//#region lib/types/client/rows/WorkspaceBrowser.js
+		/**
+		* The workspace/session browsing region filling the sidebar shell's
+		* `sidebar.workspaces` hole: section header (title + view options + add
+		* workspace), search, the grouped tree or flat list, and the workspace
+		* dialogs. Wide state renders the full browser; rail state renders no region
+		* control of its own, so the search and add requests each expand the column
+		* through the owner share and act once it is wide. Adding is the header
+		* button's one action, so it raises the directory flow with no menu in
+		* between; the flow and its error dialog live in WorkspacePicker (same package
+		* — direct composition, no slot between them).
+		*/
+		/**
+		* Column slide length (--ds-transition-duration-slow): the rail-expanded search
+		* focus and the rail-expanded add picker both wait it out — focus() forces a
+		* synchronous layout that would jank the slide, and the picker's anchor button
+		* mounts only once the same slide has made the column wide.
+		*/
+		const EXPAND_SLIDE_MS = 300;
+		/** Pause between the latest keystroke and a Host content-search request. */
+		const SEARCH_DEBOUNCE_MS = 250;
+		/** `session.search` wire bound, measured in JavaScript UTF-16 code units. */
+		const SEARCH_QUERY_MAX_CODE_UNITS = 500;
+		/** Session rows visible per Workspace before the local overflow control. */
+		const COLLAPSED_SESSION_LIMIT = 5;
+		/** Fold one Workspace without charging its provisional New Session against the ordinary-row limit. */
+		function collapsedSessionRows(sessions) {
+			let ordinaryCount = 0;
+			const rows = sessions.filter((session) => {
+				if (session.blank) return true;
+				if (ordinaryCount >= COLLAPSED_SESSION_LIMIT) return false;
+				ordinaryCount += 1;
+				return true;
+			});
+			return {
+				rows,
+				hiddenCount: sessions.length - rows.length
+			};
+		}
+		/** Keep controlled input and RPC payload inside the session.search wire contract. */
+		function sanitizeSearchQuery(value) {
+			const withoutNul = value.replaceAll("\0", "");
+			if (withoutNul.length <= SEARCH_QUERY_MAX_CODE_UNITS) return withoutNul;
+			let end = SEARCH_QUERY_MAX_CODE_UNITS;
+			const last = withoutNul.charCodeAt(end - 1);
+			const next = withoutNul.charCodeAt(end);
+			if (last >= 55296 && last <= 56319 && next >= 56320 && next <= 57343) end--;
+			return withoutNul.slice(0, end);
+		}
+		/** Immutable membership toggle for the local expand-all array. */
+		function toggled(list, key) {
+			return list.includes(key) ? list.filter((k) => k !== key) : [...list, key];
+		}
+		/**
+		* Accept the native drag at document level while a row drag is active: row
+		* hover still owns the insertion marker, and releasing outside the list must
+		* not be rendered as a rejected drop before dragend commits that last marker.
+		*/
+		function useNativeDragAcceptance(active) {
+			(0, react.useEffect)(() => {
+				if (!active) return;
+				const acceptDrag = (event) => {
+					event.preventDefault();
+					if (event.dataTransfer !== null) event.dataTransfer.dropEffect = "move";
+				};
+				const acceptDrop = (event) => {
+					event.preventDefault();
+				};
+				document.addEventListener("dragover", acceptDrag);
+				document.addEventListener("drop", acceptDrop);
+				return () => {
+					document.removeEventListener("dragover", acceptDrag);
+					document.removeEventListener("drop", acceptDrop);
+				};
+			}, [active]);
+		}
+		/** Grouping and ordering menu; own open state so it resets with the wide chrome. */
+		function ViewOptionsMenu({ groupBy, orderBy, onGroupPick, onOrderPick, t }) {
+			const [open, setOpen] = (0, react.useState)(false);
+			return (0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.Menu, {
+				open,
+				onClose: () => {
+					setOpen(false);
+				},
+				items: [
+					{
+						type: "label",
+						id: "group-by",
+						text: t("groupBy.label")
+					},
+					{
+						id: "workspace",
+						label: t("groupBy.workspace")
+					},
+					{
+						id: "workspace-tree",
+						label: t("groupBy.workspaceTree")
+					},
+					{
+						id: "flat",
+						label: t("groupBy.flat")
+					},
+					{
+						type: "separator",
+						id: "order-by-separator"
+					},
+					{
+						type: "label",
+						id: "order-by",
+						text: t("orderBy.label")
+					},
+					{
+						id: "manual",
+						label: t("orderBy.manual")
+					},
+					{
+						id: "updated",
+						label: t("orderBy.updated")
+					}
+				],
+				selectedIds: [groupBy, orderBy],
+				onSelect: (id) => {
+					if (id === "workspace" || id === "workspace-tree" || id === "flat") onGroupPick(id);
+					else if (id === "manual" || id === "updated") onOrderPick(id);
+					setOpen(false);
+				},
+				align: "end",
+				dense: true,
+				portal: true,
+				anchor: (0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.Tooltip, {
+					label: t("viewOptions.label"),
+					side: "bottom",
+					delayMs: 500,
+					children: (0, react_jsx_runtime.jsx)("button", {
+						type: "button",
+						className: clsx(WorkspaceBrowser_module_css_default.iconButton, WorkspaceBrowser_module_css_default.wide),
+						"aria-label": t("viewOptions.label"),
+						onClick: () => {
+							setOpen((v) => !v);
+						},
+						children: (0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.IconPersonalizationOutline16, {})
+					})
+				})
+			});
+		}
+		/** Resolve an insertion side across the Workspace header, descendants, and Sessions. */
+		function workspaceGroupHalf(e) {
+			const rect = e.currentTarget.getBoundingClientRect();
+			return e.clientY < rect.top + rect.height / 2 ? "before" : "after";
+		}
+		/** The scrolling session tree; unmounting drops the sessions subscription and expand-all state. */
+		function SessionTree({ list, useSessionStatus, startSession, open, forkSession, workspaces, ungroupedSessionIds, archivedSessionIds, pinnedSessionIds, onSessionPin, onSessionUnpin, workspaceReady, usePanelInfo, onRenameRequest, onDeleteRequest, onSessionRename, onSessionArchive, insertWorkspaceBefore, nestWorkspaces, groupExpansion, setGroupExpanded, setSessionOrder, home, t, renderSlot, revealSessionId, onSessionRevealed }) {
+			const panelActive = usePanelInfo((info) => info.activePanelId !== null);
+			const statuses = useSessionStatus((s) => s);
+			const current = panelActive ? void 0 : Object.values(list.byId).find((session) => (session.retainedBy.mainView ?? 0) > 0)?.id;
+			const revealGroup = revealSessionId === void 0 || !workspaceReady ? void 0 : owningGroupKey(workspaces, revealSessionId);
+			const [expandedSessionGroups, setExpandedSessionGroups] = (0, react.useState)([]);
+			const [drag, setDrag] = (0, react.useState)(null);
+			const sessionDropCommitted = (0, react.useRef)(false);
+			const [workspaceDrag, setWorkspaceDrag] = (0, react.useState)(null);
+			const workspaceDropCommitted = (0, react.useRef)(false);
+			useNativeDragAcceptance(drag !== null || workspaceDrag !== null);
+			const currentGroup = current === void 0 || !workspaceReady ? void 0 : owningGroupKey(workspaces, current);
+			(0, react.useEffect)(() => {
+				if (current === void 0 || currentGroup === void 0 || Object.hasOwn(groupExpansion, currentGroup)) return;
+				setGroupExpanded(currentGroup, true);
+			}, [
+				current,
+				currentGroup,
+				setGroupExpanded,
+				groupExpansion
+			]);
+			const parents = (0, react.useMemo)(() => {
+				if (!nestWorkspaces) return /* @__PURE__ */ new Map();
+				const keysByPath = new Map(workspaces.map((workspace) => [workspace.path, workspace.workspaceId]));
+				const paths = [...keysByPath.keys()];
+				return new Map(workspaces.map((workspace) => {
+					const path = owningParentFolder(workspace.path, paths);
+					return [workspace.workspaceId, path === void 0 ? void 0 : keysByPath.get(path)];
+				}));
+			}, [nestWorkspaces, workspaces]);
+			const currentAncestors = (0, react.useMemo)(() => {
+				const keys = /* @__PURE__ */ new Set();
+				for (let key = currentGroup === void 0 ? void 0 : parents.get(currentGroup); key !== void 0; key = parents.get(key)) keys.add(key);
+				return keys;
+			}, [currentGroup, parents]);
+			const expandedGroups = (0, react.useMemo)(() => {
+				const ancestorKeys = new Set(parents.values());
+				return [...workspaces.map((workspace) => workspace.workspaceId), ""].filter((key) => groupExpansion[key] ?? ancestorKeys.has(key));
+			}, [
+				groupExpansion,
+				parents,
+				workspaces
+			]);
+			const groups = (0, react.useMemo)(() => deriveGroups(list, workspaces, {
+				pinnedSessionIds,
+				archivedSessionIds
+			}, statuses, {
+				expandedGroups,
+				ungroupedOrder: ungroupedSessionIds
+			}), [
+				list,
+				workspaces,
+				pinnedSessionIds,
+				archivedSessionIds,
+				statuses,
+				expandedGroups,
+				ungroupedSessionIds
+			]);
+			(0, react.useEffect)(() => {
+				for (let key = revealGroup; key !== void 0; key = parents.get(key)) if (groupExpansion[key] === false || key === revealGroup && groupExpansion[key] !== true) setGroupExpanded(key, true);
+			}, [
+				groupExpansion,
+				parents,
+				revealGroup,
+				setGroupExpanded
+			]);
+			(0, react.useEffect)(() => {
+				if (revealSessionId === void 0 || revealGroup === void 0) return;
+				const group = groups.find((candidate) => candidate.key === revealGroup);
+				if (group === void 0 || !group.expanded || !group.sessions.some((row) => row.id === revealSessionId)) return;
+				if (collapsedSessionRows(group.sessions).rows.some((row) => row.id === revealSessionId)) return;
+				setExpandedSessionGroups((keys) => keys.includes(revealGroup) ? keys : [...keys, revealGroup]);
+			}, [
+				groups,
+				revealGroup,
+				revealSessionId
+			]);
+			const now = Date.now();
+			const commitSessionDrag = (activeDrag, over) => {
+				if (sessionDropCommitted.current) return;
+				sessionDropCommitted.current = true;
+				setDrag(null);
+				const group = groups.find((candidate) => candidate.key === activeDrag.accountKey);
+				if (group === void 0) return;
+				const sessionsExpanded = expandedSessionGroups.includes(group.key);
+				const renderedSessions = sessionsExpanded ? group.sessions : collapsedSessionRows(group.sessions).rows;
+				const targetIndex = renderedSessions.findIndex((session) => session.id === over.id);
+				if (targetIndex === -1) return;
+				const sourceIndex = renderedSessions.findIndex((session) => session.id === activeDrag.sessionId);
+				if (over.id === activeDrag.sessionId) return;
+				const withoutSource = renderedSessions.filter((session) => session.id !== activeDrag.sessionId);
+				const targetWithoutSourceIndex = withoutSource.findIndex((session) => session.id === over.id);
+				if (targetWithoutSourceIndex === -1) return;
+				const visibleInsertAt = over.half === "before" ? targetWithoutSourceIndex : targetWithoutSourceIndex + 1;
+				if (sourceIndex !== -1 && visibleInsertAt === sourceIndex) return;
+				const accountSessionIds = activeDrag.accountKey === "" ? ungroupedSessionIds : workspaces.find((workspace) => workspace.workspaceId === activeDrag.accountKey)?.sessionIds;
+				if (accountSessionIds === void 0 || !accountSessionIds.includes(activeDrag.sessionId)) return;
+				const nextOrder = accountSessionIds.filter((id) => id !== activeDrag.sessionId);
+				let anchor;
+				if (sessionsExpanded) anchor = over.half === "before" ? over.id : renderedSessions[targetIndex + 1]?.id;
+				else {
+					const previousVisible = withoutSource[visibleInsertAt - 1]?.id;
+					if (previousVisible === void 0) anchor = nextOrder[0];
+					else {
+						const previousIndex = nextOrder.indexOf(previousVisible);
+						if (previousIndex === -1) return;
+						anchor = nextOrder[previousIndex + 1];
+					}
+				}
+				const insertAt = anchor === void 0 ? nextOrder.length : nextOrder.indexOf(anchor);
+				nextOrder.splice(insertAt === -1 ? nextOrder.length : insertAt, 0, activeDrag.sessionId);
+				if (!sessionsExpanded && sourceIndex !== -1) {
+					const nodes = new Map(group.sessions.map((node) => [node.id, node]));
+					if (!collapsedSessionRows(nextOrder.flatMap((id) => {
+						const node = nodes.get(id);
+						return node === void 0 ? [] : [node];
+					})).rows.some((node) => node.id === activeDrag.sessionId)) return;
+				}
+				const currentBlank = group.sessions.find((node) => node.blank)?.id;
+				setSessionOrder(activeDrag.accountKey, pinCurrentBlank(nextOrder, currentBlank));
+			};
+			const commitWorkspaceDrag = (activeDrag, over) => {
+				if (workspaceDropCommitted.current) return;
+				workspaceDropCommitted.current = true;
+				setWorkspaceDrag(null);
+				const owner = parents.get(activeDrag.workspaceId);
+				const siblings = workspaces.filter((workspace) => parents.get(workspace.workspaceId) === owner);
+				const rowIndex = siblings.findIndex((workspace) => workspace.workspaceId === over.id);
+				if (rowIndex === -1) return;
+				const anchor = over.half === "before" ? over.id : siblings[rowIndex + 1]?.workspaceId;
+				if (anchor === activeDrag.workspaceId) return;
+				const sourceIndex = siblings.findIndex((workspace) => workspace.workspaceId === activeDrag.workspaceId);
+				const anchorIndex = anchor === void 0 ? siblings.length : siblings.findIndex((workspace) => workspace.workspaceId === anchor);
+				if (sourceIndex !== -1 && (anchorIndex === sourceIndex || anchorIndex === sourceIndex + 1)) return;
+				insertWorkspaceBefore(activeDrag.workspaceId, anchor).catch((reason) => {
+					console.warn("workspace reorder rejected:", reason);
+				});
+			};
+			const childrenByParent = (0, react.useMemo)(() => {
+				const children = /* @__PURE__ */ new Map();
+				for (const group of groups) {
+					const parent = parents.get(group.key);
+					const siblings = children.get(parent);
+					if (siblings === void 0) children.set(parent, [group]);
+					else siblings.push(group);
+				}
+				return children;
+			}, [groups, parents]);
+			const rootGroups = childrenByParent.get(void 0) ?? [];
+			const workspaceDropAtListStart = rootGroups[0]?.workspaceId !== void 0 && workspaceDrag?.over?.id === rootGroups[0].workspaceId && workspaceDrag.over.half === "before";
+			const renderGroup = (group, depth) => {
+				const workspaceId = group.workspaceId;
+				const children = childrenByParent.get(group.key) ?? [];
+				const compatibleDrag = workspaceDrag !== null && parents.get(workspaceDrag.workspaceId) === parents.get(group.key);
+				const collapsed = collapsedSessionRows(group.sessions);
+				const sessionsExpanded = expandedSessionGroups.includes(group.key);
+				const workspaceMarker = workspaceId !== void 0 && workspaceDrag?.over?.id === workspaceId ? workspaceDrag.over.half : null;
+				const workspaceDragProps = workspaceId === void 0 ? void 0 : {
+					start: () => {
+						workspaceDropCommitted.current = false;
+						setWorkspaceDrag({
+							workspaceId,
+							over: null
+						});
+					},
+					end: () => {
+						if (workspaceDrag?.over !== null && workspaceDrag?.over !== void 0) commitWorkspaceDrag(workspaceDrag, workspaceDrag.over);
+						else setWorkspaceDrag(null);
+						workspaceDropCommitted.current = false;
+					}
+				};
+				const hoverWorkspace = workspaceId === void 0 || !compatibleDrag ? void 0 : (half) => {
+					setWorkspaceDrag((active) => active === null ? active : {
+						...active,
+						over: {
+							id: workspaceId,
+							half
+						}
+					});
+				};
+				const dropWorkspace = workspaceId === void 0 || !compatibleDrag ? void 0 : (half) => {
+					commitWorkspaceDrag(workspaceDrag, {
+						id: workspaceId,
+						half
+					});
+				};
+				return (0, react_jsx_runtime.jsxs)("div", {
+					style: { "--dsh-workspace-indent": `${depth * 12}px` },
+					className: clsx(WorkspaceBrowser_module_css_default.groupSection, workspaceMarker === "before" && WorkspaceBrowser_module_css_default.workspaceDropBefore, workspaceMarker === "after" && WorkspaceBrowser_module_css_default.workspaceDropAfter),
+					onDragOver: workspaceDrag === null ? void 0 : (e) => {
+						e.preventDefault();
+						if (hoverWorkspace === void 0 && parents.get(group.key) !== void 0) return;
+						e.stopPropagation();
+						if (hoverWorkspace === void 0) {
+							e.dataTransfer.dropEffect = "none";
+							if (workspaceDrag.over !== null) setWorkspaceDrag({
+								...workspaceDrag,
+								over: null
+							});
+						} else {
+							e.dataTransfer.dropEffect = "move";
+							hoverWorkspace(workspaceGroupHalf(e));
+						}
+					},
+					onDrop: workspaceDrag === null ? void 0 : (e) => {
+						e.preventDefault();
+						if (dropWorkspace === void 0 && parents.get(group.key) !== void 0) return;
+						e.stopPropagation();
+						if (dropWorkspace === void 0) {
+							workspaceDropCommitted.current = true;
+							setWorkspaceDrag(null);
+						} else dropWorkspace(workspaceGroupHalf(e));
+					},
+					children: [
+						(0, react_jsx_runtime.jsx)(ProjectRowItem, {
+							group,
+							containsCurrentDescendant: currentAncestors.has(group.key),
+							home,
+							t,
+							onToggle: () => {
+								if (group.expanded) setExpandedSessionGroups((keys) => keys.filter((key) => key !== group.key));
+								setGroupExpanded(group.key, !group.expanded);
+							},
+							onCreate: () => {
+								if (group.workspaceId !== void 0) {
+									setGroupExpanded(group.key, true);
+									startSession(group.workspaceId);
+								}
+							},
+							drag: workspaceDragProps,
+							actions: group.workspaceId === void 0 ? void 0 : {
+								rename: () => {
+									/* v8 ignore next -- narrowing guard: the actions object exists only for real-workspace groups. */
+									if (group.workspaceId !== void 0) onRenameRequest(group.workspaceId, group.label);
+								},
+								delete: () => {
+									/* v8 ignore next -- narrowing guard: the actions object exists only for real-workspace groups. */
+									if (group.workspaceId !== void 0) onDeleteRequest(group.workspaceId, group.label);
+								}
+							}
+						}),
+						group.expanded && children.length > 0 && (0, react_jsx_runtime.jsx)("div", {
+							role: "group",
+							children: children.map((child) => renderGroup(child, depth + 1))
+						}),
+						(sessionsExpanded ? group.sessions : collapsed.rows).map((node) => {
+							const sameGroupDrag = drag !== null && drag.accountKey === group.key;
+							const normalizeHalf = (half) => node.blank ? "after" : half;
+							const dragProps = {
+								start: () => {
+									sessionDropCommitted.current = false;
+									setDrag({
+										accountKey: group.key,
+										sessionId: node.id,
+										over: null
+									});
+								},
+								active: sameGroupDrag,
+								marker: sameGroupDrag && drag.over?.id === node.id ? drag.over.half : null,
+								hover: (half) => {
+									/* v8 ignore next -- narrowing guard: Rows gates hover on `active`, which is false while the drag state is null. */
+									setDrag((d) => d === null ? d : {
+										...d,
+										over: {
+											id: node.id,
+											half: normalizeHalf(half)
+										}
+									});
+								},
+								drop: (half) => {
+									/* v8 ignore next -- narrowing guard: Rows gates drop on `active`, which is false while the drag state is null. */
+									if (drag === null) return;
+									commitSessionDrag(drag, {
+										id: node.id,
+										half: normalizeHalf(half)
+									});
+								},
+								end: () => {
+									if (drag?.over !== null && drag?.over !== void 0) commitSessionDrag(drag, drag.over);
+									else setDrag(null);
+									sessionDropCommitted.current = false;
+								}
+							};
+							return (0, react_jsx_runtime.jsx)(SessionNodeItem, {
+								node,
+								currentId: current,
+								now,
+								onOpen: open,
+								onRename: onSessionRename,
+								onFork: forkSession,
+								onArchive: onSessionArchive,
+								onPin: onSessionPin,
+								onUnpin: onSessionUnpin,
+								onReveal: node.id === revealSessionId && group.key === revealGroup ? () => {
+									onSessionRevealed(node.id);
+								} : void 0,
+								drag: dragProps,
+								renderSlot,
+								t
+							}, node.id);
+						}),
+						collapsed.hiddenCount > 0 && (0, react_jsx_runtime.jsx)("button", {
+							type: "button",
+							className: WorkspaceBrowser_module_css_default.sessionOverflowButton,
+							"aria-expanded": sessionsExpanded,
+							onClick: () => {
+								setExpandedSessionGroups((keys) => toggled(keys, group.key));
+							},
+							children: sessionsExpanded ? t("sessions.collapse") : t("sessions.expand", { n: collapsed.hiddenCount })
+						})
+					]
+				}, group.key);
+			};
+			return (0, react_jsx_runtime.jsxs)("div", {
+				className: clsx(WorkspaceBrowser_module_css_default.treeBody, WorkspaceBrowser_module_css_default.wide),
+				children: [
+					workspaceDropAtListStart && (0, react_jsx_runtime.jsx)("span", {
+						className: WorkspaceBrowser_module_css_default.listTopDropIndicator,
+						"aria-hidden": "true"
+					}),
+					(0, react_jsx_runtime.jsxs)("div", {
+						className: clsx(WorkspaceBrowser_module_css_default.list, workspaceDropAtListStart && WorkspaceBrowser_module_css_default.listTopDropActive),
+						role: "tree",
+						"aria-label": t("section.sessions"),
+						children: [groups.length === 0 && (0, react_jsx_runtime.jsx)("div", {
+							className: WorkspaceBrowser_module_css_default.empty,
+							children: t("empty.none")
+						}), rootGroups.map((group) => renderGroup(group, 0))]
+					}),
+					(0, react_jsx_runtime.jsx)("span", { className: WorkspaceBrowser_module_css_default.fade })
+				]
+			});
+		}
+		/** The flat "In one list" body: every session is one draggable top-level row. */
+		function FlatList({ list, sessionIds, pinnedSessionIds, useSessionStatus, open, forkSession, onSessionRename, onSessionArchive, onSessionPin, onSessionUnpin, usePanelInfo, setSessionOrder, revealSessionId, onSessionRevealed, t, renderSlot }) {
+			const panelActive = usePanelInfo((info) => info.activePanelId !== null);
+			const statuses = useSessionStatus((s) => s);
+			const rows = (0, react.useMemo)(() => deriveFlat(list, sessionIds, pinnedSessionIds, statuses), [
+				list,
+				sessionIds,
+				pinnedSessionIds,
+				statuses
+			]);
+			const [drag, setDrag] = (0, react.useState)(null);
+			const dropCommitted = (0, react.useRef)(false);
+			useNativeDragAcceptance(drag !== null);
+			const currentId = panelActive ? void 0 : Object.values(list.byId).find((session) => (session.retainedBy.mainView ?? 0) > 0)?.id;
+			const commitDrag = (activeDrag, over) => {
+				if (dropCommitted.current) return;
+				dropCommitted.current = true;
+				setDrag(null);
+				const targetIndex = rows.findIndex((row) => row.id === over.id);
+				if (targetIndex === -1) return;
+				const anchor = over.half === "before" ? over.id : rows[targetIndex + 1]?.id;
+				if (anchor === activeDrag.sessionId) return;
+				const sourceIndex = rows.findIndex((row) => row.id === activeDrag.sessionId);
+				const anchorIndex = anchor === void 0 ? rows.length : rows.findIndex((row) => row.id === anchor);
+				if (sourceIndex !== -1 && (anchorIndex === sourceIndex || anchorIndex === sourceIndex + 1)) return;
+				const nextOrder = rows.map((row) => row.id).filter((id) => id !== activeDrag.sessionId);
+				const insertAt = anchor === void 0 ? nextOrder.length : nextOrder.indexOf(anchor);
+				nextOrder.splice(insertAt === -1 ? nextOrder.length : insertAt, 0, activeDrag.sessionId);
+				const currentBlank = rows.find((node) => node.blank)?.id;
+				setSessionOrder(FLAT_SESSION_ORDER_KEY, pinCurrentBlank(nextOrder, currentBlank));
+			};
+			const now = Date.now();
+			return (0, react_jsx_runtime.jsxs)("div", {
+				className: clsx(WorkspaceBrowser_module_css_default.treeBody, WorkspaceBrowser_module_css_default.wide),
+				children: [(0, react_jsx_runtime.jsxs)("div", {
+					className: clsx(WorkspaceBrowser_module_css_default.list, WorkspaceBrowser_module_css_default.flatList),
+					role: "tree",
+					"aria-label": t("section.sessions"),
+					children: [rows.length === 0 && (0, react_jsx_runtime.jsx)("div", {
+						className: WorkspaceBrowser_module_css_default.empty,
+						children: t("empty.none")
+					}), rows.map((node) => {
+						const active = drag !== null;
+						const normalizeHalf = (half) => node.blank ? "after" : half;
+						return (0, react_jsx_runtime.jsx)(SessionNodeItem, {
+							node,
+							currentId,
+							now,
+							onOpen: open,
+							onRename: onSessionRename,
+							onFork: forkSession,
+							onArchive: onSessionArchive,
+							onPin: onSessionPin,
+							onUnpin: onSessionUnpin,
+							onReveal: node.id === revealSessionId ? () => {
+								onSessionRevealed(node.id);
+							} : void 0,
+							renderSlot,
+							drag: {
+								start: () => {
+									dropCommitted.current = false;
+									setDrag({
+										accountKey: FLAT_SESSION_ORDER_KEY,
+										sessionId: node.id,
+										over: null
+									});
+								},
+								active,
+								marker: active && drag.over?.id === node.id ? drag.over.half : null,
+								hover: (half) => {
+									setDrag((current) => current === null ? current : {
+										...current,
+										over: {
+											id: node.id,
+											half: normalizeHalf(half)
+										}
+									});
+								},
+								drop: (half) => {
+									if (drag !== null) commitDrag(drag, {
+										id: node.id,
+										half: normalizeHalf(half)
+									});
+								},
+								end: () => {
+									if (drag?.over !== null && drag?.over !== void 0) commitDrag(drag, drag.over);
+									else setDrag(null);
+									dropCommitted.current = false;
+								}
+							},
+							t
+						}, node.id);
+					})]
+				}), (0, react_jsx_runtime.jsx)("span", { className: WorkspaceBrowser_module_css_default.fade })]
+			});
+		}
+		/** Flat search body: local metadata matches plus the current Host result page. */
+		function SearchResults({ useSessions, useSessionStatus, open, workspaces, archivedSessionIds, query, remote, resultLimit, usePanelInfo, t }) {
+			const panelActive = usePanelInfo((info) => info.activePanelId !== null);
+			const list = useSessions((s) => s);
+			const statuses = useSessionStatus((s) => s);
+			const currentRemote = remote.query === query ? remote : {
+				query,
+				status: "loading",
+				items: [],
+				hasMore: false
+			};
+			const results = (0, react.useMemo)(() => deriveSearchResults(list, workspaces, query, { archivedSessionIds }, statuses, currentRemote, resultLimit), [
+				list,
+				workspaces,
+				query,
+				archivedSessionIds,
+				statuses,
+				currentRemote,
+				resultLimit
+			]);
+			const pending = currentRemote.status === "loading";
+			const failed = currentRemote.status === "error";
+			const currentId = panelActive ? void 0 : Object.values(list.byId).find((session) => (session.retainedBy.mainView ?? 0) > 0)?.id;
+			return (0, react_jsx_runtime.jsxs)("div", {
+				className: clsx(WorkspaceBrowser_module_css_default.treeBody, WorkspaceBrowser_module_css_default.wide),
+				children: [(0, react_jsx_runtime.jsxs)("div", {
+					className: WorkspaceBrowser_module_css_default.list,
+					children: [
+						(0, react_jsx_runtime.jsx)("div", {
+							className: WorkspaceBrowser_module_css_default.searchTree,
+							role: "tree",
+							"aria-label": t("search.results.aria"),
+							children: results.items.map((result) => (0, react_jsx_runtime.jsx)(SearchResultItem, {
+								result,
+								currentId,
+								onOpen: open,
+								t
+							}, result.id))
+						}),
+						pending && (0, react_jsx_runtime.jsx)("div", {
+							className: WorkspaceBrowser_module_css_default.searchStatus,
+							role: "status",
+							children: t("search.pending")
+						}),
+						failed && (0, react_jsx_runtime.jsx)("div", {
+							className: WorkspaceBrowser_module_css_default.searchWarning,
+							role: "status",
+							children: t("search.unavailable")
+						}),
+						!pending && results.items.length === 0 && (0, react_jsx_runtime.jsx)("div", {
+							className: WorkspaceBrowser_module_css_default.empty,
+							children: t("search.noMatches")
+						}),
+						results.hasMore && (0, react_jsx_runtime.jsx)("div", {
+							className: WorkspaceBrowser_module_css_default.searchStatus,
+							children: t("search.hasMore", { n: resultLimit })
+						})
+					]
+				}), (0, react_jsx_runtime.jsx)("span", { className: WorkspaceBrowser_module_css_default.fade })]
+			});
+		}
+		/**
+		* Render the browsing region.
+		* @param props - composed slot props (shell owner share + store + injected actions).
+		* @returns the region element tree.
+		*/
+		function WorkspaceBrowser({ wide, usePanelInfo, expandSidebar, useSessions, useSessionStatus, useWorkspaces, useStore, actions, startSession, open, renameSession, forkSession, renameWorkspace, deleteWorkspace, insertWorkspaceBefore, archiveSession, pinSession, unpinSession, createWorkspace, searchSessions, searchResultLimit, requestSearch, requestAddWorkspace, closeAddWorkspace, closeRenameRequest, setDirectoryBusy, useDirectoryFlow, useHostInfo, useWorkspaceShortcuts, useShortcuts, renderSlot, t }) {
+			const home = useHostInfo((info) => info.home);
+			const list = useSessions((state) => state);
+			const workspaces = useWorkspaces((state) => state.items);
+			const workspacePhase = useWorkspaces((state) => state.phase);
+			const workspaceStreamState = useWorkspaces((state) => state.state);
+			const archivedSessionIds = useWorkspaces((state) => state.archivedSessionIds);
+			const pinnedSessionIds = useWorkspaces((state) => state.pinnedSessionIds);
+			const directoryFlowAvailable = useDirectoryFlow((occupied) => occupied);
+			const groupBy = useStore((s) => s.groupBy);
+			const orderBy = useStore((s) => s.orderBy);
+			const groupExpansion = useStore((s) => s.groupExpansion);
+			const sessionOrderByAccount = useStore((s) => s.sessionOrderByAccount);
+			const workspaceReady = workspacePhase === "ready" && workspaceStreamState !== "loading";
+			const mainSessionId = Object.values(list.byId).find((session) => (session.retainedBy.mainView ?? 0) > 0)?.id;
+			const currentBlank = mainSessionId !== void 0 && list.byId[mainSessionId]?.blank === true ? mainSessionId : void 0;
+			const ungroupedMemberIds = (0, react.useMemo)(() => {
+				const accounted = new Set(workspaces.flatMap((workspace) => workspace.sessionIds));
+				return list.ids.filter((id) => list.byId[id] !== void 0 && !accounted.has(id));
+			}, [list, workspaces]);
+			const flatMemberIds = (0, react.useMemo)(() => visibleSessionIds(list, { archivedSessionIds }), [archivedSessionIds, list]);
+			const orderedWorkspaces = (0, react.useMemo)(() => workspaces.map((workspace) => {
+				const memberIds = workspace.sessionIds;
+				const baseOrder = orderBy === "updated" ? orderByRecency(memberIds, list.byId) : reconcileManualOrder(memberIds, sessionOrderByAccount[workspace.workspaceId], list.byId);
+				return {
+					...workspace,
+					sessionIds: pinCurrentBlank(baseOrder, currentBlank !== void 0 && memberIds.includes(currentBlank) ? currentBlank : void 0)
+				};
+			}), [
+				currentBlank,
+				list.byId,
+				orderBy,
+				sessionOrderByAccount,
+				workspaces
+			]);
+			const orderedUngroupedSessionIds = (0, react.useMemo)(() => {
+				return pinCurrentBlank(orderBy === "updated" ? orderByRecency(ungroupedMemberIds, list.byId) : reconcileManualOrder(ungroupedMemberIds, sessionOrderByAccount[""], list.byId), currentBlank !== void 0 && ungroupedMemberIds.includes(currentBlank) ? currentBlank : void 0);
+			}, [
+				currentBlank,
+				list.byId,
+				orderBy,
+				sessionOrderByAccount,
+				ungroupedMemberIds
+			]);
+			const orderedFlatSessionIds = (0, react.useMemo)(() => {
+				return pinCurrentBlank(orderBy === "updated" ? orderByRecency(flatMemberIds, list.byId) : reconcileManualOrder(flatMemberIds, sessionOrderByAccount[FLAT_SESSION_ORDER_KEY], list.byId), currentBlank !== void 0 && flatMemberIds.includes(currentBlank) ? currentBlank : void 0);
+			}, [
+				currentBlank,
+				flatMemberIds,
+				list.byId,
+				orderBy,
+				sessionOrderByAccount
+			]);
+			const activeSessionOrders = (0, react.useMemo)(() => Object.fromEntries([
+				...orderedWorkspaces.map((workspace) => [workspace.workspaceId, workspace.sessionIds]),
+				["", orderedUngroupedSessionIds],
+				[FLAT_SESSION_ORDER_KEY, orderedFlatSessionIds]
+			]), [
+				orderedFlatSessionIds,
+				orderedUngroupedSessionIds,
+				orderedWorkspaces
+			]);
+			(0, react.useEffect)(() => {
+				if (workspacePhase !== "ready") return;
+				actions.retainAccountKeys([
+					"",
+					FLAT_SESSION_ORDER_KEY,
+					...workspaces.map((workspace) => workspace.workspaceId)
+				]);
+			}, [
+				actions.retainAccountKeys,
+				workspacePhase,
+				workspaces
+			]);
+			(0, react.useEffect)(() => {
+				if (list.phase !== "ready" || workspaceReady || orderBy !== "manual" || currentBlank === void 0) return;
+				const changed = {};
+				for (const [key, ids] of Object.entries(activeSessionOrders)) {
+					if (key !== "__flat_session_order__" && workspacePhase !== "ready") continue;
+					const saved = sessionOrderByAccount[key] ?? [];
+					if (ids[0] !== currentBlank || saved[0] === currentBlank) continue;
+					changed[key] = [currentBlank, ...saved.filter((id) => id !== currentBlank)];
+				}
+				if (Object.keys(changed).length > 0) actions.syncSessionOrders(changed);
+			}, [
+				actions.syncSessionOrders,
+				activeSessionOrders,
+				currentBlank,
+				list.phase,
+				orderBy,
+				sessionOrderByAccount,
+				workspacePhase,
+				workspaceReady
+			]);
+			(0, react.useEffect)(() => {
+				if (list.phase !== "ready" || !workspaceReady || orderBy !== "manual") return;
+				const changed = Object.fromEntries(Object.entries(activeSessionOrders).filter(([key, ids]) => {
+					const saved = sessionOrderByAccount[key];
+					return saved === void 0 || saved.length !== ids.length || ids.some((id, index) => id !== saved[index]);
+				}));
+				if (Object.keys(changed).length > 0) actions.syncSessionOrders(changed);
+			}, [
+				actions.syncSessionOrders,
+				activeSessionOrders,
+				list.phase,
+				orderBy,
+				sessionOrderByAccount,
+				workspaceReady
+			]);
+			const saveSessionOrder = (accountKey, order) => {
+				actions.setSessionOrder(accountKey, order, activeSessionOrders);
+			};
+			const [query, setQuery] = (0, react.useState)("");
+			const [searchExpanded, setSearchExpanded] = (0, react.useState)(false);
+			const [revealSessionId, setRevealSessionId] = (0, react.useState)(void 0);
+			const normalizedQuery = sanitizeSearchQuery(query).trim();
+			const [remoteSearch, setRemoteSearch] = (0, react.useState)({
+				query: "",
+				status: "idle",
+				items: [],
+				hasMore: false
+			});
+			const searchRoot = (0, react.useRef)(null);
+			const searchInput = (0, react.useRef)(null);
+			const [wsPickerOpen, setWsPickerOpen] = (0, react.useState)(false);
+			const [addOnExpand, setAddOnExpand] = (0, react.useState)(false);
+			const wsPlusRef = (0, react.useRef)(null);
+			const composingRef = (0, react.useRef)(false);
+			const openSearchResult = (sessionId) => {
+				setRevealSessionId(sessionId);
+				setQuery("");
+				setSearchExpanded(false);
+				open(sessionId);
+			};
+			const acknowledgeSessionReveal = (sessionId) => {
+				setRevealSessionId((current) => current === sessionId ? void 0 : current);
+			};
+			(0, react.useEffect)(() => {
+				if (normalizedQuery !== "") setRevealSessionId(void 0);
+			}, [normalizedQuery]);
+			const [searchOnExpand, setSearchOnExpand] = (0, react.useState)(false);
+			(0, react.useEffect)(() => {
+				if (wide && searchOnExpand) {
+					const timer = window.setTimeout(() => {
+						searchInput.current?.focus({ preventScroll: true });
+						setSearchOnExpand(false);
+					}, EXPAND_SLIDE_MS);
+					return () => {
+						window.clearTimeout(timer);
+					};
+				}
+			}, [wide, searchOnExpand]);
+			(0, react.useEffect)(() => {
+				if (!wide || !searchExpanded || searchOnExpand) return;
+				searchInput.current?.focus({ preventScroll: true });
+			}, [
+				wide,
+				searchExpanded,
+				searchOnExpand
+			]);
+			(0, react.useEffect)(() => {
+				if (!wide || !searchExpanded || searchOnExpand) return;
+				const onClick = (event) => {
+					if (!(event.target instanceof Node) || searchRoot.current?.contains(event.target) === true) return;
+					searchInput.current?.blur();
+					if (normalizedQuery !== "") return;
+					setSearchExpanded(false);
+				};
+				document.addEventListener("click", onClick);
+				return () => {
+					document.removeEventListener("click", onClick);
+				};
+			}, [
+				normalizedQuery,
+				wide,
+				searchExpanded,
+				searchOnExpand
+			]);
+			(0, react.useEffect)(() => {
+				if (normalizedQuery === "") {
+					setRemoteSearch({
+						query: "",
+						status: "idle",
+						items: [],
+						hasMore: false
+					});
+					return;
+				}
+				const controller = new AbortController();
+				setRemoteSearch({
+					query: normalizedQuery,
+					status: "loading",
+					items: [],
+					hasMore: false
+				});
+				const timer = window.setTimeout(() => {
+					searchSessions(normalizedQuery, controller.signal).then((result) => {
+						if (controller.signal.aborted) return;
+						setRemoteSearch({
+							query: normalizedQuery,
+							status: "ready",
+							items: result.items,
+							hasMore: result.hasMore
+						});
+					}).catch(() => {
+						if (controller.signal.aborted) return;
+						setRemoteSearch({
+							query: normalizedQuery,
+							status: "error",
+							items: [],
+							hasMore: false
+						});
+					});
+				}, SEARCH_DEBOUNCE_MS);
+				return () => {
+					window.clearTimeout(timer);
+					controller.abort();
+				};
+			}, [normalizedQuery, searchSessions]);
+			const [renameTarget, setRenameTarget] = (0, react.useState)(null);
+			const [renameDraft, setRenameDraft] = (0, react.useState)("");
+			const [renaming, setRenaming] = (0, react.useState)(false);
+			const [renameError, setRenameError] = (0, react.useState)(null);
+			const renameTrimmed = renameDraft.trim();
+			const renameDuplicate = renameTarget !== null && renameTrimmed !== "" && renameTrimmed !== renameTarget.currentTitle && workspaces.some((w) => w.title === renameTrimmed);
+			const renameBlocked = renaming || renameTrimmed === "" || renameTarget === null || renameTrimmed === renameTarget.currentTitle || renameDuplicate;
+			const closeRename = () => {
+				if (renaming) return;
+				setRenameTarget(null);
+				setRenameError(null);
+			};
+			const confirmRename = () => {
+				if (renameBlocked) return;
+				setRenaming(true);
+				setRenameError(null);
+				renameWorkspace(renameTarget.workspaceId, renameTrimmed).then(() => {
+					setRenaming(false);
+					setRenameTarget(null);
+				}).catch((reason) => {
+					setRenaming(false);
+					setRenameError(reason instanceof Error ? reason.message : String(reason));
+				});
+			};
+			const [sessionRenameTarget, setSessionRenameTarget] = (0, react.useState)(null);
+			const [sessionRenameDraft, setSessionRenameDraft] = (0, react.useState)("");
+			const [sessionRenaming, setSessionRenaming] = (0, react.useState)(false);
+			const [sessionRenameError, setSessionRenameError] = (0, react.useState)(null);
+			const sessionRenameTrimmed = sessionRenameDraft.trim();
+			const sessionRenameBlocked = sessionRenaming || sessionRenameTrimmed === "" || sessionRenameTarget === null;
+			const closeSessionRename = () => {
+				if (sessionRenaming) return;
+				setSessionRenameTarget(null);
+				setSessionRenameError(null);
+			};
+			const confirmSessionRename = () => {
+				if (sessionRenameBlocked) return;
+				setSessionRenaming(true);
+				setSessionRenameError(null);
+				renameSession(sessionRenameTarget.sessionId, sessionRenameTrimmed).then(() => {
+					setSessionRenaming(false);
+					setSessionRenameTarget(null);
+				}).catch((reason) => {
+					setSessionRenaming(false);
+					setSessionRenameError(reason instanceof Error ? reason.message : String(reason));
+				});
+			};
+			const onSessionRename = (sessionId, currentTitle) => {
+				setSessionRenameTarget({
+					sessionId,
+					currentTitle
+				});
+				setSessionRenameDraft(currentTitle);
+				setSessionRenameError(null);
+			};
+			const shortcutState = useWorkspaceShortcuts((state) => state);
+			const addShortcut = useShortcuts((rows) => rows.find((row) => row.id === "workspace.add"));
+			const searchShortcut = useShortcuts((rows) => rows.find((row) => row.id === "session.search"));
+			(0, react.useEffect)(() => {
+				if (shortcutState.searchRequest === 0) return;
+				closeAddWorkspace();
+				setSearchExpanded(true);
+				if (!wide) {
+					setSearchOnExpand(true);
+					expandSidebar();
+				} else searchInput.current?.focus({ preventScroll: true });
+			}, [shortcutState.searchRequest]);
+			(0, react.useEffect)(() => {
+				if (!shortcutState.addRequested) return;
+				closeAddWorkspace();
+				if (!wide) {
+					setAddOnExpand(true);
+					expandSidebar();
+					return;
+				}
+				setWsPickerOpen(true);
+			}, [closeAddWorkspace, shortcutState.addRequested]);
+			(0, react.useEffect)(() => {
+				if (!wide || !addOnExpand) return;
+				const timer = window.setTimeout(() => {
+					setWsPickerOpen(true);
+					setAddOnExpand(false);
+				}, EXPAND_SLIDE_MS);
+				return () => {
+					window.clearTimeout(timer);
+				};
+			}, [wide, addOnExpand]);
+			(0, react.useEffect)(() => {
+				const target = shortcutState.renameTarget;
+				if (target === null) return;
+				closeRenameRequest();
+				setSessionRenameTarget({
+					sessionId: target.sessionId,
+					currentTitle: target.currentTitle
+				});
+				setSessionRenameDraft(target.currentTitle);
+				setSessionRenameError(null);
+			}, [closeRenameRequest, shortcutState.renameTarget]);
+			(0, react.useEffect)(() => {
+				setDirectoryBusy(wsPickerOpen);
+			}, [setDirectoryBusy, wsPickerOpen]);
+			const onSessionArchive = (sessionId) => {
+				archiveSession(sessionId).catch((reason) => {
+					console.warn("session archive rejected:", reason);
+				});
+			};
+			const onSessionPin = (sessionId) => {
+				pinSession(sessionId).catch((reason) => {
+					console.warn("session pin rejected:", reason);
+				});
+			};
+			const onSessionUnpin = (sessionId) => {
+				unpinSession(sessionId).catch((reason) => {
+					console.warn("session unpin rejected:", reason);
+				});
+			};
+			const [deleteTarget, setDeleteTarget] = (0, react.useState)(null);
+			const [deleting, setDeleting] = (0, react.useState)(false);
+			const [deleteCommittedId, setDeleteCommittedId] = (0, react.useState)(null);
+			const [deleteError, setDeleteError] = (0, react.useState)(null);
+			(0, react.useEffect)(() => {
+				if (deleteCommittedId === null || workspaces.some((workspace) => workspace.workspaceId === deleteCommittedId)) return;
+				setDeleting(false);
+				setDeleteCommittedId(null);
+				setDeleteTarget(null);
+			}, [deleteCommittedId, workspaces]);
+			const closeDelete = () => {
+				if (deleting) return;
+				setDeleteTarget(null);
+				setDeleteError(null);
+			};
+			const confirmDelete = () => {
+				/* v8 ignore next -- the Modal is absent without a target and its button is disabled while deleting. */
+				if (deleting || deleteTarget === null) return;
+				setDeleting(true);
+				setDeleteCommittedId(null);
+				setDeleteError(null);
+				deleteWorkspace(deleteTarget.workspaceId).then(() => {
+					setDeleteCommittedId(deleteTarget.workspaceId);
+				}).catch((reason) => {
+					setDeleting(false);
+					setDeleteError(reason instanceof Error ? reason.message : String(reason));
+				});
+			};
+			return (0, react_jsx_runtime.jsxs)("div", {
+				className: clsx(WorkspaceBrowser_module_css_default.root, !wide && WorkspaceBrowser_module_css_default.rail),
+				children: [
+					(0, react_jsx_runtime.jsxs)("div", {
+						className: WorkspaceBrowser_module_css_default.sectionHeader,
+						children: [
+							wide && (0, react_jsx_runtime.jsx)("span", {
+								className: clsx(WorkspaceBrowser_module_css_default.sectionLabel, WorkspaceBrowser_module_css_default.wide, searchExpanded && WorkspaceBrowser_module_css_default.sectionLabelHidden),
+								children: groupBy === "flat" ? t("section.sessions") : t("section.workspaces")
+							}),
+							wide && (0, react_jsx_runtime.jsx)("div", {
+								className: clsx(WorkspaceBrowser_module_css_default.searchSlot, searchExpanded && WorkspaceBrowser_module_css_default.searchSlotExpanded),
+								children: (0, react_jsx_runtime.jsxs)("div", {
+									ref: searchRoot,
+									className: clsx(WorkspaceBrowser_module_css_default.search, searchExpanded && WorkspaceBrowser_module_css_default.searchExpanded),
+									onClick: () => {
+										setWsPickerOpen(false);
+										setSearchExpanded(true);
+										searchInput.current?.focus();
+										requestSearch();
+									},
+									children: [
+										(0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.Tooltip, {
+											label: t("search"),
+											shortcutKeys: searchShortcut?.keys,
+											side: "bottom",
+											delayMs: 500,
+											disabled: searchExpanded,
+											children: (0, react_jsx_runtime.jsx)("button", {
+												type: "button",
+												className: WorkspaceBrowser_module_css_default.searchButton,
+												"aria-label": t("search.sessions.aria"),
+												"aria-keyshortcuts": searchShortcut?.aria,
+												"aria-expanded": searchExpanded,
+												onClick: () => {
+													setWsPickerOpen(false);
+													setSearchExpanded(true);
+													requestSearch();
+												},
+												children: (0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.IconSearchOutline16, { size: searchExpanded ? 11 : 14 })
+											})
+										}),
+										(0, react_jsx_runtime.jsx)("input", {
+											ref: searchInput,
+											className: WorkspaceBrowser_module_css_default.searchInput,
+											type: "text",
+											placeholder: t("search.placeholder"),
+											maxLength: SEARCH_QUERY_MAX_CODE_UNITS,
+											value: query,
+											tabIndex: searchExpanded ? 0 : -1,
+											onChange: (e) => {
+												setQuery(sanitizeSearchQuery(e.target.value));
+											},
+											onKeyDown: (e) => {
+												if (e.key !== "Escape") return;
+												setQuery("");
+												setSearchExpanded(false);
+											}
+										}),
+										searchExpanded && (0, react_jsx_runtime.jsx)("button", {
+											type: "button",
+											className: WorkspaceBrowser_module_css_default.clearButton,
+											"aria-label": t("search.clear"),
+											onClick: (e) => {
+												e.stopPropagation();
+												setQuery("");
+												setSearchExpanded(false);
+											},
+											children: (0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.IconCloseFill14, {})
+										})
+									]
+								})
+							}),
+							wide && (0, react_jsx_runtime.jsxs)("div", {
+								className: clsx(WorkspaceBrowser_module_css_default.headerActions, searchExpanded && WorkspaceBrowser_module_css_default.headerActionsHidden),
+								children: [(0, react_jsx_runtime.jsx)(ViewOptionsMenu, {
+									groupBy,
+									orderBy,
+									onGroupPick: (mode) => {
+										actions.setGroupBy(mode);
+									},
+									onOrderPick: (mode) => {
+										actions.setOrderBy(mode, activeSessionOrders);
+									},
+									t
+								}), directoryFlowAvailable && (0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.Tooltip, {
+									label: t("workspace.add"),
+									shortcutKeys: addShortcut?.keys,
+									side: "bottom",
+									delayMs: 500,
+									children: (0, react_jsx_runtime.jsx)("button", {
+										ref: wsPlusRef,
+										type: "button",
+										className: WorkspaceBrowser_module_css_default.iconButton,
+										"aria-label": t("workspace.add"),
+										"aria-keyshortcuts": addShortcut?.aria,
+										onClick: () => {
+											requestAddWorkspace();
+										},
+										children: (0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.IconProjectAddOutline16, { size: 16 })
+									})
+								})]
+							}),
+							(0, react_jsx_runtime.jsx)(WorkspacePickFlow, {
+								t,
+								open: wsPickerOpen,
+								anchorRef: wsPlusRef,
+								useWorkspaces,
+								createWorkspace,
+								useDirectoryFlow,
+								renderDirectoryFlow: (owner) => renderSlot("sidebar.workspaces.directoryFlow", owner),
+								addOnly: true,
+								side: "right",
+								onPick: (workspaceId) => {
+									setWsPickerOpen(false);
+									startSession(workspaceId);
+								},
+								onClose: () => {
+									setWsPickerOpen(false);
+								}
+							})
+						]
+					}),
+					(0, react_jsx_runtime.jsx)("div", {
+						id: "workbench-list-panel",
+						className: WorkspaceBrowser_module_css_default.listArea,
+						children: wide && (normalizedQuery !== "" ? (0, react_jsx_runtime.jsx)(SearchResults, {
+							usePanelInfo,
+							useSessions,
+							useSessionStatus,
+							open: openSearchResult,
+							workspaces,
+							archivedSessionIds,
+							query: normalizedQuery,
+							remote: remoteSearch,
+							resultLimit: searchResultLimit,
+							t
+						}) : groupBy === "flat" ? (0, react_jsx_runtime.jsx)(FlatList, {
+							usePanelInfo,
+							list,
+							sessionIds: orderedFlatSessionIds,
+							useSessionStatus,
+							open,
+							forkSession,
+							onSessionRename,
+							onSessionArchive,
+							onSessionPin,
+							onSessionUnpin,
+							pinnedSessionIds,
+							setSessionOrder: saveSessionOrder,
+							revealSessionId,
+							onSessionRevealed: acknowledgeSessionReveal,
+							renderSlot,
+							t
+						}) : (0, react_jsx_runtime.jsx)(SessionTree, {
+							usePanelInfo,
+							list,
+							useSessionStatus,
+							renderSlot,
+							onSessionRename,
+							onSessionArchive,
+							onSessionPin,
+							onSessionUnpin,
+							forkSession,
+							workspaces: orderedWorkspaces,
+							ungroupedSessionIds: orderedUngroupedSessionIds,
+							workspaceReady,
+							nestWorkspaces: groupBy === "workspace-tree",
+							groupExpansion,
+							setGroupExpanded: actions.setGroupExpanded,
+							setSessionOrder: saveSessionOrder,
+							archivedSessionIds,
+							pinnedSessionIds,
+							startSession,
+							open,
+							insertWorkspaceBefore,
+							revealSessionId,
+							onSessionRevealed: acknowledgeSessionReveal,
+							home,
+							t,
+							onRenameRequest: (workspaceId, currentTitle) => {
+								setRenameTarget({
+									workspaceId,
+									currentTitle
+								});
+								setRenameDraft(currentTitle);
+								setRenameError(null);
+							},
+							onDeleteRequest: (workspaceId, title) => {
+								setDeleteTarget({
+									workspaceId,
+									title
+								});
+								setDeleteError(null);
+							}
+						}))
+					}),
+					(0, react_jsx_runtime.jsxs)(_qilin_agent_client_ui_primitives.Modal, {
+						open: renameTarget !== null,
+						onClose: closeRename,
+						closeLabel: t("close"),
+						title: t("rename.workspace.title"),
+						footer: (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [(0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.Button, {
+							variant: "outline",
+							disabled: renaming,
+							onClick: closeRename,
+							children: t("cancel")
+						}), (0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.Button, {
+							variant: "primary",
+							disabled: renameBlocked,
+							onClick: confirmRename,
+							children: t("rename")
+						})] }),
+						children: [
+							(0, react_jsx_runtime.jsx)("input", {
+								className: WorkspaceBrowser_module_css_default.renameInput,
+								value: renameDraft,
+								"aria-label": t("field.workspaceName"),
+								autoFocus: true,
+								disabled: renaming,
+								onFocus: (e) => {
+									e.target.select();
+								},
+								onChange: (e) => {
+									setRenameDraft(e.target.value);
+									setRenameError(null);
+								},
+								onCompositionStart: () => {
+									composingRef.current = true;
+								},
+								onCompositionEnd: () => {
+									composingRef.current = false;
+								},
+								onKeyDown: (e) => {
+									if (e.key === "Enter" && !composingRef.current) {
+										e.preventDefault();
+										confirmRename();
+									}
+								}
+							}),
+							renameDuplicate && (0, react_jsx_runtime.jsx)("div", {
+								className: WorkspaceBrowser_module_css_default.renameError,
+								role: "alert",
+								children: t("conflict.named", { name: renameTrimmed })
+							}),
+							renameError !== null && (0, react_jsx_runtime.jsx)("div", {
+								className: WorkspaceBrowser_module_css_default.renameError,
+								role: "alert",
+								children: renameError
+							})
+						]
+					}),
+					(0, react_jsx_runtime.jsxs)(_qilin_agent_client_ui_primitives.Modal, {
+						open: sessionRenameTarget !== null,
+						onClose: closeSessionRename,
+						closeLabel: t("close"),
+						title: t("rename.session.title"),
+						footer: (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [(0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.Button, {
+							variant: "outline",
+							disabled: sessionRenaming,
+							onClick: closeSessionRename,
+							children: t("cancel")
+						}), (0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.Button, {
+							variant: "primary",
+							disabled: sessionRenameBlocked,
+							onClick: confirmSessionRename,
+							children: t("rename")
+						})] }),
+						children: [(0, react_jsx_runtime.jsx)("input", {
+							className: WorkspaceBrowser_module_css_default.renameInput,
+							value: sessionRenameDraft,
+							"aria-label": t("field.sessionName"),
+							autoFocus: true,
+							disabled: sessionRenaming,
+							onFocus: (e) => {
+								e.target.select();
+							},
+							onChange: (e) => {
+								setSessionRenameDraft(e.target.value);
+								setSessionRenameError(null);
+							},
+							onCompositionStart: () => {
+								composingRef.current = true;
+							},
+							onCompositionEnd: () => {
+								composingRef.current = false;
+							},
+							onKeyDown: (e) => {
+								if (e.key === "Enter" && !composingRef.current) {
+									e.preventDefault();
+									confirmSessionRename();
+								}
+							}
+						}), sessionRenameError !== null && (0, react_jsx_runtime.jsx)("div", {
+							className: WorkspaceBrowser_module_css_default.renameError,
+							role: "alert",
+							children: sessionRenameError
+						})]
+					}),
+					(0, react_jsx_runtime.jsxs)(_qilin_agent_client_ui_primitives.Modal, {
+						open: deleteTarget !== null,
+						onClose: closeDelete,
+						closeLabel: t("close"),
+						title: t("delete.workspace"),
+						...deleteTarget === null ? {} : { description: t("delete.desc", { name: deleteTarget.title }) },
+						footer: (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [(0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.Button, {
+							variant: "outline",
+							disabled: deleting,
+							onClick: closeDelete,
+							children: t("cancel")
+						}), (0, react_jsx_runtime.jsx)(_qilin_agent_client_ui_primitives.Button, {
+							variant: "outline",
+							className: WorkspaceBrowser_module_css_default.deleteAction,
+							disabled: deleting,
+							onClick: confirmDelete,
+							children: t("delete.workspace")
+						})] }),
+						children: [deleting && (0, react_jsx_runtime.jsx)("div", {
+							className: WorkspaceBrowser_module_css_default.deleteStatus,
+							role: "status",
+							children: t("delete.pending")
+						}), deleteError !== null && (0, react_jsx_runtime.jsx)("div", {
+							className: WorkspaceBrowser_module_css_default.renameError,
+							role: "alert",
+							children: deleteError
+						})]
+					})
+				]
+			});
+		}
+		//#endregion
+		//#region lib/types/client/locales.js
+		/**
+		* `workspace` namespace dictionaries: the browsing region (section header,
+		* search, tree rows, dialogs) and the pick/add flow. Runtime failure
+		* messages (wire error strings) pass through untranslated by policy.
+		*/
+		/** Simplified Chinese dictionary (the key-set source of truth). */
+		const zh = {
+			"group.ungrouped": "未分组",
+			"session.new": "新会话",
+			"session.untitled": "未命名",
+			"shortcut.noSession": "请先选择一个会话",
+			"shortcut.noPicker": "目录选择器不可用",
+			"shortcut.directoryBusy": "正在选择或添加工作区",
+			"shortcut.noCompletedTurn": "当前会话没有已结束的轮次",
+			"section.workspaces": "工作区",
+			"section.sessions": "会话",
+			"workbench.tabs.aria": "切换工作台",
+			"workbench.general": "通用",
+			"workbench.coding": "编码",
+			"preset.aria": "运行模式",
+			"preset.hint": "选择新任务使用的运行模式",
+			"viewOptions.label": "视图选项",
+			"groupBy.label": "分组方式",
+			"groupBy.workspace": "按工作区",
+			"groupBy.workspaceTree": "按工作区树",
+			"groupBy.flat": "单列表",
+			"orderBy.label": "排序方式",
+			"orderBy.manual": "手动排序",
+			"orderBy.updated": "最近更新",
+			"sessions.expand": "展开其余 {n} 个会话",
+			"sessions.collapse": "收起",
+			"empty.none": "暂无会话",
+			"empty.noMatches": "无匹配结果",
+			"workspace.add": "添加工作区",
+			"search.sessions.aria": "搜索会话",
+			"search.placeholder": "搜索会话…",
+			"search.clear": "清除搜索",
+			"search.results.aria": "搜索结果",
+			"search.pending": "正在搜索会话历史…",
+			"search.unavailable": "内容搜索暂不可用，仅显示名称匹配。",
+			"search.noMatches": "无匹配会话",
+			"search.hasMore": "仅显示前 {n} 条结果，请缩小搜索范围。",
+			"menu.addWorkspace": "添加工作区…",
+			"picker.loading": "正在加载工作区…",
+			"conflict.named": "已存在名为“{name}”的工作区。",
+			"folderError.title": "无法打开文件夹",
+			"folderError.retry": "重新选择",
+			"rename": "重命名",
+			"rename.workspace.title": "重命名工作区",
+			"rename.session.title": "重命名会话",
+			"field.workspaceName": "工作区名称",
+			"field.sessionName": "会话名称",
+			"delete.workspace": "删除工作区",
+			"delete.desc": "将把“{name}”从工作区列表中移除。文件夹与会话记录会保留，其会话将显示在“未分组”下。",
+			"delete.pending": "正在删除工作区…",
+			"menu.pinSession": "置顶会话",
+			"menu.unpinSession": "取消置顶",
+			"menu.fork": "分叉会话",
+			"menu.archiveSession": "归档会话",
+			"row.pinned": "已置顶",
+			"sessions.count.one": "{n} 个会话",
+			"sessions.count.other": "{n} 个会话",
+			"actions.workspace.aria": "工作区“{name}”的操作",
+			"actions.session.aria": "会话“{name}”的操作",
+			"actions.newSession.aria": "在“{name}”中新建会话",
+			"actions.pin": "置顶会话",
+			"actions.unpin": "取消置顶",
+			"status.running": "进行中",
+			"status.subagentsRunning.one": "{n} 个子代理运行中",
+			"status.subagentsRunning.other": "{n} 个子代理运行中",
+			"status.idle": "空闲",
+			"status.waitingApproval": "等待审批",
+			"status.planReview": "计划待审",
+			"status.waitingAnswer": "等待回答",
+			"status.completed": "已完成",
+			"hover.created": "创建于 {time}",
+			"hover.copied": "已复制",
+			"date.ymd": "{y}年{m}月{d}日",
+			"time.now": "刚刚",
+			"time.minutes": "{n}分钟",
+			"time.hours": "{n}小时",
+			"time.days": "{n}天",
+			"time.months": "{n}个月",
+			"time.years": "{n}年",
+			"time.ago": "{t}前"
+		};
+		/** English dictionary, checked complete against the zh key set. */
+		const en = {
+			"group.ungrouped": "Ungrouped",
+			"session.new": "New Session",
+			"session.untitled": "Untitled",
+			"shortcut.noSession": "Select a session first",
+			"shortcut.noPicker": "Directory picker unavailable",
+			"shortcut.directoryBusy": "Selecting or adding a workspace",
+			"shortcut.noCompletedTurn": "This session has no completed turn",
+			"section.workspaces": "Workspaces",
+			"section.sessions": "Sessions",
+			"workbench.tabs.aria": "Switch workbench",
+			"workbench.general": "General",
+			"workbench.coding": "Coding",
+			"preset.aria": "Run mode",
+			"preset.hint": "Choose the run mode for new tasks",
+			"viewOptions.label": "View options",
+			"groupBy.label": "Group by",
+			"groupBy.workspace": "WorkSpace",
+			"groupBy.workspaceTree": "Workspace Tree",
+			"groupBy.flat": "In one list",
+			"orderBy.label": "Order by",
+			"orderBy.manual": "Manual",
+			"orderBy.updated": "Last updated",
+			"sessions.expand": "Show {n} more sessions",
+			"sessions.collapse": "Show less",
+			"empty.none": "No sessions yet",
+			"empty.noMatches": "No matches",
+			"workspace.add": "Add workspace",
+			"search.sessions.aria": "Search sessions",
+			"search.placeholder": "Search sessions...",
+			"search.clear": "Clear search",
+			"search.results.aria": "Search results",
+			"search.pending": "Searching session history…",
+			"search.unavailable": "Content search is temporarily unavailable. Showing name matches.",
+			"search.noMatches": "No matching sessions",
+			"search.hasMore": "Showing the first {n} results. Narrow your search.",
+			"menu.addWorkspace": "Add workspace…",
+			"picker.loading": "Loading workspaces…",
+			"conflict.named": "A workspace named “{name}” already exists.",
+			"folderError.title": "Couldn’t open folder",
+			"folderError.retry": "Choose again",
+			"rename": "Rename",
+			"rename.workspace.title": "Rename workspace",
+			"rename.session.title": "Rename session",
+			"field.workspaceName": "Workspace name",
+			"field.sessionName": "Session name",
+			"delete.workspace": "Delete workspace",
+			"delete.desc": "This removes “{name}” from the workspace list. The folder and session logs will be kept. Its sessions will appear under Ungrouped.",
+			"delete.pending": "Deleting workspace…",
+			"menu.pinSession": "Pin session",
+			"menu.unpinSession": "Unpin session",
+			"menu.fork": "Fork session",
+			"menu.archiveSession": "Archive session",
+			"row.pinned": "Pinned",
+			"sessions.count.one": "{n} session",
+			"sessions.count.other": "{n} sessions",
+			"actions.workspace.aria": "Workspace actions for {name}",
+			"actions.session.aria": "Session actions for {name}",
+			"actions.newSession.aria": "New session in {name}",
+			"actions.pin": "Pin",
+			"actions.unpin": "Unpin",
+			"status.running": "Running",
+			"status.subagentsRunning.one": "{n} subagent running",
+			"status.subagentsRunning.other": "{n} subagents running",
+			"status.idle": "Idle",
+			"status.waitingApproval": "Waiting for approval",
+			"status.planReview": "Plan awaiting review",
+			"status.waitingAnswer": "Waiting for answer",
+			"status.completed": "Completed",
+			"hover.created": "Created {time}",
+			"hover.copied": "Copied",
+			"date.ymd": "{y}-{m}-{d}",
+			"time.now": "now",
+			"time.minutes": "{n}min",
+			"time.hours": "{n}h",
+			"time.days": "{n}d",
+			"time.months": "{n}mo",
+			"time.years": "{n}y",
+			"time.ago": "{t} ago"
+		};
+		//#endregion
+		//#region lib/types/client/index.js
+		/** Dictionary namespace owned by this plugin. */
+		const NS = "workspace";
+		/**
+		* Required services (cordis fiber inject). The target slots are declared by
+		* the ui-sidebar / ui-conversation applies, whose activation order relative
+		* to this one is NOT constrained: qilin.client.inject edges are informational
+		* (loading/prefetch metadata, never apply sequencing) and neither owner
+		* provides a waitable service. apply therefore depends on each slot
+		* declaration through `slots.inject()` instead of assuming order.
+		*/
+		const inject = [
+			"slots",
+			"sessions",
+			"workspaces",
+			"locale",
+			"remote",
+			"remote.directoryPicker",
+			"remote.agentPresets",
+			"workbench",
+			"layout",
+			"shortcuts"
+		];
+		/**
+		* Register the browser and picker once their slot declarations are on the
+		* ledger. Inject factories return plain callbacks; data reads use the
+		* framework's global hooks.
+		* @param ctx - client root context.
+		*/
+		function apply(ctx) {
+			const sessions = ctx.get("sessions");
+			const workspaces = ctx.get("workspaces");
+			const workbench = ctx.get("workbench");
+			const viewHandle = createWorkspaceViewStore();
+			const viewInstance = viewHandle.create();
+			const viewStore = {
+				...viewHandle,
+				create: () => viewInstance
+			};
+			const uiWorkspace = new UiWorkspaceService(ctx, ctx.remote.directoryPicker, ctx.remote.agentPresets, workbench, workspaces, sessions, viewInstance.actions);
+			ctx.slots.provideRoot({ hooks: { workspaces: workspaces.list } });
+			ctx.effect(() => ctx.locale.register(NS, {
+				zh,
+				en
+			}), "ui-workspace: dictionaries");
+			const shortcutControls = createWorkspaceShortcutControls();
+			const onWorkbenchSwitch = (tag) => {
+				workbench.setActive(tag);
+				uiWorkspace.rebindBlanksAfterTagSwitch();
+			};
+			const searchSessions = async (query, signal) => {
+				const result = await sessions.search(query, signal);
+				if (!result.ok) throw new Error(result.error.message);
+				return result.value;
+			};
+			const flowSource = (hole) => ({
+				getSnapshot: () => ctx.slots.entries(hole).length > 0,
+				subscribe: (listener) => ctx.slots.subscribe(hole, listener)
+			});
+			const browserFlowSource = flowSource("sidebar.workspaces.directoryFlow");
+			const hostInfo = {
+				getSnapshot: () => ctx.remote.$host,
+				subscribe: (listener) => ctx.on("connection/reset", listener)
+			};
+			const pickerFlowSource = flowSource("conversation.hero.workspace.directoryFlow");
+			const openSession = (sessionId) => {
+				uiWorkspace.openSession(sessionId);
+			};
+			const browserInjected = () => ({
+				startSession: (workspaceId) => {
+					uiWorkspace.startSession(workspaceId);
+				},
+				open: openSession,
+				searchSessions,
+				searchResultLimit: sessions.searchResultLimit,
+				renameSession: async (sessionId, title) => {
+					const result = await sessions.using(sessionId, { source: "workspaceOperation" }, (reference) => reference.binding.session.rename(title));
+					if (!result.ok) throw new Error(result.error.message);
+				},
+				forkSession: (sessionId) => {
+					uiWorkspace.forkSession(sessionId).catch(() => {});
+				},
+				renameWorkspace: async (workspaceId, title) => {
+					await workspaces.rename(workspaceId, title);
+				},
+				deleteWorkspace: async (workspaceId) => {
+					await workspaces.delete(workspaceId);
+				},
+				insertWorkspaceBefore: async (workspaceId, beforeWorkspaceId) => {
+					await workspaces.insertBefore(workspaceId, beforeWorkspaceId);
+				},
+				archiveSession: async (sessionId) => {
+					await uiWorkspace.archiveSession(sessionId);
+				},
+				pinSession: (sessionId) => uiWorkspace.pinSession(sessionId),
+				unpinSession: (sessionId) => uiWorkspace.unpinSession(sessionId),
+				createWorkspace: (input) => workspaces.create(input),
+				requestSearch: shortcutControls.search,
+				requestAddWorkspace: shortcutControls.add,
+				closeAddWorkspace: shortcutControls.closeAdd,
+				closeRenameRequest: shortcutControls.closeRename,
+				setDirectoryBusy: shortcutControls.directoryBusy,
+				hooks: {
+					directoryFlow: browserFlowSource,
+					hostInfo,
+					workspaceShortcuts: shortcutControls.state,
+					shortcuts: ctx.shortcuts.catalog
+				}
+			});
+			installWorkspaceShortcuts(ctx, uiWorkspace, shortcutControls, (sessionId) => {
+				uiWorkspace.archiveSession(sessionId);
+			});
+			const pickerInjected = () => ({
+				createWorkspace: (input) => workspaces.create(input),
+				hooks: { directoryFlow: pickerFlowSource }
+			});
+			ctx.slots.inject("sidebar.workbench", () => ctx.slots.register({
+				name: "sidebar.workbench",
+				inject: () => ({
+					hooks: { workbench: workbench.state },
+					onWorkbenchSwitch
+				}),
+				locale: NS
+			}, WorkbenchSwitchSeat));
+			ctx.slots.inject("sidebar.workspaces", () => ctx.slots.register({
+				name: "sidebar.workspaces",
+				children: {
+					"sidebar.workspaces.directoryFlow": {
+						kind: "single",
+						scope: "root"
+					},
+					"sidebar.session.row.leading": {
+						kind: "list",
+						scope: "root"
+					},
+					"sidebar.session.row.hover": {
+						kind: "list",
+						scope: "root"
+					}
+				},
+				store: viewStore,
+				inject: browserInjected,
+				locale: NS
+			}, WorkspaceBrowser));
+			ctx.slots.inject("conversation.hero.workspace", () => ctx.slots.register({
+				name: "conversation.hero.workspace",
+				children: { "conversation.hero.workspace.directoryFlow": {
+					kind: "single",
+					scope: "root"
+				} },
+				inject: pickerInjected,
+				locale: NS
+			}, WorkspacePicker));
+			const rosterStore = (0, _qilin_agent_client_store.createSnapshotStore)({
+				status: "idle",
+				presets: []
+			});
+			let rosterGeneration = 0;
+			const loadRoster = () => {
+				const generation = ++rosterGeneration;
+				ctx.remote.agentPresets.list().then((result) => {
+					if (generation !== rosterGeneration) return;
+					if (!result.ok && result.error.code === "gateway/invocation-unavailable") {
+						rosterStore.set({
+							status: "ready",
+							presets: []
+						});
+						return;
+					}
+					if (!result.ok) {
+						rosterStore.set({
+							status: "failed",
+							presets: []
+						});
+						return;
+					}
+					rosterStore.set({
+						status: "ready",
+						presets: result.value.presets.filter((preset) => preset.broken === void 0).map((preset) => ({
+							id: preset.id,
+							...preset.name === void 0 ? {} : { name: preset.name },
+							...preset.description === void 0 ? {} : { description: preset.description }
+						}))
+					});
+				}).catch(() => {
+					if (generation === rosterGeneration) rosterStore.set({
+						status: "failed",
+						presets: []
+					});
+				});
+			};
+			ctx.effect(() => {
+				loadRoster();
+				return ctx.on("connection/reset", loadRoster);
+			}, "ui-workspace: preset roster refresh");
+			const pickPreset = (presetId) => {
+				workbench.setPresetFor(workbench.state.getSnapshot().active, presetId);
+				uiWorkspace.adoptBlankSessionPreset(presetId);
+			};
+			ctx.slots.inject("conversation.hero.agentPreset", () => ctx.slots.register({
+				name: "conversation.hero.agentPreset",
+				priority: -1,
+				inject: () => ({
+					hooks: {
+						workbench: workbench.state,
+						roster: rosterStore
+					},
+					tagChoices: (tag) => workbench.tagChoices(tag),
+					pick: pickPreset
+				}),
+				locale: NS
+			}, AgentPresetChip));
+		}
+		//#endregion
+		exports.apply = apply;
+		exports.inject = inject;
+		return module.exports;
+	}
+});
+
+//# sourceMappingURL=client.js.map