dsh-vscode-mode 0.1.57 → 0.1.59

package/package.json

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

package/src/ai/inline.ts

@@ -0,0 +1,192 @@
+/**
+ * dsh-vscode-mode host — AI 内联补全服务。
+ * 一次性非会话调用：配置解析（开关→provider/model 路由→思考档位）→ ctx.llm.stream
+ * 流式汇聚（只收 text-delta，reasoning-delta 天然不进补全）→ 早停 → 输出清理。
+ * llm 服务经 ctx.get('llm') 惰性获取（不用 inject：缺失时插件仍加载，AI 补全降级）。
+ * 模型目录（edrv.ai.models）：listProviders/listModels/resolveModelInfo 逐模型取档位，
+ * 进程级缓存 5 分钟，单模型 resolve 失败降级为无档位条目。
+ * 作者 ddj
+ */
+import type { Ctx } from '../store.js'
+import { log } from '../log.js'
+import type { LlmRuntimeLike, StreamChunk } from './llmTypes.js'
+import {
+  AI_EARLY_STOP_CHARS, AI_INLINE_SYSTEM, AI_MAX_LINES, AI_MAX_TOKENS, AI_TIMEOUT_MS,
+  buildInlinePrompt, cleanInlineText,
+  type AiConfigView, type AiDirectoryView, type AiInlineRequest, type AiInlineResult,
+} from '../shared/ai.js'
+
+/** AI 补全配置来源（settings section，fileOpenSettings.ts 提供 getter）。 */
+export interface AiConfigSource {
+  get(): AiConfigView
+}
+
+/** host 补全服务依赖（装配时一次性注入）。 */
+export interface AiInlineDeps {
+  ctx: Ctx
+  config: AiConfigSource
+}
+
+/** 模型目录缓存（进程级：5 分钟 TTL，避免每次打开设置页都逐模型 resolve）。 */
+const DIR_TTL_MS = 5 * 60 * 1000
+let dirCache: { view: AiDirectoryView; at: number } | null = null
+
+/** 复位目录缓存（测试隔离用）。 */
+export function resetAiDirCache(): void {
+  dirCache = null
+}
+
+/**
+ * 取 llm 运行时（惰性；缺失/未装配返回 null 并给诊断）。
+ * @author ddj
+ * @param ctx DSH 上下文
+ * @returns llm 运行时或 null
+ */
+function llmOf(ctx: Ctx): LlmRuntimeLike | null {
+  try {
+    const llm = ctx.get('llm') as LlmRuntimeLike | undefined
+    return llm && typeof llm.stream === 'function' ? llm : null
+  } catch {
+    return null
+  }
+}
+
+/**
+ * 解析请求路由：用户配置优先（provider/model 均非空），否则取目录首个 provider+model。
+ * @author ddj
+ * @param llm llm 运行时
+ * @param cfg AI 配置
+ * @returns 路由（provider/model）；不可路由返回 null
+ */
+async function routeOf(llm: LlmRuntimeLike, cfg: AiConfigView): Promise<{ provider: string; model: string } | null> {
+  if (cfg.provider && cfg.model) return { provider: cfg.provider, model: cfg.model }
+  const providers = llm.listProviders()
+  if (!providers.length) return null
+  const provider = cfg.provider || providers[0].id
+  const models = await llm.listModels(provider).catch(() => [])
+  if (!models.length) return null
+  return { provider, model: models[0].id }
+}
+
+/**
+ * 单次 AI 内联补全。
+ * @author ddj
+ * @param deps 服务依赖
+ * @param req 补全请求（client 已裁剪窗口）
+ * @returns 补全结果（text 空 = 无建议）
+ */
+export async function aiInlineComplete(deps: AiInlineDeps, req: AiInlineRequest): Promise<AiInlineResult> {
+  const cfg = deps.config.get()
+  if (!cfg.enabled) return { text: '' }
+  if (!req || typeof req.prefix !== 'string' || !req.prefix) return { text: '' }
+  const llm = llmOf(deps.ctx)
+  if (!llm) return { text: '', note: 'llm 服务不可用' }
+  const route = await routeOf(llm, cfg)
+  if (!route) return { text: '', note: '未找到可用模型（请检查 DSH 模型配置）' }
+  const controller = new AbortController()
+  const timer = setTimeout(() => controller.abort(new Error('timeout')), AI_TIMEOUT_MS)
+  try {
+    const stream = llm.stream({
+      provider: route.provider,
+      model: route.model,
+      ...(cfg.effort ? { reasoningEffort: cfg.effort } : {}),
+      messages: [
+        {
+          role: 'user',
+          content: [{ type: 'text', text: buildInlinePrompt(req) }],
+          source: { kind: 'user' },
+        } as never,
+      ],
+      system: AI_INLINE_SYSTEM,
+      temperature: 0.2,
+      maxTokens: AI_MAX_TOKENS,
+      // 不传 stop：llm-pi-ai 等适配器不支持该选项（UNSUPPORTED_OPTION 直接 error finish）；
+      // 截断由行数/字符早停兜底
+      signal: controller.signal,
+    })
+    let text = ''
+    let aborted = false
+    let failNote = ''
+    let reasoningChars = 0
+    for await (const chunk of stream) {
+      const c = chunk as StreamChunk
+      if (c.type === 'text-delta') {
+        text += c.text
+        // 早停：满 3 行或 300 字符即掐断流，省尾部 token 延迟
+        if (text.split('\n').length > AI_MAX_LINES || text.length >= AI_EARLY_STOP_CHARS) {
+          controller.abort(new Error('early-stop'))
+          aborted = true
+        }
+      } else if (c.type === 'reasoning-delta') {
+        reasoningChars += c.text.length
+      } else if (c.type === 'finish') {
+        // 适配器失败走 finish(error/aborted) 而非抛异常：检查 reason.kind 带回诊断
+        const kind = (c.reason as { kind?: string })?.kind
+        if (kind === 'error' || kind === 'aborted') {
+          const failure = (c.reason as { failure?: { code?: string; message?: string } }).failure
+          failNote = (failure?.code ?? kind) + ': ' + (failure?.message ?? '模型调用失败')
+          log.debug('[ai-inline] 流失败：' + failNote)
+        }
+        break
+      } else if (c.type === 'usage' || c.type === 'block-start' || c.type === 'block-end') {
+        // 汇聚无关块：跳过
+      } else if (c.type === 'tool-call-delta') {
+        // 工具块不进补全
+      }
+      if (aborted) break
+    }
+    if (failNote) return { text: '', note: 'AI 补全失败：' + failNote }
+    const clean = cleanInlineText(text, req.prefix)
+    if (!clean) {
+      // 思考型模型常见症状：正文空但思考有内容 → 明确提示换非思考模型（debug 实证 isd/deepseek-v4-flash）
+      if (text.length === 0 && reasoningChars > 0) {
+        log.debug('[ai-inline] 仅思考无正文（reasoning ' + reasoningChars + ' 字符）')
+        return { text: '', note: '该模型只返回了思考没有正文，请在设置页换非思考模型' }
+      }
+      log.debug('[ai-inline] 空输出（原始 ' + text.length + ' 字符）')
+      return { text: '' }
+    }
+    return { text: clean }
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error)
+    log.debug('[ai-inline] 失败：' + msg)
+    return { text: '', note: 'AI 补全失败：' + msg }
+  } finally {
+    clearTimeout(timer)
+  }
+}
+
+/**
+ * 模型目录视图（edrv.ai.models）：DSH 已配置 provider 全量 + 逐模型思考档位。
+ * @author ddj
+ * @param ctx DSH 上下文
+ * @param force 跳过缓存强制刷新
+ * @returns 目录视图（llm 缺失时 note 说明 + 空目录）
+ */
+export async function aiModels(ctx: Ctx, force = false): Promise<AiDirectoryView> {
+  if (!force && dirCache && Date.now() - dirCache.at < DIR_TTL_MS) return dirCache.view
+  const llm = llmOf(ctx)
+  if (!llm) {
+    return { providers: [], note: 'llm 服务不可用（无法枚举模型）' }
+  }
+  const out: AiDirectoryView = { providers: [] }
+  for (const p of llm.listProviders()) {
+    const models = await llm.listModels(p.id).catch(() => [])
+    const entries = []
+    for (const m of models) {
+      let efforts: Array<{ id: string; name: string }> = []
+      let def = ''
+      try {
+        const info = await llm.resolveModelInfo(p.id, m.id)
+        efforts = (info.reasoning?.efforts ?? []).map((e: { id: string; name: string }) => ({ id: e.id, name: e.name }))
+        def = info.reasoning?.defaultEffort ?? ''
+      } catch {
+        // 单模型元数据失败：降级为无档位条目（不影响目录其余部分）
+      }
+      entries.push({ provider: p.id, model: m.id, name: m.name || m.id, efforts, defaultEffort: def })
+    }
+    out.providers.push({ id: p.id, name: p.name || p.id, models: entries })
+  }
+  dirCache = { view: out, at: Date.now() }
+  return out
+}

