dsh-vscode-mode 0.13.1 → 0.14.1

package/lib/client.js

@@ -8942,7 +8942,13 @@ window.__ModuleLoader__.load({
 			/** 规则面板 UI 状态（RulesPanel v1：Tab 与项目工作区选择，全局不按会话）。 */
 			rules: "edrv.rules.v1.",
 			/** SVN 变更面板 UI 状态（SvnPanel v1：未版本控制/忽略项显示开关，按作用域隔离）。 */
-			svn: "edrv.svn.v1."
+			svn: "edrv.svn.v1.",
+			/** Markdown 预览态（EditorView v1：处于预览态的 Markdown 路径集合，按作用域隔离）。 */
+			mdPreview: "edrv.md-preview.v1.",
+			/** 官方侧边栏「文件编辑」Tab 展开/激活态（officialSidebar v1：重启后自动回到编辑 Tab）。 */
+			editorTab: "edrv.editor-tab.v1.",
+			/** 编辑器导航历史双栈（navStateCache v1：重启后前进/后退与当前位置仍在，按作用域隔离）。 */
+			navHistory: "edrv.nav-history.v1."
 		};
 		//#endregion
 		//#region src/client/state/viewStateCache.ts
@@ -9048,6 +9054,654 @@ window.__ModuleLoader__.load({
 				window.localStorage.setItem(KEY_PREFIX$4 + String(scope), serializeViewStates(states));
 			} catch (error) {}
 		}
+		/**
+		* 归一化预览态路径表：丢弃非字符串/空串、去重（保留首次出现顺序），超限截断。
+		* @author ddj 2026年09月28号
+		* @param value 待归一化的解析产物（任意输入，非数组 → 空表）
+		* @returns 路径数组
+		*/
+		function normalizeMdPreview(value) {
+			if (!Array.isArray(value)) return [];
+			const out = [];
+			for (const item of value) {
+				if (typeof item !== "string" || !item) continue;
+				if (out.includes(item)) continue;
+				out.push(item);
+				if (out.length >= 50) break;
+			}
+			return out;
+		}
+		/**
+		* 解析存档文本（空/损坏/非数组 → 空表）。
+		* @author ddj 2026年09月28号
+		* @param text localStorage 原文
+		* @returns 路径数组
+		*/
+		function parseMdPreview(text) {
+			if (!text) return [];
+			try {
+				return normalizeMdPreview(JSON.parse(text));
+			} catch (error) {
+				return [];
+			}
+		}
+		/**
+		* 读某作用域处于预览态的 Markdown 路径集合。
+		* @author ddj 2026年09月28号
+		* @param scope 作用域键（scopeStore.workspaceScopeOf 产物）
+		* @returns 预览态路径集合（存储不可用/无存档 → 空集）
+		*/
+		function mdPreviewLoad(scope) {
+			try {
+				return new Set(parseMdPreview(localStorage.getItem(CACHE_KEY.mdPreview + scope)));
+			} catch (error) {
+				return /* @__PURE__ */ new Set();
+			}
+		}
+		/**
+		* 写某作用域的预览态集合（空集删除键，避免残留空数组）。
+		* @author ddj 2026年09月28号
+		* @param scope 作用域键
+		* @param paths 预览态路径集合
+		*/
+		function mdPreviewSave(scope, paths) {
+			try {
+				const list = normalizeMdPreview(Array.from(paths));
+				if (!list.length) {
+					localStorage.removeItem(CACHE_KEY.mdPreview + scope);
+					return;
+				}
+				localStorage.setItem(CACHE_KEY.mdPreview + scope, JSON.stringify(list));
+			} catch (error) {}
+		}
+		//#endregion
+		//#region src/client/sessionScope.ts
+		/** 对象窄化（非对象返回 undefined，供后续安全取字段）。 */
+		function asRecord(value) {
+			return value && typeof value === "object" ? value : void 0;
+		}
+		/** 非空字符串取值（其他类型一律视为缺失）。 */
+		function strOf(value) {
+			return typeof value === "string" && value ? value : void 0;
+		}
+		/**
+		* 从 `uiSession.current` 快照读出 sessionId。
+		* 兼容两种形态：绑定源本身（`{ key }`）与其包裹形态（`{ value: { key } }`）——
+		* 官方 `createBindingSource` 的 `getSnapshot()` 返回绑定值本身，但跨版本包裹层存在差异，
+		* 故两者都尝试。
+		* @author ddj 2026年09月18号
+		* @param snapshot `uiSession.current` 的 `getSnapshot()` 结果（任意形状）
+		* @returns sessionId，或 undefined
+		*/
+		function uiSessionIdOf(snapshot) {
+			const binding = asRecord(snapshot);
+			if (!binding) return void 0;
+			return strOf(binding.key) ?? strOf(asRecord(binding.value)?.key);
+		}
+		/**
+		* 从 `sessions.list` 快照读出 sessionId。
+		* 先取旧版 `current`；缺失时回退 `byId` 中 `retainedBy.mainView > 0` 的首行
+		* （与官方 ui-session 的 publishMain 同判据，故新版行为与官方视图一致）。
+		* @author ddj 2026年09月18号
+		* @param list `sessions.list` 的 `getSnapshot()` 结果（任意形状）
+		* @returns sessionId，或 undefined
+		*/
+		function listSessionId(list) {
+			const snap = asRecord(list);
+			if (!snap) return void 0;
+			const current = strOf(snap.current);
+			if (current) return current;
+			const byId = asRecord(snap.byId);
+			if (!byId) return void 0;
+			for (const [id, row] of Object.entries(byId)) {
+				const mainView = asRecord(asRecord(row)?.retainedBy)?.mainView;
+				if (typeof mainView === "number" && mainView > 0) return id;
+			}
+		}
+		/**
+		* 三级取值链（纯函数）：决定当前会话 id 与其 cwd。
+		* 优先级 uiSession > list.current > list.byId.retainedBy > fallback。
+		* @author ddj 2026年09月18号
+		* @param sources 候选来源集合
+		* @returns 会话作用域（字段缺失即省略该键，不写 undefined 占位）
+		*/
+		function pickSessionScope(sources) {
+			const sessionId = uiSessionIdOf(sources.uiSession) ?? listSessionId(sources.list) ?? strOf(sources.fallbackSessionId);
+			if (!sessionId) return {};
+			const cwd = strOf(asRecord(asRecord(asRecord(sources.list)?.byId)?.[sessionId])?.cwd);
+			return cwd ? {
+				sessionId,
+				cwd
+			} : { sessionId };
+		}
+		/** 读 `ctx.get(name)`（缺失/异常返回 undefined，不抛错）。 */
+		function safeGet(ctx, name) {
+			try {
+				return ctx.get(name);
+			} catch {
+				return;
+			}
+		}
+		/** 取 `uiSession.current` 快照（服务或订阅面缺失时返回 undefined）。 */
+		function uiCurrentSnapshot(ctx) {
+			const current = asRecord(asRecord(safeGet(ctx, "uiSession"))?.current);
+			const getSnapshot = current?.getSnapshot;
+			if (typeof getSnapshot !== "function") return void 0;
+			try {
+				return getSnapshot.call(current);
+			} catch {
+				return;
+			}
+		}
+		/** 取 `sessions.list` 快照（服务缺失时返回 undefined）。 */
+		function listSnapshot(ctx) {
+			const list = asRecord(asRecord(safeGet(ctx, "sessions"))?.list);
+			const getSnapshot = list?.getSnapshot;
+			if (typeof getSnapshot !== "function") return void 0;
+			try {
+				return getSnapshot.call(list);
+			} catch {
+				return;
+			}
+		}
+		/**
+		* 读当前会话作用域（服务面取值 + 三级链）。
+		* @author ddj 2026年09月18号
+		* @param ctx 客户端根上下文（只需 `get`）
+		* @param fallbackSessionId 槽位注入的 sessionId（可选）
+		* @returns 会话作用域
+		*/
+		function readSessionScope(ctx, fallbackSessionId) {
+			return pickSessionScope({
+				uiSession: uiCurrentSnapshot(ctx),
+				list: listSnapshot(ctx),
+				fallbackSessionId
+			});
+		}
+		/**
+		* 订阅会话切换（同时挂 `uiSession.current` 与新/旧 `sessions.list`）。
+		* 旧版无 `uiSession`，新版 `list` 不再变（切会话只动 uiSession），故两条都要挂；
+		* 回调可能因两条源先后触发而重复，调用方按上一次 sessionId 自行去重。
+		* @author ddj 2026年09月18号
+		* @param ctx 客户端根上下文（只需 `get`）
+		* @param listener 变更回调
+		* @returns 取消订阅函数（幂等）
+		*/
+		function subscribeScope(ctx, listener) {
+			const disposers = [];
+			const attach = (owner) => {
+				const subscribe = asRecord(owner)?.subscribe;
+				if (typeof subscribe !== "function") return;
+				try {
+					const disposer = subscribe.call(owner, listener);
+					if (typeof disposer === "function") disposers.push(disposer);
+				} catch {}
+			};
+			attach(asRecord(asRecord(safeGet(ctx, "uiSession"))?.current));
+			attach(asRecord(asRecord(safeGet(ctx, "sessions"))?.list));
+			return () => {
+				for (const disposer of disposers.splice(0)) try {
+					disposer();
+				} catch {}
+			};
+		}
+		//#endregion
+		//#region src/client/state/uiStatePersist.ts
+		/**
+		* dsh-vscode-mode client — 界面状态镜像（把 `edrv.*` 的 localStorage 状态写穿到 host）。
+		*
+		* 背景：Web GUI 的 origin（含端口）每次启动可能变化，而 localStorage 按 origin 分区，
+		* 于是页签/侧栏/预览态等状态「重启就忘」。本模块包装 localStorage 写口：
+		* 只拦 `edrv.` 前缀键（跳过镜像自身标记键与派生条目缓存，见 `SKIP_PREFIX`），400ms 去抖后
+		* 增量上送 `edrv.uiState.set`：按体积分批，整批被拒则逐键回退，避免个别超大键拖垮同批。
+		* 启动（含换 origin）后 `edrv.uiState.get` 水合，仅填本地缺失的键（本地优先，绝不覆盖）；
+		* 首次搬运标记只在整批落盘成功后写入（失败则下次加载重试）。
+		* 全局键（不随工作区变化）走 globals 分区，其余按键原值搬进工作区分区。
+		*
+		* 降级：存储不可用/包装失败/host 读写失败/超限一律静默退回纯 localStorage（诊断日志留痕）。
+		* 纯逻辑与依赖注入分离，`createUiStateMirror` 可在 node 环境单测。
+		* 作者 ddj 2026-09-28
+		*/
+		/** 参与镜像的键前缀（只拦插件自己的键，不碰其他插件的 localStorage）。 */
+		const MIRROR_PREFIX = "edrv.";
+		/** 首次回填标记键（把既有 `edrv.*` 状态一次性推给 host；自身不参与镜像）。 */
+		const SEEDED_KEY = "edrv.uistate.v1.seeded";
+		/** 水合完成事件名（换 origin 回填后广播，供界面重跑恢复逻辑）。 */
+		const READY_EVENT = "edrv:ui-state-ready";
+		/** 全局键（不随工作区变化，落用户级镜像文件）。 */
+		const GLOBAL_EXACT = ["edrv.debug", CACHE_KEY.sideHint];
+		/** 全局键前缀（不随工作区变化）。 */
+		const GLOBAL_PREFIX = [CACHE_KEY.workspaceFold];
+		/** 单次上送的字节上限（host 单文件上限 512KB；分批避免个别超大键拖垮整批）。 */
+		const CHUNK_BYTES = 65536;
+		/** 不参与镜像的派生缓存前缀（目录条目 SWR 缓存可达数百 KB，且 host 侧 tree.v1.json 已覆盖同类信息）。 */
+		const SKIP_PREFIX = [CACHE_KEY.entries];
+		/**
+		* 是否参与镜像（`edrv.` 前缀且非标记键）。
+		* @author ddj 2026年09月28号
+		* @param key localStorage 键
+		* @returns 是否镜像
+		*/
+		function isMirroredKey(key) {
+			if (!key.startsWith(MIRROR_PREFIX) || key === "edrv.uistate.v1.seeded") return false;
+			return !SKIP_PREFIX.some((prefix) => key.startsWith(prefix));
+		}
+		/**
+		* 是否全局键（不随工作区变化）。
+		* @author ddj 2026年09月28号
+		* @param key localStorage 键
+		* @returns 是否全局键
+		*/
+		function isGlobalKey(key) {
+			if (GLOBAL_EXACT.includes(key)) return true;
+			return GLOBAL_PREFIX.some((prefix) => key.startsWith(prefix));
+		}
+		/**
+		* 收集本地全部镜像键（存储不可读 → 空数组）。
+		* @author ddj 2026年09月28号
+		* @param storage localStorage 替身
+		* @returns 镜像键清单
+		*/
+		function localMirrorKeys(storage) {
+			const keys = [];
+			try {
+				for (let index = 0; index < storage.length; index++) {
+					const key = storage.key(index);
+					if (key && isMirroredKey(key)) keys.push(key);
+				}
+			} catch (error) {}
+			return keys;
+		}
+		/**
+		* 按键值体积切分补丁（单键超限则独占一批，仍由 host 容量上限裁决）。
+		* @author ddj 2026年09月29号
+		* @param patch 待上送补丁
+		* @param limit 单批体积上限（字节；按字符数近似）
+		* @returns 批次数组（空补丁 → 空数组）
+		*/
+		function chunkPatch(patch, limit = CHUNK_BYTES) {
+			const chunks = [];
+			let current = {};
+			let size = 0;
+			for (const [key, value] of Object.entries(patch)) {
+				const cost = key.length + (value === null ? 0 : value.length);
+				if (size > 0 && size + cost > limit) {
+					chunks.push(current);
+					current = {};
+					size = 0;
+				}
+				current[key] = value;
+				size += cost;
+			}
+			if (size > 0) chunks.push(current);
+			return chunks;
+		}
+		/**
+		* 创建界面状态镜像实例。
+		* @author ddj 2026年09月28号
+		* @param deps 依赖（存储/上送/取回/调度）
+		* @returns 镜像实例
+		*/
+		function createUiStateMirror(deps) {
+			const { storage } = deps;
+			const schedule = deps.schedule ?? ((fn, ms) => setTimeout(fn, ms));
+			const cancel = deps.cancel ?? ((handle) => clearTimeout(handle));
+			const log = deps.log ?? (() => {});
+			const report = deps.report ?? ((text, level) => log(text));
+			const pending = {
+				keys: {},
+				globals: {}
+			};
+			let timer = null;
+			let inflight = null;
+			let suppressed = 0;
+			let done = false;
+			let installed = false;
+			let lastError = "";
+			/** 水合尝试次数（失败重试；超过 `HYDRATE_RETRY_MAX` 放弃并解禁）。 */
+			let attempts = 0;
+			let settleDone = false;
+			/** 记入待推送批次并安排去抖上送（水合期间或非镜像键 → 跳过）。 */
+			function queue(key, value) {
+				if (suppressed > 0 || !isMirroredKey(key)) return;
+				const bucket = isGlobalKey(key) ? pending.globals : pending.keys;
+				bucket[key] = value;
+				if (timer !== null) cancel(timer);
+				timer = schedule(() => {
+					timer = null;
+					flush();
+				}, 400);
+			}
+			/** 上送一批补丁（失败重试一次）。 */
+			async function pushBatch(payload) {
+				for (let attempt = 0; attempt < 2; attempt++) try {
+					await deps.push(payload, deps.sessionIdOf?.());
+					return true;
+				} catch (error) {
+					lastError = String(error);
+				}
+				return false;
+			}
+			/** 逐键回退上送（整批被拒后用，避免个别大键拖垮同批其它键），返回丢弃键数。 */
+			async function pushEach(bucket, asGlobal) {
+				let lost = 0;
+				for (const [key, value] of Object.entries(bucket)) {
+					if (await pushBatch(asGlobal ? { globals: { [key]: value } } : { keys: { [key]: value } })) continue;
+					lost++;
+					log("界面状态镜像上送失败（已丢弃 " + key + "）: " + lastError);
+				}
+				return lost;
+			}
+			/** 分区上送：按体积分批，整批被拒则逐键回退，返回最终丢弃的键数。 */
+			async function pushBucket(bucket, asGlobal) {
+				let lost = 0;
+				for (const chunk of chunkPatch(bucket, deps.chunkBytes)) if (!await pushBatch(asGlobal ? { globals: chunk } : { keys: chunk })) lost += await pushEach(chunk, asGlobal);
+				return lost;
+			}
+			/** 立即上送待推送批次（空批次不请求；与在途上送串行），返回最终丢弃的键数。 */
+			async function flush() {
+				if (inflight) await inflight.catch(() => {});
+				if (timer !== null) {
+					cancel(timer);
+					timer = null;
+				}
+				const keys = pending.keys;
+				const globals = pending.globals;
+				const hasKeys = Object.keys(keys).length > 0;
+				const hasGlobals = Object.keys(globals).length > 0;
+				if (!hasKeys && !hasGlobals) return 0;
+				pending.keys = {};
+				pending.globals = {};
+				const run = (async () => {
+					let lost = 0;
+					if (hasKeys) lost += await pushBucket(keys, false);
+					if (hasGlobals) lost += await pushBucket(globals, true);
+					return lost;
+				})();
+				inflight = run.then(() => {}, () => {});
+				return run;
+			}
+			/** 回填本地缺失键（本地已有值一律保留）。 */
+			function applyHydration(snapshot) {
+				let filled = 0;
+				suppressed++;
+				try {
+					const all = {
+						...snapshot.globals,
+						...snapshot.keys
+					};
+					for (const [key, value] of Object.entries(all)) {
+						if (!isMirroredKey(key) || typeof value !== "string") continue;
+						if (storage.getItem(key) !== null) continue;
+						storage.setItem(key, value);
+						filled++;
+						report("回填键 " + key + "（" + value.length + " 字符）");
+					}
+				} catch (error) {
+					log("界面状态回填写入失败: " + String(error));
+				} finally {
+					suppressed--;
+				}
+				return filled;
+			}
+			/** 首次运行时把既有本地状态一次性推给 host（只入队；成功后才落标记，避免失败后永不重试）。 */
+			function seedLocal() {
+				try {
+					if (storage.getItem("edrv.uistate.v1.seeded") === "1") return 0;
+					const keys = localMirrorKeys(storage);
+					for (const key of keys) queue(key, storage.getItem(key));
+					return keys.length;
+				} catch (error) {
+					log("界面状态首次搬运失败: " + String(error));
+					return 0;
+				}
+			}
+			/** 落首次搬运标记（仅在本批全部落盘成功后调用；写失败下次加载重搬，幂等）。 */
+			function markSeeded() {
+				try {
+					storage.setItem(SEEDED_KEY, "1");
+				} catch (error) {}
+			}
+			/** 广播水合完成事件（无 window 环境静默）。 */
+			function emitReady() {
+				try {
+					if (typeof window !== "undefined") window.dispatchEvent(new Event(READY_EVENT));
+				} catch (error) {}
+			}
+			/**
+			* 结束水合阶段（成功或重试耗尽）：解禁界面落盘，并广播就绪事件让恢复逻辑补跑一次。
+			* 冷启动早期会话未就绪时 `edrv.uiState.get` 会返回「会话不存在」，故本阶段必须可重试；
+			* 未结束前界面不得写存档，否则空初值会覆盖 host 上的真实状态。
+			*/
+			function settle() {
+				if (settleDone) return;
+				settleDone = true;
+				emitReady();
+				report("水合阶段结束（就绪；" + (done ? "已回填" : "未回填，退回纯 localStorage") + "）");
+			}
+			/**
+			* 取回 host 镜像并回填本地缺失键；失败按 `HYDRATE_RETRY_MS` 重试，超限则结束水合阶段。
+			* @returns 本次回填键数（失败/重试中为 0）
+			*/
+			async function hydrate() {
+				try {
+					report("水合开始（origin=" + originOf() + "，第 " + (attempts + 1) + " 次）");
+					const snapshot = await deps.fetch(deps.sessionIdOf?.());
+					const seeded = seedLocal();
+					const filled = applyHydration(snapshot);
+					const stored = Object.keys({
+						...snapshot.globals,
+						...snapshot.keys
+					}).length;
+					done = true;
+					report("水合完成：host 镜像 " + stored + " 键、本地搬运 " + seeded + " 键、回填 " + filled + " 键");
+					if (seeded > 0) {
+						const lost = await flush();
+						report("首次搬运输送完成：丢弃 " + lost + " 键");
+						if (lost === 0) markSeeded();
+					}
+					settle();
+					return filled;
+				} catch (error) {
+					attempts++;
+					if (attempts < 8) {
+						report("水合失败（第 " + attempts + " 次，800ms 后重试）: " + String(error), "warn");
+						schedule(() => {
+							hydrate();
+						}, 800);
+						return 0;
+					}
+					report("水合放弃（重试 " + attempts + " 次仍失败）: " + String(error), "warn");
+					settle();
+					return 0;
+				}
+			}
+			return {
+				install() {
+					if (installed) return true;
+					try {
+						const proto = Object.getPrototypeOf(storage);
+						const rawSet = proto?.setItem;
+						const rawRemove = proto?.removeItem;
+						if (typeof rawSet !== "function" || typeof rawRemove !== "function") return false;
+						storage.setItem = function(key, value) {
+							rawSet.call(storage, key, value);
+							queue(String(key), String(value));
+						};
+						storage.removeItem = function(key) {
+							rawRemove.call(storage, key);
+							queue(String(key), null);
+						};
+						installed = true;
+						report("镜像已包装 localStorage 写口");
+						return true;
+					} catch (error) {
+						report("界面状态镜像包装失败（退回纯 localStorage）: " + String(error), "warn");
+						return false;
+					}
+				},
+				hydrate,
+				flush,
+				hydrated() {
+					return done;
+				},
+				settled() {
+					return settleDone;
+				}
+			};
+		}
+		/** 单例镜像（installUiStatePersist 幂等：HMR 重挂不重复包装）。 */
+		let singleton = null;
+		/** 是否已回填过（晚到的订阅者据此立即执行）。 */
+		let uiReady = false;
+		/** 无门控上报出口（由 installUiStatePersist 注入；未装配时静默）。 */
+		let reporter = null;
+		/** 在途水合（供 apply 等待，尽量让回填先于界面挂载）。 */
+		let hydrating = null;
+		/** 当前页面 origin（无 location 环境返回 '?'）。 */
+		function originOf() {
+			try {
+				if (typeof location !== "undefined" && location.origin) return location.origin;
+			} catch (error) {}
+			return "?";
+		}
+		/**
+		* 上报界面状态镜像事件（无门控：绕过客户端 debug 开关，直接落 host 诊断日志）。
+		* @author ddj 2026年09月29号
+		* @param text 事件文本
+		* @param level 日志级别（缺省 'debug'）
+		*/
+		function reportUiStateEvent(text, level) {
+			try {
+				reporter?.(text, level);
+			} catch (error) {}
+		}
+		/**
+		* 触发（或加入）一次水合并等待结果：让界面挂载前尽量拿到回填值；水合阶段已结束则返回 0。
+		* @author ddj 2026年09月29号
+		* @returns 本次回填键数
+		*/
+		async function hydrateUiState() {
+			if (!singleton || singleton.settled()) return 0;
+			if (hydrating) return hydrating;
+			return singleton.hydrate();
+		}
+		/**
+		* 水合阶段是否已结束（未结束时界面不得写存档：空初值会覆盖 host 上的真实状态）。
+		* @author ddj 2026年09月29号
+		* @returns 是否已结束（未装配视为已结束，退回纯 localStorage 行为）
+		*/
+		function uiStateSettled() {
+			return singleton ? singleton.settled() : true;
+		}
+		/** 读浏览器 localStorage（不可用 → null）。 */
+		function readLocalStorage() {
+			try {
+				if (typeof localStorage === "undefined") return null;
+				return localStorage;
+			} catch (error) {
+				return null;
+			}
+		}
+		/** 上送镜像（host 返回 ok:false 视为失败，触发内部重试）。 */
+		async function pushViaRpc(payload, sessionId) {
+			const res = await rpc("edrv.uiState.set", {
+				sessionId,
+				keys: payload.keys,
+				globals: payload.globals
+			});
+			if (!res.ok) throw new Error(res.error);
+		}
+		/** 取回镜像。 */
+		async function fetchViaRpc(sessionId) {
+			const res = await rpc("edrv.uiState.get", { sessionId });
+			if (!res.ok) throw new Error(res.error);
+			return {
+				keys: res.keys,
+				globals: res.globals
+			};
+		}
+		/**
+		* 安装界面状态镜像（幂等）：包装 localStorage 写口并触发一次回填。
+		* @author ddj 2026年09月28号
+		* @param ctx 客户端根上下文（只需 `get`，用于解析当前会话）
+		* @param schedule 去抖调度（客户端 apply 提供的 ctx.timeout 包装）
+		* @param report 无门控上报（缺省静默；传入后所有镜像事件绕过 debug 开关落 host 日志）
+		* @returns 是否安装成功（存储不可用 → false，功能退回纯 localStorage）
+		*/
+		function installUiStatePersist(ctx, schedule, report) {
+			if (singleton) return true;
+			if (report) reporter = report;
+			const storage = readLocalStorage();
+			if (!storage) {
+				reportUiStateEvent("镜像安装失败：localStorage 不可用", "warn");
+				return false;
+			}
+			const sessionIdOf = () => readSessionScope(ctx).sessionId;
+			const mirror = createUiStateMirror({
+				storage,
+				push: pushViaRpc,
+				fetch: fetchViaRpc,
+				sessionIdOf,
+				schedule,
+				report: (text, level) => reportUiStateEvent(text, level),
+				log: (text) => {
+					try {
+						dbg(sessionIdOf(), "ui-state: " + text, "warn");
+					} catch (error) {}
+				}
+			});
+			if (!mirror.install()) {
+				reportUiStateEvent("镜像安装失败：localStorage 写口无法包装", "warn");
+				return false;
+			}
+			singleton = mirror;
+			try {
+				if (typeof window !== "undefined") window.addEventListener("pagehide", () => {
+					mirror.flush();
+				});
+			} catch (error) {}
+			hydrating = mirror.hydrate().then((filled) => {
+				if (filled > 0 || mirror.settled()) uiReady = true;
+				return filled;
+			});
+			hydrating.finally(() => {
+				if (mirror.settled()) {
+					uiReady = true;
+					hydrating = null;
+				}
+			});
+			return true;
+		}
+		/**
+		* 订阅「界面状态回填完成」（已回填过则立即执行一次）。
+		* @author ddj 2026年09月28号
+		* @param listener 回调
+		* @returns 取消订阅函数（幂等）
+		*/
+		function onUiStateReady(listener) {
+			if (typeof window === "undefined") {
+				if (uiReady) listener();
+				return () => {};
+			}
+			if (uiReady) {
+				listener();
+				return () => {};
+			}
+			const handler = () => {
+				listener();
+			};
+			window.addEventListener(READY_EVENT, handler);
+			return () => window.removeEventListener(READY_EVENT, handler);
+		}
+		/**
+		* 立即上送待推送批次（卸载/隐藏前调用，尽量少丢最后一次改动）。
+		* @author ddj 2026年09月28号
+		* @returns 上送完成
+		*/
+		async function flushUiState() {
+			if (singleton) await singleton.flush();
+		}
 		//#endregion
 		//#region src/client/state/scopeStore.ts
 		/**
@@ -9273,6 +9927,27 @@ window.__ModuleLoader__.load({
 		function getSidebarMinWidth() {
 			return currentMin;
 		}
+		/**
+		* 归一化条目数组：丢弃无路径项；line/column 仅保留正整数，剥掉 viewState（体积大且另有存档）；
+		* 超限时保留末尾（最近的）cap 条。
+		* @author ddj 2026年09月28号
+		* @param entries 待归一化的原始数组（非数组 → 空表）
+		* @param cap 单栈上限（默认 NAV_PERSIST_CAP）
+		* @returns 归一化条目数组
+		*/
+		function cleanNavEntries(entries, cap = 30) {
+			if (!Array.isArray(entries)) return [];
+			const out = [];
+			for (const raw of entries) {
+				const entry = raw;
+				if (!entry || typeof entry.path !== "string" || !entry.path) continue;
+				const item = { path: entry.path };
+				if (typeof entry.line === "number" && Number.isInteger(entry.line) && entry.line > 0) item.line = entry.line;
+				if (typeof entry.column === "number" && Number.isInteger(entry.column) && entry.column > 0) item.column = entry.column;
+				out.push(item);
+			}
+			return out.length > cap ? out.slice(out.length - cap) : out;
+		}
 		/** scope → 导航历史实例（同工作区跨会话复用同一份历史）。 */
 		const scopeHistories = /* @__PURE__ */ new Map();
 		/** 路径一致（容忍相对路径大小写差异，对齐既有 sameFile 语义常用写法）。 */
@@ -9335,6 +10010,19 @@ window.__ModuleLoader__.load({
 				},
 				peekForward() {
 					return future.length ? future[future.length - 1] : null;
+				},
+				snapshot() {
+					return {
+						past: past.map((entry) => ({ ...entry })),
+						future: future.map((entry) => ({ ...entry }))
+					};
+				},
+				restore(state) {
+					if (!state) return;
+					past.length = 0;
+					future.length = 0;
+					past.push(...cleanNavEntries(state.past, cap));
+					future.push(...cleanNavEntries(state.future, cap));
 				}
 			};
 		}
