dsh-vscode-mode 0.1.60 → 0.1.62

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-vscode-mode",
-  "version": "0.1.60",
+  "version": "0.1.62",
   "description": "DSH 上的类 VSCode 编码体验：Monaco 编辑器（文件页签/QuickOpen/状态栏，可驻 DSH 0.1.5+ 官方右侧 Sidebar 与对话同屏）+ Agent 编辑差异审查（整文件差异/采纳/拒绝/归档/回滚）+ 语言服务器（LSP）智能（跳转定义/引用/hover/大纲 + VSIX 扩展市场安装），状态持久化到工作区旁车",
   "keywords": [
     "dsh",

package/src/client/index.ts

@@ -30,7 +30,7 @@ import { setupExtOpen } from './externalOpen.js'
 import { SettingsContext } from './settingsContext.js'
 import { SIDEBAR_PLUGIN, pickSettingsBinder, registerSlotSafely } from './compat.js'
 import { detectSidebarService, installSideEditor, setEnsureSideEditor, SIDEBAR_INSTALL_CMD } from './sidebarBridge.js'
-import { detectOfficial, installOfficial, registerOfficialFileClaim, OFFICIAL_TAB_TITLE } from './officialSidebar.js'
+import { detectOfficial, installOfficial, registerOfficialFileClaim, OFFICIAL_TAB_KIND, OFFICIAL_TAB_TITLE, isEditorTabActive, restoreEditorTab } from './officialSidebar.js'
 import { SideEditorTab } from './ui/SideEditorTab.js'
 import { OfficialSideTab } from './ui/OfficialSideTab.js'
 import { createAddToConversation } from './addToConversation.js'
@@ -98,6 +98,24 @@ export function apply(ctx: any): void {
       setSession(list.getSnapshot()?.current)
     }), 'vscode-mode: lsp session sync')
   }
+  // 会话切换 → 编辑 Tab 跨会话自动恢复：上一会话编辑区激活时，新会话自动展开并激活
+  //（官方停靠面按会话隔离，新会话默认收起；先试 openTabIn 直写新会话面，未 adopt 走有界重试）。
+  // 注意：首次打开某会话时通知早于 current 字段落定，故通知只调度延迟任务，执行时再读最新快照
+  if (monacoList && typeof monacoList.subscribe === 'function') {
+    const list = monacoList as { getSnapshot: () => { current?: string }; subscribe: (listener: () => void) => () => void }
+    ctx.effect(() => {
+      let lastCurrent = list.getSnapshot?.()?.current
+      const check = () => {
+        const current = list.getSnapshot?.()?.current
+        if (!current || current === lastCurrent) return
+        lastCurrent = current
+        if (!isEditorTabActive() || officialService === undefined) return
+        try { officialService.service.openTabIn?.(current, OFFICIAL_TAB_KIND, {}) } catch { /* 未 adopt 等 seat 就绪走重试 */ }
+        restoreEditorTab(officialService.service, schedule)
+      }
+      return list.subscribe(() => schedule(check, 0))
+    }, 'vscode-mode: editor tab restore')
+  }
   const originalOpenPath = workspaces?.openPath
   const binder = pickSettingsBinder(ctx)
   const settings = binder.scope

package/src/client/navHistory.ts

@@ -4,7 +4,7 @@
  * 后退回到上一处焦点，前进回到下一处，跨文件生效。
  * 数据模型：past（末位 = 当前）+ future 两个栈；record 压栈并清空 future；
  * 与栈顶同 path+line+column 视为同一位置：仅刷新 viewState 快照，不压栈、不清 future。
- * 纯逻辑无 DOM 依赖，可单测。
+ * 纯逻辑无 DOM 依赖，可单测；navHistoryFor 提供按工作区作用域的实例仓（跨会话复用）。
  * 作者 ddj 2026年09月04号
  */
 
@@ -41,6 +41,12 @@ export interface NavHistory {
 /** 后退栈默认容量上限（超出逐出最旧）。 */
 export const NAV_HISTORY_CAP = 200
 
+/** 工作区历史实例缓存上限（FIFO 逐出最久未用作用域，防长期驻留泄漏）。 */
+export const NAV_SCOPE_CAP = 6
+
+/** scope → 导航历史实例（同工作区跨会话复用同一份历史）。 */
+const scopeHistories = new Map<string, NavHistory>()
+
 /** 路径一致（容忍相对路径大小写差异，对齐既有 sameFile 语义常用写法）。 */
 function samePath(a: string, b: string): boolean {
   if (a === b) return true
@@ -102,3 +108,24 @@ export function createNavHistory(cap = NAV_HISTORY_CAP): NavHistory {
     },
   }
 }
