dsh-vscode-mode 0.21.2 → 0.21.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-vscode-mode",
-  "version": "0.21.2",
+  "version": "0.21.4",
   "description": "DSH 上的类 VSCode 编码体验：Monaco 编辑器（文件页签/QuickOpen/状态栏，可驻 DSH 0.1.5+ 官方右侧 Sidebar 与对话同屏）+ 命令栏（Ctrl+Shift+P）与可扩展指令系统 + VS Code 兼容代码片段（.code-snippets 全局/项目，IntelliSense 展开）+ Agent 编辑差异审查（整文件差异/采纳/拒绝/归档/回滚）+ SVN 集成（侧栏变更面板/日志弹窗/并排差异）+ 语言服务器（LSP）智能（跳转定义/引用/hover/大纲 + VSIX 扩展市场安装），状态持久化到工作区旁车，界面状态（页签/光标/侧栏/编辑 Tab/导航历史）镜像到 DSH home 跨重启恢复",
   "icon": "assets/icon.svg",
   "keywords": [

package/src/client/addToConversation.ts

@@ -281,28 +281,78 @@ interface SessionBridge {
   scope?: (id: string) => unknown
 }
 
-/** @private @author ddj 2026年10月28号 @param ctx Lifecycle owner. @param sessions Public Controller. @param id Fixed target. @param text Task body. @returns Acceptance; failures never retry another transport. @sideEffects Retains one generation until completion or unload. */
-async function sendOwned(ctx: CtxLike, sessions: SessionBridge, id: string, text: string): Promise<boolean> {
+/** Detailed admission evidence; none of these states proves task completion. */
+export interface TaskSendResult {
+  status: 'accepted' | 'rejected' | 'unavailable' | 'unknown' | 'submitted' | 'cancelled'
+  /** Historical boolean from this same attempt, not an admission marker. */
+  legacyOk: boolean
+}
+
+/** @private @author ddj 2026年10月29号 @param receipt Raw selected-channel receipt. @returns Explicit admission evidence and the historical boolean. */
+function taskReceipt(receipt: unknown): TaskSendResult {
+  const ok = (receipt as { ok?: unknown } | null)?.ok
+  if (ok === true) return { status: 'accepted', legacyOk: true }
+  if (ok === false) return { status: 'rejected', legacyOk: false }
+  return { status: 'unknown', legacyOk: false }
+}
+
+/** @private @author ddj 2026年10月29号 @param ctx Lifecycle owner. @param sessions Public Controller. @param id Fixed target. @param text Task body. @returns Admission evidence without switching transport. @sideEffects Retains and releases exactly one generation. */
+async function sendOwned(ctx: CtxLike, sessions: SessionBridge, id: string, text: string): Promise<TaskSendResult> {
   const controller = new AbortController()
   const reference = sessions.retain!(id, { source: 'controllerOperation', signal: controller.signal })
   let released = false
-  /** @private @author ddj 2026年10月28号 Cancel pending admission and release this exact generation once. */
+  let cleanupFailed = false
+  /** @private @author ddj 2026年10月29号 Cancels and releases this exact generation once; remembers unload cleanup failures. */
   function release(): void {
     if (released) return
     released = true
     controller.abort()
-    reference.release()
+    try { reference.release() } catch (error) { cleanupFailed = true; throw error }
   }
   let remove: (() => void) | undefined
+  let started = false
+  let result: TaskSendResult = { status: 'unavailable', legacyOk: false }
   try {
     remove = ctx.effect?.(() => release, 'vscode-mode: task session reference')
     const binding = await reference.ready
-    if (controller.signal.aborted) return false
-    return (await binding.session.prompt([{ type: 'text', text }], 'queue', controller.signal)).ok === true
-  } finally {
-    release()
-    remove?.()
+    if (controller.signal.aborted) result = { status: 'cancelled', legacyOk: false }
+    else {
+      started = true
+      result = taskReceipt(await binding.session.prompt([{ type: 'text', text }], 'queue', controller.signal))
+    }
+  } catch {
+    result = { status: started ? 'unknown' : 'unavailable', legacyOk: false }
+  }
+
+  // Snapshot cancellation before normal cleanup aborts our own signal.
+  const cancelled = controller.signal.aborted
+  try { release() } catch { cleanupFailed = true }
+  try { remove?.() } catch { cleanupFailed = true }
+  if (cleanupFailed) result = { status: started ? 'unknown' : 'unavailable', legacyOk: false }
+  if (cancelled) result = { status: 'cancelled', legacyOk: result.legacyOk }
+  return result
+}
+
+/** @private @author ddj 2026年10月29号 @param ctx Service owner. @param id Fixed target. @param text Task body. @returns One legacy-channel attempt; no cross-channel retry. */
+async function sendLegacy(ctx: CtxLike, id: string, text: string): Promise<TaskSendResult> {
+  const input = inputFor(ctx, id) as { setDraft?: (task: string) => void; submit?: () => void } | undefined
+  if (typeof input?.setDraft === 'function' && typeof input.submit === 'function') {
+    let submitted = false
+    try {
+      input.setDraft(text)
+      submitted = true
+      input.submit()
+      return { status: 'submitted', legacyOk: true }
+    } catch { return { status: submitted ? 'unknown' : 'unavailable', legacyOk: false } }
   }
+
+  const remote = ctx.get('remote.session') as { prompt?: (req: unknown) => Promise<unknown> } | undefined
+  if (typeof remote?.prompt !== 'function') return httpTaskResult(id, text)
+  try {
+    const payload = { sessionId: id, mode: 'queue', content: [{ type: 'text', text }] }
+    const receipt = await remote.prompt(slotArg(payload))
+    return taskReceipt((receipt as { result?: unknown } | null)?.result ?? receipt)
+  } catch { return { status: 'unknown', legacyOk: false } }
 }
 
 /** 新建会话结果（ok=false 供调用方降级回当前对话注入）。 */
@@ -386,6 +436,11 @@ async function apiSessionCreate(cwd: string | undefined): Promise<string> {
  * @returns 是否受理
  */
 export async function apiSessionPrompt(sessionId: string, text: string): Promise<boolean> {
+  return (await httpTaskResult(sessionId, text)).legacyOk
+}
+
+/** @private @author ddj 2026年10月29号 @param sessionId Fixed target. @param text Task body. @returns HTTP receipt evidence; errors after request entry are never safe rejection. */
+async function httpTaskResult(sessionId: string, text: string): Promise<TaskSendResult> {
   try {
     const payload = { sessionId, mode: 'queue', content: [{ type: 'text', text }] }
     const res = await fetch(appUrl(SESSION_PROMPT_PATH), {
@@ -399,9 +454,9 @@ export async function apiSessionPrompt(sessionId: string, text: string): Promise
       }),
     })
     const json = await res.json().catch(() => null) as { result?: { ok?: boolean } } | null
-    return json?.result?.ok === true
+    return taskReceipt(json?.result)
   } catch {
-    return false
+    return { status: 'unknown', legacyOk: false }
   }
 }
 
@@ -466,8 +521,10 @@ export interface AddToConversation {
   appendText(sessionId: string | undefined, text: string): Promise<AddOutcome>
   /** 新建独立会话并切换（旁路任务隔离；失败 ok:false 供降级回当前对话）。 */
   startDraftSession(cwd?: string): Promise<DraftSessionResult>
-  /** 发送任务给目标会话 agent（点击即发送；失败 false 供降级）。 */
+  /** Historical compatibility result, not proof that a task was accepted. */
   sendTask(sessionId: string | undefined, text: string): Promise<boolean>
+  /** Optional on older injected facades; detailed callers must not infer acceptance from sendTask. */
+  sendTaskResult?(sessionId: string | undefined, text: string): Promise<TaskSendResult>
 }
 
 /**
@@ -640,32 +697,22 @@ export function createAddToConversation(ctx: CtxLike): AddToConversation {
   /**
    * 发送任务给目标会话 agent（点击即发送方案：任务落地会话即非 blank，列表可见）。
    * 新版持有目标 Controller 到 prompt 结束；旧版按能力选择唯一通道，不跨通道重发。
-   * @author ddj 2026年09月23号 / 2026年10月28号
+   * @author ddj 2026年10月29号
    * @param sessionId 目标会话 id
    * @param text 任务文本
-   * @returns 是否受理
+   * @returns 同一次调用的历史boolean语义，不能作为受理事实
    */
-  const sendTask: AddToConversation['sendTask'] = async (sessionId, text) => {
-    if (!sessionId) return false
+  const sendTask: AddToConversation['sendTask'] = async (sessionId, text) => (await sendTaskResult(sessionId, text)).legacyOk
+
+  /** @private @author ddj 2026年10月29号 @param sessionId Fixed target. @param text Task body. @returns Detailed evidence from exactly one selected transport. */
+  async function sendTaskResult(sessionId: string | undefined, text: string): Promise<TaskSendResult> {
+    if (!sessionId) return { status: 'unavailable', legacyOk: false }
     try {
       const sessions = ctx.get('sessions') as SessionBridge | undefined
       if (typeof sessions?.retain === 'function') return await sendOwned(ctx, sessions, sessionId, text)
-
-      // Legacy composer remains an exclusive channel; never overwrite the draft and then retry elsewhere.
-      const input = inputFor(ctx, sessionId) as { setDraft?: (task: string) => void; submit?: () => void } | undefined
-      if (typeof input?.setDraft === 'function' && typeof input.submit === 'function') {
-        input.setDraft(text)
-        input.submit()
-        return true
-      }
-      const remote = ctx.get('remote.session') as { prompt?: (req: unknown) => Promise<unknown> } | undefined
-      if (typeof remote?.prompt === 'function') {
-        const payload = { sessionId, mode: 'queue', content: [{ type: 'text', text }] }
-        return rpcOk(await remote.prompt(slotArg(payload))).ok
-      }
-      return await apiSessionPrompt(sessionId, text)
-    } catch { return false }
+      return await sendLegacy(ctx, sessionId, text)
+    } catch { return { status: 'unavailable', legacyOk: false } }
   }
 
-  return { appendReference, appendText, startDraftSession, sendTask }
+  return { appendReference, appendText, startDraftSession, sendTask, sendTaskResult }
 }

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