@@ -9358,6 +10046,79 @@ window.__ModuleLoader__.load({
 			}
 			return created;
 		}
+		/**
+		* 序列化双栈（空栈 → 空串，调用方据此删键）。
+		* @author ddj 2026年09月28号
+		* @param state 双栈快照（null/undefined → 空串）
+		* @returns 存档文本
+		*/
+		function serializeNavState(state) {
+			if (!state) return "";
+			const past = cleanNavEntries(state.past, 30);
+			const future = cleanNavEntries(state.future, 30);
+			if (!past.length && !future.length) return "";
+			return JSON.stringify({
+				v: 1,
+				past,
+				future
+			});
+		}
+		/**
+		* 解析存档文本（空/损坏/版本不符/无可恢复条目 → null）。
+		* @author ddj 2026年09月28号
+		* @param text localStorage 原文
+		* @returns 双栈快照
+		*/
+		function parseNavState(text) {
+			if (!text) return null;
+			try {
+				const value = JSON.parse(text);
+				if (!value || typeof value !== "object" || value.v !== 1) return null;
+				const past = cleanNavEntries(value.past, 30);
+				const future = cleanNavEntries(value.future, 30);
+				if (!past.length && !future.length) return null;
+				return {
+					past,
+					future
+				};
+			} catch (error) {
+				return null;
+			}
+		}
+		/** scope → 最近写入的原文（去重写：光标移动触发的快照大多与上次相同）。 */
+		const lastWritten = /* @__PURE__ */ new Map();
+		/**
+		* 读某作用域的导航历史存档。
+		* @author ddj 2026年09月28号
+		* @param scope 作用域键（scopeStore.workspaceScopeOf 产物）
+		* @returns 双栈快照（无存档/存储不可用 → null）
+		*/
+		function navStateLoad(scope) {
+			try {
+				return parseNavState(localStorage.getItem(CACHE_KEY.navHistory + scope));
+			} catch (error) {
+				return null;
+			}
+		}
+		/**
+		* 写某作用域的导航历史存档（空存档删键；原文未变跳过写入）。
+		* @author ddj 2026年09月28号
+		* @param scope 作用域键
+		* @param state 双栈快照（null → 删除存档）
+		*/
+		function navStateSave(scope, state) {
+			try {
+				const text = serializeNavState(state);
+				if (lastWritten.get(scope) === text) return;
+				lastWritten.set(scope, text);
+				const key = CACHE_KEY.navHistory + scope;
+				if (!text) {
+					localStorage.removeItem(key);
+					return;
+				}
+				localStorage.setItem(key, text);
+			} catch (error) {}
+		}
 		//#endregion
 		//#region src/client/addToConversation.ts
 		/**
@@ -14806,6 +15567,57 @@ window.__ModuleLoader__.load({
 		let editorTabActive = false;
 		/** 正文挂载纪元（每次挂载自增；延迟判定期间有新挂载则放弃清除）。 */
 		let mountEpoch = 0;