+
+/**
+ * 取（或建）某工作区作用域的导航历史实例：同 scope 跨会话复用同一实例，
+ * 后退/前进历史在切换对话后保留（对齐「同一工作区同一编辑区」体感）。
+ * 超出 NAV_SCOPE_CAP 时逐出最旧的实例（Map 插入序近似 LRU）。
+ * @author ddj 2026年09月09号
+ * @param scope 作用域键（scopeStore.workspaceScopeOf 产物）
+ * @param cap 后退栈容量上限（透传 createNavHistory）
+ * @returns 导航历史实例
+ */
+export function navHistoryFor(scope: string, cap = NAV_HISTORY_CAP): NavHistory {
+  const existing = scopeHistories.get(scope)
+  if (existing) return existing
+  const created = createNavHistory(cap)
+  scopeHistories.set(scope, created)
+  if (scopeHistories.size > NAV_SCOPE_CAP) {
+    const oldest = scopeHistories.keys().next().value
+    if (typeof oldest === 'string') scopeHistories.delete(oldest)
+  }
+  return created
+}

package/src/client/officialSidebar.ts

@@ -44,10 +44,14 @@ export interface SidebarRightTabsLike {
   register: (definition: unknown) => () => void
 }
 
-/** sidebarRight 服务的最小结构面（openTab 页路由 + openResource 资源路由）。 */
+/** sidebarRight 服务的最小结构面（openTab 页路由 + openResource 资源路由 + 可选查询/定向打开）。 */
 export interface SidebarRightServiceLike {
   openTab: (kind: string, options?: { params?: unknown }) => void
   openResource?: (address: string, options?: { params?: unknown }) => void
+  /** 挂载会话的激活 Tab（判读编辑 Tab 是否已激活；无 seat 时 undefined）。 */
+  active?: () => { kind?: string } | undefined
+  /** 向指定会话的停靠面打开页类型（store 未 adopt 时 no-op）。 */
+  openTabIn?: (sessionId: string, kind: string, options?: { params?: unknown }) => void
 }
 
 /** slots 服务的最小结构面（等待声明 + 注册）。 */
@@ -279,3 +283,70 @@ export function registerOfficialFileClaim(options: {
     if (typeof bodyDisposer === 'function') bodyDisposer()
   }
 }
+
+// --region 编辑 Tab 跨会话自动恢复
+
+/** 编辑 Tab 是否处于激活态（正文挂载 = 激活；模块级，跨会话存活）。 */
+let editorTabActive = false
+/** 正文挂载纪元（每次挂载自增；延迟判定期间有新挂载则放弃清除）。 */
+let mountEpoch = 0
+
+/**
+ * 标记编辑 Tab 激活并推进挂载纪元（正文挂载时调用）。
+ * @author ddj 2026年09月09号
+ */
+export function markEditorMounted(): void {
+  mountEpoch += 1
+  markEditorActive(true)
+}
+
+/**
+ * 直接设置激活标记（正文卸载延迟判定用；测试 also 用作状态编排入口）。
+ * @author ddj 2026年09月09号
+ * @param active 是否激活
+ */
+export function markEditorActive(active: boolean): void {
+  editorTabActive = active
+}
+
+/**
+ * 读编辑 Tab 激活标记（会话切换时决定是否自动恢复编辑栏）。
+ * @author ddj 2026年09月09号
+ * @returns 上次标记的激活状态
+ */
+export function isEditorTabActive(): boolean {
+  return editorTabActive
+}
+
+/**
+ * 读当前挂载纪元（卸载延迟判定用：纪元已推进 = 有新正文接管，不清标记）。
+ * @author ddj 2026年09月09号
+ * @returns 当前纪元
+ */
+export function editorMountEpoch(): number {
+  return mountEpoch
+}
+
+/**
+ * 在挂载会话恢复编辑 Tab：已激活跳过（官方幂等）；seat 未就绪抛错时有界重试。
+ * openTab 官方语义「打开即展开侧栏」，一次调用同时完成展开 + 激活。
+ * @author ddj 2026年09月09号
+ * @param service 官方 sidebarRight 服务（缺失/未装配直接返回）
+ * @param schedule 延时调度（ctx.timeout；重试节拍）
+ * @param attempts 剩余尝试次数（默认 10 次 × 150ms ≈ 1.5s 窗口）
+ */
+export function restoreEditorTab(
+  service: SidebarRightServiceLike | undefined | null,
+  schedule: (fn: () => void, ms: number) => void,
+  attempts = 10,
+): void {
+  if (!service || typeof service.openTab !== 'function' || !editorTabActive) return
+  try {
+    if (service.active?.()?.kind === OFFICIAL_TAB_KIND) return
+    service.openTab(OFFICIAL_TAB_KIND, {})
+  } catch {
+    // seat 未挂载/未绑定（会话面尚未渲染）：等一拍再试，放弃后保持现状不阻塞
+    if (attempts > 1) schedule(() => restoreEditorTab(service, schedule, attempts - 1), 150)
+  }
+}
+// --endregion