package/src/ai/llmTypes.ts

@@ -0,0 +1,83 @@
+/**
+ * dsh-vscode-mode host — @deepseek-ai/dsh-llm 精简类型（AI 内联补全消费面）。
+ * 以 profile 实装 0.1.3-alpha.2 d.ts 为准的最小子集；宿主环境经 external 解析，
+ * 这里只声明本插件用到的形状（运行时值来自 ctx.get('llm')，无直接 import）。
+ * 作者 ddj
+ */
+
+/** 文本块（模型可见）。 */
+export interface TextBlock {
+  type: 'text'
+  text: string
+}
+
+/** 消息内容块（本插件只产 text）。 */
+export type ContentBlock = TextBlock
+
+/** 消息来源：手工构造一次性请求只产 user。 */
+export type MessageSource = { kind: 'user' }
+
+/** 流式模型调用的一条消息。 */
+export interface LlmMessage {
+  readonly id: string
+  readonly role: 'system' | 'user' | 'assistant'
+  readonly content: ContentBlock[]
+  readonly source: MessageSource
+}
+
+/** 生成请求（reasoningEffort 为模型元数据里的档位 id）。 */
+export interface GenerateOptions {
+  provider: string
+  model: string
+  reasoningEffort?: string
+  messages: readonly LlmMessage[]
+  system?: string
+  temperature?: number
+  maxTokens?: number
+  stop?: string[]
+  signal?: AbortSignal
+}
+
+/** 流块：本插件消费 text-delta / finish（其余忽略）。 */
+export type StreamChunk =
+  | { type: 'block-start'; index: number; blockType: string }
+  | { type: 'text-delta'; index: number; text: string }
+  | { type: 'reasoning-delta'; index: number; text: string }
+  | { type: 'tool-call-delta'; index: number; id: string; name?: string; argumentsDelta: string }
+  | { type: 'block-end'; index: number; block: unknown }
+  | { type: 'usage'; usage: unknown }
+  | { type: 'finish'; reason: { kind: string }; replayState?: unknown }
+
+/** provider 展示元数据。 */
+export interface LlmProviderInfo {
+  id: string
+  name: string
+}
+
+/** 模型条目（目录级，未解档位）。 */
+export interface LlmModelInfo {
+  provider: string
+  id: string
+  name: string
+  description?: string
+}
+
+/** 可选思考档位表（模型元数据驱动）。 */
+export interface LlmModelReasoningInfo {
+  efforts: readonly { id: string; name: string }[]
+  defaultEffort?: string
+}
+
+/** 精确模型元数据（含 reasoning）。 */
+export interface LlmResolvedModelInfo extends LlmModelInfo {
+  context?: { contextWindow: number }
+  reasoning?: LlmModelReasoningInfo
+}
+
+/** llm 运行时（ctx.get('llm') 取得）的最小子集。 */
+export interface LlmRuntimeLike {
+  listProviders(): LlmProviderInfo[]
+  listModels(provider: string): Promise<LlmModelInfo[]>
+  resolveModelInfo(provider: string, model: string, signal?: AbortSignal): Promise<LlmResolvedModelInfo>
+  stream(options: GenerateOptions): AsyncIterable<StreamChunk>
+}

