dsh-code-ui 1.3.2 → 1.4.1

package/lib/client.js

@@ -80,9 +80,15 @@ window.__ModuleLoader__.load({
       .cdex-sb-expand{width:18px;flex:0 0 auto;display:flex;align-items:center;justify-content:center;cursor:pointer;color:var(--dsw-alias-label-secondary,#9d9d9d);background:var(--dsw-specific-sidebar-fill,#252526);border-right:1px solid var(--dsw-alias-border-l1,#333333);font-size:15px;user-select:none;}
       .cdex-sb-expand:hover{color:var(--dsw-alias-label-primary,#d4d4d4);background:var(--dsw-alias-interactive-bg-hover,#3a3a41);}
       .cdex-tree{flex:1;overflow:auto;padding:4px;}
-      .cdex-node{display:flex;align-items:center;gap:5px;padding:2px 6px;border-radius:4px;cursor:pointer;white-space:nowrap;color:var(--dsw-alias-label-primary,#cccccc);font-size:13px;}
+      .cdex-node{position:relative;display:flex;align-items:center;gap:5px;padding:2px 6px;border-radius:4px;cursor:pointer;white-space:nowrap;color:var(--dsw-alias-label-primary,#cccccc);font-size:13px;}
       .cdex-node:hover{background:var(--dsw-alias-bg-layer-1,#2a2d2e);}
-      .cdex-node.active{background:var(--dsw-alias-bg-layer-2,#37373d);}
+      /* 选中态：专用令牌（浅色下层级灰几乎隐形），底色 + 左缘强调条双保险（照活动栏做法）。
+         注意勿用 --cdex-accent-bg 当底色：浅色主题下它是近黑、深色下是白，反着给按钮用的。 */
+      /* 选中底色跟随宿主信息蓝令牌（与 dshUI「对话/轨迹」页签同源，宿主换肤自动同步）。
+         本地两套主题变量未定义该令牌，运行时从宿主根继承；#4176e6 为宿主无此令牌时的回退。 */
+      .cdex-node.active{background:var(--dsw-alias-button-info-fill,#4176e6);color:#ffffff;}
+      .cdex-node.active .cdex-arrow,.cdex-node.active .cdex-file,.cdex-node.active .cdex-folder{color:#ffffff;}
+      .cdex-node.active::before{content:'';position:absolute;left:0;top:3px;bottom:3px;width:2px;background:#ffffff;border-radius:1px;}
       .cdex-arrow{width:14px;flex:0 0 auto;color:var(--dsw-alias-label-secondary,#888888);text-align:center;font-size:11px;}
       .cdex-folder{color:#dcb67a;}
       .cdex-file{color:var(--dsw-alias-label-primary,#cccccc);}
@@ -126,6 +132,13 @@ window.__ModuleLoader__.load({
       .cdex-menu{position:fixed;z-index:10002;background:var(--dsw-alias-bg-overlay,#252526);border:1px solid var(--dsw-alias-border-l2,#454545);border-radius:6px;padding:4px;min-width:180px;box-shadow:0 8px 24px rgba(0,0,0,.5);max-height:calc(100vh - 24px);overflow-y:auto;}
       .cdex-menu-item{display:flex;gap:8px;align-items:center;padding:7px 10px;border-radius:4px;cursor:pointer;font-size:13px;color:var(--dsw-alias-label-primary,#d4d4d4);}
       .cdex-menu-item:hover{background:var(--cdex-accent-bg,#0f1115);color:var(--cdex-accent-fg,#ffffff);}
+      .cdex-menu-item.disabled{opacity:.45;cursor:default;}
+      .cdex-menu-item.disabled:hover{background:transparent;color:var(--dsw-alias-label-primary,#d4d4d4);}
+      .cdex-menu-sep{height:1px;margin:4px 6px;background:var(--dsw-alias-border-l2,#454545);}
+      .cdex-confirm-list{max-height:160px;overflow-y:auto;margin:8px 0 0;display:flex;flex-direction:column;gap:2px;}
+      .cdex-confirm-file{font-size:13px;color:var(--dsw-alias-label-primary,#d4d4d4);padding:2px 0;}
+      .cdex-confirm-more{font-size:12px;color:var(--dsw-alias-label-secondary,#9d9d9d);padding:2px 0;}
+      .cdex-btn-primary{background:var(--dsw-alias-button-info-fill,#4176e6);color:#ffffff;border-color:transparent;}
       .cdex-modal{position:fixed;inset:0;background:rgba(0,0,0,.55);display:flex;align-items:center;justify-content:center;z-index:10002;pointer-events:auto;}
       .cdex-modal-box{background:var(--dsw-alias-bg-overlay,#252526);border:1px solid var(--dsw-alias-border-l2,#454545);border-radius:8px;padding:16px;width:560px;max-width:92vw;}
       .cdex-modal-title{font-weight:600;margin-bottom:10px;color:var(--dsw-alias-label-primary,#e8e8e8);word-break:break-all;}
@@ -245,6 +258,7 @@ window.__ModuleLoader__.load({
       nodes: {},
       tabs: [],
       activePath: null,
+      closeConfirm: null, // 关闭未保存确认框：{ paths 待关列表, dirty 脏文件列表, keepActive 批量关闭后应激活的标签 }
       buffers: {},
       savedContent: {},
       dirty: {},
@@ -265,9 +279,10 @@ window.__ModuleLoader__.load({
       toast: null,
       toastKeep: false,
       toastPos: null,
-      sessionId: null,     // 当前会话 id（InputBridge 从 slot kit 捕获）：文件树默认根跟随当前会话
-      rootIsAuto: true,    // 根是否为自动跟随（用户「以此文件夹为根」后置 false，不再跟随）
-      rootSessionId: null, // 当前自动根来自哪个会话（落后于 sessionId 时触发重新解析）
+      sessionId: null,     // 当前会话 id（InputBridge 从 slot kit 捕获；blank 会话头隐藏时由 SessionWatch 兜底）：文件树根按会话解析/记忆
+      rootSessionId: null, // 当前根归属哪个会话（落后于 sessionId 时触发重新解析；手动根由宿主按会话记忆）
+      sessionEditor: {},   // 会话 id -> { tabs, activePath, nodes, rootPath }：切换会话时快照/恢复编辑器标签与文件树展开状态（滚动位按文件路径记忆于 scrollPos）
+      scrollPos: {},       // 文件路径 -> {top,left}：每个标签记住自己的滚动位置（切换后恢复）
       error: null,
     }
     const listeners = new Set()
@@ -598,6 +613,129 @@ window.__ModuleLoader__.load({
       return out.join('')
     }
 
+    /* ============ §3.5 highlight.js 接线（vendor 资产经宿主路由懒加载；未就绪/失败回退上方自研 tokenizer） ============ */
+    // 主题表：与 tools/vendor-hljs.mjs 的 THEMES、宿主端 SYN_THEME_IDS 一一对应（展示名单点维护）
+    const SYN_THEMES = [
+      ['github', 'GitHub'], ['github-dark', 'GitHub Dark'], ['atom-one-dark', 'Atom One Dark'], ['atom-one-light', 'Atom One Light'],
+      ['monokai', 'Monokai'], ['dracula', 'Dracula'], ['nord', 'Nord'], ['vs', 'VS 浅色'], ['vs2015', 'VS2015 深色'], ['tokyo-night-dark', 'Tokyo Night Dark'],
+    ]
+    const HLJS_VENDOR_BASE = '/dsh-code-ui/vendor/'
+    const HLJS_BIG_CHARS = 512 * 1024 // 超大文件不做 hljs（防卡顿），继续用轻量 tokenizer
+    const HLJS_SYNC_MAX = 32 * 1024 // 该阈值内同步走 hljs：单帧渲染，杜绝 tokenizer↔hljs 交换帧（交换帧会重写 innerHTML 丢滚动位 → 每敲一个字符文本抖动）
+    // langOf 的输出大多是 hljs 语言 id/别名；少数需归一，其余交给 hljs.getLanguage 解析，失败回退 plaintext
+    const HLJS_LANG_FIX = { text: 'plaintext', jsx: 'javascript', tsx: 'typescript', htm: 'xml' }
+    function hljsLangOf(lang) {
+      const hljs = window.hljs
+      if (!hljs || typeof hljs.getLanguage !== 'function') return null
+      const l = HLJS_LANG_FIX[lang] || lang
+      try { if (hljs.getLanguage(l)) return l } catch (e) {}
+      return 'plaintext'
+    }
+    // 懒加载单例：经典 <script>/<link> 注入（切勿在 ModuleLoader factory 内 eval——UMD 会检测到
+    // 假 module/exports 走 CJS 分支，挂到 module.exports 而不是 window.hljs）。
+    // Electron(file://)/断网/路由缺失 → 失败态，永久回退自研 tokenizer（保底可用）。
+    let hljsState = 'idle' // idle | loading | ready | failed
+    let hljsPromise = null
+    let selfVersion = '' // get-self 回填，用作 vendor 资产的 cache-bust query
+    function loadHljs() {
+      if (hljsState === 'ready') return Promise.resolve(true)
+      if (hljsState === 'failed') return Promise.resolve(false)
+      if (hljsPromise) return hljsPromise
+      hljsState = 'loading'
+      hljsPromise = new Promise((resolve) => {
+        const settle = (ok) => {
+          if (hljsState === 'ready') { resolve(true); return }
+          hljsState = ok ? 'ready' : 'failed'
+          if (!ok) hljsPromise = null
+          resolve(ok)
+          emit() // 就绪后重渲染：已打开文件从 tokenizer 输出切到 hljs 输出
+        }
+        try {
+          const v = encodeURIComponent(selfVersion)
+          const q = v ? ('?v=' + v) : ''
+          const link = document.createElement('link')
+          link.rel = 'stylesheet'
+          link.href = HLJS_VENDOR_BASE + 'hljs-themes.css' + q
+          const script = document.createElement('script')
+          script.src = HLJS_VENDOR_BASE + 'highlight.full.min.js' + q
+          script.onload = () => { settle(!!(window.hljs && typeof window.hljs.highlight === 'function')) }
+          script.onerror = () => { settle(false) }
+          // 超时兜底：15s 仍未就绪按失败处理（script 若迟到加载成功，onload 仍会升级为 ready）
+          setTimeout(() => { if (hljsState === 'loading') settle(false) }, 15000)
+          document.head.appendChild(link)
+          document.head.appendChild(script)
+        } catch (e) { settle(false) }
+      })
+      return hljsPromise
+    }
+    // 语法配色偏好：auto(默认,随编辑器明暗 GitHub/GitHub Dark) 或 SYN_THEMES 之一
+    let synThemePref = 'auto'
+    function editorPrefersDark() {
+      if (themeMode === 'dark') return true
+      if (themeMode === 'light') return false
+      if (themeMode === 'system') return systemPrefersDark()
+      return dshPrefersDark()
+    }
+    function synThemeId() {
+      if (synThemePref !== 'auto') return synThemePref
+      return editorPrefersDark() ? 'github-dark' : 'github'
+    }
+    // hljs 结果缓存 + 防抖重高亮：内容未变直接复用；变了先用自研 tokenizer 顶上（同步、有色、
+    // 新敲的字符永远立即可见），停顿 ~60ms 后异步换成 hljs 输出并重渲染。
+    const hljsCache = new Map()   // path -> { content, html }（超 24 个逐出最旧，防内存无界）
+    const hljsPending = new Map() // path -> 取消句柄
+    function hljsDelay(fn, ms) {
+      if (timer && typeof timer.timeout === 'function') return timer.timeout(fn, ms)
+      const t = setTimeout(fn, ms)
+      return () => clearTimeout(t)
+    }
+    function scheduleHljs(p, content, lang) {
+      const prev = hljsPending.get(p)
+      if (prev) { try { prev() } catch (e) {} }
+      const cancel = hljsDelay(() => {
+        hljsPending.delete(p)
+        let html = ''
+        try {
+          html = window.hljs.highlight(content, { language: hljsLangOf(lang) || 'plaintext', ignoreIllegals: true }).value
+        } catch (e) {
+          html = highlight(content, lang) // 单文件异常（不应发生）：退回 tokenizer 输出
+        }
+        // 与 tokenizer 输出保持行数一致：末尾换行补齐（textarea 会渲染最后的空行）
+        if (content.endsWith('\n') && !html.endsWith('\n')) html += '\n'
+        if (hljsCache.size > 24) { const first = hljsCache.keys().next().value; if (first !== undefined) hljsCache.delete(first) }
+        hljsCache.set(p, { content, html })
+        if (store.tabs.some((t) => t.path === p)) emit()
+      }, 60)
+      hljsPending.set(p, cancel)
+    }
+    // 编辑区高亮统一入口：hljs 就绪且文件不大 → hljs（缓存命中直用，否则防抖调度）；
+    // 否则自研 tokenizer 同步渲染（加载中/失败/超大文件的回退面）
+    function renderHighlight(p, content) {
+      const lang = langOf(p)
+      if (hljsState === 'idle') loadHljs() // 首次真正需要高亮时才触发懒加载
+      if (hljsState !== 'ready' || content.length > HLJS_BIG_CHARS) return highlight(content, lang)
+      const cached = hljsCache.get(p)
+      if (cached && cached.content === content) return cached.html
+      // 小文件同步走 hljs：一次渲染直接出最终结果。原「tokenizer 顶上 + 60ms 后换 hljs」
+      // 的交换帧会让高亮层每击键重写两次 innerHTML（浏览器重写时 scrollTop/scrollLeft 被
+      // 重置为 0），表现为滚动过的文件每敲一个字符文本抖动一下。
+      if (content.length <= HLJS_SYNC_MAX) {
+        let html
+        try {
+          html = window.hljs.highlight(content, { language: hljsLangOf(lang) || 'plaintext', ignoreIllegals: true }).value
+        } catch (e) {
+          html = highlight(content, lang) // 单文件异常（不应发生）：退回 tokenizer 输出
+        }
+        // 与 tokenizer 输出保持行数一致：末尾换行补齐（textarea 会渲染最后的空行）
+        if (content.endsWith('\n') && !html.endsWith('\n')) html += '\n'
+        if (hljsCache.size > 24) { const first = hljsCache.keys().next().value; if (first !== undefined) hljsCache.delete(first) }
+        hljsCache.set(p, { content, html })
+        return html
+      }
+      scheduleHljs(p, content, lang)
+      return highlight(content, lang) // 大文件：tokenizer 顶上（同步、即时），60ms 防抖后换 hljs
+    }
+
     /* ============ §4 RPC 操作层（文件树 / 标签页 / 引用备注） ============ */
     // —— 文件浏览器 ——
     async function browseDir(path) {
@@ -628,36 +766,66 @@ window.__ModuleLoader__.load({
     }
     async function setWorkspaceRoot(path) {
       if (!path) return
-      const res = await callHost('set-root', { path })
+      // sessionId 一并上送：手动根按会话记忆（宿主 sessionRoots），其它会话不受影响
+      const res = await callHost('set-root', { path, sessionId: store.sessionId })
       if (res && res.error) { showToast('设置失败：' + res.error); return }
-      store.rootIsAuto = false // 用户显式选择：此后不再跟随会话切换
-      store.rootSessionId = null
+      store.rootSessionId = store.sessionId // 手动根归属当前会话
       await applyRoot((res && res.root) ? res.root : path)
       showToast('工作区根目录：' + store.rootPath)
     }
-    // 换根并整体重置文件树/标签页/缓冲（自动跟随与手动设置共用）
+    // 换根：标签页/缓冲/脏标记按会话记忆（handleSessionSwitch 快照恢复，均以绝对路径为键、
+    // 跨根安全）。树状态（目录展开/已加载子目录）同样按会话恢复——nodes 里已有该根节点时
+    // 跳过重置（同根换会话、或恢复了目标会话的树快照），只在新根没有树状态时重建。
+    // 注意不能用 toggleExpand 展开：它是切换语义，会把已展开的根折叠回去。
     async function applyRoot(newRoot) {
       store.rootPath = newRoot
-      store.nodes = {}
-      store.tabs = []
-      store.activePath = null
-      store.buffers = {}
-      store.savedContent = {}
-      store.dirty = {}
+      if (!store.nodes[newRoot]) {
+        store.nodes = {}
+        store.browsePath = null
+        store.browseEntries = []
+        store.nodes[newRoot] = { name: baseName(newRoot), path: newRoot, isDir: true, children: [], expanded: true, loaded: false }
+        store.filePickerOpen = false
+        emit()
+        await toggleExpand(newRoot)
+        return
+      }
+      emit()
+    }
+    // —— 会话切换：编辑器状态按会话记忆 ——
+    // 切换时快照当前会话的标签页/激活项/文件树（展开+已加载子目录）/根路径，恢复目标会话的；
+    // 滚动位按文件路径记忆于 store.scrollPos（标签恢复挂载时自动回滚），焦点不恢复、由用户
+    // 自己点击决定。缓冲/脏标记以绝对路径为键全局保留：切走再切回，未保存内容与 ● 状态
+    // 原样还在，因此不再需要「有脏文件暂不跟随」守卫——根始终跟随新会话。
+    function handleSessionSwitch(nextSid) {
+      if (!nextSid || nextSid === store.sessionId) return
+      const prevSid = store.sessionId
+      const keyOf = (s) => s || '__no-session__'
+      if (prevSid && store.rootPath) {
+        store.sessionEditor[keyOf(prevSid)] = {
+          tabs: store.tabs,
+          activePath: store.activePath,
+          nodes: store.nodes,
+          rootPath: store.rootPath,
+        }
+      }
+      const saved = store.sessionEditor[keyOf(nextSid)]
+      store.tabs = saved ? saved.tabs : []
+      store.activePath = saved ? saved.activePath : null
+      store.nodes = saved && saved.nodes ? saved.nodes : {}
+      store.rootPath = saved && saved.rootPath ? saved.rootPath : null
       store.activeNotes = []
-      store.browsePath = null
-      store.browseEntries = []
-      store.nodes[newRoot] = { name: baseName(newRoot), path: newRoot, isDir: true, children: [], expanded: true, loaded: false }
-      store.filePickerOpen = false
+      store.sessionId = nextSid
       emit()
-      await toggleExpand(newRoot)
+      if (store.activePath) loadNotes(store.activePath)
+      refresh()
     }
     // —— 文件树 ——
     async function refresh() {
       store.error = null
       const sid = store.sessionId
-      // 自动根模式：首次无根、或会话已切换（rootSessionId 落后）都重新解析当前会话的工作区
-      if (!store.rootPath || (store.rootIsAuto && sid && sid !== store.rootSessionId)) {
+      // 首次无根、或会话已切换（rootSessionId 落后）都重新解析当前会话的根：
+      // 自动=该会话 cwd；手动=宿主 sessionRoots 里该会话记忆的根
+      if (!store.rootPath || (sid && sid !== store.rootSessionId)) {
         const r = await callHost('get-root', sid ? { sessionId: sid } : {})
         const root = (r && r.root) || null
         if (!root) { store.error = '未找到工作区根目录'; emit(); return }
@@ -723,6 +891,37 @@ window.__ModuleLoader__.load({
       // 标签关闭：释放 host 端 watcher
       callHost('unwatch-file', { path }).then(() => {})
     }
+    // 统一关闭入口（标签 ✕、右键菜单各关闭项都走这里）：波及脏文件时弹确认框
+    //（方案 A：保存并关闭 / 不保存 / 取消），干净的直接关。关闭已保存项除外——它只关干净的。
+    function requestCloseTabs(paths, keepActive) {
+      const list = (paths || []).filter((p) => store.tabs.some((t) => t.path === p))
+      if (!list.length) return
+      const dirtyList = list.filter((p) => store.dirty[p])
+      if (!dirtyList.length) { closeTabsNow(list, keepActive); return }
+      store.closeConfirm = { paths: list, dirty: dirtyList, keepActive: keepActive || null }
+      emit()
+    }
+    // 立即关闭一批标签（不做脏检查）：顺序复用 closeTab 的邻居激活 + watcher 释放；
+    // keepActive＝「关闭其他/关闭右侧」场景：结束后激活落到触发菜单的标签上
+    function closeTabsNow(list, keepActive) {
+      for (let i = 0; i < list.length; i++) closeTab(list[i])
+      if (keepActive && store.tabs.some((t) => t.path === keepActive)) {
+        store.activePath = keepActive
+        loadNotes(keepActive)
+      }
+      emit()
+    }
+    // 确认框「保存并关闭」：逐个保存；保存失败（dirty 保持 true）的保留打开，其余关闭
+    async function confirmSaveAndClose() {
+      const cc = store.closeConfirm
+      if (!cc) return
+      store.closeConfirm = null
+      emit()
+      for (let i = 0; i < cc.dirty.length; i++) await saveFile(cc.dirty[i])
+      closeTabsNow(cc.paths.filter((p) => !store.dirty[p]), cc.keepActive)
+      const failed = cc.dirty.filter((p) => store.dirty[p])
+      if (failed.length) showToast('有 ' + failed.length + ' 个文件保存失败，已保留打开')
+    }
     // 外部修改同步：从磁盘重读单文件（脏缓冲不被自动覆盖，只有用户点 ⚡ 或确认后才走这里）
     async function reloadFromFile(path) {
       const res = await callHost('read-file', { path })
@@ -794,6 +993,28 @@ window.__ModuleLoader__.load({
       emit()
     }
     function closeMenu() { store.ctxMenu = null; emit() }
+    // 标签页右键菜单：关闭 / 关闭其他 / 关闭右侧 / 关闭已保存 / 关闭全部 + 复制路径。
+    // 智能禁用：单项动作在无对象时置灰；「关闭已保存」只关干净标签、不触发确认框。
+    function onTabContext(e, path) {
+      const idx = store.tabs.findIndex((t) => t.path === path)
+      if (idx < 0) return
+      const savedPaths = store.tabs.filter((t) => !store.dirty[t.path]).map((t) => t.path)
+      const rightPaths = store.tabs.slice(idx + 1).map((t) => t.path)
+      store.ctxMenu = { x: e.clientX, y: e.clientY, items: [
+        { icon: '', label: '关闭', act: () => requestCloseTabs([path]) },
+        { icon: '', label: '关闭其他', disabled: store.tabs.length <= 1,
+          act: () => requestCloseTabs(store.tabs.filter((t) => t.path !== path).map((t) => t.path), path) },
+        { icon: '', label: '关闭右侧标签页', disabled: rightPaths.length === 0,
+          act: () => requestCloseTabs(rightPaths, path) },
+        { icon: '', label: '关闭已保存', disabled: savedPaths.length === 0,
+          act: () => closeTabsNow(savedPaths) },
+        { icon: '', label: '关闭全部', disabled: store.tabs.length === 0,
+          act: () => requestCloseTabs(store.tabs.map((t) => t.path)) },
+        { sep: true },
+        { icon: '📋', label: '复制路径', act: () => { copyText(path); showToast('路径已复制') } },
+      ] }
+      emit()
+    }
     async function doCite(sel) {
       const ref = await callHost('add-reference', { path: sel.path, language: sel.language, lineStart: sel.lineStart, lineEnd: sel.lineEnd, text: sel.text, kind: 'cite' })
       if (ref && ref.reference) { store.references.push(ref.reference); emit() }
@@ -1043,15 +1264,8 @@ window.__ModuleLoader__.load({
           store.inputDraft = inputState.draft
           store.inputPhase = inputState.phase
         }
-        // 捕获当前会话 id：文件树默认根跟随当前会话的工作区目录
-        if (props.sessionId && props.sessionId !== store.sessionId) {
-          store.sessionId = props.sessionId
-          if (store.rootIsAuto) {
-            const hasDirty = Object.keys(store.dirty || {}).some((k) => store.dirty[k])
-            if (hasDirty) showToast('会话已切换：有未保存文件，工作区暂不跟随（保存后点 ⟳ 刷新即可）')
-            else refresh()
-          }
-        }
+        // 捕获当前会话 id：编辑器状态按会话记忆（标签快照/恢复 + 根解析），见 handleSessionSwitch
+        if (props.sessionId) handleSessionSwitch(props.sessionId)
         emit()
       })
       // 挂钩 DSH 原生输入条的发送：存在引用时把指针附进草稿再发（整文件=绝对路径）。
@@ -1077,6 +1291,19 @@ window.__ModuleLoader__.load({
       }, [inputActions])
       return null
     }
+    // 常驻会话监视器：空新对话（blank 会话）时宿主隐藏会话头 chrome（hideChrome），
+    // InputBridge 所在的 conversation.session.header.actions slot 不渲染、拿不到会话 id；
+    // 改从 root 作用域标准 props useSessions（ui-session 提供，任意 scope 可用）监听当前
+    // 选中会话——blank 会话也是合法的 current，且宿主侧 agent 在 session/create 时即已
+    // 创建（cwd=所选工作区路径），get-root 上送 blank 会话 id 即可正确解析根目录。
+    function SessionWatch(props) {
+      const useSessions = props.useSessions
+      const sid = typeof useSessions === 'function' ? useSessions((s) => s.current) : undefined
+      React.useEffect(() => {
+        if (sid) handleSessionSwitch(sid)
+      }, [sid])
+      return null
+    }
     function AiInput() {
       const st = useStore()
       let taEl = null
@@ -1287,16 +1514,17 @@ window.__ModuleLoader__.load({
       )
     }
     let gutterEl = null
+    let editorTaEl = null // 编辑器 textarea 当前 DOM（用于识别真挂载，避免内联 ref 每次渲染重复触发）
     function syncGutter(ta) {
       if (gutterEl) gutterEl.scrollTop = ta.scrollTop
     }
     function TabBar() {
       const st = useStore()
       return h('div', { className: 'cdex-tabs' },
-        st.tabs.map((t) => h('div', { key: t.path, className: 'cdex-tab' + (st.activePath === t.path ? ' active' : ''), onClick: () => { st.activePath = t.path; loadNotes(t.path); emit() } },
+        st.tabs.map((t) => h('div', { key: t.path, className: 'cdex-tab' + (st.activePath === t.path ? ' active' : ''), onClick: () => { st.activePath = t.path; loadNotes(t.path); emit() }, onContextMenu: (e) => { e.preventDefault(); onTabContext(e, t.path) } },
           h('span', null, (st.externalChanged[t.path] ? '⚡' : '') + t.name + (st.dirty[t.path] ? ' ●' : '')),
           st.externalChanged[t.path] ? h('button', { className: 'cdex-tab-close', title: '文件已在磁盘上被外部修改，点击加载新内容（会覆盖本地未保存的修改）', onClick: (e) => { e.stopPropagation(); reloadFromFile(t.path) } }, '⇩') : null,
-          h('button', { className: 'cdex-tab-close', onClick: (e) => { e.stopPropagation(); closeTab(t.path) } }, '✕'),
+          h('button', { className: 'cdex-tab-close', onClick: (e) => { e.stopPropagation(); requestCloseTabs([t.path]) } }, '✕'),
         )),
         h('div', { className: 'cdex-tab-actions' },
           h('button', { className: 'cdex-btn', title: '保存 (Ctrl+S)', onClick: () => saveFile() }, '保存'),
@@ -1305,6 +1533,19 @@ window.__ModuleLoader__.load({
     }
     function Editor() {
       const st = useStore()
+      // 高亮层 innerHTML 被替换时浏览器会把 scrollTop/scrollLeft 重置为 0；每次渲染提交后
+      // 从 textarea 回同步（也覆盖大文件 60ms 防抖换帧路径），杜绝输入时文本抖动。
+      // 必须放在 early return 之前（Hooks 顺序约束）。
+      React.useEffect(() => {
+        const ta = editorTaEl
+        if (!ta) return
+        const layer = ta.parentNode
+        if (!layer) return
+        const preEl = layer.querySelector('.cdex-code-pre')
+        if (preEl) { preEl.scrollTop = ta.scrollTop; preEl.scrollLeft = ta.scrollLeft }
+        const gutEl = layer.parentNode ? layer.parentNode.querySelector('.cdex-gutter') : null
+        if (gutEl) gutEl.scrollTop = ta.scrollTop
+      })
       if (!st.activePath) {
         // 空态时显式展示当前工作区根，避免「以此文件夹为根」后误认为未切换
         return h('div', { className: 'cdex-editor' },
@@ -1320,8 +1561,8 @@ window.__ModuleLoader__.load({
       const lineCount = content.split('\n').length
       const gutter = []
       for (let i = 1; i <= lineCount; i++) gutter.push(String(i))
-      // 高亮 HTML（overlay 下层展示）
-      const html = highlight(content, langOf(p))
+      // 高亮 HTML（overlay 下层展示）：hljs 就绪走 hljs，否则回退自研 tokenizer
+      const html = renderHighlight(p, content)
       // 滚动同步：把 pre 滚动到与 textarea 相同
       const syncOverlayScroll = (taEl) => {
         if (!taEl) return
@@ -1335,7 +1576,7 @@ window.__ModuleLoader__.load({
         h('div', { className: 'cdex-codearea' },
           h('div', { className: 'cdex-gutter', ref: (el) => { gutterEl = el } }, gutter.join('\n')),
           h('div', { className: 'cdex-code-layer' },
-            h('pre', { className: 'cdex-code-pre', 'aria-hidden': true, dangerouslySetInnerHTML: { __html: html } }),
+            h('pre', { className: 'cdex-code-pre cdex-syn-' + synThemeId(), 'aria-hidden': true, dangerouslySetInnerHTML: { __html: html } }),
             h('textarea', {
               // key 拼上加载序号：内容异步读回后 key 变化触发重挂载，defaultValue 才会生效（否则编辑区空白、与高亮层脱节）
               key: p + ':' + (st.loadSeq[p] || 0),
@@ -1343,7 +1584,24 @@ window.__ModuleLoader__.load({
               defaultValue: content,
               spellCheck: false,
               wrap: 'off',
-              onScroll: (e) => syncOverlayScroll(e.target),
+              ref: (el) => {
+                if (!el) return
+                // 仅在真正挂载时恢复滚动（换标签/内容重挂）；不抢焦点，光标由用户自己点击决定
+                if (el !== editorTaEl) {
+                  editorTaEl = el
+                  const saved = store.scrollPos[p]
+                  if (saved) {
+                    try { el.scrollTop = saved.top || 0; el.scrollLeft = saved.left || 0 } catch (e) {}
+                  }
+                  syncOverlayScroll(el)
+                }
+              },
+              onScroll: (e) => {
+                // 记住本文件的滚动位置（切换标签后可恢复）；不触发重渲染
+                const el = e.target
+                store.scrollPos[p] = { top: el.scrollTop, left: el.scrollLeft }
+                syncOverlayScroll(el)
+              },
               onContextMenu: onEditorContext,
               onChange: (e) => {
                 store.buffers[p] = e.target.value
@@ -1398,9 +1656,11 @@ window.__ModuleLoader__.load({
       } catch (e) {}
       return h('div', { className: 'cdex-menu-backdrop', onClick: closeMenu },
         h('div', { className: 'cdex-menu', style: { left: mx, top: my }, onClick: (e) => e.stopPropagation() },
-          items.map((it, i) => h('div', { key: i, className: 'cdex-menu-item', onClick: () => { try { it.act() } finally { closeMenu() } } },
-            h('span', null, it.icon), h('span', null, it.label),
-          )),
+          items.map((it, i) => it.sep
+            ? h('div', { key: i, className: 'cdex-menu-sep' })
+            : h('div', { key: i, className: 'cdex-menu-item' + (it.disabled ? ' disabled' : ''), onClick: () => { if (it.disabled) return; try { it.act() } finally { closeMenu() } } },
+              h('span', null, it.icon), h('span', null, it.label),
+            )),
         ),
       )
     }
@@ -1468,6 +1728,35 @@ window.__ModuleLoader__.load({
       )
     }
     let noteTa = null
+    // 关闭未保存文件确认（方案 A）：保存并关闭 / 不保存 / 取消（点遮罩＝取消）。
+    // 单文件精简文案；多文件列清单（>5 折叠计数）。保存失败的文件保留打开并 toast。
+    function CloseConfirm() {
+      const st = useStore()
+      const cc = st.closeConfirm
+      if (!cc) return null
+      const cancel = () => { st.closeConfirm = null; emit() }
+      const discard = () => { const c = st.closeConfirm; st.closeConfirm = null; emit(); closeTabsNow(c.paths, c.keepActive) }
+      const n = cc.dirty.length
+      return h('div', { className: 'cdex-modal', onClick: cancel },
+        h('div', { className: 'cdex-modal-box', onClick: (e) => e.stopPropagation() },
+          h('div', { className: 'cdex-modal-title' }, n === 1 ? '未保存的更改' : '未保存的更改（' + n + ' 个文件）'),
+          n === 1
+            ? h('div', { className: 'cdex-confirm-msg' }, '是否保存对 ', h('b', null, baseName(cc.dirty[0])), ' 的更改？')
+            : h('div', { className: 'cdex-confirm-msg' },
+                '以下文件有未保存的更改，关闭前要保存吗？',
+                h('div', { className: 'cdex-confirm-list' },
+                  cc.dirty.slice(0, 5).map((p, i) => h('div', { key: i, className: 'cdex-confirm-file' }, '● ', baseName(p))),
+                  n > 5 ? h('div', { className: 'cdex-confirm-more' }, '…等共 ' + n + ' 个文件') : null,
+                ),
+              ),
+          h('div', { className: 'cdex-modal-actions' },
+            h('button', { className: 'cdex-btn-ghost', onClick: cancel }, '取消'),
+            h('button', { className: 'cdex-btn', onClick: discard }, '不保存'),
+            h('button', { className: 'cdex-btn cdex-btn-primary', onClick: () => { confirmSaveAndClose() } }, '保存并关闭'),
+          ),
+        ),
+      )
+    }
     function NoteEditor() {
       const st = useStore()
       const ne = st.noteEditor
@@ -1537,6 +1826,7 @@ window.__ModuleLoader__.load({
         st.ctxMenu ? h(ContextMenu) : null,
         st.noteEditor ? h(NoteEditor) : null,
         st.nameDialog ? h(NameDialog) : null,
+        st.closeConfirm ? h(CloseConfirm) : null,
         st.confirmBox ? h(ConfirmBox) : null,
         st.toast ? h(Toast) : null,
       )
@@ -1651,6 +1941,7 @@ window.__ModuleLoader__.load({
         st.ctxMenu ? h(ContextMenu) : null,
         st.noteEditor ? h(NoteEditor) : null,
         st.nameDialog ? h(NameDialog) : null,
+        st.closeConfirm ? h(CloseConfirm) : null,
         st.confirmBox ? h(ConfirmBox) : null,
         st.toast ? h(Toast) : null,
       )
@@ -1669,6 +1960,12 @@ window.__ModuleLoader__.load({
         { name: 'conversation.session.header.actions', id: 'cdex-input-bridge', order: 9999, label: '' },
         (props) => h(InputBridge, props),
       )))
+      // 常驻会话监视器：root 作用域 shell.overlay，不随会话头 chrome 隐藏而消失
+      //（空新对话 blank 会话时 InputBridge 所在 slot 不渲染，会话 id 由这里兜底捕获）
+      disposers.push(slots.inject('shell.overlay', () => slots.register(
+        { name: 'shell.overlay', id: 'cdex-session-watch', order: 4, label: '' },
+        (props) => h(SessionWatch, props),
+      )))
       // 切换按钮：按用户选择注册（与布局模式解耦，任意组合）
       if (toggleStyle === 'bar') {
         // 悬浮模式条：可拖动横条，两键切换 code UI / dsh UI
@@ -1739,6 +2036,8 @@ window.__ModuleLoader__.load({
     // RPC 失败回退到「可见+会话头按钮」保证可发现性）
     callHost('get-self').then((r) => {
       if (r && !r.error) {
+        selfVersion = String(r.version || '')
+        synThemePref = (typeof r.synTheme === 'string' && SYN_THEMES.some((x) => x[0] === r.synTheme)) ? r.synTheme : 'auto'
         setThemeMode(r.theme)
         layoutMode = (r.layout === 'float') ? 'float' : 'dock'
         toggleStyle = (r.toggle === 'header') ? 'header' : 'bar'
@@ -1764,6 +2063,7 @@ window.__ModuleLoader__.load({
       const [theming, setTheming] = React.useState(false)
       const [uishing, setUishing] = React.useState(false)
       const [toggling, setToggling] = React.useState(false)
+      const [synTheming, setSynTheming] = React.useState(false)
       const lastPayloadRef = React.useRef(null)
       const pollDisposeRef = React.useRef(null)
 
@@ -1783,6 +2083,22 @@ window.__ModuleLoader__.load({
         })
       }
 
+      // 语法配色：写 host settings 持久化；成功后立即换主题类
+      function setSynTheme(m) {
+        if (!self || synTheming) return
+        setSynTheming(true)
+        callHost('set-syn-theme', { synTheme: m }).then((r) => {
+          setSynTheming(false)
+          if (r && !r.error) {
+            setSelf(Object.assign({}, self, { synTheme: m }))
+            synThemePref = m
+            showToast('语法配色已切换：' + (m === 'auto' ? '自动（随明暗）' : ((SYN_THEMES.find((x) => x[0] === m) || [null, m])[1])))
+          } else {
+            showToast('切换失败：' + ((r && r.error) || '未知错误'))
+          }
+        })
+      }
+
       // 编辑器界面（三态，合并原「布局模式 × 界面模式」）：
       // dock=右侧停靠 / float=悬浮窗口 / hidden=隐藏(dsh UI，内部记住当前布局，切回原样恢复)
       function setUiShape(v) {
@@ -1961,6 +2277,22 @@ window.__ModuleLoader__.load({
             ),
             h('p', { className: 'cdx-pc-note' }, '「跟随 DSH」随 DSH 整体外观（默认）；「跟随系统」随操作系统浅色/深色实时切换；浅色/深色为强制指定。切换立即生效，仅作用于编辑器界面，选择持久化保存。'),
           ),
+          // 字段：语法配色（highlight.js 主题）
+          h('div', { className: 'cdx-pc-field' },
+            h('div', { className: 'cdx-pc-head' },
+              h('span', { className: 'cdx-pc-label' }, '语法配色'),
+              h('span', { className: 'cdx-pc-head' },
+                [{ id: 'auto', name: '自动' }].concat(SYN_THEMES.map((x) => ({ id: x[0], name: x[1] }))).map((t) => h('button', {
+                  key: t.id,
+                  type: 'button',
+                  className: 'cdx-pc-btn ' + (((self && self.synTheme) || 'auto') === t.id ? 'cdx-pc-btn-primary' : 'cdx-pc-btn-outline'),
+                  disabled: !self || synTheming,
+                  onClick: () => setSynTheme(t.id),
+                }, t.name)),
+              ),
+            ),
+            h('p', { className: 'cdx-pc-note' }, '代码语法高亮的配色（highlight.js，193 种语言）。「自动」（默认）随编辑器明暗在 GitHub / GitHub Dark 间切换；其余为固定主题，可与明暗任意搭配。编辑器底色与界面风格仍由「编辑器主题」管理。切换即时生效，持久化保存。'),
+          ),
           // 字段：编辑器界面（三态，合并原「布局模式 × 界面模式」）
           h('div', { className: 'cdx-pc-field' },
             h('div', { className: 'cdx-pc-head' },