+		/** 作用域解析器（index.ts 装配时注入；未注入则不落盘，退回纯内存标记）。 */
+		let tabScopeOf = null;
+		/**
+		* 注入编辑 Tab 状态的作用域解析器（index.ts 装配一次；键跟随会话/工作区切换）。
+		* @author ddj 2026年09月28号
+		* @param resolve 返回工作区作用域键（scopeStore.workspaceScopeOf 产物）
+		*/
+		function setEditorTabScope(resolve) {
+			tabScopeOf = resolve;
+		}
+		/**
+		* 编辑 Tab 状态的作用域键（未注入/解析失败 → 空串，调用方跳过持久化）。
+		* @author ddj 2026年09月28号
+		* @returns localStorage 键
+		*/
+		function editorTabKey() {
+			if (!tabScopeOf) return "";
+			try {
+				const scope = tabScopeOf();
+				return scope ? CACHE_KEY.editorTab + scope : "";
+			} catch (error) {
+				return "";
+			}
+		}
+		/**
+		* 读回「上次退出时编辑 Tab 是否处于激活态」（供冷启动自动展开编辑 Tab）。
+		* @author ddj 2026年09月28号
+		* @returns 是否曾被激活（存储不可用/未注入 → false）
+		*/
+		function readSavedTab() {
+			const key = editorTabKey();
+			if (!key) return false;
+			try {
+				return localStorage.getItem(key) === "1";
+			} catch (error) {
+				return false;
+			}
+		}
+		/**
+		* 持久化编辑 Tab 激活态（存储不可用静默；镜像层会把它写穿到 host 跨重启保留）。
+		* @author ddj 2026年09月28号
+		* @param active 是否激活
+		*/
+		function saveTabActive(active) {
+			const key = editorTabKey();
+			if (!key) return;
+			try {
+				if (active) localStorage.setItem(key, "1");
+				else localStorage.removeItem(key);
+			} catch (error) {}
+		}
 		/**
 		* 标记编辑 Tab 激活并推进挂载纪元（正文挂载时调用）。
 		* @author ddj 2026年09月09号
@@ -14816,11 +15628,13 @@ window.__ModuleLoader__.load({
 		}
 		/**
 		* 直接设置激活标记（正文卸载延迟判定用；测试 also 用作状态编排入口）。
-		* @author ddj 2026年09月09号
+		* 同时写穿到 localStorage（镜像层负责跨重启保留），供下次冷启动恢复。
+		* @author ddj 2026年09月09号 / 2026年09月28号
 		* @param active 是否激活
 		*/
 		function markEditorActive(active) {
 			editorTabActive = active;
+			saveTabActive(active);
 		}
 		/**
 		* 读编辑 Tab 激活标记（会话切换时决定是否自动恢复编辑栏）。
@@ -19019,6 +19833,7 @@ window.__ModuleLoader__.load({
 			const loadSeqRef = react.default.useRef(0);
 			const programmaticRef = react.default.useRef(false);
 			const restoredScopeRef = react.default.useRef(null);
+			const [hydrateTick, setHydrateTick] = react.default.useState(0);
 			const pendingFocusRef = react.default.useRef(null);
 			const navFlashRef = react.default.useRef([]);
 			const navFlashTimerRef = react.default.useRef(null);
@@ -20043,6 +20858,7 @@ window.__ModuleLoader__.load({
 				restoredScopeRef.current = scope;
 				modelsRef.current = modelsForScope(scope);
 				viewStatesRef.current = viewStatesLoad(scope);
+				mdPreviewRef.current = mdPreviewLoad(String(scope));
 				try {
 					const raw = localStorage.getItem(CACHE_KEY.editor + String(scope)) ?? localStorage.getItem(CACHE_KEY.editorLegacy + String(scope));
 					if (raw) {
@@ -20058,21 +20874,51 @@ window.__ModuleLoader__.load({
 							const kept = plan.length ? restored.filter((tab) => !dropped.has(tab.path)) : restored;
 							setTabs(kept);
 							setActive(kept.some((tab) => tab.path === activePath) ? activePath : kept[0]?.path ?? null);
-						}
-					}
-				} catch (e) {}
-			}, [sessionId, scope]);
+							reportUiStateEvent("页签恢复（scope=" + String(scope) + "）：存档 " + restored.length + " 个、保留 " + kept.length + " 个、活动 " + String(activePath));
+						} else reportUiStateEvent("页签恢复（scope=" + String(scope) + "）：存档非空但归一化后为 0 个");
+					} else reportUiStateEvent("页签恢复（scope=" + String(scope) + "）：localStorage 无存档");
+				} catch (e) {
+					reportUiStateEvent("页签恢复失败（scope=" + String(scope) + "）: " + String(e), "warn");
+				}
+			}, [
+				sessionId,
+				scope,
+				hydrateTick
+			]);
+			react.default.useEffect(() => onUiStateReady(() => {
+				if (tabsRef.current.length) return;
+				restoredScopeRef.current = null;
+				setHydrateTick((v) => v + 1);
+			}), []);
 			react.default.useEffect(() => {
-				navRef.current = navHistoryFor(scope);
+				const history = navHistoryFor(scope);
+				const current = history.snapshot();
+				if (!current.past.length && !current.future.length) {
+					const saved = navStateLoad(String(scope));
+					if (saved) history.restore(saved);
+					reportUiStateEvent("导航历史恢复（scope=" + String(scope) + "）：" + (saved ? "past=" + saved.past.length + " future=" + saved.future.length : "localStorage 无存档"));
+				}
+				navRef.current = history;
 				navPendingRef.current = null;
 				if (navCursorTimerRef.current) {
 					clearTimeout(navCursorTimerRef.current);
 					navCursorTimerRef.current = null;
 				}
 				setNavTick((v) => v + 1);
-			}, [scope]);
+			}, [scope, hydrateTick]);
 			react.default.useEffect(() => {
-				if (!sessionId) return;
+				if (!sessionId || !uiStateSettled()) return;
+				navStateSave(String(scope), navRef.current?.snapshot?.() ?? null);
+			}, [
+				navTick,
+				cursor,
+				active,
+				sessionId,
+				scope,
+				hydrateTick
+			]);
+			react.default.useEffect(() => {
+				if (!sessionId || !uiStateSettled()) return;
 				try {
 					const payload = {
 						tabs: tabs.map((t) => t.pinned ? {
@@ -20087,7 +20933,8 @@ window.__ModuleLoader__.load({
 				tabs,
 				active,
 				sessionId,
-				scope
+				scope,
+				hydrateTick
 			]);
 			/**
 			* 标记页签为「最近使用」（LRU 序号单调递增；编辑动作也算使用，见 onEdit）。
@@ -20133,9 +20980,16 @@ window.__ModuleLoader__.load({
 						if (typeof saved.on === "boolean") setSidebarOn(saved.on);
 						if (typeof saved.width === "number") setSidebarW(Math.max(getSidebarMinWidth(), Math.min(560, saved.width)));
 						if (typeof saved.panel === "string") setActivePanel(saved.panel);
-					}
-				} catch (e) {}
-			}, [sessionId, sidebarKey]);
+						reportUiStateEvent("侧栏恢复（键 " + sidebarKey + "）：on=" + String(saved.on) + " width=" + String(saved.width) + " panel=" + String(saved.panel));
+					} else reportUiStateEvent("侧栏恢复（键 " + sidebarKey + "）：localStorage 无存档");
+				} catch (e) {
+					reportUiStateEvent("侧栏恢复失败（键 " + sidebarKey + "）: " + String(e), "warn");
+				}
+			}, [
+				sessionId,
+				sidebarKey,
+				hydrateTick
+			]);
 			const [sidebarMinW, setSidebarMinW] = react.default.useState(() => getSidebarMinWidth());
 			react.default.useEffect(() => {
 				const onMinChange = () => {
@@ -20146,7 +21000,7 @@ window.__ModuleLoader__.load({
 				return () => window.removeEventListener("edrv:sidebar-min-width", onMinChange);
 			}, []);
 			react.default.useEffect(() => {
-				if (!sessionId) return;
+				if (!sessionId || !uiStateSettled()) return;
 				try {
 					localStorage.setItem(sidebarKey, JSON.stringify({
 						on: sidebarOn,
@@ -20159,7 +21013,8 @@ window.__ModuleLoader__.load({
 				sidebarW,
 				activePanel,
 				sessionId,
-				sidebarKey
+				sidebarKey,
+				hydrateTick
 			]);
 			/**
 			* 打开搜索面板（Ctrl+Shift+F 与命令栏「在工作区中搜索」的唯一动作）。
@@ -20798,6 +21653,7 @@ window.__ModuleLoader__.load({
 			react.default.useEffect(() => () => {
 				flushSave();
 				flushNavCursor();
+				navStateSave(String(scope), navRef.current?.snapshot?.() ?? null);
 				saveViewStateRef.current?.();
 				diffRendererRef.current?.dispose?.();
 				if (navFlashTimerRef.current) {
@@ -21353,6 +22209,7 @@ window.__ModuleLoader__.load({
 					next.add(path);
 				} else next.delete(path);
 				mdPreviewRef.current = next;
+				mdPreviewSave(String(scope), next);
 				setStatus(entering ? "已切换为 Markdown 预览" : "已切换为源码编辑");
 			};
 			toggleMdPreviewRef.current = toggleMdPreview;
@@ -26990,137 +27847,6 @@ window.__ModuleLoader__.load({
 			});
 		}
 		//#endregion
-		//#region src/client/sessionScope.ts
-		/** 对象窄化（非对象返回 undefined，供后续安全取字段）。 */
-		function asRecord(value) {
-			return value && typeof value === "object" ? value : void 0;
-		}
-		/** 非空字符串取值（其他类型一律视为缺失）。 */
-		function strOf(value) {
-			return typeof value === "string" && value ? value : void 0;
-		}
-		/**
-		* 从 `uiSession.current` 快照读出 sessionId。
-		* 兼容两种形态：绑定源本身（`{ key }`）与其包裹形态（`{ value: { key } }`）——
-		* 官方 `createBindingSource` 的 `getSnapshot()` 返回绑定值本身，但跨版本包裹层存在差异，
-		* 故两者都尝试。
-		* @author ddj 2026年09月18号
-		* @param snapshot `uiSession.current` 的 `getSnapshot()` 结果（任意形状）
-		* @returns sessionId，或 undefined
-		*/
-		function uiSessionIdOf(snapshot) {
-			const binding = asRecord(snapshot);
-			if (!binding) return void 0;
-			return strOf(binding.key) ?? strOf(asRecord(binding.value)?.key);
-		}
-		/**
-		* 从 `sessions.list` 快照读出 sessionId。
-		* 先取旧版 `current`；缺失时回退 `byId` 中 `retainedBy.mainView > 0` 的首行
-		* （与官方 ui-session 的 publishMain 同判据，故新版行为与官方视图一致）。
-		* @author ddj 2026年09月18号
-		* @param list `sessions.list` 的 `getSnapshot()` 结果（任意形状）
-		* @returns sessionId，或 undefined
-		*/
-		function listSessionId(list) {
-			const snap = asRecord(list);
-			if (!snap) return void 0;
-			const current = strOf(snap.current);
-			if (current) return current;
-			const byId = asRecord(snap.byId);
-			if (!byId) return void 0;
-			for (const [id, row] of Object.entries(byId)) {
-				const mainView = asRecord(asRecord(row)?.retainedBy)?.mainView;
-				if (typeof mainView === "number" && mainView > 0) return id;
-			}
-		}
-		/**
-		* 三级取值链（纯函数）：决定当前会话 id 与其 cwd。
-		* 优先级 uiSession > list.current > list.byId.retainedBy > fallback。
-		* @author ddj 2026年09月18号
-		* @param sources 候选来源集合
-		* @returns 会话作用域（字段缺失即省略该键，不写 undefined 占位）
-		*/
-		function pickSessionScope(sources) {
-			const sessionId = uiSessionIdOf(sources.uiSession) ?? listSessionId(sources.list) ?? strOf(sources.fallbackSessionId);
-			if (!sessionId) return {};
-			const cwd = strOf(asRecord(asRecord(asRecord(sources.list)?.byId)?.[sessionId])?.cwd);
-			return cwd ? {
-				sessionId,
-				cwd
-			} : { sessionId };
-		}
-		/** 读 `ctx.get(name)`（缺失/异常返回 undefined，不抛错）。 */
-		function safeGet(ctx, name) {
-			try {
-				return ctx.get(name);
-			} catch {
-				return;
-			}
-		}
-		/** 取 `uiSession.current` 快照（服务或订阅面缺失时返回 undefined）。 */
-		function uiCurrentSnapshot(ctx) {
-			const current = asRecord(asRecord(safeGet(ctx, "uiSession"))?.current);
-			const getSnapshot = current?.getSnapshot;
-			if (typeof getSnapshot !== "function") return void 0;
-			try {
-				return getSnapshot.call(current);
-			} catch {
-				return;
-			}
-		}
-		/** 取 `sessions.list` 快照（服务缺失时返回 undefined）。 */
-		function listSnapshot(ctx) {
-			const list = asRecord(asRecord(safeGet(ctx, "sessions"))?.list);
-			const getSnapshot = list?.getSnapshot;
-			if (typeof getSnapshot !== "function") return void 0;
-			try {
-				return getSnapshot.call(list);
-			} catch {
-				return;
-			}
-		}
-		/**
-		* 读当前会话作用域（服务面取值 + 三级链）。
-		* @author ddj 2026年09月18号
-		* @param ctx 客户端根上下文（只需 `get`）
-		* @param fallbackSessionId 槽位注入的 sessionId（可选）
-		* @returns 会话作用域
-		*/
-		function readSessionScope(ctx, fallbackSessionId) {
-			return pickSessionScope({
-				uiSession: uiCurrentSnapshot(ctx),
-				list: listSnapshot(ctx),
-				fallbackSessionId
-			});
-		}
-		/**
-		* 订阅会话切换（同时挂 `uiSession.current` 与新/旧 `sessions.list`）。
-		* 旧版无 `uiSession`，新版 `list` 不再变（切会话只动 uiSession），故两条都要挂；
-		* 回调可能因两条源先后触发而重复，调用方按上一次 sessionId 自行去重。
-		* @author ddj 2026年09月18号
-		* @param ctx 客户端根上下文（只需 `get`）
-		* @param listener 变更回调
-		* @returns 取消订阅函数（幂等）
-		*/
-		function subscribeScope(ctx, listener) {
-			const disposers = [];
-			const attach = (owner) => {
-				const subscribe = asRecord(owner)?.subscribe;
-				if (typeof subscribe !== "function") return;
-				try {
-					const disposer = subscribe.call(owner, listener);
-					if (typeof disposer === "function") disposers.push(disposer);
-				} catch {}
-			};
-			attach(asRecord(asRecord(safeGet(ctx, "uiSession"))?.current));
-			attach(asRecord(asRecord(safeGet(ctx, "sessions"))?.list));
-			return () => {
-				for (const disposer of disposers.splice(0)) try {
-					disposer();
-				} catch {}
-			};
-		}
-		//#endregion
 		//#region src/client/ui/OfficialSideTab.ts
 		/**
 		* dsh-vscode-mode client — OfficialSideTab：DSH 官方右侧 Sidebar「文件编辑」页签正文包装。
@@ -32928,8 +33654,40 @@ window.__ModuleLoader__.load({
 		* @author ddj 2026年08月20号
 		* @param ctx 客户端根上下文（slots + timer 服务）
 		*/