package/src/ai/rpc.ts

@@ -0,0 +1,35 @@
+/**
+ * dsh-vscode-mode host — edrv.ai.* RPC handlers。
+ * inline：AI 内联补全（一次调用一次结果，无状态）；models：模型目录（缓存）；
+ * configGet/configUpdate：settings section 的 AI 字段读写。
+ * 作者 ddj
+ */
+import type { RpcHandlerMap } from '../shared/rpc.js'
+import type { FileOpenSettingsState } from '../fileOpenSettings.js'
+import type { AiConfigView } from '../shared/ai.js'
+import { aiInlineComplete, aiModels, type AiInlineDeps } from './inline.js'
+
+/** AI RPC 依赖（settings 状态由 index.ts 装配时桥接）。 */
+export interface AiRpcDeps {
+  ctx: AiInlineDeps['ctx']
+  settings: FileOpenSettingsState & {
+    ai: () => AiConfigView
+    aiUpdate: (patch: import('../shared/ai.js').AiConfigPatch, expectedRevision?: number) => Promise<AiConfigView>
+  }
+}
+
+/**
+ * 构造 edrv.ai.* handlers（一次性创建，无跨请求状态——目录缓存在 inline.ts 模块级）。
+ * @author ddj
+ * @param deps 依赖（ctx/settings）
+ * @returns handlers
+ */
+export function createAiRpc(deps: AiRpcDeps): { handlers: Partial<RpcHandlerMap> } {
+  const handlers: Partial<RpcHandlerMap> = {
+    'edrv.ai.inline': async (args) => ({ ok: true, ...(await aiInlineComplete({ ctx: deps.ctx, config: { get: () => deps.settings.ai() } }, args)) }),
+    'edrv.ai.models': async (args) => ({ ok: true, ...(await aiModels(deps.ctx, args?.force === true)) }),
+    'edrv.ai.configGet': async () => ({ ok: true, ...deps.settings.ai() }),
+    'edrv.ai.configUpdate': async (args) => ({ ok: true, ...(await deps.settings.aiUpdate(args)) }),
+  }
+  return { handlers }
+}

