dsh-vscode-mode 0.5.2 → 0.6.0

package/src/client/ui/EditorView.ts

@@ -12,6 +12,8 @@ import { dbg, rpc } from '../rpc.js'
 import { emitFileChanged, emitRefresh } from '../events.js'
 import { langOf, loadMonaco, snippetLanguageOf } from '../monaco/loader.js'
 import { dataUrlOf, isImagePath, isSvgPath } from '../imagePreview.js'
+import { isMarkdownPath } from '../markdownPreview.js'
+import { MarkdownPanel } from '../md/mdPanel.js'
 import { base64ToBytes, isPdfPath } from '../pdfPreview.js'
 import {
   clearBaseline,
@@ -30,6 +32,7 @@ import { createDiffRenderer } from '../monaco/diffRender.js'
 import { ST, callIdAttr, noopHunk, summarize } from '../state/records.js'
 import { diffRegions } from '../state/regions.js'
 import { QuickOpen } from './QuickOpen.js'
+import { attachHorizontalWheel } from './horizontalWheel.js'
 import { CommandPalette } from './CommandPalette.js'
 import { closeCommandPalette } from '../commandPaletteStore.js'
 import { DiffLauncher } from './DiffLauncher.js'
@@ -47,6 +50,7 @@ import { bindingsOf, chordOf, matchEvent, useKeybindingsVersion } from '../keybi
 import { getSidebarMinWidth } from '../sidebarMin.js'
 import { navHistoryFor } from '../navHistory.js'
 import { statusOfAdd } from '../addToConversation.js'
+import { setSearchSeed } from '../searchSeed.js'
 import { CACHE_KEY } from '../paths.js'
 import { runGoToDefinition, runFindReferences, hideReferencesOverlay } from '../monaco/lsp/providers.js'
 import { bindLspUnderline } from '../monaco/lsp/underline.js'
@@ -54,12 +58,15 @@ import { onLspProgress, refreshStatus, setSession as setLspSession } from '../mo
 import { setupAiInline, trackAiEditor, aiInlineEnabled } from '../ai/inlineProvider.js'
 import { SnippetsPicker } from './SnippetsPicker.js'
 import { invalidateSnippets, setSnippetsSession, setupSnippets } from '../snippets/provider.js'
+import { setupLaunchJson, prefetchSnippets } from '../dap/launchSnippetProvider.js'
+import { findArrayPos, LAUNCH_JSON_RE } from '../dap/launchInsert.js'
 import {
   absoluteOf, ancestorDirsOf, applyClose, baseNameOf, closeAll, closeOthers, closeRight, closeSaved,
-  insertTab, isTreeRevealable, normalizeTabs, pickActive, relativeOf, tabPathOf, togglePin,
+  evictPlan, insertTab, isTreeRevealable, normalizeTabs, pickActive, relativeOf, tabPathOf, togglePin,
 } from '../tabActions.js'
+import { getMaxOpenEditors } from '../editorLimit.js'
 import { buildTabMenu } from '../tabMenu.js'
-import { ensureSvnChanges, ensureSvnStatus, getSvnChanges, getSvnStatus, refreshSvnChanges, svnAdd, svnChangeMapOf, svnDiffBase, svnEditorActions, svnRevert, svnTortoise, svnUpdate } from '../svnStatus.js'
+import { ensureSvnChanges, ensureSvnStatus, getSvnChanges, getSvnStatus, refreshSvnChanges, svnAdd, svnChangeMapOf, svnDiffBase, svnDiffLocalPair, svnEditorActions, svnRevert, svnTortoise, svnUpdate } from '../svnStatus.js'
 import { ensureSvnLog, getSvnLog, refreshSvnLog, svnDiffPair, svnDiffRev, svnDiffWorking, svnLogKeyOf, svnLogLoadedLimit, svnLogTruncated, svnWcRev, SVN_LOG_SHOW_ALL_LIMIT } from '../svnLog.js'
 import { runSvnAction } from '../svnActions.js'
 import { dshTrace } from '../svnStore.js'
@@ -69,7 +76,18 @@ import type { SvnAction } from '../../shared/svn.js'
 import { createSaveTimer } from '../saveDebounce.js'
 import { ContextMenu } from './ContextMenu.js'
 import { SvnLogDialog } from './SvnLogDialog.js'
+import { SvnPatchDialog } from './SvnPatchDialog.js'
+import { SvnSumDialog } from './SvnSumDialog.js'
 import { LogDialog } from './LogDialog.js'
+import { dapStore } from '../dap/store.js'
+import { bpDisabledLinesOf, bpLinesOf } from '../dap/breakpoints.js'
+import { applyBpDecorations, setEditingLine, setHintLine, setPausedLine } from '../dap/decorate.js'
+import { hintLineFor } from '../dap/hintLine.js'
+import { createBpWidget } from '../dap/BpWidget.js'
+import { buildBpMenu } from '../dap/bpMenu.js'
+import { clampToolbarPosition, loadToolbarPosition, saveToolbarPosition } from '../dap/toolbarDrag.js'
+import { editorModelPathOf } from '../dap/modelPath.js'
+import { dapTrace } from '../dap/trace.js'
 
 /** 日志弹窗每次加载条数（「加载更多」按此步长递增；上限由 host 的 SVN_LOG_SHOW_ALL_CAP 约束）。 */
 const SVN_LOG_PAGE = 100
@@ -85,6 +103,18 @@ function svnLogOptsOf(svnLog) {
   return { stopOnCopy: svnLog.soc === true, showMerged: svnLog.merged === true, range: svnLog.range ?? null }
 }
 
+/**
+ * 工作区相对路径 → 所在目录相对路径（W2-2 目录对比的默认目标；无目录 = 工作副本根）。
+ * @author ddj 2026年09月20号
+ * @param relPath 工作区相对路径（可空）
+ * @returns 目录相对路径（'' = 工作副本根）
+ */
+function dirOfRel(relPath) {
+  const value = String(relPath ?? '').replace(/\\/g, '/')
+  const cut = value.lastIndexOf('/')
+  return cut > 0 ? value.slice(0, cut) : ''
+}
+
 /** 跳转目标高亮的保留时长（LSP/搜索跳转落地后给用户的位置提示，到期自动清除）。 */
 const NAV_FLASH_MS = 1200
 
@@ -165,6 +195,7 @@ export function EditorView(props) {
   const [imgSize, setImgSize] = React.useState(null) // 图片自然尺寸 { w, h }（路径栏 meta）
   const [imgBroken, setImgBroken] = React.useState(false) // 图片解码失败（onError），显示占位与重试
   const svgTextRef = React.useRef(new Set()) // 强制以文本打开的 SVG 路径集合（toggleSvgText 维护）
+  const mdPreviewRef = React.useRef(new Set()) // 处于预览态的 Markdown 路径集合（toggleMdPreview 维护；不持久化）
   const [pdfBytes, setPdfBytes] = React.useState(null) // 当前 PDF tab 的原始字节（null=加载中/非 PDF）
   const pdfB64CacheRef = React.useRef(new Map()) // path → base64（tab 切回免重读；FIFO 上限防内存膨胀）
   const pdfCtlRef = React.useRef(new Map()) // path → PDF 面板控制器（mount 产出，关闭/卸载销毁）
@@ -188,7 +219,9 @@ export function EditorView(props) {
   const [tabMenu, setTabMenu] = React.useState(null) // Tab 右键菜单 { x,y,path }（编辑区右键走 Monaco 原生菜单，无此浮层）
   const [svnStatus, setSvnStatus] = React.useState(null) // SVN 能力状态（SvnStatusPayload；null=未加载，SVN 入口隐藏）
   const [svnChanges, setSvnChanges] = React.useState(null) // SVN 变更清单（null=未加载；徽标/菜单判定）
-  const [svnDiff, setSvnDiff] = React.useState(null) // 差异视图 { path, base, working, reason, message, leftLabel, rightLabel, scheme }（null=关闭）
+  const [svnDiff, setSvnDiff] = React.useState(null) // 差异视图 { path, base, working, reason, message, leftLabel, rightLabel, scheme, logTarget?, binary?, encodingHint? }（null=关闭；logTarget 存在 = 来自日志弹窗，差异条可返回日志）
+  const [patchDialog, setPatchDialog] = React.useState(null) // W2-1 补丁对话框 { path, text, truncated, binary }（null = 关闭）
+  const [sumDialog, setSumDialog] = React.useState(null) // W2-2 目录对比对话框 { path }（null = 关闭）
   const [svnLog, setSvnLog] = React.useState(null) // 日志弹窗 { target, limit, soc?, range? }（null=关闭；P1-4/P1-6 增选项维度）
   const [svnLogData, setSvnLogData] = React.useState(null) // 日志条目（null=未加载）
   const [svnLogBusy, setSvnLogBusy] = React.useState(false) // 日志在途
@@ -229,6 +262,7 @@ export function EditorView(props) {
   const navBackRef = React.useRef(null) // 后退动作最新闭包（窗口级键盘监听读取）
   const navForwardRef = React.useRef(null) // 前进动作最新闭包（窗口级键盘监听读取）
   const cycleTabRef = React.useRef(null) // 页签循环动作最新闭包（Ctrl+Alt+←/→、Ctrl+PgUp/PgDn）
+  const toggleMdPreviewRef = React.useRef(null) // Markdown 预览切换动作最新闭包（窗口键位监听读取，防陈旧闭包）
   const rowNavColRef = React.useRef(null) // 整行上下移动的期望列（连续移动保持列位）
   const rowNavMoveRef = React.useRef(false) // 本次光标变化是否由整行移动触发（否则清空期望列）
   const activeRef = React.useRef(null) // 当前活动文件的最新值（空依赖闭包/指令回调读取）
@@ -240,6 +274,9 @@ export function EditorView(props) {
   const dirtyRef = React.useRef({}) // 脏标记最新值（菜单禁用判定与关闭时落盘读）
   dirtyRef.current = dirtyMap
   const tabsHostRef = React.useRef(null) // 页签栏容器（切换后把当前页签滚入可见区）
+  // 页签上限与 LRU 使用序（超限淘汰最久未用者；见下方 tabTouchEffect / tabEvictEffect）
+  const [tabLimit, setTabLimit] = React.useState(() => getMaxOpenEditors())
+  const tabUseRef = React.useRef({ seq: 0, used: {} })
   const [navTick, setNavTick] = React.useState(0) // 历史可用性版本（按钮 disabled 重渲染）
   const hoverRegionsRef = React.useRef([]) // 当前 pending 区域镜像（稳定回调读取）
   const lineRegionMapRef = React.useRef(new Map()) // 行 → 区域 映射（hover 命中）
@@ -252,6 +289,82 @@ export function EditorView(props) {
   const batchBusyRef = React.useRef(false) // 批量 Keep All/Undo All 防重入
   const menuHandlersRef = React.useRef(null) // 右键菜单动作的最新闭包（Monaco addAction 空依赖回调读取）
   const svnMenuDisposersRef = React.useRef([]) // Monaco 右键 SVN 组当前 disposables（同步时先注销旧组）
+  // 调试（DAP）：store 订阅 tick 驱动重渲 + gutter/F9 切换闭包（ensureEditor 空依赖读取）
+  const [dapTick, setDapTick] = React.useState(0)
+  React.useEffect(() => dapStore.subscribe(() => setDapTick((t) => t + 1)), [])
+  const dapSnap = dapStore.getSnapshot()
+  const [dapBarPos, setDapBarPos] = React.useState(() => loadToolbarPosition(scope))
+  const [dapBarDragging, setDapBarDragging] = React.useState(false)
+  const dapBarRef = React.useRef(null)
+  const dapDragRef = React.useRef(null)
+  React.useEffect(() => {
+    setDapBarPos(loadToolbarPosition(scope))
+  }, [scope])
+  React.useEffect(() => {
+    const onMove = (event) => {
+      const drag = dapDragRef.current
+      const bar = dapBarRef.current
+      const area = bar?.parentElement
+      if (!drag || !bar || !area) return
+      const areaRect = area.getBoundingClientRect()
+      const barRect = bar.getBoundingClientRect()
+      const next = clampToolbarPosition({
+        left: event.clientX - areaRect.left - drag.offsetX,
+        top: event.clientY - areaRect.top - drag.offsetY,
+      }, {
+        width: areaRect.width,
+        height: areaRect.height,
+        barWidth: barRect.width,
+        barHeight: barRect.height,
+      })
+      setDapBarPos(next)
+    }
+    const onUp = () => {
+      if (!dapDragRef.current) return
+      dapDragRef.current = null
+      setDapBarDragging(false)
+      const latest = dapBarPosRef.current
+      if (latest) saveToolbarPosition(scope, latest)
+    }
+    document.addEventListener('pointermove', onMove)
+    document.addEventListener('pointerup', onUp)
+    return () => {
+      document.removeEventListener('pointermove', onMove)
+      document.removeEventListener('pointerup', onUp)
+    }
+  }, [scope])
+  const dapBarPosRef = React.useRef(dapBarPos)
+  dapBarPosRef.current = dapBarPos
+  const startDapBarDrag = (event) => {
+    if (event.button !== 0 || !dapBarRef.current) return
+    const rect = dapBarRef.current.getBoundingClientRect()
+    event.preventDefault()
+    event.stopPropagation()
+    dapDragRef.current = { offsetX: event.clientX - rect.left, offsetY: event.clientY - rect.top }
+    setDapBarDragging(true)
+    event.currentTarget.setPointerCapture?.(event.pointerId)
+  }
+  // 进程选择器选中项（多候选附加时；候选集变化回落首个）
+  const [dapPickPid, setDapPickPid] = React.useState(0)
+  React.useEffect(() => { setDapPickPid(dapSnap.candidates?.[0]?.pid ?? 0) }, [dapSnap.candidates])
+  // 断点右键菜单（glyph 区右键）与行内断点编辑浮层（Monaco content widget）
+  const [dapBpMenu, setDapBpMenu] = React.useState(null)
+  const bpWidgetRef = React.useRef(null) // { close, path, line } | null
+  const dapScopeRef = React.useRef(scope)
+  const dapCwdRef = React.useRef(cwd)
+  dapScopeRef.current = scope
+  dapCwdRef.current = cwd
+  const dapToggleRef = React.useRef(null)
+  dapToggleRef.current = (path, line) => {
+    if (!cwd || !path || !line) return
+    // 严格对齐 CodeBuddy：任意文件都可切换断点（不再限定 .lua 调试目标）
+    dapStore.toggleAt(scope, cwd, path, line)
+  }
+  // 工作区变化同步调试 store（配置清单/启动基准）；有 cwd 时预拉 launch.json 配置
+  React.useEffect(() => {
+    dapStore.setWorkspace(cwd || '')
+    if (cwd) void dapStore.ensureConfigs()
+  }, [cwd])
   const svnStatusRef = React.useRef(null) // svnStatus 渲染值镜像（ensureEditor 空依赖闭包读取最新状态）
   const [snippetPicker, setSnippetPicker] = React.useState(null) // 'configure' | 'insert' | null（代码片段浮层）
   const doSaveRef = React.useRef(null) // 保存动作的最新闭包（窗口级保存监听读取）
@@ -282,6 +395,9 @@ export function EditorView(props) {
   const isImageActive = !!active && isImagePath(active) && !svgTextRef.current.has(active)
   // 当前 tab 是否为 PDF 面板（与 loadContent 分派条件同源）
   const isPdfActive = !!active && isPdfPath(active)
+  // 当前 tab 是否为可预览的 Markdown，以及是否正处于预览态（预览态替换 Monaco host，只读）
+  const isMdActive = !!active && isMarkdownPath(active)
+  const mdPreviewing = isMdActive && mdPreviewRef.current.has(active)
   const regions = React.useMemo(() => diffRegions(currentRecords, contentReady ? content : null).filter((r) => !r.superseded), [currentRecords, content, contentPath, active])
   // useMemo 稳定引用：否则 hover 等重渲染会让 view zone effect 反复重建（- 号闪烁）
   const pendingRegions = React.useMemo(() => regions.filter((r) => r.status === ST.PENDING && !r.stale), [regions])
@@ -627,8 +743,9 @@ export function EditorView(props) {
         setStatus('已加载')
       } else {
         const base = res?.error ? String(res.error) : '读取失败'
+        dapTrace('read-failed', { path, error: base, resolvedPath: res?.resolvedPath, cwd })
         // 带出 host 解析后的真实路径：跳转失败时一眼看出是路径解析错还是目标不存在
-        const message = res?.resolvedPath ? base + '：' + String(res.resolvedPath) : base
+        const message = res?.resolvedPath ? base + '：' + relativeOf(String(res.resolvedPath), cwd) : base
         setLoadError(message)
         setError(message)
         setStatus('读取失败')
@@ -972,10 +1089,18 @@ export function EditorView(props) {
         // G9：迁移历史持久化里的绝对路径页签（旧版差异入口写入），并顺带按新形态去重
         const restored = normalizeTabs(saved?.tabs, cwd)
         if (restored.length) {
-          setTabs(restored)
           // 活动路径同形态归一，否则恢复后匹配不到任何页签（pickActive 回退首个）
           const wanted = typeof saved?.active === 'string' ? tabPathOf(saved.active, cwd) : saved?.active
-          setActive(pickActive(restored, wanted))
+          const activePath = pickActive(restored, wanted)
+          // 上限已下调过（或历史存档超限）：恢复即收敛。此时页签均未编辑、无脏数据，
+          // 故只做纯计算裁剪，不走 closeTabs（避免无谓的落盘探测与状态栏提示）。
+          // evictPlan 已保护活动页签，无需额外 keep。
+          const limit = getMaxOpenEditors()
+          const plan = evictPlan(restored, limit, { active: activePath, used: {} })
+          const dropped = new Set(plan)
+          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) { /* 损坏忽略 */ }
@@ -999,6 +1124,45 @@ export function EditorView(props) {
     catch (e) { /* 忽略 */ }
   }, [tabs, active, sessionId, scope])
 
+  /**
+   * 标记页签为「最近使用」（LRU 序号单调递增；编辑动作也算使用，见 onEdit）。
+   * @author ddj 2026年09月18号
+   * @param path 页签路径
+   */
+  const touchTab = (path) => {
+    if (!path) return
+    const state = tabUseRef.current
+    state.seq += 1
+    state.used[path] = state.seq
+  }
+
+  // 页签上限设置变更（edrv:max-open-editors）→ 更新上限态并触发下方淘汰 effect 复算
+  React.useEffect(() => {
+    const onLimit = () => setTabLimit(getMaxOpenEditors())
+    window.addEventListener('edrv:max-open-editors', onLimit)
+    return () => window.removeEventListener('edrv:max-open-editors', onLimit)
+  }, [])
+
+  // LRU 使用序维护：活动页签变化即标记；顺带把 used 表裁剪到当前页签集合，
+  // 否则长会话中已关闭页签的条目会永久堆积（内存无界增长）。
+  // ⚠️ 本 effect 必须声明在淘汰 effect 之前：先标记再淘汰，才能保证「刚打开/刚切到的
+  // 页签」不会在同一次 commit 里被当作最久未用者淘汰。
+  React.useEffect(() => {
+    if (active) touchTab(active)
+    const alive = new Set(tabs.map((t) => t.path))
+    const used = tabUseRef.current.used
+    for (const path of Object.keys(used)) if (!alive.has(path)) delete used[path]
+  }, [tabs, active])
+
+  // 页签超限淘汰：关闭最久未使用的页签（固定页签与活动页签受保护；见 tabActions.evictPlan）。
+  // 复用 closeTabs：它已实现 flushSave + persistDirty（脏页签先静默落盘）+ releaseTab + commitClose，
+  // 故「超限淘汰脏页签」不会丢用户编辑。淘汰后 tabs 变化 → 本 effect 复算 evictPlan 返回空 → 自然收敛。
+  React.useEffect(() => {
+    const plan = evictPlan(tabsRef.current, tabLimit, { active: activeRef.current, used: tabUseRef.current.used })
+    if (!plan.length) return
+    closeTabs(applyClose(tabsRef.current, new Set(plan), activeRef.current), '已关闭最久未使用的页签')
+  }, [tabs, tabLimit, active])
+
   // 侧边栏状态：恢复（显隐/宽度/激活面板）；侧栏形态独立键（默认收起，不共享页签形态偏好）
   // 宽度下限来自通用设置 sidebarMinWidth（默认 300），恢复值按其重夹
   const sidebarKey = CACHE_KEY.sidebar + (layout === 'side' ? 'side.' : '') + String(scope)
@@ -1056,14 +1220,51 @@ export function EditorView(props) {
     return () => window.removeEventListener('keydown', onKey, true)
   }, [])
 
-  // Ctrl+Shift+F 全局搜索：展开侧边栏 + 激活搜索页签，随后聚焦搜索输入框
+  /**
+   * 打开搜索面板（Ctrl+Shift+F 与命令栏「在工作区中搜索」的唯一动作）。
+   *
+   * 若编辑器有选区，把选区文本作为一次性种子交给搜索面板自动填入（需求 1）；
+   * 无选区/无编辑器时种子为空，行为与改动前一致（仅展开并聚焦）。
+   * 种子经 searchSeed 模块交棒而非事件 detail：侧栏原本收起时搜索面板尚未挂载，
+   * 事件 detail 会丢；面板挂载后自行取走槽内种子。
+   * @author ddj 2026年09月18号
+   */
+  const openSearchPanel = () => {
+    const ed = editorRef.current
+    const model = ed?.getModel?.()
+    const sel = ed?.getSelection?.()
+    let selected = ''
+    if (model && sel && (sel.startLineNumber !== sel.endLineNumber || sel.startColumn !== sel.endColumn)) {
+      // 选中区间文本（多行时 seedQueryOf 只取首行）
+      selected = model.getValueInRange?.(sel) ?? ''
+    }
+    setSearchSeed(selected)
+    setSidebarOn(true)
+    setActivePanel('search')
+    setTimeout(() => window.dispatchEvent(new CustomEvent('edrv:search-focus')), 0)
+  }
+
+  // Ctrl+Shift+F 全局搜索：展开侧边栏 + 激活搜索页签，随后聚焦搜索输入框（有选中则填入）
   React.useEffect(() => {
     const onKey = (e) => {
       if (!matchEvent(e, bindingsOf('edrv.searchInFiles'))) return
       e.preventDefault(); e.stopPropagation()
-      setSidebarOn(true)
-      setActivePanel('search')
-      setTimeout(() => window.dispatchEvent(new CustomEvent('edrv:search-focus')), 0)
+      openSearchPanel()
+    }
+    window.addEventListener('keydown', onKey, true)
+    return () => window.removeEventListener('keydown', onKey, true)
+  }, [])
+
+  // Ctrl+Shift+V 切换 Markdown 预览：仅活动文件是 Markdown 时吞键；
+  // 其余情况直接放行（不 preventDefault），保留浏览器/输入框原生的「无格式粘贴」语义
+  // ——与 closeTab / addSelectionRef「不可用时放行按键」同款约定。
+  React.useEffect(() => {
+    const onKey = (e) => {
+      if (!matchEvent(e, bindingsOf('edrv.toggleMarkdownPreview'))) return
+      const path = activeRef.current
+      if (!isMarkdownPath(path)) return
+      e.preventDefault(); e.stopPropagation()
+      toggleMdPreviewRef.current?.(path)
     }
     window.addEventListener('keydown', onKey, true)
     return () => window.removeEventListener('keydown', onKey, true)
@@ -1181,10 +1382,11 @@ export function EditorView(props) {
       ['edrv.command.save', () => { if (editorRef.current?.getModel?.()) { flushSave(); doSaveRef.current?.(false) } }],
       // 快速打开由 QuickOpen 自己接该事件（它持有搜索框 ref），此处不重复实现
       ['edrv.command.toggleSidebar', () => setSidebarOn((v) => !v)],
-      ['edrv.command.searchInFiles', () => {
-        setSidebarOn(true)
-        setActivePanel('search')
-        setTimeout(() => window.dispatchEvent(new CustomEvent('edrv:search-focus')), 0)
+      ['edrv.command.searchInFiles', () => openSearchPanel()],
+      ['edrv.command.toggleMarkdownPreview', () => {
+        const path = activeRef.current
+        if (!isMarkdownPath(path)) { setStatus('当前文件不是 Markdown'); return }
+        toggleMdPreviewRef.current?.(path)
       }],
       ['edrv.command.navigateBack', () => navBackRef.current?.()],
       ['edrv.command.navigateForward', () => navForwardRef.current?.()],
@@ -1226,6 +1428,20 @@ export function EditorView(props) {
       ['edrv.command.svnAdd', () => runSvnAdd(activeRef.current)],
       ['edrv.command.svnRevertCli', () => runSvnRevertCli(activeRef.current)],
       ['edrv.command.svnLog', () => openSvnLog(activeRef.current || undefined)],
+      ['edrv.command.svnCreatePatch', () => runSvnAction(SVN_ACTION_BY_ID['create-patch'], {
+        sessionId,
+        scope,
+        path: activeRef.current ?? '',
+        notify: (message) => setStatus(message),
+        openPatchDialog: (payload) => setPatchDialog(payload),
+      })],
+      ['edrv.command.svnDiffSum', () => runSvnAction(SVN_ACTION_BY_ID['diff-summarize'], {
+        sessionId,
+        scope,
+        path: dirOfRel(activeRef.current ?? ''),
+        notify: (message) => setStatus(message),
+        openSumDialog: (target) => setSumDialog({ path: target }),
+      })],
       ['edrv.command.svnCleanup', () => runSvnAction(SVN_ACTION_BY_ID.cleanup, {
         sessionId,
         scope,
@@ -1265,6 +1481,10 @@ export function EditorView(props) {
     else if (right > host.scrollLeft + host.clientWidth) host.scrollLeft = right - host.clientWidth
   }, [active, tabs.length])
 
+  // 页签栏滚轮横向滚动（需求 3）：页签栏溢出时，鼠标滚轮（含触控板纵向手势）横滚页签栏，
+  // 不溢出时不接管（保持页面垂直滚动）；Shift+滚轮交由浏览器原生横滚。详见 horizontalWheel.ts。
+  React.useEffect(() => attachHorizontalWheel(tabsHostRef.current), [])
+
   // 鼠标侧键后退/前进：Logitech 官方默认「后退/前进」= XButton 鼠标事件（button 3/4），不产生键盘事件。
   // pointerdown 触发导航（preventDefault 后兼容 mousedown 可能不再触发，避免双触发）；
   // mousedown 兜底仅取消浏览器历史导航默认动作（MDN：preventDefault mousedown/pointerdown 可抑制）。
@@ -1326,6 +1546,8 @@ export function EditorView(props) {
       setupAiInline(m)
       // 代码片段补全 provider 注册（幂等；条目按会话工作区懒加载）
       setupSnippets(m)
+      // launch.json「添加配置」补全 provider 注册（幂等；仅 launch.json configurations 数组内出条目）
+      setupLaunchJson(m)
     }).catch((e) => {
       if (alive) {
         setMonacoErr(String(e?.message ?? e))
@@ -1359,10 +1581,7 @@ export function EditorView(props) {
   monacoRef.current = monaco
 
   /** 从编辑器实例 model URI 解析活动文件路径（工作区相对；无模型返回 null）。 */
-  const modelPathOf = (edx) => {
-    const uriPath = edx?.getModel?.()?.uri?.path
-    return uriPath ? decodeURIComponent(String(uriPath).replace(/^\//, '')) : null
-  }
+  const modelPathOf = (edx) => editorModelPathOf(edx)
 
   /**
    * 同步 Monaco 右键菜单 SVN 组：先注销旧组，再按最新 svn 状态注册（空状态 = 全部移除）。
@@ -1401,6 +1620,7 @@ export function EditorView(props) {
             path: def.id === 'update' ? (relPath ?? '') : relPath,
             notify: (message) => setStatus(message),
             openSvnDiff: (p) => runSvnDiffBase(p),
+            openSvnLocalPair: runSvnDiffLocalPair,
             openSvnLog: (p) => openSvnLog(p ?? relPath),
             refreshChanges: () => refreshSvnChanges(sessionId, scope),
           })
@@ -1550,6 +1770,9 @@ export function EditorView(props) {
     const ed = editorRef.current
     if (!ed || !active) return
     setDirtyMap((d) => Object.assign({}, d, { [active]: true }))
+    // 编辑即「使用」：需求 2 的淘汰口径是「最近没有改动」，故有改动时刷新 LRU 序号，
+    // 使长时间只在某文件里编辑的页签不会被其它文件的打开动作挤出。
+    touchTab(active)
     setStatus('编辑中…')
     // 外部改动尚未处理（冲突/文件被删）：抑制自动保存，避免用陈旧缓冲反复覆盖磁盘；
     // 手工 Ctrl+S 不受抑制（doSave 会走版本守卫并给冲突提示）。
@@ -1564,6 +1787,9 @@ export function EditorView(props) {
   // ⚠️ 必须以 contentReady（contentPath === active）为门，不能用 `content !== null`：
   // 切页签的那一帧 content 仍是**上一个文件**的内容，据此建 model 会先塞入陈旧文本，
   // 待真实内容到达再由 getModel→setValue 覆盖，光标随之被重置（见下方跳转 effect 注释）。
+  // ⚠️ 依赖必须含 mdPreviewing：Markdown 预览态不渲染 Monaco host（见 body 分派的 mdPreviewing 分支），
+  // 切回源码时 ensureEditor 会**新建**编辑器实例，而 active/content 都没变；缺此依赖则本 effect
+  // 不重跑 → 空 model、行内差异标记消失。同款原因见下方差异自绘 effect。
   React.useEffect(() => {
     if (!monaco || !editorRef.current || !active || !contentReady) return
     const ed = editorRef.current
@@ -1571,7 +1797,7 @@ export function EditorView(props) {
     if (ed.getModel() !== model) ed.setModel(model)
     restoreViewState(active)
     setLoadStage((prev) => ({ progress: Math.max(96, prev.progress), message: '创建编辑器视图…' }))
-  }, [monaco, active, content, contentReady])
+  }, [monaco, active, content, contentReady, mdPreviewing])
 
   // PDF 面板外壳 ref 回调（div 仅在 PDF 分支渲染，refs 先于 effect 就绪）
   const ensurePdfHost = (node) => { pdfHostRef.current = node }
@@ -1598,11 +1824,13 @@ export function EditorView(props) {
   }, [isPdfActive, pdfBytes, active])
 
   // 行内差异自绘（decorations / view zones / minus overlay）→ diffRenderer
+  // ⚠️ 依赖含 mdPreviewing：切回源码时编辑器实例被重建（见上方 model 同步 effect 的说明），
+  // 不重跑则新实例上没有任何差异装饰，表现为「差异标记全部消失」。
   React.useEffect(() => {
     if (!monaco || !editorRef.current || !active || content === null) return
     diffRendererRef.current.render(monaco, editorRef.current, pendingRegions, sessionId)
     setLoadStage({ progress: 100, message: '编辑器已就绪' })
-  }, [monaco, active, content, pendingRegions])
+  }, [monaco, active, content, pendingRegions, mdPreviewing])
 
   React.useEffect(() => () => {
     flushSave()
@@ -1777,9 +2005,105 @@ export function EditorView(props) {
       if (hideTimerRef.current) { clearTimeout(hideTimerRef.current); hideTimerRef.current = null }
       setHoverAct({ region: hit, top, right })
     })
+    // 调试断点：行首 glyph 圆点区**左键**点击切换（右键走下方 contextmenu 菜单，
+    // 必须区分按键——否则右键会既 toggle 断点又弹菜单）。
+    // ⚠️ 枚举在 monaco.editor 子命名空间（monaco.editor.MouseTargetType，值为 2）；
+    //    取顶层 m.MouseTargetType 是 undefined，会让点击永远静默返回（实测踩坑）。
+    ed.onMouseDown((e) => {
+      const target = e?.target
+      if (!e?.event?.leftButton) return
+      const GUTTER = m.editor?.MouseTargetType?.GUTTER_GLYPH_MARGIN ?? 2
+      if (!target || target.type !== GUTTER) return
+      const line = target.position?.lineNumber
+      const path = pathOf(ed)
+      if (line && path) dapToggleRef.current?.(path, line)
+    })
+    // 断点 hover 预览（对齐 VS Code `ensureBreakpointHintDecoration`）：
+    // 鼠标移到 glyph 区（type=2）或行号区（type=3）的可下断点行 → 半透明红点 + pointer 光标；
+    // 移开/离开编辑器 → 清除。已有断点的行不显示预览（避免与实心红点重叠）。
+    ed.onMouseMove((e) => {
+      const target = e?.target
+      const path = pathOf(ed)
+      const list = path ? (dapStore.bpMapOf(dapScopeRef.current)[path] ?? []) : []
+      const line = hintLineFor(target?.type, target?.position?.lineNumber, list.map((it) => it.line))
+      setHintLine(ed, line || null)
+    })
+    ed.onMouseLeave(() => setHintLine(ed, null))
+    // 断点右键菜单：glyph 区右键**始终**由本插件接管（严格对齐 CodeBuddy：任意文件都出菜单，
+    // 不再限定 .lua）。命中行改用 Monaco 官方 getTargetAtClientPoint——
+    // 手算 floor((relY+scrollTop)/lineHeight)+1 **未扣编辑器 padding-top**（实测 6px），
+    // 点在某行框下半部会被算成下一行 → 对空行显示"添加"菜单（实测踩坑）。
+    const glyphHitLine = (ev) => {
+      const edi = editorRef.current
+      if (!edi?.getTargetAtClientPoint) return null
+      const rect = edi.getDomNode?.()?.getBoundingClientRect?.()
+      if (!rect) return null
+      const layout = edi.getLayoutInfo?.()
+      if (!layout) return null
+      const relX = ev.clientX - rect.left
+      if (relX < layout.glyphMarginLeft || relX > layout.glyphMarginLeft + layout.glyphMarginWidth) return null
+      const GUTTER = m.editor?.MouseTargetType?.GUTTER_GLYPH_MARGIN ?? 2
+      const target = edi.getTargetAtClientPoint(ev.clientX, ev.clientY)
+      if (!target || target.type !== GUTTER) return null
+      return target.position?.lineNumber ?? null
+    }
+    const onBpCtxCapture = (ev) => {
+      const line = glyphHitLine(ev)
+      if (!line) return
+      const path = pathOf(editorRef.current)
+      if (!path) return
+      const entry = (dapStore.bpMapOf(dapScopeRef.current)[path] ?? []).find((it) => it.line === line)
+      ev.preventDefault()
+      ev.stopPropagation()
+      setDapBpMenu({
+        x: ev.clientX,
+        y: ev.clientY,
+        path,
+        line,
+        hasBp: !!entry,
+        enabled: entry ? entry.enabled !== false : true,
+        isLogpoint: !!(entry && entry.logMessage),
+      })
+    }
+    node.addEventListener('contextmenu', onBpCtxCapture, true)
     editorRef.current = ed
   }, [])
 
+  // 调试断点装饰：断点表/活动文件变化时全量替换行首圆点（独立 collection，与差异/下划线互不干扰）；
+  // 适配器真实回执 verified:false 的行渲染空心红圈（对齐 VS Code 未验证语义）
+  React.useEffect(() => {
+    const ed = editorRef.current
+    if (!ed || !active) return
+    const map = dapStore.bpMapOf(scope)
+    const unverified = bpLinesOf(map, active).filter((line) => dapStore.ackOf(active, line)?.verified === false)
+    applyBpDecorations(ed, bpLinesOf(map, active), bpDisabledLinesOf(map, active), unverified)
+  }, [scope, active, contentPath, dapSnap.bpVersion, dapSnap.bpAckVersion, monaco])
+
+  // 行内断点编辑浮层：切换文件 / 编辑器重建时关闭（浮层锚定旧 model 的行号，留着会错位）
+  React.useEffect(() => {
+    closeBpWidget()
+  }, [active, contentPath])
+
+  // 编辑浮层的目标断点被删除（如 agent 清理埋点/用户在面板删除）→ 浮层自动关闭
+  React.useEffect(() => {
+    const held = bpWidgetRef.current
+    if (!held) return
+    const entry = (dapStore.bpMapOf(scope)[held.path] ?? []).some((it) => it.line === held.line)
+    if (!entry) closeBpWidget()
+  }, [scope, dapSnap.bpVersion])
+
+  // 编辑器卸载时移除浮层（content widget 不随 React 树回收）
+  React.useEffect(() => () => closeBpWidget(), [])
+
+  // 调试停帧行：paused 且首帧属于当前文件时高亮该行；继续/停止/切走自动清除
+  React.useEffect(() => {
+    const ed = editorRef.current
+    if (!ed) return
+    const top = dapSnap.topFrame
+    const hit = top && top.file && sameFile(top.file, active)
+    setPausedLine(ed, hit ? top.line : null)
+  }, [dapSnap.phase, dapSnap.topFrame, active, contentPath, sameFile])
+
   /**
    * 跳转落地后给目标区域挂临时高亮（默认 1.2s 后自动清除）。
    *
@@ -1811,6 +2135,14 @@ export function EditorView(props) {
 
   // 打开文件后的跳转（导航历史恢复/差异聚焦/搜索与 LSP 行列跳转，目标内容就绪后执行一次）
   //
+  // ⚠️ 依赖必须含 monaco：contentReady 在**文本到达**时即为真，可能早于 Monaco 就绪；
+  // 那一帧 editorRef.current 仍是 null → 本 effect 提前返回并保留 pendingFocus，随后
+  // Monaco 载入、ensureEditor 建好编辑器，若 effect 不因 monaco 变化重跑，pendingFocus
+  // 就永久滞留 —— 观感是「首次跳转只打开文件不定位，手动再触发一次才落到目标行」
+  // （实测复现：Monaco 未就绪时派发 line=500，首次停在 1:1，二次触发才到 500）。
+  // ⚠️ 依赖也必须含 mdPreviewing：预览态切换会替换 Monaco host 并**重建**编辑器实例，
+  // 而 active/content 都没变；缺此依赖同样不重跑（同下方 model 同步 effect）。
+  //
   // ⚠️ 门控必须用 contentReady（contentPath === active），不能用 `content === null`：
   // 跨文件跳转时切页签的那一帧 content 仍是**上一个文件**的内容（非 null），据此判定
   // 「已就绪」会提前定位；随后真实内容到达触发 model 重设/内容写入，Monaco 会重置光标，
@@ -1852,7 +2184,7 @@ export function EditorView(props) {
     ed.revealLineInCenter(Math.max(1, target.start ?? 1))
     ed.setPosition({ lineNumber: Math.max(1, target.start ?? 1), column: 1 })
     ed.focus()
-  }, [active, content, contentReady, pendingRegions, focusRequest])
+  }, [active, content, contentReady, pendingRegions, focusRequest, monaco, mdPreviewing])
 
   const jumpTo = (region) => {
     if (editorRef.current) {
@@ -1982,6 +2314,32 @@ export function EditorView(props) {
     loadContent(path, sessionId, true)
   }
 
+  /**
+   * Markdown 在源码编辑与预览之间切换（按路径记忆，不持久化）。
+   *
+   * ⚠️ 进入预览前必须 flushSave()：预览态会替换 Monaco host，切回时编辑器实例是新建的；
+   * 若此刻还有未到期的 700ms 防抖保存，定时器到点时 editorRef.current 已被清空
+   * （见 EditorView 卸载清理），doSave 会静默 return —— 用户改动永不落盘。
+   * 同时保存视图状态，保证切回源码后光标/滚动位置不丢。
+   * @author ddj 2026年09月18号
+   * @param path Markdown 文件路径
+   */
+  const toggleMdPreview = (path) => {
+    if (!path) return
+    const next = new Set(mdPreviewRef.current)
+    const entering = !next.has(path)
+    if (entering) {
+      flushSave()
+      saveViewState(path)
+      next.add(path)
+    } else {
+      next.delete(path)
+    }
+    mdPreviewRef.current = next
+    setStatus(entering ? '已切换为 Markdown 预览' : '已切换为源码编辑')
+  }
+  toggleMdPreviewRef.current = toggleMdPreview
+
   /**
    * 图片预览面板：工具条（尺寸 meta / SVG 文本切换 / 刷新）+ 棋盘底自适应图片。
    * @author ddj 2026年09月08号
@@ -2243,6 +2601,8 @@ export function EditorView(props) {
         leftLabel: 'BASE',
         rightLabel: '工作区',
         scheme: 'edrv-svn-base',
+        binary: outcome.binary === true,
+        encodingHint: outcome.encodingHint === true,
       })
       setStatus(outcome.message)
     })
@@ -2254,8 +2614,9 @@ export function EditorView(props) {
    * @author ddj 2026年09月16号
    * @param relPath 目标工作区相对路径
    * @param revision 目标版本
+   * @param logTarget 来自日志弹窗时的日志目标（不传 = 非日志入口）
    */
-  const runSvnDiffRev = (relPath, revision) => {
+  const runSvnDiffRev = (relPath, revision, logTarget) => {
     if (!relPath) { setStatus('无目标文件'); return }
     setStatus('读取 r' + revision + ' 差异…')
     void svnDiffRev(sessionId, relPath, revision).then((outcome) => {
@@ -2270,6 +2631,9 @@ export function EditorView(props) {
         leftLabel: 'r' + Math.max(1, revision - 1),
         rightLabel: 'r' + revision,
         scheme: 'edrv-svn-rev' + revision,
+        binary: outcome.binary === true,
+        encodingHint: outcome.encodingHint === true,
+        logTarget,
       })
       setStatus('已打开 r' + revision + ' 差异')
     })
@@ -2282,8 +2646,9 @@ export function EditorView(props) {
    * @param relPath 目标工作区相对路径
    * @param revA 左侧版本（选中顺序在前）
    * @param revB 右侧版本（选中顺序在后）
+   * @param logTarget 来自日志弹窗时的日志目标（不传 = 非日志入口）
    */
-  const runSvnDiffPair = (relPath, revA, revB) => {
+  const runSvnDiffPair = (relPath, revA, revB, logTarget) => {
     if (!relPath) { setStatus('仅文件目标支持比较两个修订'); return }
     setStatus('读取 r' + revA + ' ↔ r' + revB + ' 差异…')
     void svnDiffPair(sessionId, relPath, revA, revB).then((outcome) => {
@@ -2300,6 +2665,9 @@ export function EditorView(props) {
         leftLabel: 'r' + revA,
         rightLabel: 'r' + revB,
         scheme: 'edrv-svn-pair-' + revA + '-' + revB,
+        binary: outcome.binary === true,
+        encodingHint: outcome.encodingHint === true,
+        logTarget,
       })
       setStatus('已打开 r' + revA + ' ↔ r' + revB + ' 差异')
     })
@@ -2311,8 +2679,9 @@ export function EditorView(props) {
    * @author ddj 2026年09月17号
    * @param relPath 目标工作区相对路径
    * @param revision 左侧版本
+   * @param logTarget 来自日志弹窗时的日志目标（不传 = 非日志入口）
    */
-  const runSvnDiffWorking = (relPath, revision) => {
+  const runSvnDiffWorking = (relPath, revision, logTarget) => {
     if (!relPath) { setStatus('仅文件目标支持与工作副本比较'); return }
     setStatus('读取 r' + revision + ' ↔ 工作副本 差异…')
     void svnDiffWorking(sessionId, relPath, revision).then((outcome) => {
@@ -2326,11 +2695,42 @@ export function EditorView(props) {
         leftLabel: 'r' + revision,
         rightLabel: '工作区',
         scheme: 'edrv-svn-work-' + revision,
+        binary: outcome.binary === true,
+        encodingHint: outcome.encodingHint === true,
+        logTarget,
       })
       setStatus('已打开 r' + revision + ' ↔ 工作副本 差异')
     })
   }
 
+  /**
+   * 打开双侧本地文件差异（W2-4 冲突副本 `.rN` ↔ `.mine`，只读并排；resolve 由用户自行执行）。
+   * @author ddj 2026年09月20号
+   * @param left 左侧工作区相对路径
+   * @param right 右侧工作区相对路径
+   * @param leftLabel 左侧标签（如 `.r293524`）
+   * @param rightLabel 右侧标签（如 `.mine`）
+   * @param title 标题（冲突文件路径）
+   */
+  const runSvnDiffLocalPair = (left, right, leftLabel, rightLabel, title) => {
+    setStatus('读取冲突副本差异…')
+    void svnDiffLocalPair(sessionId, left, right).then((outcome) => {
+      if (!outcome.ok) { setStatus(outcome.message); return }
+      setSvnDiff({
+        path: title,
+        base: outcome.leftText ?? null,
+        working: outcome.rightText ?? '',
+        message: '解决后执行 svn resolve --accept working（本插件不自动执行）',
+        leftLabel,
+        rightLabel,
+        scheme: 'edrv-svn-local',
+        binary: outcome.binary === true,
+        encodingHint: outcome.encodingHint === true,
+      })
+      setStatus('已打开冲突副本对比')
+    })
+  }
+
   /**
    * 打开日志弹窗（P3）：加载该目标的提交历史。
    * @author ddj 2026年09月16号
@@ -2346,6 +2746,17 @@ export function EditorView(props) {
     ensureSvnLog(sessionId, scope, target, SVN_LOG_PAGE)
   }
 
+  /**
+   * 从日志弹窗打开的差异视图返回日志：按打开时记录的日志目标重开弹窗。
+   * 日志数据走 scope 缓存（openSvnLog → ensureSvnLog 命中即不重查）；选中项不复原。
+   * @author ddj 2026年09月18号
+   */
+  const backToSvnLog = () => {
+    const target = svnDiff?.logTarget ?? ''
+    setSvnDiff(null)
+    openSvnLog(target)
+  }
+
   /** 加入版本控制（活动文件；未纳入版本控制的文件才有意义，host 侧会再校验）。 */
   const runSvnAdd = (relPath) => {
     if (!relPath) { setStatus('无活动文件'); return }
@@ -2448,6 +2859,7 @@ export function EditorView(props) {
         path,
         notify: (message) => setStatus(message),
         openSvnDiff: (p) => runSvnDiffBase(p),
+        openSvnLocalPair: runSvnDiffLocalPair,
         openSvnLog: (p) => openSvnLog(p ?? path),
         refreshChanges: () => refreshSvnChanges(sessionId, scope),
       })
@@ -2545,6 +2957,8 @@ export function EditorView(props) {
    */
   const openFileAt = (path, line, column, endLine, endColumn) => {
     if (!path) return
+    const tracePath = tabPathOf(path, cwd)
+    dapTrace('open-file-at', { input: path, normalized: tracePath, line, cwd })
     recordNav()
     // G9：同 openFile，先归一再进页签，保证待跳转路径与 active 同形态
     const normalized = addTabNorm(path, true)
@@ -2553,6 +2967,51 @@ export function EditorView(props) {
     setFocusRequest((value) => value + 1)
   }
 
+  // 停帧跳转/调试命令监听（openFileAt 每渲染重建，经 ref 让空依赖监听读最新闭包）
+  const dapOpenRef = React.useRef(null)
+  dapOpenRef.current = openFileAt
+  React.useEffect(() => {
+    const onStopped = (e) => {
+      const detail = e?.detail
+      dapTrace('debug-stopped', detail)
+      if (!detail?.file) {
+        // 适配器只给了 chunkname 且工作区未定位到源文件：明确告知，不留静默无反应
+        setStatus('已暂停：未定位到源文件')
+        return
+      }
+      dapOpenRef.current?.(detail.file, detail.line, 1)
+    }
+    const onToggle = () => {
+      const ed = editorRef.current
+      const path = modelPathOf(ed)
+      const line = ed?.getPosition?.()?.lineNumber
+      if (path && line) dapToggleRef.current?.(path, line)
+      else setStatus('无活动文件，无法切换断点')
+    }
+    const onToggleEvt = () => onToggle()
+    const onStart = () => dapStore.startOrContinue()
+    const onStop = () => { void dapStore.stop() }
+    const onStepOver = () => { void dapStore.action('next') }
+    const onStepIn = () => { void dapStore.action('stepIn') }
+    const onStepOut = () => { void dapStore.action('stepOut') }
+    window.addEventListener('edrv:debug-stopped', onStopped)
+    window.addEventListener('edrv.command.debugToggleBreakpoint', onToggleEvt)
+    window.addEventListener('edrv.command.debugStartContinue', onStart)
+    window.addEventListener('edrv.command.debugStepOver', onStepOver)
+    window.addEventListener('edrv.command.debugStepInto', onStepIn)
+    window.addEventListener('edrv.command.debugStepOut', onStepOut)
+    window.addEventListener('edrv.command.debugStop', onStop)
+    return () => {
+      window.removeEventListener('edrv:debug-stopped', onStopped)
+      window.removeEventListener('edrv.command.debugToggleBreakpoint', onToggleEvt)
+      window.removeEventListener('edrv.command.debugStartContinue', onStart)
+      window.removeEventListener('edrv.command.debugStepOver', onStepOver)
+      window.removeEventListener('edrv.command.debugStepInto', onStepIn)
+      window.removeEventListener('edrv.command.debugStepOut', onStepOut)
+      window.removeEventListener('edrv.command.debugStop', onStop)
+    }
+  }, [])
+
   const openPath = () => {
     const p = (pathDraft || '').trim()
     if (!p) return
@@ -2598,6 +3057,13 @@ export function EditorView(props) {
   const pathBar = React.createElement('div', { className: 'edrv-pathbar', title: active || '' },
     React.createElement('span', { className: 'edrv-pb-name' }, active ? String(active).split(/[\\/]/).pop() : '未打开文件'),
     React.createElement('span', { className: 'edrv-pb-full' }, active || '使用右上搜索框 (' + (chordOf('edrv.quickOpen') ?? 'Ctrl+P') + ') 打开文件'),
+    // Markdown 预览/源码切换（需求 4）：仅 .md 文件出现；命令栏与 Ctrl+Shift+V 为同一动作
+    (isMdActive ? React.createElement('button', {
+      className: 'edrv-pill edrv-pill-ghost edrv-pb-mdbtn',
+      title: (mdPreviewing ? '切回源码编辑' : '预览 Markdown') + '（' + (chordOf('edrv.toggleMarkdownPreview') ?? '未绑定') + '）',
+      onClick: () => toggleMdPreview(active),
+    }, mdPreviewing ? '源码' : '预览') : null),
+    (mdPreviewing ? React.createElement('span', { className: 'edrv-pb-meta' }, '预览') : null),
     (active && !isImageActive && langOf(active) ? React.createElement('span', { className: 'edrv-pb-meta' }, langOf(active)) : null),
     (isImageActive && imgSize ? React.createElement('span', { className: 'edrv-pb-meta' }, imgSize.w + '×' + imgSize.h) : null),
     (cursor ? React.createElement('span', { className: 'edrv-pb-meta' }, cursor) : null),
@@ -2757,6 +3223,7 @@ export function EditorView(props) {
       message: svnDiff.message,
       leftLabel: svnDiff.leftLabel,
       rightLabel: svnDiff.rightLabel,
+      onBack: svnDiff.logTarget !== undefined ? backToSvnLog : undefined,
       onClose: () => setSvnDiff(null),
     })
   } else if (!monaco && !monacoErr) {
@@ -2786,6 +3253,17 @@ export function EditorView(props) {
     body = React.createElement('div', { className: 'edrv-pdf-host', ref: ensurePdfHost, key: active })
   } else if (isPdfActive) {
     body = loadingBody(loadStage.message || '读取 PDF…', loadStage.progress)
+  } else if (mdPreviewing && contentReady) {
+    // Markdown 预览（需求 4）：复用已加载的文本内容渲染，不额外请求；编辑仍在源码态完成
+    body = React.createElement(MarkdownPanel, {
+      key: 'edrv-md-' + active,
+      text: content,
+      onToggleSource: () => toggleMdPreview(active),
+      onReload: () => reloadFile(),
+      onOpenFile: (path, line) => openFileAt(path, line ?? 1),
+    })
+  } else if (mdPreviewing) {
+    body = loadingBody(loadStage.message || '读取 Markdown…', loadStage.progress)
   } else if (content === null) {
     body = loadingBody(loadStage.message || '读取文件内容…', loadStage.progress)
   } else {
@@ -2910,14 +3388,125 @@ export function EditorView(props) {
     svnChanges,
     svnChangeMap: svnChangeMapOf(scope),
     openSvnDiff: (p) => runSvnDiffBase(p),
+    openSvnLocalPair: runSvnDiffLocalPair,
     refreshSvnChanges: () => refreshSvnChanges(sessionId, scope),
     openSvnLog: (p) => openSvnLog(p),
     confirm: (message) => (typeof window === 'undefined' ? false : window.confirm(message)),
     notify: (message) => setStatus(message),
   }
 
+  // 调试工具条（VS Code 浮动条紧凑版，图2 形态）：配置下拉 + 启动/继续 + 单步组 + 停止 + 相位。
+  // 配置来自工作区 .dsh/launch.json（插件专属，与 VS Code 互不干扰）；无配置时下拉提示且按钮禁用。
+  const dapPhaseTextOf = () => ({
+    idle: '', starting: '启动中…', waiting: '等待目标…', running: '运行中', paused: '已暂停', terminated: '已结束',
+  }[dapSnap.phase] || '')
+  const dapActive = dapSnap.phase !== 'idle' && dapSnap.phase !== 'terminated'
+  const dapPaused = dapSnap.phase === 'paused'
+  const dapBtn = (label, title, disabled, onClick) => React.createElement('button', {
+    key: title, className: 'edrv-dapbar-btn', title, disabled: disabled === true, onClick,
+  }, label)
+  const dapBarVisible = dapActive || Boolean(dapSnap.candidates)
+  const dapBarStyle = dapBarPos
+    ? { left: dapBarPos.left, top: dapBarPos.top, right: 'auto' }
+    : undefined
+  const dapBar = dapBarVisible ? React.createElement('div', {
+    ref: dapBarRef,
+    className: 'edrv-dapbar' + (dapBarVisible ? ' on' : '') + (dapBarDragging ? ' dragging' : ''),
+    style: dapBarStyle,
+  },
+    React.createElement('span', {
+      className: 'edrv-dapbar-grip',
+      role: 'button',
+      tabIndex: 0,
+      title: '拖动调试工具条',
+      'aria-label': '拖动调试工具条',
+      onPointerDown: startDapBarDrag,
+    }, '⠿'),
+    (dapSnap.candidates
+      ? [
+          React.createElement('select', {
+            key: 'pick', className: 'edrv-dapbar-cfg', title: '选择附加目标进程（processName 命中多个候选）',
+            value: String(dapPickPid || dapSnap.candidates[0]?.pid || ''),
+            onChange: (e) => setDapPickPid(Number(e.target.value)),
+          },
+            dapSnap.candidates.map((it) => React.createElement('option', { key: it.pid, value: String(it.pid) },
+              it.pid + ' : ' + it.name + (it.title ? ' — ' + it.title.slice(0, 44) : '')))),
+          dapBtn('✓', '附加到选中进程', false, () => dapStore.confirmPick(dapPickPid || dapSnap.candidates![0]?.pid || 0)),
+          dapBtn('✕', '取消', false, () => dapStore.cancelPick()),
+        ]
+      : React.createElement('select', {
+          className: 'edrv-dapbar-cfg',
+          title: '调试配置（读取工作区 .dsh/launch.json；适配器由扩展清单 contributes.debuggers 提供）',
+          value: dapSnap.selectedConfig ?? '',
+          onChange: (e) => dapStore.selectConfig(e.target.value),
+        },
+          dapSnap.configs.length
+            ? dapSnap.configs.map((c) => {
+                // 旧 host 无 adapters 数据时视为全部可用（保持兼容）；有数据则按可用性置灰并给原因
+                const adapter = dapSnap.adapters.find((a) => a.type === c.type)
+                const ready = dapSnap.adapters.length === 0 || adapter?.available === true
+                const suffix = ready ? '' : '（' + (adapter?.reason || '未发现该类型适配器') + '）'
+                return React.createElement('option', { key: c.name, value: c.name, disabled: !ready }, c.name + suffix)
+              })
+            : React.createElement('option', { value: '' }, '无可用调试配置'))),
+    dapBtn(dapPaused ? '▶' : '▶', '启动 / 继续（F5）', !dapPaused && (!dapSnap.configs.some((c) => dapSnap.adapters.length === 0 || dapSnap.adapters.find((a) => a.type === c.type)?.available === true) || dapActive), () => dapStore.startOrContinue()),
+    dapBtn('⏸', '暂停', !dapActive, () => { void dapStore.action('pause') }),
+    dapBtn('⤵', '单步跳过（F10）', !dapPaused, () => { void dapStore.action('next') }),
+    dapBtn('↓', '单步步入（F11）', !dapPaused, () => { void dapStore.action('stepIn') }),
+    dapBtn('↑', '单步步出（Shift+F11）', !dapPaused, () => { void dapStore.action('stepOut') }),
+    dapBtn('⏹', '停止（Shift+F5）', !dapActive, () => { void dapStore.stop() }),
+    (dapPhaseTextOf()
+      ? React.createElement('span', { className: 'edrv-dapbar-phase' + (dapPaused ? ' paused' : '') },
+          dapPhaseTextOf() + (dapSnap.pid ? ' · pid ' + dapSnap.pid : ''))
+      : null),
+    (dapSnap.error
+      ? React.createElement('span', { className: 'edrv-dapbar-err', title: dapSnap.error }, '⚠ ' + dapSnap.error.slice(0, 40))
+      : null)) : null
+
+  /**
+   * 「添加配置」按钮点击：定位 configurations 数组插入点（数组开头行首），
+   * 显式拉起 Monaco 补全下拉选择调试配置片段插入。
+   * @author ddj 2026年09月22号
+   */
+  const addLaunchConfig = async () => {
+    const ed = editorRef.current
+    if (!ed) { setStatus('无活动编辑器'); return }
+    const path = modelPathOf(ed)
+    if (!path || !LAUNCH_JSON_RE.test(String(path).replace(/\\/g, '/'))) {
+      setStatus('请先打开 .dsh/launch.json')
+      return
+    }
+    const model = ed.getModel && ed.getModel()
+    const pos = model ? findArrayPos(model.getValue()) : null
+    if (!pos) { setStatus('未找到 configurations 数组'); return }
+    // 预拉片段并预检可用条数：全不可用时不弹空 suggest（否则按钮点了无反馈）
+    const snippets = await prefetchSnippets().catch(() => [])
+    if (!snippets.some((snip) => snip.available !== false)) {
+      setStatus('无可用适配器的配置模板（适配器入口缺失或未发现该类型适配器）')
+      return
+    }
+    ed.focus()
+    ed.setPosition({ lineNumber: pos.line, column: pos.column })
+    if (typeof ed.revealPositionInCenterIfOutsideViewport === 'function') {
+      ed.revealPositionInCenterIfOutsideViewport({ lineNumber: pos.line, column: pos.column })
+    }
+    ed.trigger('edrv-addcfg', 'editor.action.triggerSuggest', null)
+    setStatus('选择要插入的调试配置')
+  }
+
+  // 「添加配置」按钮（VSCode 同款形态，编辑区右下角）：仅插件专属 launch.json 打开且非差异审阅态显示
+  const addCfgBtn = (active && !svnDiff && LAUNCH_JSON_RE.test(String(active).replace(/\\/g, '/')))
+    ? React.createElement('button', {
+        className: 'edrv-addcfg',
+        title: '添加调试配置（插入到 configurations 数组开头）',
+        onClick: addLaunchConfig,
+      }, '添加配置…')
+    : null
+
   // 主编辑列（侧边栏右侧）：pathBar + tabRow + 编辑/差异区（底部整条留给 DSH 对话输入栏）
   const editorArea = React.createElement('div', { className: 'edrv-editor-area' },
+    dapBar,
+    addCfgBtn,
     body,
     hoverEl,
     overlay)
@@ -3062,31 +3651,124 @@ export function EditorView(props) {
           setSvnLog({ ...svnLog, limit: SVN_LOG_SHOW_ALL_LIMIT })
           ensureSvnLog(sessionId, scope, svnLog.target || '', SVN_LOG_SHOW_ALL_LIMIT, true, svnLogOptsOf(svnLog))
         },
-        onOpenDiff: (relPath, revision) => { setSvnLog(null); runSvnDiffRev(relPath, revision) },
-        onComparePair: (revA, revB) => { setSvnLog(null); runSvnDiffPair(svnLog.target || '', revA, revB) },
-        onCompareWorking: (revision) => { setSvnLog(null); runSvnDiffWorking(svnLog.target || '', revision) },
+        onOpenDiff: (relPath, revision) => { setSvnLog(null); runSvnDiffRev(relPath, revision, svnLog.target || '') },
+        onComparePair: (revA, revB) => { setSvnLog(null); runSvnDiffPair(svnLog.target || '', revA, revB, svnLog.target || '') },
+        onCompareWorking: (revision) => { setSvnLog(null); runSvnDiffWorking(svnLog.target || '', revision, svnLog.target || '') },
         onOpenFile: (relPath) => { setSvnLog(null); openFile(relPath, false) },
         onClose: () => { setSvnLog(null); setSvnLogError('') },
       })
     : null
+  // W2-1 补丁对话框 / W2-2 目录对比对话框：portal 到 body，与日志弹窗同一挂载方式
+  const patchDialogEl = patchDialog
+    ? React.createElement(SvnPatchDialog, {
+        key: 'edrv-svn-patch',
+        path: patchDialog.path,
+        text: patchDialog.text,
+        truncated: patchDialog.truncated === true,
+        binary: patchDialog.binary === true,
+        onNote: (message) => setStatus(message),
+        onClose: () => setPatchDialog(null),
+      })
+    : null
+  const sumDialogEl = sumDialog
+    ? React.createElement(SvnSumDialog, {
+        key: 'edrv-svn-sum',
+        sessionId,
+        path: sumDialog.path,
+        onNote: (message) => setStatus(message),
+        onClose: () => setSumDialog(null),
+      })
+    : null
   // 诊断日志弹窗：portal 到 body，与命令栏/SVN 日志弹窗同一挂载方式
   const dlogEl = dlogOpen
     ? React.createElement(LogDialog, { key: 'edrv-dlog', sessionId, onClose: () => setDlogOpen(false) })
     : null
+  // 断点右键菜单（逐条对齐 CodeBuddy：4 项添加类 / 删除·编辑·启停 / 记录点名词 / 暂停追加运行到行）
+  const runBpMenuAction = (action) => {
+    const scope = dapScopeRef.current
+    const cwd = dapCwdRef.current
+    const menu = dapBpMenu
+    if (!menu) return
+    const { path, line } = menu
+    if (action === 'add') { dapStore.toggleAt(scope, cwd, path, line); return }
+    if (action === 'delete') { if (menu.hasBp) dapStore.toggleAt(scope, cwd, path, line); return }
+    if (action === 'disable' || action === 'enable') { dapStore.setBpEnabled(scope, cwd, path, line, action === 'enable'); return }
+    if (action === 'edit') { openBpEditor(path, line); return }
+    if (action === 'run-to-line') { dapStore.runTo(cwd, path, line); return }
+    if (action === 'add-triggered') { setStatus('当前 Lua 调试器不支持触发的断点'); return }
+    // 添加条件断点 / 添加记录点：先建点，再开浮层并选中对应模式（0 表达式 / 2 日志消息）
+    dapStore.toggleAt(scope, cwd, path, line)
+    openBpEditor(path, line, action === 'add-logpoint' ? 2 : 0)
+  }
+  const openBpEditor = (path, line, mode) => {
+    const entry = (dapStore.bpMapOf(dapScopeRef.current)[path] ?? []).find((it) => it.line === line)
+    if (!entry) return
+    const ed = editorRef.current
+    if (!ed?.changeViewZones) return
+    // 行内浮层（View Zone，整编辑区宽 + 推开内容，对齐 VS Code breakpointWidget）：同一时刻只挂一个
+    closeBpWidget()
+    bpWidgetRef.current = { ...createBpWidget(ed, {
+      line,
+      entry,
+      mode,
+      onSave: (fields) => {
+        dapStore.applyBpFields(dapScopeRef.current, dapCwdRef.current, path, line, fields)
+        setStatus('断点已更新')
+        closeBpWidget()
+      },
+      onClose: () => closeBpWidget(),
+    }), path, line }
+  }
+  const closeBpWidget = () => {
+    const held = bpWidgetRef.current
+    if (!held) return
+    bpWidgetRef.current = null
+    try { held.close() } catch { /* 编辑器可能已销毁 */ }
+  }
+  const dapBpMenuEl = dapBpMenu
+    ? React.createElement(ContextMenu, {
+        x: dapBpMenu.x,
+        y: dapBpMenu.y,
+        onClose: () => setDapBpMenu(null),
+        entries: buildBpMenu({
+          hasBreakpoint: dapBpMenu.hasBp,
+          enabled: dapBpMenu.enabled,
+          isLogpoint: dapBpMenu.isLogpoint,
+          paused: dapSnap.phase === 'paused',
+          canRunTo: true,
+          canTriggered: false,
+        }).map((item) => ({
+          id: 'dap-bp-' + item.id,
+          label: item.label,
+          hint: item.hint,
+          separator: item.separator,
+          onClick: () => runBpMenuAction(item.id),
+        })),
+      })
+    : null
+  const dapBpEditEl = null
   const rootEl = layout === 'side'
     ? React.createElement('div', { ref: viewRootRef, 'data-edrv-view': '1', 'data-edrv-layout': 'side', className: 'edrv-view-side', style: Object.assign({}, baseStyle, { height: '100%' }) },
         editorRow,
         tabMenuEl,
         paletteEl,
         svnLogEl,
+        patchDialogEl,
+        sumDialogEl,
         dlogEl,
-        snippetPickerEl)
+        snippetPickerEl,
+        dapBpMenuEl,
+        dapBpEditEl)
     : React.createElement('div', { ref: viewRootRef, 'data-edrv-view': '1', style: Object.assign({}, baseStyle, { height: 'var(--edrv-editor-height, 100%)', maxHeight: 'var(--edrv-editor-height, 100%)' }) },
         editorRow,
         tabMenuEl,
         paletteEl,
         svnLogEl,
+        patchDialogEl,
+        sumDialogEl,
         dlogEl,
-        snippetPickerEl)
+        snippetPickerEl,
+        dapBpMenuEl,
+        dapBpEditEl)
   return rootEl
 }