dsh-vscode-mode 0.1.59 → 0.1.61

package/src/client/state/explorerEntriesCache.ts

@@ -1,6 +1,6 @@
 /**
  * dsh-vscode-mode client — 资源管理栏目录条目缓存（SWR：旧数据即时渲染 + 后台刷新）。
- * 与 explorerCache（展开状态持久化）互补：本文件只缓存目录条目数据，键按会话隔离。
+ * 与 explorerCache（展开状态持久化）互补：本文件只缓存目录条目数据，键按工作区作用域隔离。
  * 纯函数（序列化/解析/裁剪）导出可单测；内存镜像 Map 同步读避免每次渲染 parse
  * localStorage，落盘 300ms 防抖；配额满/隐私模式 try/catch 降级纯内存。
  * 作者 ddj 2026-08-31
@@ -78,9 +78,9 @@ export function entriesParse(text: string | null): EntriesCacheData | null {
 }
 
 // --region 内存镜像 + 防抖落盘
-/** sessionId → 缓存镜像（同步读，避免每次渲染 parse）。 */
+/** scope → 缓存镜像（同步读，避免每次渲染 parse）。 */
 const mirrors = new Map<string, EntriesCacheData>()
-/** sessionId → 落盘防抖计时器。 */
+/** scope → 落盘防抖计时器。 */
 const saveTimers = new Map<string, ReturnType<typeof setTimeout>>()
 /** 单调时钟：连续 put 的 ts 严格递增（同毫秒不并列，逐出顺序可预期）。 */
 let clock = 0
@@ -92,38 +92,38 @@ function nextTs(): number {
 }
 
 /** localStorage 读取（不可用 → null）。 */