package/src/capture.ts

@@ -11,6 +11,7 @@ import { fileMaxBatch, prune } from './model.js'
 import type { Registry } from './registry.js'
 import { cwdOf } from './registry.js'
 import { invalidateIndex } from './treeIndex.js'
+import { log } from './log.js'
 
 /** 校验并提取工具 result meta 中的文件 hunk。 */
 function validHunks(raw: unknown): Hunk[] {
@@ -101,6 +102,6 @@ export async function captureToolResult(ctx: Ctx, registry: Registry, exec: any,
     // agent 写盘后目录树可能变化（新建/删除文件/目录）：父目录+祖先进失效，后台自愈。
     invalidateIndex(ctx, cwd, path)
   } catch (error) {
-    console.error('edrv capture failed', error)
+    log.error('capture failed: ' + String(error))
   }
 }

package/src/client/ai/inlineProvider.ts

@@ -0,0 +1,190 @@
+// @ts-nocheck
+/**
+ * dsh-vscode-mode client — AI 内联补全（ghost text）provider。
+ * 速度设计：内部 150ms 去抖（Monaco 逐键调用 provider，不逐键打 LLM）、
+ * 在飞取消（新请求 abort 旧的）+ 序号守卫（过期响应丢弃）、
+ * 位置+前缀缓存（dismiss 后同位置重查不重复计费）、前后缀窗口裁剪。
+ * 状态经 edrv:ai-status 事件广播给编辑器底部状态栏；
+ * 差异审查期间静默（edrv 差异块存在时返回空，不与 Keep/Undo 浮层打架）。
+ * 作者 ddj
+ */
+import { rpc } from '../rpc.js'
+import { RPC_PATH } from '../../shared/rpc.js'
+import {
+  AI_PREFIX_MAX, AI_SUFFIX_MAX, inlineWorth, trimInlineWindow,
+} from '../../shared/ai.js'
+
+/**
+ * 广播补全状态给编辑器底部状态栏（EditorView 监听 edrv:ai-status 渲染）。
+ * @author ddj
+ * @param state busy=请求中 ok=完成（detail.ms 耗时） error=失败（detail.note） idle=就绪 config=开关变化
+ * @param detail 附加信息
+ */
+function emitAiStatus(state, detail) {
+  try { window.dispatchEvent(new CustomEvent('edrv:ai-status', { detail: { state, detail } })) } catch { /* 状态广播失败不影响补全 */ }
+}
+
+/** 去抖等待（毫秒）：Monaco 逐键调用 provider，静默该时长才真正发 RPC；
+ *  网关 TTFT 本身 3.5s+（debug 实证），client 侧去抖压到 150ms 不再叠加明显延迟。 */
+const DEBOUNCE_MS = 150
+/** 缓存容量上限（LRU 超限即整体清空；键空间小，够用）。 */
+const CACHE_MAX = 30
+/** 缓存 TTL（毫秒）。 */
+const CACHE_TTL_MS = 60_000
+
+let registered = false
+let seq = 0
+let inFlight = null
+let debounceTimer = null
+const cache = new Map()
+
+/** 上次开关状态（configUpdate 后经事件刷新，关闭时立即静默）。 */
+let enabled = false
+
+/** 供设置面板保存后同步开关状态（不重载页面即时生效）。 */
+export function setAiInlineEnabled(value) {
+  enabled = value === true
+  emitAiStatus('config', { enabled })
+  if (!enabled) {
+    seq += 1 // 作废在飞响应
+    cache.clear()
+  }
+}
+
+/** 当前开关（EditorView 装配时决定是否注册）。 */
+export function aiInlineEnabled() {
+  return enabled
+}
+
+/** 初始化开关（启动时从 configGet 拉一次）。 */
+export async function initAiInlineState() {
+  try {
+    const res = await rpc('edrv.ai.configGet', {})
+    setAiInlineEnabled(res?.ok && res.enabled === true)
+  } catch {
+    setAiInlineEnabled(false)
+  }
+}
+
+/**
+ * 缓存键：路径 + 行:列 + 前缀尾 24 字符（同位置不同文本区分）。
+ * @author ddj
+ */
+function cacheKey(path, line, column, prefix) {
+  return path + ':' + line + ':' + column + ':' + String(prefix || '').slice(-24)
+}
+
+/**
+ * 差异审查期间静默：编辑器上存在 AI 补全应避让的 pending 差异装饰时返回 true。
+ * 通过编辑器实例上的 edrv 差异装饰类名判定，缺失视为无差异。
+ * @author ddj
+ */
+function diffPending(editor) {
+  try {
+    const model = editor?.getModel?.()
+    const decos = model?.getAllDecorations?.() ?? []
+    return decos.some((d) => String(d?.options?.className || '').includes('edrv-mn-'))
+  } catch {
+    return false
+  }
+}
+
+/**
+ * 注册 AI 内联补全 provider（幂等；Monaco 就绪后调用一次）。
+ * @author ddj
+ * @param monaco window.monaco
+ */
+export function registerAiInline(monaco) {
+  if (registered || !monaco?.languages?.registerInlineCompletionsProvider) return
+  registered = true
+  monaco.languages.registerInlineCompletionsProvider('*', {
+    async provideInlineCompletions(model, position, context, token) {
+      const t0 = Date.now()
+      if (!enabled || token?.isCancellationRequested) return { items: [] }
+      const path = decodeURIComponent(String(model?.uri?.path || '').replace(/^\//, ''))
+      if (!path || model.uri.scheme !== 'edrv') return { items: [] }
+      const editor = monacoRef?.activeEditor
+      if (editor && diffPending(editor)) return { items: [] }
+      const offset = model.getOffsetAt(position)
+      const value = model.getValue()
+      const trimmed = trimInlineWindow(value.slice(0, offset), value.slice(offset))
+      if (!inlineWorth(trimmed.prefix)) return { items: [] }
+      const key = cacheKey(path, position.lineNumber, position.column, trimmed.prefix)
+      const hit = cache.get(key)
+      if (hit && Date.now() - hit.at < CACHE_TTL_MS) {
+        return hit.items.length ? { items: hit.items } : { items: [] }
+      }
+      return new Promise((resolve) => {
+        // 去抖：登记最新意图，静默 DEBOUNCE_MS 后才发 RPC；期间新请求顶掉旧的
+        seq += 1
+        const mySeq = seq
+        if (inFlight) { try { inFlight.abort() } catch { /* 已结束 */ } inFlight = null }
+        if (debounceTimer) clearTimeout(debounceTimer)
+        debounceTimer = setTimeout(async () => {
+          debounceTimer = null
+          if (mySeq !== seq || token?.isCancellationRequested) { resolve({ items: [] }); return }
+          const controller = new AbortController()
+          inFlight = controller
+          emitAiStatus('busy')
+          try {
+            const res = await fetch(RPC_PATH, {
+              method: 'POST',
+              headers: { 'content-type': 'application/json' },
+              body: JSON.stringify({ method: 'edrv.ai.inline', args: { path, prefix: trimmed.prefix, suffix: trimmed.suffix } }),
+              signal: controller.signal,
+            })
+            const data = await res.json()
+            if (mySeq !== seq || !data?.ok || typeof data.text !== 'string' || !data.text) {
+              cache.set(key, { items: [], at: Date.now() })
+              if (data?.note) emitAiStatus('error', { note: String(data.note) })
+              else emitAiStatus('idle')
+              resolve({ items: [] })
+              return
+            }
+            const items = [{ insertText: data.text, range: undefined }]
+            cacheSet(key, items)
+            emitAiStatus('ok', { ms: Date.now() - t0 })
+            resolve({ items })
+          } catch (error) {
+            emitAiStatus('error', { note: String(error && error.message || error).slice(0, 80) })
+            resolve({ items: [] })
+          } finally {
+            if (inFlight === controller) inFlight = null
+          }
+        }, DEBOUNCE_MS)
+        // 提前取消：token 取消/新请求顶替时清掉待发定时器
+        const guard = setInterval(() => {
+          if (mySeq !== seq || token?.isCancellationRequested) {
+            clearInterval(guard)
+            if (debounceTimer) { clearTimeout(debounceTimer); debounceTimer = null }
+            resolve({ items: [] })
+          } else if (!debounceTimer) {
+            clearInterval(guard)
+          }
+        }, 120)
+      })
+    },
+    freeInlineCompletions() { /* 无资源需释放 */ },
+  })
+}
+
+/** 缓存写入（超限整体清空，LRU 简化）。 */
+function cacheSet(key, items) {
+  if (cache.size >= CACHE_MAX) cache.clear()
+  cache.set(key, { items, at: Date.now() })
+}
+
+/** EditorView ref 注入口（差异静默判定用当前编辑器）。 */
+let monacoRef = null
+
+/** EditorView 装配后调用（注册 provider + 初始化开关）。 */
+export function setupAiInline(monaco) {
+  monacoRef = monaco && { activeEditor: null }
+  if (!registered) registerAiInline(monaco)
+  void initAiInlineState()
+}
+
+/** EditorView 每次创建/切换编辑器实例时刷新引用。 */
+export function trackAiEditor(editor) {
+  if (monacoRef) monacoRef.activeEditor = editor
+}

package/src/client/compat.ts

@@ -3,6 +3,7 @@
  * 纯逻辑与薄 ctx 胶水，node 环境可单测（不依赖 DOM）。
  * 作者 ddj 2026年08月24号
  */
+import { log } from './log.js'
 
 /** 本插件包名（与 host compat.PLUGIN_NAME 对应）。 */
 export const PLUGIN_NAME = 'dsh-vscode-mode'
@@ -59,14 +60,14 @@ export interface SlotSpec {
 export function registerSlotSafely(ctx: { slots?: { inject?: (name: string, register: () => unknown) => unknown; register?: (...args: unknown[]) => unknown } }, spec: SlotSpec, render: (props: unknown) => unknown): (() => void) | null {
   const slots = ctx?.slots as { inject: (name: string, register: () => unknown) => unknown; register: (...args: unknown[]) => unknown } | undefined
   if (!slots || typeof slots.inject !== 'function' || typeof slots.register !== 'function') {
-    console.warn('[' + PLUGIN_NAME + '] slots 服务不可用，跳过 slot ' + spec.name)
+    log.warn('slots 服务不可用，跳过 slot ' + spec.name)
     return null
   }
   try {
     const disposer = slots.inject(spec.name, () => slots.register(spec, render))
     return typeof disposer === 'function' ? disposer as () => void : null
   } catch (error) {
-    console.warn('[' + PLUGIN_NAME + '] slot ' + spec.name + ' 注册失败（' + String(error) + '），已跳过')
+    log.warn('slot ' + spec.name + ' 注册失败（' + String(error) + '），已跳过')
     return null
   }
 }

package/src/client/externalOpen.ts

@@ -8,6 +8,7 @@
 import { EDRV_PARAM_KEYS, parseOpenParams } from '../shared/externalOpen.js'
 import { openDeepLink } from './openFlow.js'
 import { rpc } from './rpc.js'
+import { log } from './log.js'
 
 /** toast 自隐时长。 */
 const TOAST_MS = 5000
@@ -38,12 +39,12 @@ export function setupExtOpen(ctx: unknown, options: ExtOpenOptions = {}): void {
   const referrer = options.referrer ?? (typeof document !== 'undefined' ? document.referrer : '')
   const origin = options.origin ?? (typeof location !== 'undefined' ? location.origin : '')
   if (!referrerAllowed(referrer, origin)) {
-    console.warn('[dsh-vscode-mode] 已忽略跨源深链请求（referrer=' + referrer + '）')
+    log.warn('已忽略跨源深链请求（referrer=' + referrer + '）')
     return
   }
   stripCurrentUrl()
   void openDeepLink(ctx, params).catch((error) => {
-    console.warn('[dsh-vscode-mode] 深链打开失败：' + String(error))
+    log.warn('深链打开失败：' + String(error))
     toastDom('深链打开失败：' + String((error as Error)?.message ?? error))
   })
 }

package/src/client/index.ts

@@ -43,6 +43,7 @@ import { createOutlineSourceRegistry, registerBuiltinOutlineSources } from './ou
 import { createLspOutlineSource } from './outline/lspSource.js'
 import { keybindingsApply } from './keybindings.js'
 import { sidebarMinApply } from './sidebarMin.js'
+import { log } from './log.js'
 import { setupLsp, setSession } from './monaco/lsp/index.js'
 import type { CompatAdapter } from '../shared/compat.js'
 
@@ -101,8 +102,8 @@ export function apply(ctx: any): void {
   let selected = autoValue('auto')
   /** 0.1.3+ 会话文件链接路由（remote.session.openWorkspacePath）是否已安装（compatSummary 展示用）。 */
   let remoteOpenInstalled = false
-  /** 两条文件链接路由共用的路由日志（openPathRouter / remoteOpenRouter）。 */
-  const routeLogger = (message: string): void => console.warn('[dsh-vscode-mode] ' + message)
+  /** 两条文件链接路由共用的路由日志（openPathRouter / remoteOpenRouter；统一走插件日志器）。 */
+  const routeLogger = (message: string): void => log.warn(message)
   /** 两条路由共用的 FileOpenContext：当前会话 id 与工作区 cwd。 */
   const openContext = (): FileOpenContext => {
     const current = sessions?.list?.getSnapshot?.()
@@ -198,7 +199,7 @@ export function apply(ctx: any): void {
   let remoteRetries = 0
   const retryRemoteOpen = (): void => {
     if (remoteOpenInstalled || remoteRetries >= 15) {
-      if (!remoteOpenInstalled) console.warn('[dsh-vscode-mode] 未探测到 remote.session.openWorkspacePath，0.1.3+ 会话文件链接路由未安装')
+      if (!remoteOpenInstalled) log.warn('未探测到 remote.session.openWorkspacePath，0.1.3+ 会话文件链接路由未安装')
       return
     }
     remoteRetries += 1
@@ -211,12 +212,12 @@ export function apply(ctx: any): void {
       }
       const disposer = patchRemoteOpen(service, { registry, selected: () => selected, context: openContext, logger: routeLogger })
       if (!disposer) {
-        console.warn('[dsh-vscode-mode] remote.session 存在但 openWorkspacePath 不可补丁，会话文件链接路由未安装')
+        log.warn('remote.session 存在但 openWorkspacePath 不可补丁，会话文件链接路由未安装')
         return
       }
       remoteOpenInstalled = true
       ctx.effect(() => disposer, 'vscode-mode: remote file link routing')
-      console.info('[dsh-vscode-mode] 已安装 0.1.3+ 会话文件链接路由（remote.session.openWorkspacePath）')
+      log.info('已安装 0.1.3+ 会话文件链接路由（remote.session.openWorkspacePath）')
     }, 2000)
   }
   retryRemoteOpen()
@@ -271,7 +272,7 @@ export function apply(ctx: any): void {
       if (sideService !== undefined) return
       sideService = detectSidebarService(ctx)
       if (sideService !== undefined) {
-        console.info('[dsh-vscode-mode] 检测到 ' + SIDEBAR_PLUGIN + '，切换侧边栏编辑形态')
+        log.info('检测到 ' + SIDEBAR_PLUGIN + '，切换侧边栏编辑形态')
         applySideForm()
       } else {
         retrySideService()

package/src/client/log.ts

@@ -0,0 +1,10 @@
+/**
+ * dsh-vscode-mode client — 日志单例（全 client 面唯一日志入口）。
+ * client 无 ctx.logger 服务，固定 console 出口；格式/级别语义与 host 面一致（shared/logger.ts）。
+ * 用法：`import { log } from './log.js'` → `log.debug/info/warn/error(msg)`；子域用 `log.child('scope')`。
+ * 作者 ddj 2026-09-08
+ */
+import { createLogger } from '../shared/logger.js'
+
+/** client 面插件日志单例。 */
+export const log = createLogger()