-		function apply(ctx) {
+		async function apply(ctx) {
 			const schedule = (fn, ms) => ctx.timeout(fn, ms);
+			/**
+			* 无门控上报界面状态镜像事件（绕过客户端 edrv.debug 开关，直接落 host 诊断日志）。
+			* 开关关闭时 dbg 直接 return，「重启后没恢复」这类问题会在客户端侧彻底无痕，故另开一条通路。
+			* @author ddj 2026年09月29号
+			* @param text 事件文本
+			* @param level 日志级别（缺省 'debug'）
+			*/
+			const reportMirror = (text, level) => {
+				const lv = level === "info" || level === "warn" || level === "error" ? level : "debug";
+				try {
+					rpc("edrv.debug", {
+						sessionId: readSessionScope(ctx).sessionId,
+						text: "ui-state: " + text,
+						level: lv
+					}).catch(() => {});
+				} catch (error) {}
+			};
+			if (installUiStatePersist(ctx, schedule, reportMirror)) {
+				reportMirror("镜像装配成功（origin=" + (typeof location === "undefined" ? "?" : location.origin) + "）");
+				log.info("界面状态镜像已装配：界面状态随 host 持久化（重启/换端口可恢复）");
+			} else {
+				reportMirror("镜像装配失败：localStorage 不可用", "warn");
+				log.warn("界面状态镜像不可用（无 localStorage）：界面状态仅存当前 origin");
+			}
+			if (readSessionScope(ctx).sessionId) try {
+				await Promise.race([hydrateUiState(), new Promise((resolve) => {
+					schedule(() => resolve(), 600);
+				})]);
+			} catch (error) {}
+			ctx.effect(() => () => {
+				flushUiState();
+			}, "vscode-mode: ui state flush");
 			ctx.effect(() => {
 				let disposed = false;
 				let attempts = 0;
@@ -33306,6 +34064,19 @@ window.__ModuleLoader__.load({
 					return;
 				}
 				officialDisposer = ctx.effect(() => outcome, "vscode-mode: official sidebar editor tab");
+				setEditorTabScope(() => {
+					const scope = readSessionScope(ctx);
+					return workspaceScopeOf(scope.cwd, scope.sessionId);
+				});
+				const restoreActiveTab = () => {
+					const saved = readSavedTab();
+					const active = isEditorTabActive();
+					reportUiStateEvent("编辑 Tab 恢复：本地存档=" + String(saved) + "、当前激活=" + String(active));
+					if (!active && saved) markEditorActive(true);
+					restoreEditorTab(official.service, schedule);
+				};
+				restoreActiveTab();
+				ctx.effect(() => onUiStateReady(restoreActiveTab), "vscode-mode: editor tab state hydration");
 				if (typeof official.service.openResource === "function") {
 					ctx.effect(() => registry.register(officialSidebarOpener(official.service)), "vscode-mode: official sidebar opener");
 					ctx.effect(() => {
@@ -33440,6 +34211,15 @@ window.__ModuleLoader__.load({
 					resetNativeOpen();
 				} catch {}
 			}, "vscode-mode: monaco providers teardown");
+			ctx.effect(() => subscribeScope(ctx, () => {
+				if (!uiStateSettled()) hydrateUiState();
+			}), "vscode-mode: ui state rehydrate");
+			try {
+				await Promise.race([hydrateUiState(), new Promise((resolve) => {
+					schedule(() => resolve(), 1200);
+				})]);
+			} catch (error) {}
+			reportUiStateEvent("客户端装配完成：水合" + (uiStateSettled() ? "已结束" : "仍在进行（界面稍后重跑恢复）"));
 		}
 		//#endregion
 		exports.apply = apply;