package/src/client/paths.ts

@@ -6,7 +6,7 @@
  * 作者 ddj 2026-09-01
  */
 
-/** localStorage 键前缀表（按功能隔离；均按会话拼接）。 */
+/** localStorage 键前缀表（按功能隔离；与 scopeStore 作用域键拼接：工作区优先，无 cwd 回退会话）。 */
 export const CACHE_KEY = {
   /** 展开状态（explorerCache v1，当前使用）。 */
   expanded: 'edrv.cache.explorer.v1.',
@@ -20,7 +20,7 @@ export const CACHE_KEY = {
   sidebar: 'edrv.sidebar.',
   /** 搜索面板条件（SearchPanel v1）。 */
   search: 'edrv.search.v1.',
-  /** 侧边栏提示已关闭标记（全局，无会话）。 */
+  /** 侧边栏提示已关闭标记（全局，无作用域）。 */
   sideHint: 'edrv.side-hint-dismissed',
   /** 「性能优化」页工作区栏目展开状态（workspaceFoldCache v1，全局不按会话）。 */
   workspaceFold: 'edrv.ws-fold.v1.',
@@ -28,7 +28,7 @@ export const CACHE_KEY = {
   rules: 'edrv.rules.v1.',
 } as const
 
-/** 按前缀拼会话键（侧边栏/编辑器等需要布局段时自行拼接后传入）。 */
+/** 按前缀拼作用域键（scopeStore 产出作用域；侧边栏/编辑器等需要布局段时自行拼接后传入）。 */
 export function cacheKey(prefix: string, sessionId: string): string {
   return prefix + sessionId
 }

package/src/client/sidebar/panels/FileExplorer.ts

@@ -14,6 +14,7 @@ import { ContextMenu } from '../../ui/ContextMenu.js'
 import { buildTreeMenu } from '../contextMenu.js'
 import { explorerLoad, explorerSave } from '../../state/explorerCache.js'
 import { entriesCacheGet, entriesCacheIsFresh, entriesCachePut } from '../../state/explorerEntriesCache.js'
+import { workspaceScopeOf } from '../../state/scopeStore.js'
 import type { SidebarCtx } from '../types.js'
 
 const DIR_CAP = 4000
@@ -29,6 +30,8 @@ const PREFETCH_EXCLUDED = new Set(['node_modules', '.git', '.hg', '.svn', '.pnpm
 export function FileExplorer(props) {
   const ctx = props?.ctx
   const sessionId = ctx?.sessionId
+  // 状态作用域：展开树/条目缓存按工作区隔离（同工作区切对话恢复同一份），无 cwd 回退会话
+  const scope = ctx?.scope ?? workspaceScopeOf(null, sessionId)
   const openFile = ctx?.openFile
   const activePath = ctx?.activePath ?? null
   const pendingByPath = ctx?.pendingByPath ?? {}
@@ -51,7 +54,7 @@ export function FileExplorer(props) {
   const refreshRef = React.useRef(null)
 
   /** 渲染取数：内存态 → 本地条目缓存 → null（显示加载态）。 */
-  const entriesOf = (rel) => dirsRef.current[rel] ?? entriesCacheGet(sessionId, rel) ?? null
+  const entriesOf = (rel) => dirsRef.current[rel] ?? entriesCacheGet(scope, rel) ?? null
 
   /** 预取子目录：≤4 个、排除重型目录、缓存新鲜跳过、已加载跳过、不级联。 */
   const prefetchDirs = (rel, entries) => {
@@ -59,7 +62,7 @@ export function FileExplorer(props) {
     for (const e of entries) {
       if (e.type !== 'directory') continue
       if (PREFETCH_EXCLUDED.has(e.name)) continue
-      if (entriesCacheIsFresh(sessionId, e.path)) continue
+      if (entriesCacheIsFresh(scope, e.path)) continue
       if (dirsRef.current[e.path] !== undefined) continue
       want.push(e.path)
       if (want.length >= PREFETCH_MAX) break
@@ -90,7 +93,7 @@ export function FileExplorer(props) {
       if (res && res.ok && Array.isArray(res.entries)) {
         setDirs((prev) => Object.assign({}, prev, { [rel]: res.entries }))
         if (res.root) setRoot((prev) => prev || res.root)
-        entriesCachePut(sessionId, rel, res.entries)
+        entriesCachePut(scope, rel, res.entries)
         if (doPrefetch) prefetchDirs(rel, res.entries)
       } else {
         // 有可渲染数据时静默（旧数据可能过期但可用）；全无数据才报错
@@ -151,7 +154,7 @@ export function FileExplorer(props) {
     setMenu(null)
     setRoot(null)
     // 恢复上次展开状态（对齐 VSCode：持久化展开路径，条目缓存即时渲染、后台刷新）
-    const cached = sessionId ? explorerLoad(sessionId) : null
+    const cached = scope ? explorerLoad(scope) : null
     const restored = cached?.expanded ?? []
     if (cached?.root) setRoot(cached.root)
     if (restored.length) {
@@ -164,21 +167,21 @@ export function FileExplorer(props) {
       if (rel) void loadDir(rel, { prefetch: true })
     }
     // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [sessionId])
+  }, [scope])
 
-  // 展开状态防抖写回 localStorage（重启后恢复展开结构）
+  // 展开状态防抖写回 localStorage（重启后恢复展开结构；按工作区作用域隔离）
   React.useEffect(() => {
     if (saveTimerRef.current) { clearTimeout(saveTimerRef.current); saveTimerRef.current = null }
-    if (!sessionId) return
+    if (!scope) return
     saveTimerRef.current = setTimeout(() => {
       saveTimerRef.current = null
       const expandedList = Object.keys(expanded).filter((k) => expanded[k] === true)
-      explorerSave(sessionId, { root, expanded: expandedList })
+      explorerSave(scope, { root, expanded: expandedList })
     }, SAVE_DEBOUNCE_MS)
     return () => {
       if (saveTimerRef.current) { clearTimeout(saveTimerRef.current); saveTimerRef.current = null }
     }
-  }, [expanded, root, sessionId])
+  }, [expanded, root, scope])
 
   // edrv:refresh（差异决策/回滚后）：保留旧条目，强制后台重列
   React.useEffect(() => {
@@ -190,7 +193,7 @@ export function FileExplorer(props) {
 
   // 10s 轻量跟随：已展开目录后台刷新（命中 host 索引，近零成本），树跟随 agent 写入
   React.useEffect(() => {
-    if (!sessionId) return
+    if (!scope) return
     const timer = setInterval(() => {
       const open = Object.keys(expandedRef.current).filter((k) => expandedRef.current[k] === true)
       if (!open.length) return
@@ -198,7 +201,7 @@ export function FileExplorer(props) {
     }, FOLLOW_INTERVAL_MS)
     return () => clearInterval(timer)
     // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [sessionId])
+  }, [scope])
 
   const rootName = root ? String(root).split(/[\\/]/).pop() || root : ''
 

package/src/client/sidebar/panels/SearchPanel.ts

@@ -11,6 +11,7 @@ import React from 'react'
 import { rpc } from '../../rpc.js'
 import type { SidebarCtx } from '../types.js'
 import { CACHE_KEY } from '../../paths.js'
+import { workspaceScopeOf } from '../../state/scopeStore.js'
 
 const DEBOUNCE_MS = 250
 const INCLUDE_PLACEHOLDER = '例如 *.ts, src/**/include'
@@ -44,6 +45,8 @@ function splitHit(text, start, end) {
 export function SearchPanel(props) {
   const ctx = props?.ctx
   const sessionId = ctx?.sessionId
+  // 搜索条件按工作区作用域记忆（同工作区切对话恢复同一份），无 cwd 回退会话
+  const scope = ctx?.scope ?? workspaceScopeOf(null, sessionId)
   const openFileAt = ctx?.openFileAt ?? (() => {})
   const activePath = ctx?.activePath ?? null
   const [query, setQuery] = React.useState('')
@@ -76,11 +79,11 @@ export function SearchPanel(props) {
     exclude: excludeOn ? splitGlobs(excludeText) : [],
   }
 
-  // 按会话恢复上次查询、选项与过滤模式（VSCode 记忆搜索词）
+  // 按作用域恢复上次查询、选项与过滤模式（VSCode 记忆搜索词）
   React.useEffect(() => {
-    if (!sessionId) return
+    if (!scope) return
     try {
-      const saved = JSON.parse(localStorage.getItem(CACHE_KEY.search + String(sessionId)) || 'null')
+      const saved = JSON.parse(localStorage.getItem(CACHE_KEY.search + String(scope)) || 'null')
       if (saved && typeof saved === 'object') {
         if (typeof saved.query === 'string') setQuery(saved.query)
         if (typeof saved.matchCase === 'boolean') setMatchCase(saved.matchCase)
@@ -93,17 +96,17 @@ export function SearchPanel(props) {
         if (typeof saved.sectionOpen === 'boolean') setSectionOpen(saved.sectionOpen)
       }
     } catch (e) { /* 损坏忽略 */ }
-  }, [sessionId])
+  }, [scope])
 
   // 查询/选项/过滤变化 → 持久化
   React.useEffect(() => {
-    if (!sessionId) return
+    if (!scope) return
     try {
-      localStorage.setItem(CACHE_KEY.search + String(sessionId), JSON.stringify({
+      localStorage.setItem(CACHE_KEY.search + String(scope), JSON.stringify({
         query, matchCase, wholeWord, regex, includeText, excludeText, onlyActive, excludeOn, sectionOpen,
       }))
     } catch (e) { /* 忽略 */ }
-  }, [sessionId, query, matchCase, wholeWord, regex, includeText, excludeText, onlyActive, excludeOn, sectionOpen])
+  }, [scope, query, matchCase, wholeWord, regex, includeText, excludeText, onlyActive, excludeOn, sectionOpen])
 
   /**
    * 执行内容搜索（请求参数从 ref 读最新值）。

package/src/client/sidebar/types.ts

@@ -12,6 +12,8 @@ export interface SidebarCtx {
   sessionId?: string
   /** 当前会话工作区 cwd（来自 sessions 快照；规则面板项目 Tab 自动匹配用）。 */
   cwd?: string | null
+  /** 状态作用域键（工作区优先，无 cwd 回退会话；面板持久化统一走它，scopeStore 产出）。 */
+  scope?: string
   openFile: (path: string) => void
   /** 打开文件并跳转到指定行/列（搜索面板命中跳转；缺省仅打开）。 */
   openFileAt?: (path: string, line?: number, column?: number) => void

package/src/client/state/explorerCache.ts

@@ -6,7 +6,7 @@
  */
 import { CACHE_KEY } from '../paths.js'
 
-/** localStorage 键前缀（按会话隔离）。 */
+/** localStorage 键前缀（按工作区作用域隔离，无 cwd 会话回退会话键）。 */
 const KEY_PREFIX = CACHE_KEY.expanded
 
 /** 展开路径容量上限：超出丢弃最旧（按写入顺序近似 LRU）。 */
@@ -88,27 +88,27 @@ export function parseExplorer(text: string | null): ExplorerCacheData | null {
 }
 
 /**
- * 读取某会话的展开状态缓存（localStorage 不可用 → null）。
+ * 读取某作用域的展开状态缓存（localStorage 不可用 → null）。
  * @author ddj 2026年08月28号
- * @param sessionId 会话 id
+ * @param scope 作用域键（scopeStore.workspaceScopeOf 产物）
  * @returns 缓存数据或 null
  */
-export function explorerLoad(sessionId: string): ExplorerCacheData | null {
+export function explorerLoad(scope: string): ExplorerCacheData | null {
   try {
-    return parseExplorer(window.localStorage.getItem(KEY_PREFIX + String(sessionId)))
+    return parseExplorer(window.localStorage.getItem(KEY_PREFIX + String(scope)))
   } catch (error) {
     return null
   }
 }
 
 /**
- * 写入某会话的展开状态缓存（损坏/配额满 → 忽略）。
+ * 写入某作用域的展开状态缓存（损坏/配额满 → 忽略）。
  * @author ddj 2026年08月28号
- * @param sessionId 会话 id
+ * @param scope 作用域键（scopeStore.workspaceScopeOf 产物）
  * @param data 缓存数据
  */
-export function explorerSave(sessionId: string, data: ExplorerCacheData): void {
+export function explorerSave(scope: string, data: ExplorerCacheData): void {
   try {
-    window.localStorage.setItem(KEY_PREFIX + String(sessionId), serializeExplorer(data))
+    window.localStorage.setItem(KEY_PREFIX + String(scope), serializeExplorer(data))
   } catch (error) { /* 配额满/隐私模式忽略 */ }
 }

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)
+  }
+}