@@ -39,6 +39,7 @@ import type { ContextMenuEntry } from '../../ui/ContextMenu.js'
 import { SvnAiPlanDialog } from '../../ui/SvnAiPlanDialog.js'
 import { budgetGroupsOf } from './svnListBudget.js'
 import type { SidebarCtx } from '../types.js'
+import type { DraftSessionResult, TaskSendResult } from '../../addToConversation.js'
 
 /** 未分组条目的分组键（changelist 为空）。 */
 const NO_CHANGELIST = '（未分组）'
@@ -845,10 +846,9 @@ export function SvnPanel(props) {
 
   /**
    * 深度分析入口（02-deep-session-prompt 修正版）：**新建独立会话**承载任务
-   * （不污染当前对话），草稿箱填入分析任务（变更清单由 agent 自跑只读 svn status
-   * 取数，prompt 定长）→ 用户在新会话发送 → agent 投递方案回面板收件箱。
-   * 降级：不支持自动新建会话时回落当前对话注入 + notify 注明。
-   * @author ddj 2026年09月23号
+   * （不污染当前对话），显式受理才等待方案；不明回执不重发或填入另一草稿。
+   * 未发送或明确拒绝时仅填当前草稿，提示用户手动发送，prompt使用实际草稿会话。
+   * @author ddj 2026年10月29号
    */
   const runDeepPlan = React.useCallback(() => {
     const live = ctxRef.current
@@ -858,34 +858,42 @@ export function SvnPanel(props) {
     const since = Date.now()
     const add = live?.addToConversation
     if (!add?.appendText) { live?.notify?.('无法填入任务（无会话或输入框不可用）'); return }
-    /** 降级：当前对话注入（不支持自动新建会话时兜底）。 */
-    const degrade = (prompt) => {
-      void add.appendText(sessionId, prompt).then((outcome) => {
-        if (outcome === 'ok' || outcome === 'busy') {
-          live?.notify?.('已填入当前对话（降级），任务已自动发送，请在本对话查看')
-          startDeepPoll(since)
-        } else {
-          live?.notify?.('发起失败：' + (outcome === 'unavailable' ? '无会话或输入框不可用' : '输入框忙，请重试'))
-        }
-      })
+
+    /** @private @author ddj 2026年10月29号 @returns Draft insertion only; never submits or starts a task poll. */
+    async function draftCurrent(): Promise<void> {
+      if (!sessionId) { live?.notify?.('无法填入任务（无会话或输入框不可用）'); return }
+      try {
+        const outcome = await add.appendText(sessionId, buildAgentPrompt(wcRoot, sessionId))
+        if (outcome === 'ok' || outcome === 'busy') live?.notify?.('已填入当前草稿，请手动发送')
+        else live?.notify?.('发起失败：' + (outcome === 'unavailable' ? '无会话或输入框不可用' : '输入框忙，请重试'))
+      } catch { live?.notify?.('草稿填入失败，请检查当前输入框') }
     }
-    /** 统一收尾（点击即发送方案）：create 后构建 prompt（内嵌新会话 id）→ 发送任务。 */
-    const sendAndWatch = (id) => {
-      const prompt = buildAgentPrompt(wcRoot, id || sessionId || '')
-      if (!id || typeof add.sendTask !== 'function') { degrade(prompt); return }
-      void add.sendTask(id, prompt).then((sent) => {
-        if (sent) {
-          live?.notify?.('已在新会话「AI 深度分析」发起任务并自动发送，请在左侧会话列表点开查看进度')
-          startDeepPoll(since)
-        } else {
-          degrade(prompt)
-        }
-      })
+    /** @private @author ddj 2026年10月29号 @param id Created target. @returns One detailed send decision; ambiguous receipts never retry. */
+    async function sendAndWatch(id): Promise<void> {
+      if (!id) { await draftCurrent(); return }
+      if (typeof add.sendTaskResult !== 'function') {
+        live?.notify?.('发送接口不支持受理确认，本次未自动发送，请手动处理')
+        return
+      }
+      let result: TaskSendResult | undefined
+      try { result = await add.sendTaskResult(id, buildAgentPrompt(wcRoot, id)) }
+      catch { result = { status: 'unknown', legacyOk: false } }
+      if (result?.status === 'accepted') {
+        live?.notify?.('已在新会话「AI 深度分析」受理任务，请在左侧会话列表点开查看进度')
+        startDeepPoll(since)
+      } else if (result?.status === 'rejected' || result?.status === 'unavailable') await draftCurrent()
+      else if (result?.status === 'cancelled') live?.notify?.('发送操作已取消，任务可能已提交，请检查目标会话：' + id)
+      else if (result?.status === 'submitted') live?.notify?.('已调用提交但受理未确认，请检查目标会话，不要重复发送：' + id)
+      else live?.notify?.('任务受理未确认，请检查目标会话，不要重复发送：' + id)
+    }
+    /** @private @author ddj 2026年10月29号 @returns Creates a target before sending; creation failure can only insert a manual draft. */
+    async function beginDeep(): Promise<void> {
+      let result: DraftSessionResult | undefined
+      try { result = await add.startDraftSession?.(wcRoot || undefined) }
+      catch { result = { ok: false } }
+      await sendAndWatch(result?.ok ? result.id : undefined)
     }
-    void (add.startDraftSession
-      ? add.startDraftSession(wcRoot || undefined)
-      : Promise.resolve({ ok: false })
-    ).then((result) => { sendAndWatch(result?.ok ? result.id : undefined) })
+    void beginDeep()
   }, [aiBusy, aiRun, deepWaiting, entries, sessionId, startDeepPoll])
 
   // --endregion

package/src/mcpPool.ts

@@ -12,6 +12,11 @@ export interface PoolSpec {
   config: MpcConfig
   policy: McpPolicy
 }
+/** Startup caller settlement, independent from the owned resource lifetime. */
+interface StartupResult {
+  resolve(): void
+  reject(error: unknown): void
+}
 export interface PoolEntry {
   key: string
   spec: PoolSpec
@@ -27,6 +32,9 @@ export interface PoolEntry {
   bridge?: McpBridge
   fiber?: any
   ready: Promise<void>
+  /** Entire queued mount/cleanup lifetime; rejection means closure remains unconfirmed. */
+  quiescence: Promise<void>
+  cleanupFailed?: boolean
   close?: Promise<void>
   idle?: ReturnType<typeof setTimeout>
   live: boolean
@@ -95,7 +103,7 @@ export class McpPool {
     }
     if (entry && !entry.live) throw new Error(entry.error ?? 'MCP 旧连接仍在释放，暂不能创建替代实例')
     if (!entry) {
-      entry = { key, spec, refs: 0, phase: 'queued', queuedAt: Date.now(), phaseAt: Date.now(), ready: Promise.resolve(), live: true, calls: Promise.resolve() }
+      entry = { key, spec, refs: 0, phase: 'queued', queuedAt: Date.now(), phaseAt: Date.now(), ready: Promise.resolve(), quiescence: Promise.resolve(), live: true, calls: Promise.resolve() }
       this.entries.set(key, entry)
       entry.ready = this.schedule(entry)
       void entry.ready.catch(() => undefined)
@@ -111,16 +119,27 @@ export class McpPool {
     } }
   }
 
-  /** @private @author ddj 2026年10月20号 @param entry New entry. @returns Queued initialization, bounded to two concurrent starts. */
+  /** @private @author ddj 2026年10月29号 @param entry New entry. @returns Caller result, independent from the two-slot cleanup lifetime. */
   private schedule(entry: PoolEntry): Promise<void> {
-    return new Promise<void>((resolve, reject) => {
-      /** @author ddj 2026年10月20号 Initializes a still-owned queue item. */
-      const run = async (): Promise<void> => {
-        try { await this.start(entry); resolve() } catch (error) { reject(error) }
+    let result!: StartupResult
+    const ready = new Promise<void>((resolve, reject) => { result = { resolve, reject } })
+    let lifetime!: StartupResult
+    entry.quiescence = new Promise<void>((resolve, reject) => { lifetime = { resolve, reject } })
+    void entry.quiescence.catch(() => undefined)
+
+    /** @private @author ddj 2026年10月29号 Runs and observes the complete owned mount even after caller rejection. */
+    const run = async (): Promise<void> => {
+      try {
+        await this.start(entry, result)
+        lifetime.resolve()
+      } catch (error) {
+        result.reject(error)
+        lifetime.reject(error)
       }
-      this.queue.push(run)
-      this.pump()
-    })
+    }
+    this.queue.push(run)
+    this.pump()
+    return ready
   }
 
   /** @private @author ddj 2026年10月20号 Advances FIFO work; each task holds its slot until startup or cleanup quiesces. */
@@ -137,9 +156,9 @@ export class McpPool {
     }
   }
 
-  /** @private @author ddj 2026年10月20号 @param entry Connection to initialize. @returns Initialization completion, or failure after owned cleanup. */
-  private async start(entry: PoolEntry): Promise<void> {
-    if (!entry.live || this.stopped) throw new Error('MCP 启动已取消')
+  /** @private @author ddj 2026年10月29号 @param entry Connection to initialize. @param result Caller settlement. @returns Full startup and cleanup lifetime. */
+  private async start(entry: PoolEntry, result: StartupResult): Promise<void> {
+    if (!entry.live || this.stopped) { result.reject(new Error('MCP 启动已取消')); return }
     entry.phase = 'loading'
     entry.phaseAt = Date.now()
     entry.startAt = entry.phaseAt
@@ -155,33 +174,41 @@ export class McpPool {
       entry.phase = 'ready'
       entry.finishedAt = Date.now()
       entry.connectedAt = entry.finishedAt
+      result.resolve()
     } catch (error) {
-      entry.error = 'MCP 初始化失败或超时，请查看 Host 日志'
+      if (!entry.cleanupFailed) entry.error = 'MCP 初始化失败或超时；旧连接清理尚未确认，暂不能重建，请查看 Host 日志'
       const diagnostic = 'MCP initialization failed; phase=' + entry.phase + '; transport=' + entry.spec.config.transport
         + '; elapsedMs=' + (Date.now() - entry.startAt) + '; ' + mcpErrorText(error, entry.spec.config)
       debugRecord(this.ctx, entry.spec.workspace, diagnostic, 'warn')
       // Invalidation precedes disposal; neither late module load nor callbacks may publish.
       entry.live = false
       entry.phase = 'stopping'
-      const closing = this.closeBridge(entry)
-      await Promise.allSettled([closing, work])
-      entry.phase = 'error'
-      entry.finishedAt = Date.now()
-      entry.retryAt = Date.now() + 5000
-      // Failed generations stay invalid; acquire can replace them only after confirmed closure and cooldown.
-      throw new Error(entry.error)
+      result.reject(new Error(entry.error))
+      await this.finishFailure(entry, work)
     } finally {
       if (timer) clearTimeout(timer)
     }
   }
 
+  /** @private @author ddj 2026年10月29号 @param entry Failed generation. @param work Entire mount, including late factory cleanup. @returns Confirmed quiescence; throws when closure is unconfirmed. */
+  private async finishFailure(entry: PoolEntry, work: Promise<void>): Promise<void> {
+    await Promise.allSettled([this.closeBridge(entry), work])
+    if (entry.cleanupFailed) throw new Error(entry.error)
+
+    entry.phase = 'error'
+    entry.finishedAt = Date.now()
+    entry.retryAt = entry.finishedAt + 5000
+    entry.error = 'MCP 初始化失败或超时，请查看 Host 日志'
+  }
+
   /** @private @author ddj 2026年10月20号 @param entry Owned generation. @returns Official initial sync; never publishes after invalidation. */
   private async mount(entry: PoolEntry): Promise<void> {
     const official = await this.load()
     if (!entry.live || this.stopped) return
     const bridge = await this.make()
-    if (!entry.live || this.stopped) { await bridge.dispose(); return }
     entry.bridge = bridge
+    // Keep late factory ownership visible, including synchronous or rejected disposal failures.
+    if (!entry.live || this.stopped) { await this.closeBridge(entry); return }
     entry.phase = 'starting'
     entry.phaseAt = Date.now()
     entry.fiber = bridge.scope.ctx.plugin(official, entry.spec.config)
@@ -189,10 +216,14 @@ export class McpPool {
     if (entry.fiber?.state !== undefined && entry.fiber.state !== 2) throw new Error('MCP 插件未完成激活')
   }
 
-  /** @private @author ddj 2026年10月20号 @param entry Connection to close. @returns Shared closure barrier; rejection retains a fenced entry. */
+  /** @private @author ddj 2026年10月29号 @param entry Connection to close. @returns Shared closure barrier; synchronous throws and rejections retain a fenced entry. */
   private async closeBridge(entry: PoolEntry): Promise<void> {
     if (entry.close) return entry.close
-    const close = entry.bridge?.dispose() ?? Promise.resolve()
+    const bridge = entry.bridge
+    if (!bridge) return
+    /** @private @author ddj 2026年10月29号 @returns Deferred disposal so synchronous throws are owned by the shared barrier. */
+    const dispose = (): Promise<void> => bridge.dispose()
+    const close = Promise.resolve().then(dispose)
     entry.close = close
     try {
       await close
@@ -200,6 +231,7 @@ export class McpPool {
       entry.fiber = undefined
       entry.close = undefined
     } catch (error) {
+      entry.cleanupFailed = true
       entry.error = 'MCP 释放未确认，禁止重建，请查看 Host 日志'
       this.ctx.logger?.warn?.('MCP cleanup failed: ' + String(error))
       throw error
@@ -220,10 +252,10 @@ export class McpPool {
     entry.live = false
     entry.phase = 'stopping'
     if (entry.idle) clearTimeout(entry.idle)
-    await this.closeBridge(entry)
-    await entry.ready.catch(() => undefined)
-    // A late mount checks live before assigning its bridge.
-    await entry.calls.catch(() => undefined)
+    const closures = await Promise.allSettled([this.closeBridge(entry), entry.quiescence, entry.calls])
+    const failure = closures.find((closure) => closure.status === 'rejected')
+    if (failure?.status === 'rejected') throw failure.reason
+    // Only the whole mount barrier proves that no late factory can still create a scope.
     if (this.entries.get(entry.key) === entry) this.entries.delete(entry.key)
   }
 
@@ -243,7 +275,9 @@ export class McpPool {
   /** @public @author ddj 2026年10月20号 @returns Full disposal of entries, queue, timers and owned work. */
   async dispose(): Promise<void> {
     this.stopped = true
-    await Promise.all([...this.entries.values()].map((entry) => this.retire(entry)))
+    const closures = await Promise.allSettled([...this.entries.values()].map((entry) => this.retire(entry)))
     await Promise.all([...this.jobs])
+    const failure = closures.find((closure) => closure.status === 'rejected')
+    if (failure?.status === 'rejected') throw failure.reason
   }
 }