-function readRaw(sessionId: string): string | null {
+function readRaw(scope: string): string | null {
   try {
-    return window.localStorage.getItem(KEY_PREFIX + sessionId)
+    return window.localStorage.getItem(KEY_PREFIX + scope)
   } catch (error) {
     return null
   }
 }
 
 /** localStorage 写入（配额/隐私模式失败静默）。 */
-function writeRaw(sessionId: string, text: string): void {
+function writeRaw(scope: string, text: string): void {
   try {
-    window.localStorage.setItem(KEY_PREFIX + sessionId, text)
+    window.localStorage.setItem(KEY_PREFIX + scope, text)
   } catch (error) { /* 配额满/隐私模式忽略 */ }
 }
 
-/** 取（或建）会话缓存镜像。 */
-function mirrorOf(sessionId: string): EntriesCacheData {
-  const existing = mirrors.get(sessionId)
+/** 取（或建）作用域缓存镜像。 */
+function mirrorOf(scope: string): EntriesCacheData {
+  const existing = mirrors.get(scope)
   if (existing) return existing
-  const data = entriesParse(readRaw(sessionId)) ?? { v: 2, root: null, dirs: {} }
-  mirrors.set(sessionId, data)
+  const data = entriesParse(readRaw(scope)) ?? { v: 2, root: null, dirs: {} }
+  mirrors.set(scope, data)
   return data
 }
 
 /** 调度防抖落盘（重置已有计时器）。 */
-function scheduleSave(sessionId: string): void {
-  const prev = saveTimers.get(sessionId)
+function scheduleSave(scope: string): void {
+  const prev = saveTimers.get(scope)
   if (prev) clearTimeout(prev)
-  saveTimers.set(sessionId, setTimeout(() => {
-    saveTimers.delete(sessionId)
-    const data = mirrors.get(sessionId)
-    if (data) writeRaw(sessionId, entriesSerialize(entriesTrim(data)))
+  saveTimers.set(scope, setTimeout(() => {
+    saveTimers.delete(scope)
+    const data = mirrors.get(scope)
+    if (data) writeRaw(scope, entriesSerialize(entriesTrim(data)))
   }, CACHE_SAVE_DEBOUNCE_MS))
 }
 // --endregion
@@ -131,13 +131,13 @@ function scheduleSave(sessionId: string): void {
 /**
  * 读某目录缓存条目（无 → null；展示不受新鲜度限制）。
  * @author ddj 2026年08月31号
- * @param sessionId 会话 id
+ * @param scope 作用域键（scopeStore.workspaceScopeOf 产物）
  * @param rel 目录相对路径（'' = 根）
  * @returns 缓存条目或 null
  */
-export function entriesCacheGet(sessionId: string | undefined, rel: string): TreeEntry[] | null {
-  if (!sessionId) return null
-  const dir = mirrorOf(sessionId).dirs[rel]
+export function entriesCacheGet(scope: string | undefined, rel: string): TreeEntry[] | null {
+  if (!scope) return null
+  const dir = mirrorOf(scope).dirs[rel]
   if (!dir || !dir.entries.length) return null
   return dir.entries
 }
@@ -145,28 +145,28 @@ export function entriesCacheGet(sessionId: string | undefined, rel: string): Tre
 /**
  * 某目录缓存是否新鲜（预取去重用）。
  * @author ddj 2026年08月31号
- * @param sessionId 会话 id
+ * @param scope 作用域键（scopeStore.workspaceScopeOf 产物）
  * @param rel 目录相对路径
  * @returns 新鲜返回 true
  */
-export function entriesCacheIsFresh(sessionId: string | undefined, rel: string): boolean {
-  if (!sessionId) return false
-  const dir = mirrorOf(sessionId).dirs[rel]
+export function entriesCacheIsFresh(scope: string | undefined, rel: string): boolean {
+  if (!scope) return false
+  const dir = mirrorOf(scope).dirs[rel]
   return Boolean(dir && Date.now() - dir.ts < CACHE_FRESH_MS)
 }
 
 /**
  * 写入某目录缓存条目（内存镜像 + 防抖落盘；单目录条目截断）。
  * @author ddj 2026年08月31号
- * @param sessionId 会话 id
+ * @param scope 作用域键（scopeStore.workspaceScopeOf 产物）
  * @param rel 目录相对路径
  * @param entries 目录条目
  */
-export function entriesCachePut(sessionId: string | undefined, rel: string, entries: TreeEntry[]): void {
-  if (!sessionId) return
-  const data = mirrorOf(sessionId)
+export function entriesCachePut(scope: string | undefined, rel: string, entries: TreeEntry[]): void {
+  if (!scope) return
+  const data = mirrorOf(scope)
   data.dirs[rel] = { ts: nextTs(), entries: entries.slice(0, CACHE_DIR_ENTRIES) }
   const trimmed = entriesTrim(data)
   data.dirs = trimmed.dirs
-  scheduleSave(sessionId)
+  scheduleSave(scope)
 }

package/src/client/state/modelCache.ts

@@ -0,0 +1,77 @@
+/**
+ * dsh-vscode-mode client — Monaco model 跨挂载缓存（按工作区作用域）。
+ * 编辑区每会话重挂载会销毁实例，但文件 model（内容）与工作区绑定：
+ * 按作用域把 model 缓存在模块级，重挂载后 loadContent 命中缓存同步种出内容，
+ * 消除切换对话时的加载闪烁。切换作用域时释放上一作用域未附着编辑器的模型
+ * （附着中的仅移出缓存，交由编辑器自身生命周期，防正在显示的模型被销毁）。
+ * 纯对象容器逻辑，不依赖 monaco，可单测。
+ * 作者 ddj 2026-09-09
+ */
+
+// --region 常量与状态
+
+/** 单作用域缓存上限（超出按写入序逐出最旧，近似 LRU）。 */
+export const MODEL_CACHE_CAP = 40
+
+/** scope →（path → model）缓存表。 */
+const caches = new Map<string, Map<string, unknown>>()
+/** 当前激活作用域（切换时释放上一个）。 */
+let activeScope: string | null = null
+// --endregion
+
+/** 模型是否仍附着在某个编辑器实例上（缺方法视为未附着）。 */
+function isAttached(model: unknown): boolean {
+  const fn = (model as { isAttachedToEditor?: () => boolean } | null)?.isAttachedToEditor
+  return typeof fn === 'function' ? fn.call(model) === true : false
+}
+
+/** 释放模型（仅未附着编辑器时真正 dispose；附着中的保留给编辑器自毁）。 */
+function disposeIfFree(model: unknown): void {
+  if (!model || isAttached(model)) return
+  try { (model as { dispose: () => void }).dispose() } catch { /* 已释放/异常忽略 */ }
+}
+
+/**
+ * 取（或切）某作用域的 model 缓存：同作用域重复调用复用同一 Map（跨挂载存活）；
+ * 作用域变化时释放上一作用域的模型（未附着的 dispose，附着中的仅移出缓存）。
+ * @author ddj 2026年09月09号
+ * @param scope 作用域键（scopeStore.workspaceScopeOf 产物）
+ * @returns 该作用域的 path → model Map
+ */
+export function modelsForScope(scope: string): Map<string, unknown> {
+  const existing = caches.get(scope)
+  if (existing && activeScope === scope) return existing
+  if (activeScope !== null && activeScope !== scope) {
+    const prev = caches.get(activeScope)
+    if (prev) {
+      for (const model of prev.values()) disposeIfFree(model)
+      prev.clear()
+      caches.delete(activeScope)
+    }
+  }
+  activeScope = scope
+  if (existing) return existing
+  const map = new Map<string, unknown>()
+  caches.set(scope, map)
+  return map
+}
+
+/**
+ * 记入模型并刷新 LRU 序（先删后插保证最新），超上限逐出最旧（未附着才 dispose）。
+ * @author ddj 2026年09月09号
+ * @param map 作用域缓存 Map
+ * @param path 工作区相对路径
+ * @param model Monaco model（或测试桩）
+ */
+export function rememberModel(map: Map<string, unknown>, path: string, model: unknown): void {
+  if (!path || !model) return
+  map.delete(path)
+  map.set(path, model)
+  while (map.size > MODEL_CACHE_CAP) {
+    const oldest = map.keys().next().value
+    if (oldest === undefined) break
+    const evicted = map.get(oldest)
+    map.delete(oldest)
+    disposeIfFree(evicted)
+  }
+}

package/src/client/state/scopeStore.ts

@@ -0,0 +1,96 @@
+/**
+ * dsh-vscode-mode client — 编辑区状态作用域键（scope key）。
+ * 编辑区 UI 状态（页签/展开树/视图状态/侧边栏等）按「工作区」隔离：同一工作区下
+ * 切换对话恢复同一份状态，无体感差别；会话没有 cwd 时回退按会话隔离（旧行为）。
+ * 另提供旧「会话键」数据到「工作区键」的一次性迁移（只复制不删除，幂等）。
+ * 键前缀统一走 paths.ts PathConst（CACHE_KEY），本模块只产出拼接用的作用域串。
+ * 作者 ddj 2026-09-09
+ */
+import { CACHE_KEY } from '../paths.js'
+
+// --region 归一化与作用域键
+
+/** Windows 盘符绝对路径（如 D:/ 或 d:\），大小写不敏感。 */
+const WIN_DRIVE_RE = /^[a-z]:\//i
+
+/**
+ * 归一化工作区路径：trim、反斜杠→斜杠、去尾部斜杠；
+ * Windows 盘符绝对路径整体小写（文件系统大小写不敏感），POSIX 路径保留大小写。
+ * @author ddj 2026年09月09号
+ * @param cwd 工作区目录（sessions 快照 byId[sessionId].cwd）
+ * @returns 归一化路径；空值返回 ''
+ */
+export function normalizeWsPath(cwd: string | undefined | null): string {
+  const s = String(cwd ?? '').trim().replace(/\\/g, '/').replace(/\/+$/, '')
+  if (!s) return ''
+  return WIN_DRIVE_RE.test(s) ? s.toLowerCase() : s
+}
+
+/**
+ * 计算编辑区状态作用域键：有 cwd → 'ws:' + 归一化路径（同工作区共享）；
+ * 无 cwd → 'sid:' + sessionId（回退按会话隔离，对齐旧行为）。
+ * @author ddj 2026年09月09号
+ * @param cwd 工作区目录（可为 null/undefined）
+ * @param sessionId 会话 id（cwd 缺失时的隔离键）
+ * @returns 作用域键字符串
+ */
+export function workspaceScopeOf(cwd: string | undefined | null, sessionId: string | undefined): string {
+  const ws = normalizeWsPath(cwd)
+  if (ws) return 'ws:' + ws
+  return 'sid:' + String(sessionId ?? '')
+}
+// --endregion
+
+// --region 旧会话键迁移
+
+/** 参与迁移的 localStorage 键前缀（编辑区全部按会话持久化的旧键）。 */
+const MIGRATE_PREFIXES: readonly string[] = [
+  CACHE_KEY.editor,
+  CACHE_KEY.viewstate,
+  CACHE_KEY.sidebar + 'side.',
+  CACHE_KEY.sidebar,
+  CACHE_KEY.search,
+  CACHE_KEY.expanded,
+  CACHE_KEY.entries,
+]
+
+/** 已迁移过的 scope+sessionId 组合（按 storage 实例分组；每页生命周期只跑一次）。 */
+const migratedPairs = new WeakMap<object, Set<string>>()
+
+/**
+ * 把旧「前缀+sessionId」键的数据一次性复制到「前缀+scope」键（目标已存在则跳过）。
+ * 只复制不删除旧键；幂等，可安全重复调用。升级后首个工作区键为空时兜底恢复旧数据。
+ * @author ddj 2026年09月09号
+ * @param scope 目标作用域键
+ * @param sessionId 旧数据所属会话 id
+ * @param storage localStorage 注入口（缺省 window.localStorage，测试可传内存桩）
+ */
+export function migrateScopedKeys(scope: string, sessionId: string | undefined, storage?: Storage): void {
+  if (!scope || !sessionId) return
+  let store: Storage | null = null
+  try {
+    store = storage ?? window.localStorage
+  } catch (error) {
+    return
+  }
+  if (!store) return
+  let pairs = migratedPairs.get(store)
+  if (!pairs) {
+    pairs = new Set()
+    migratedPairs.set(store, pairs)
+  }
+  const pair = scope + '|' + sessionId
+  if (pairs.has(pair)) return
+  pairs.add(pair)
+  const legacy = String(sessionId)
+  for (const prefix of MIGRATE_PREFIXES) {
+    const target = prefix + scope
+    try {
+      if (store.getItem(target) !== null) continue
+      const raw = store.getItem(prefix + legacy)
+      if (raw === null) continue
+      store.setItem(target, raw)
+    } catch (error) { /* 配额满/隐私模式忽略，不阻塞 */ }
+  }
+}
+// --endregion

package/src/client/state/viewStateCache.ts

@@ -7,7 +7,7 @@
  */
 import { CACHE_KEY } from '../paths.js'
 
-/** localStorage 键前缀（按会话隔离）。 */
+/** localStorage 键前缀（按工作区作用域隔离，无 cwd 会话回退会话键）。 */
 const KEY_PREFIX = CACHE_KEY.viewstate
 
 /** 视图状态条目容量上限。 */
@@ -95,27 +95,27 @@ export function upsertViewState(
 }
 
 /**
- * 读取某会话的视图状态缓存（localStorage 不可用 → 空映射）。
+ * 读取某作用域的视图状态缓存（localStorage 不可用 → 空映射）。
  * @author ddj 2026年08月28号
- * @param sessionId 会话 id
+ * @param scope 作用域键（scopeStore.workspaceScopeOf 产物）
  * @returns path → viewState 映射
  */
-export function viewStatesLoad(sessionId: string): Record<string, unknown> {
+export function viewStatesLoad(scope: string): Record<string, unknown> {
   try {
-    return parseViewStates(window.localStorage.getItem(KEY_PREFIX + String(sessionId))) ?? {}
+    return parseViewStates(window.localStorage.getItem(KEY_PREFIX + String(scope))) ?? {}
   } catch (error) {
     return {}
   }
 }
 
 /**
- * 写入某会话的视图状态缓存（损坏/配额满 → 忽略）。
+ * 写入某作用域的视图状态缓存（损坏/配额满 → 忽略）。
  * @author ddj 2026年08月28号
- * @param sessionId 会话 id
+ * @param scope 作用域键（scopeStore.workspaceScopeOf 产物）
  * @param states path → viewState 映射
  */
-export function viewStatesSave(sessionId: string, states: Record<string, unknown>): void {
+export function viewStatesSave(scope: string, states: Record<string, unknown>): void {
   try {
-    window.localStorage.setItem(KEY_PREFIX + String(sessionId), serializeViewStates(states))
+    window.localStorage.setItem(KEY_PREFIX + String(scope), serializeViewStates(states))
   } catch (error) { /* 配额满/隐私模式忽略 */ }
 }

package/src/client/ui/EditorView.ts

@@ -3,6 +3,8 @@
  * dsh-vscode-mode client — EditorView：中央 VSCode 式文件编辑器（编排层）。
  * 迁移自原 src/client/index.ts 的 EditorView，语义不改；差异自绘已抽到 monaco/diffRender。
  * 职责：页签/QuickOpen/Monaco 编辑器/差异审查（DiffBox/Launcher/Badge 事件装配）/状态栏/自动保存。
+ * 状态作用域：页签/视图状态/侧边栏/展开树等 UI 状态按工作区作用域（cwd）隔离，
+ * 同一工作区切换对话恢复同一份状态；无 cwd 会话回退按会话隔离（scopeStore）。
  * 作者 ddj 2026-08-20
  */
 import React from 'react'
@@ -25,9 +27,11 @@ import { editorHeight } from '../editorLayout.js'
 import { revealInExplorer as revealPathInExplorer } from '../fileReveal.js'
 import { setSidePending, SIDEBAR_INSTALL_CMD } from '../sidebarBridge.js'
 import { upsertViewState, viewStatesLoad, viewStatesSave } from '../state/viewStateCache.js'
+import { migrateScopedKeys, workspaceScopeOf } from '../state/scopeStore.js'
+import { modelsForScope, rememberModel } from '../state/modelCache.js'
 import { bindingsOf, chordOf, matchEvent, useKeybindingsVersion } from '../keybindings.js'
 import { getSidebarMinWidth } from '../sidebarMin.js'
-import { createNavHistory } from '../navHistory.js'
+import { navHistoryFor } from '../navHistory.js'
 import { statusOfAdd } from '../addToConversation.js'
 import { CACHE_KEY } from '../paths.js'
 import { bindLspEditor, runGoToDefinition, runFindReferences, hideReferencesOverlay } from '../monaco/lsp/providers.js'
@@ -49,6 +53,22 @@ export function EditorView(props) {
   const addToConversation = props.addToConversation
   const layout = props?.layout === 'side' ? 'side' : 'tab'
   const sideHint = props?.sideHint
+  // 当前会话工作区 cwd（sessions 快照反应式读取；cwd 变化时作用域跟随刷新）
+  const sessionsList = props?.sessions?.list
+  const cwd = React.useSyncExternalStore(
+    React.useCallback((onStoreChange) => (
+      typeof sessionsList?.subscribe === 'function' ? sessionsList.subscribe(onStoreChange) : () => {}
+    ), [sessionsList]),
+    () => sessionsList?.getSnapshot?.()?.byId?.[sessionId]?.cwd ?? null,
+    () => null,
+  )
+  // 状态作用域（scopeStore）：同工作区共享一份编辑区状态，无 cwd 回退会话隔离；
+  // 迁移放渲染期（useMemo）——子面板恢复 effect 先于父 effect 执行，须先补齐工作区键
+  const scope = React.useMemo(() => {
+    const s = workspaceScopeOf(cwd, sessionId)
+    migrateScopedKeys(s, sessionId)
+    return s
+  }, [cwd, sessionId])
   const [monaco, setMonaco] = React.useState(null)
   const [monacoErr, setMonacoErr] = React.useState(null)
   const [records, setRecords] = React.useState({})
@@ -93,17 +113,19 @@ export function EditorView(props) {
   const editorRef = React.useRef(null)
   const viewRootRef = React.useRef(null)
   const monacoRef = React.useRef(null)
-  const modelsRef = React.useRef(new Map())
+  const modelsRef = React.useRef(null)
+  // model 跨挂载缓存（按工作区作用域）：重挂载秒显内容，消除切换对话闪烁
+  if (!modelsRef.current) modelsRef.current = modelsForScope(scope)
   // 视图状态缓存（path → Monaco viewState；重启后恢复光标/滚动/折叠位置）
   const viewStatesRef = React.useRef({})
   const saveTimerRef = React.useRef(null)
   const loadSeqRef = React.useRef(0)
   const programmaticRef = React.useRef(false)
-  const bootRef = React.useRef(false)
+  const restoredScopeRef = React.useRef(null) // 已恢复状态的作用域（cwd 晚到 sid→ws 时允许重恢复）
   const pendingFocusRef = React.useRef(null) // { path, region } 内容加载后跳转
   // 导航历史（后退/前进）：跨文件焦点位置；按会话隔离，会话切换重置
   const navRef = React.useRef(null)
-  if (!navRef.current) navRef.current = createNavHistory()
+  if (!navRef.current) navRef.current = navHistoryFor(scope)
   const navPendingRef = React.useRef(null) // { path,line,column,viewState } 待恢复条目（内容就绪后消费）
   const navCursorTimerRef = React.useRef(null) // 光标位置防抖记录计时器
   const navBackRef = React.useRef(null) // 后退动作最新闭包（窗口级键盘监听读取）
@@ -120,6 +142,7 @@ export function EditorView(props) {
   const batchBusyRef = React.useRef(false) // 批量 Keep All/Undo All 防重入
   const menuHandlersRef = React.useRef(null) // 右键菜单动作的最新闭包（Monaco addAction 空依赖回调读取）
   const doSaveRef = React.useRef(null) // 保存动作的最新闭包（窗口级保存监听读取）
+  const saveViewStateRef = React.useRef(null) // 视图状态保存的最新闭包（卸载清理读取，避免过期 active）
   const diffRendererRef = React.useRef(null)
   const layoutRef = React.useRef(layout) // ensureEditor 空依赖闭包读取的稳定布局
   layoutRef.current = layout
@@ -163,7 +186,7 @@ export function EditorView(props) {
   }
 
   /**
-   * 保存当前活动文件的视图状态（光标/滚动/折叠）到会话缓存。
+   * 保存当前活动文件的视图状态（光标/滚动/折叠）到工作区作用域缓存。
    * @author ddj 2026年08月28号
    * @param path 要保存的文件路径（缺省 = 当前 active）
    */
@@ -175,9 +198,10 @@ export function EditorView(props) {
       const state = ed.saveViewState()
       if (!state) return
       viewStatesRef.current = upsertViewState(viewStatesRef.current, target, state)
-      viewStatesSave(sessionId, viewStatesRef.current)
+      viewStatesSave(scope, viewStatesRef.current)
     } catch (e) { /* 视图状态保存失败忽略 */ }
   }
+  saveViewStateRef.current = saveViewState
 
   /**
    * 恢复指定文件的视图状态（内容就绪、setModel 后调用；恢复后即消费删除）。
@@ -618,13 +642,15 @@ export function EditorView(props) {
     }
   }, [sessionId, layout])
 
-  // localStorage v2 恢复页签
+  // localStorage v2 恢复页签（按工作区作用域；cwd 晚到 sid→ws 切换时重恢复一次）
   React.useEffect(() => {
-    if (bootRef.current || !sessionId) return
-    bootRef.current = true
-    viewStatesRef.current = viewStatesLoad(sessionId)
+    if (!sessionId || restoredScopeRef.current === scope) return
+    restoredScopeRef.current = scope
+    // model 缓存跟随作用域（切工作区释放旧作用域模型；同工作区跨挂载复用）
+    modelsRef.current = modelsForScope(scope)
+    viewStatesRef.current = viewStatesLoad(scope)
     try {
-      const raw = localStorage.getItem(CACHE_KEY.editor + String(sessionId))
+      const raw = localStorage.getItem(CACHE_KEY.editor + String(scope))
       if (raw) {
         const saved = JSON.parse(raw)
         if (Array.isArray(saved.tabs) && saved.tabs.length) {
@@ -633,25 +659,25 @@ export function EditorView(props) {
         }
       }
     } catch (e) { /* 损坏忽略 */ }
-  }, [sessionId])
+  }, [sessionId, scope])
 
-  // 导航历史会话隔离：切换会话时重置（历史仅会话内存，不跨会话串扰）
+  // 导航历史按工作区作用域隔离：同工作区切换对话保留历史，跨工作区换实例
   React.useEffect(() => {
-    navRef.current = createNavHistory()
+    navRef.current = navHistoryFor(scope)
     navPendingRef.current = null
     if (navCursorTimerRef.current) { clearTimeout(navCursorTimerRef.current); navCursorTimerRef.current = null }
     setNavTick((v) => v + 1)
-  }, [sessionId])
+  }, [scope])
 
   React.useEffect(() => {
     if (!sessionId) return
-    try { localStorage.setItem(CACHE_KEY.editor + String(sessionId), JSON.stringify({ tabs: tabs.map((t) => t.path), active })) }
+    try { localStorage.setItem(CACHE_KEY.editor + String(scope), JSON.stringify({ tabs: tabs.map((t) => t.path), active })) }
     catch (e) { /* 忽略 */ }
-  }, [tabs, active, sessionId])
+  }, [tabs, active, sessionId, scope])
 
   // 侧边栏状态：恢复（显隐/宽度/激活面板）；侧栏形态独立键（默认收起，不共享页签形态偏好）
   // 宽度下限来自通用设置 sidebarMinWidth（默认 300），恢复值按其重夹
-  const sidebarKey = CACHE_KEY.sidebar + (layout === 'side' ? 'side.' : '') + String(sessionId)
+  const sidebarKey = CACHE_KEY.sidebar + (layout === 'side' ? 'side.' : '') + String(scope)
   React.useEffect(() => {
     if (!sessionId) return
     try {
@@ -682,7 +708,6 @@ export function EditorView(props) {
     try { localStorage.setItem(sidebarKey, JSON.stringify({ on: sidebarOn, width: sidebarW, panel: activePanel })) }
     catch (e) { /* 忽略 */ }
   }, [sidebarOn, sidebarW, activePanel, sessionId, sidebarKey])
-
   // 切换侧边栏（capture 抢占，避免与 DSH 全局冲突；键位随快捷键配置）
   React.useEffect(() => {
     const onKey = (e) => {
@@ -836,8 +861,10 @@ export function EditorView(props) {
     const cache = modelsRef.current
     let model = cache.get(path)
     if (!model) {
-      model = window.monaco.editor.createModel(text ?? '', langOf(path), window.monaco.Uri.parse('edrv:///' + encodeURI(path)))
-      cache.set(path, model)
+      // 注册表守卫：同 URI 已存在的 model 直接复用（HMR 换 bundle 后防重复创建抛错）
+      const uri = window.monaco.Uri.parse('edrv:///' + encodeURI(path))
+      model = window.monaco.editor.getModel(uri) || window.monaco.editor.createModel(text ?? '', langOf(path), uri)
+      rememberModel(cache, path, model)
     } else if (text !== undefined && model.getValue() !== text) {
       programmaticRef.current = true
       model.setValue(text)
@@ -930,12 +957,14 @@ export function EditorView(props) {
 
   React.useEffect(() => () => {
     flushSave()
-    saveViewState(active)
+    // 卸载即切作用域/重挂载：先把待记录光标落进历史，再存当前文件视图状态
+    //（经 ref 取最新闭包，修正旧实现捕获挂载时 active 的问题）
+    flushNavCursor()
+    saveViewStateRef.current?.()
     diffRendererRef.current?.dispose?.()
     hideReferencesOverlay()
     if (editorRef.current) { editorRef.current.dispose(); editorRef.current = null }
-    for (const m of modelsRef.current.values()) m.dispose()
-    modelsRef.current.clear()
+    // model 不在此销毁：跨挂载缓存按作用域存活（modelCache 切作用域时统一释放）
     for (const ctl of pdfCtlRef.current.values()) ctl.destroy()
     pdfCtlRef.current.clear()
     const root = editorRef.current && editorRef.current.getDomNode ? editorRef.current.getDomNode() : null
@@ -1683,8 +1712,10 @@ export function EditorView(props) {
   const sidebarPanels = props.sidebarPanels
   const sidebarCtx = {
     sessionId,
-    // 当前会话工作区（sessions 快照 byId[sessionId].cwd；规则面板项目 Tab 自动匹配）
-    cwd: props.sessions?.list?.getSnapshot?.()?.byId?.[sessionId]?.cwd ?? null,
+    // 当前会话工作区（反应式 cwd；规则面板项目 Tab 自动匹配）
+    cwd: cwd ?? null,
+    // 状态作用域键（工作区优先，无 cwd 回退会话；面板持久化统一走它）
+    scope,
     openFile: (p) => openFile(p, false),
     openFileAt,
     activePath: active,
@@ -1713,7 +1744,7 @@ export function EditorView(props) {
   }
   const sideHintEl = (layout === 'tab' && sideHint && !hintDismissed)
     ? React.createElement('div', { className: 'edrv-side-hint' },
-        React.createElement('span', { className: 'edrv-side-hint-text' }, '安装 dsh-better-sidebar 后可启用侧边栏编辑（对话+编辑同屏）：'),
+        React.createElement('span', { className: 'edrv-side-hint-text' }, 'DSH 0.1.5+ 自带官方右侧侧边栏（升级即用）；旧版可安装 dsh-better-sidebar 启用侧边栏编辑（对话+编辑同屏）：'),
         React.createElement('code', { className: 'edrv-side-hint-cmd' }, SIDEBAR_INSTALL_CMD),
         React.createElement('button', { className: 'edrv-pill edrv-pill-ghost', title: '复制安装命令', onClick: copyInstallCmd }, '复制命令'),
         React.createElement('button', { className: 'edrv-side-hint-close', title: '关闭提示', 'aria-label': '关闭提示', onClick: dismissHint }, '×'))

package/src/client/ui/OfficialSideTab.ts

@@ -0,0 +1,92 @@
+// @ts-nocheck
+/**
+ * dsh-vscode-mode client — OfficialSideTab：DSH 官方右侧 Sidebar「文件编辑」Tab 正文包装。
+ * 双用途：页类型 Tab（edrvEditor）经 navigation.params（openPath/focusDiff）打开；
+ * file 资源类型 Tab（edrvEditorFile，认领 dsh-resource://file/**）经 navigation.address
+ * 解码出真实路径并透传 params.line 行号定位。派发既有 edrv:open-editor 事件复用
+ * EditorView 打开流；按会话 key 保证切会话干净重建。
+ * Tab 正文切换后重挂载时按最新导航恢复打开（对齐 better-sidebar 形态的种子行为）。
+ * 作者 ddj 2026年09月09号
+ */
+import React from 'react'
+import { EditorView } from './EditorView.js'
+import { setSideEditorMounted } from '../sidebarBridge.js'
+import { editorMountEpoch, markEditorMounted, parseOfficialFileAddress, resolveNavOpen } from '../officialSidebar.js'
+
+/**
+ * 官方侧边栏 Tab 正文组件（keyed slot sidebar.right.pane.tab 装配）。
+ * @param props slot 框架注入（useTabInfo/sessionId）+ 装配依赖（schedule 等）
+ * @returns EditorView 侧栏形态
+ */
+export function OfficialSideTab(props) {
+  const sessionId = props?.sessionId
+  const useTabInfo = props?.useTabInfo
+  let navigation
+  // useTabInfo 是 slot 框架按组件实例生成的 hook，须在组件顶层无条件调用
+  if (typeof useTabInfo === 'function') {
+    try {
+      navigation = useTabInfo()?.tab?.navigation
+    } catch {
+      navigation = undefined
+    }
+  }
+  const revision = typeof navigation?.revision === 'number' ? navigation.revision : -1
+  const revisionRef = React.useRef(-1)
+  // 最新 sessionId 镜像（卸载清理判读「切会话 vs 本会话关闭」用）
+  const sessionIdRef = React.useRef(sessionId)
+  sessionIdRef.current = sessionId
+
+  // 编辑 Tab 激活标记：挂载即激活；卸载时延迟判定「切会话（保持，供新会话自动恢复）
+  // vs 本会话关闭/切走其他 Tab（清除，尊重用户选择）」——通知早于会话状态落定，必须延后读；
+  // 纪元守卫：判定期间有新正文挂载（HMR/自动恢复）则放弃清除
+  React.useEffect(() => {
+    setSideEditorMounted(true)
+    markEditorMounted()
+    return () => {
+      setSideEditorMounted(false)
+      const epoch = editorMountEpoch()
+      const self = sessionIdRef.current
+      const schedule = props?.schedule
+      const decide = () => {
+        if (editorMountEpoch() !== epoch) return
+        const current = props?.sessions?.list?.getSnapshot?.()?.current
+        markEditorActive(current === self)
+      }
+      if (typeof schedule === 'function') schedule(decide, 0)
+      else decide()
+    }
+  }, [])
+
+  React.useEffect(() => {
+    if (revision === revisionRef.current) return
+    revisionRef.current = revision
+    // revision 0 = 无地址打开（种子/撤销恢复），没有可执行的打开请求
+    if (revision <= 0) return
+    // file 资源 Tab：地址即文件（解码出真实路径，透传 params.line 行号定位）
+    const fileHit = parseOfficialFileAddress(navigation?.address)
+    if (fileHit) {
+      const line = navigation?.params?.line
+      window.dispatchEvent(new CustomEvent('edrv:open-editor', {
+        detail: { path: fileHit.path, line: typeof line === 'number' ? line : undefined },
+      }))
+      return
+    }
+    // 页类型 Tab：params 携带打开请求
+    const request = resolveNavOpen(navigation?.params)
+    window.dispatchEvent(new CustomEvent('edrv:open-editor', {
+      detail: { path: request.path, focusDiff: request.focusDiff },
+    }))
+  })
+
+  return React.createElement(EditorView, {
+    key: sessionId,
+    sessionId,
+    layout: 'side',
+    schedule: props?.schedule,
+    addToConversation: props?.addToConversation,
+    sidebarPanels: props?.sidebarPanels,
+    outlineSources: props?.outlineSources,
+    fileMenuItems: props?.fileMenuItems,
+    sessions: props?.sessions,
+  })
+}