dsh-vscode-mode 0.1.52 → 0.1.53

package/package.json

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

package/src/client/chooseDialog.ts

@@ -0,0 +1,70 @@
+// @ts-nocheck
+/**
+ * dsh-vscode-mode client — 工作区选择弹窗（深链打开规则 1）。
+ * 复用与「添加 MCP」一致的 vsm-mcp-modal / vsm-mcp-dialog 模态（页面居中卡片 + 遮罩 + 主题
+ * token），React portal 挂 body；Esc / 遮罩点击 / 取消 → null（中止流程不改任何状态）。
+ * 作者 ddj 2026-09-07
+ */
+import React from 'react'
+import { createRoot } from 'react-dom/client'
+
+/** 用户选择：使用最近的工作区 / 新建工作区 / null=中止。 */
+export type WorkspaceChoice = 'recent' | 'create' | null
+
+/** 弹窗组件属性。 */
+interface ChoiceModalProps {
+  /** 匹配到的工作区标题。 */
+  title: string
+  /** 触发打开的文件夹路径。 */
+  folder: string
+  /** 选择回调（首次调用即卸载）。 */
+  done: (choice: WorkspaceChoice) => void
+}
+
+/** 选择弹窗（vsm-mcp-modal 遮罩 + vsm-mcp-dialog 卡片，Esc/遮罩点击取消）。 */
+function ChoiceModal({ title, folder, done }: ChoiceModalProps) {
+  React.useEffect(() => {
+    const onKey = (event) => {
+      if (event.key === 'Escape') done(null)
+    }
+    window.addEventListener('keydown', onKey)
+    return () => window.removeEventListener('keydown', onKey)
+  }, [])
+  return React.createElement('div', {
+    className: 'vsm-mcp-modal',
+    onMouseDown: (event) => {
+      if (event.target === event.currentTarget) done(null)
+    },
+  },
+    React.createElement('div', { className: 'vsm-mcp-dialog' },
+      React.createElement('h3', null, '在 DSH 中打开'),
+      React.createElement('label', null, '文件夹 ' + folder + ' 位于已注册的工作区「' + title + '」内，选择打开方式：'),
+      React.createElement('div', { className: 'vsm-mcp-dialog-actions' },
+        React.createElement('button', { onClick: () => done(null) }, '取消'),
+        React.createElement('button', { onClick: () => done('create') }, '新建工作区'),
+        React.createElement('button', { className: 'vsm-primary', onClick: () => done('recent') }, '使用最近的工作区'),
+      ),
+    ),
+  )
+}
+
+/**
+ * 弹出工作区选择弹窗（深链打开规则 1）。
+ * @author ddj 2026年09月07号
+ * @param title 匹配到的工作区标题
+ * @param folder 文件夹路径
+ * @returns 用户选择；null = 取消/中止
+ */
+export function chooseWorkspace(title: string, folder: string): Promise<WorkspaceChoice> {
+  return new Promise((resolve) => {
+    const host = document.createElement('div')
+    document.body.appendChild(host)
+    const root = createRoot(host)
+    const done = (choice: WorkspaceChoice) => {
+      root.unmount()
+      host.remove()
+      resolve(choice)
+    }
+    root.render(React.createElement(ChoiceModal, { title, folder, done }))
+  })
+}

package/src/client/externalOpen.ts

@@ -0,0 +1,130 @@
+/**
+ * dsh-vscode-mode client — 外部深链落地（Windows 右键菜单 / Unity 外部编辑器）。
+ * 启动时解析 location.search 的 edrvOpen 深链：跨源 referrer 守卫防外部网页诱导；
+ * 处理完剥离 URL 参数防刷新重开；执行委托 openFlow 打开规则引擎（工作区/对话智能路由）。
+ * 另挂 3s 移交轮询（兼活跃心跳）：launcher 投递的打开请求由已打开页面就地执行，避免重复开新页。
+ * 作者 ddj 2026-09-07 / 2026-09-08
+ */
+import { EDRV_PARAM_KEYS, parseOpenParams } from '../shared/externalOpen.js'
+import { openDeepLink } from './openFlow.js'
+import { rpc } from './rpc.js'
+
+/** toast 自隐时长。 */
+const TOAST_MS = 5000
+/** 深链移交轮询周期（兼活跃心跳）。 */
+const HANDOFF_POLL_MS = 3000
+
+/** 深链装配选项（全部可注入便于测试；缺省读浏览器全局）。 */
+export interface ExtOpenOptions {
+  /** 查询串（缺省 location.search）。 */
+  search?: string
+  /** referrer（缺省 document.referrer）。 */
+  referrer?: string
+  /** 当前源（缺省 location.origin）。 */
+  origin?: string
+}
+
+/**
+ * 装配外部深链：深链参数缺失时仅保持移交轮询（零额外开销）。
+ * @author ddj 2026年09月07号
+ * @param ctx 客户端根上下文（sessions/workspaces 服务）
+ * @param options 可注入选项
+ */
+export function setupExtOpen(ctx: unknown, options: ExtOpenOptions = {}): void {
+  startPresencePoll(ctx)
+  const search = options.search ?? (typeof location !== 'undefined' ? location.search : '')
+  const params = parseOpenParams(search)
+  if (!params) return
+  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 + '）')
+    return
+  }
+  stripCurrentUrl()
+  void openDeepLink(ctx, params).catch((error) => {
+    console.warn('[dsh-vscode-mode] 深链打开失败：' + String(error))
+    toastDom('深链打开失败：' + String((error as Error)?.message ?? error))
+  })
+}
+
+/**
+ * 深链移交轮询：每 3s 向 host 领取待打开请求（兼活跃心跳，launcher 据此决定是否开新页）。
+ * 页面级单例（window 标记防 HMR 重复）；领取到即执行打开规则。
+ * @author ddj 2026年09月08号
+ * @param ctx 客户端根上下文
+ */
+function startPresencePoll(ctx: unknown): void {
+  if (typeof window === 'undefined') return
+  const marker = window as { __edrvExtPoll?: boolean }
+  if (marker.__edrvExtPoll) return
+  marker.__edrvExtPoll = true
+  let executing = false
+  window.setInterval(() => {
+    if (executing) return
+    executing = true
+    void rpc('edrv.external.pending', {})
+      .then(async (result) => {
+        if (!result.ok || !result.open) return
+        await openDeepLink(ctx, { paths: result.open.paths, line: result.open.line, column: result.open.column })
+      })
+      .catch(() => { /* 旧版 host 无此方法/离线：忽略 */ })
+      .finally(() => { executing = false })
+  }, HANDOFF_POLL_MS)
+}
+
+/**
+ * 跨源守卫：referrer 为空（launcher/Unity 直开）或同源 → 允许。
+ * @author ddj 2026年09月07号
+ * @param referrer 文档 referrer
+ * @param origin 当前页面源
+ * @returns 是否允许处理深链
+ */
+export function referrerAllowed(referrer: string, origin: string): boolean {
+  if (!referrer) return true
+  try {
+    return new URL(referrer).origin === origin
+  } catch {
+    return false
+  }
+}
+
+/**
+ * 剥离 URL 中的深链参数（保留其余参数与 hash，防刷新重开）。
+ * @author ddj 2026年09月07号
+ * @param href 完整 URL
+ * @returns 清理后的 URL（pathname+search+hash）
+ */
+export function stripOpenHref(href: string): string {
+  const url = new URL(href)
+  for (const key of EDRV_PARAM_KEYS) url.searchParams.delete(key)
+  return url.pathname + url.search + url.hash
+}
+
+/** 清理当前页面 URL（best-effort，失败不阻塞打开）。 */
+function stripCurrentUrl(): void {
+  try {
+    if (typeof location === 'undefined' || typeof history === 'undefined') return
+    const next = stripOpenHref(location.href)
+    if (next !== location.pathname + location.search + location.hash) history.replaceState(null, '', next)
+  } catch { /* 清理失败忽略 */ }
+}
+
+/**
+ * 轻量 toast（编辑器未挂载也能提示；5s 自隐；openFlow 通知与错误呈现共用）。
+ * @author ddj 2026年09月07号
+ * @param text 提示文本
+ */
+export function toastDom(text: string): void {
+  if (typeof document === 'undefined') return
+  const toast = document.createElement('div')
+  toast.textContent = text
+  toast.setAttribute('style', [
+    'position:fixed', 'left:50%', 'bottom:28px', 'transform:translateX(-50%)',
+    'z-index:99999', 'padding:8px 14px', 'border-radius:8px', 'max-width:80vw',
+    'background:#2a2a2a', 'color:#ddd', 'border:1px solid #444', 'font-size:12px',
+    'box-shadow:0 4px 16px rgba(0,0,0,.35)',
+  ].join(';'))
+  document.body?.appendChild(toast)
+  setTimeout(() => toast.remove(), TOAST_MS)
+}

package/src/client/index.ts

@@ -25,6 +25,7 @@ import { loadMonaco } from './monaco/loader.js'
 import { createFileOpenerRegistry, scanSidebar, type FileOpenContext } from './fileOpeners.js'
 import type { FileOpenerRegistry } from './fileOpeners.js'
 import { installOpenPathRouter, vscodeOpener, autoValue } from './openPathRouter.js'
+import { setupExtOpen } from './externalOpen.js'
 import { SettingsContext } from './settingsContext.js'
 import { SIDEBAR_PLUGIN, pickSettingsBinder, registerSlotSafely } from './compat.js'
 import { detectSidebarService, installSideEditor, setEnsureSideEditor, SIDEBAR_INSTALL_CMD } from './sidebarBridge.js'
@@ -62,6 +63,9 @@ export function apply(ctx: any): void {
   const workspaces = ctx.get('workspaces')
   const sessions = ctx.get('sessions')
 
+  // 外部深链落地：Windows 右键菜单 / Unity 外部编辑器 → 浏览器 URL 参数 → 打开规则路由
+  setupExtOpen(ctx)
+
   // Monaco 加载时机：不再 DSH 启动即预热，改为进入会话界面（sessions.list.current 出现）后再后台加载，
   // 用户点开「文件编辑」页签即用；空闲时仍由 EditorView 挂载兜底加载。
   // 模块级 promise 去重，重复触发只首次真正加载；requestIdleCallback 让出会话首屏带宽，缺省回退延时调度；

package/src/client/openFlow.ts

@@ -0,0 +1,330 @@
+/**
+ * dsh-vscode-mode client — 深链打开规则引擎（资源管理器右键 / Unity 外部编辑器落地）。
+ * 规则：文件夹 ⊂ 某已注册工作区 → 页面内弹窗二选一（使用最近的工作区 / 新建工作区）；
+ * 文件夹不在任何工作区 → 直达最近对话所在工作区新增；文件 → 最近对话 + 编辑器展开
+ * （无任何会话 → 以文件父目录注册工作区引导创建）。首路径驱动规则，其余路径：文件进
+ * 编辑器、文件夹补引用。纯函数可单测；编排依赖经 OpenDeps 注入（mock 可测）。
+ * 作者 ddj 2026-09-07
+ */
+import { rpc } from './rpc.js'
+import { chooseWorkspace } from './chooseDialog.js'
+import { emitOpenAt, openEditorView } from './events.js'
+import { toastDom } from './externalOpen.js'
+import { createAddToConversation } from './addToConversation.js'
+import type { AddOutcome, CtxLike } from './addToConversation.js'
+import type { OpenParams } from '../shared/externalOpen.js'
+
+/** 路径类型（host edrv.externalStat 判定）。 */
+export type PathKind = 'file' | 'directory' | 'missing'
+
+/** 打开规则分派结果。 */
+export type OpenRule = 'choose' | 'folderNew' | 'fileRecent' | 'bootstrap' | 'abort'
+
+/** 工作区视图最小形状（ctx.workspaces.list 快照行）。 */
+export interface WsView {
+  workspaceId: string
+  path: string
+  title: string
+  sessionIds?: readonly string[]
+  updatedAt?: string
+}
+
+/** 会话行最小形状（ctx.sessions.list 快照行）。 */
+export interface SessionRow {
+  id: string
+  cwd?: string
+  updatedAt?: number
+  origin?: 'subagent'
+}
+
+/** 打开编排依赖（全部可注入，便于 mock 测试）。 */
+export interface OpenDeps {
+  stat(path: string): Promise<PathKind>
+  workspaces(): { items: WsView[]; ready: boolean }
+  sessions(): { ids: string[]; byId: Record<string, SessionRow>; ready: boolean }
+  createSession(opts: { workspaceId?: string; cwd?: string }): Promise<string>
+  createWorkspace(path: string): Promise<{ workspaceId: string; title: string }>
+  openSession(id: string): void
+  reference(sessionId: string, path: string, appearance: 'file' | 'folder'): Promise<boolean>
+  choose(title: string, folder: string): Promise<'recent' | 'create' | null>
+  openEditor(path: string | null, line?: number, column?: number): void
+  schedule(fn: () => void, ms: number): void
+  notify(text: string): void
+}
+
+/** 等列表/输入就绪的节奏。 */
+const READY_TIMEOUT_MS = 15000
+const READY_TICK_MS = 300
+const REF_RETRY_MAX = 20
+const REF_RETRY_MS = 300
+const REST_STEP_MS = 150
+const LINE_AT_DELAY_MS = 200
+
+/**
+ * 路径规范化：`\→/`、小写、去尾分隔符（Windows 大小写不敏感前缀匹配用）。
+ * @author ddj 2026年09月07号
+ */
+export function normPath(p: string): string {
+  return String(p ?? '').replace(/\\/g, '/').replace(/\/+$/, '').toLowerCase()
+}
+
+/**
+ * 目录包含判定：child === root 或 child 位于 root 之下。
+ * @author ddj 2026年09月07号
+ */
+export function containsPath(root: string, child: string): boolean {
+  const r = normPath(root)
+  const c = normPath(child)
+  return c === r || c.startsWith(r + '/')
+}
+
+/**
+ * 父目录（文件引导创建工作区用；根路径回退自身）。
+ * @author ddj 2026年09月07号
+ */
+export function dirnameOf(p: string): string {
+  const norm = String(p ?? '').replace(/[\\/]+$/, '')
+  const cut = Math.max(norm.lastIndexOf('/'), norm.lastIndexOf('\\'))
+  return cut > 0 ? norm.slice(0, cut) : norm
+}
+
+/**
+ * 最近一次对话：排除子代理行，updatedAt 最新优先。
+ * @author ddj 2026年09月07号
+ */
+export function recentSession(byId: Record<string, SessionRow>, ids?: string[]): SessionRow | undefined {
+  const rows = (ids ?? Object.keys(byId)).map((id) => byId[id]).filter((row) => row && row.origin !== 'subagent')
+  return rows.sort((a, b) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0))[0]
+}
+
+/**
+ * 文件夹命中的已注册工作区（前缀包含），updatedAt 新者优先。
+ * @author ddj 2026年09月07号
+ */
+export function matchWorkspaces(items: WsView[], folder: string): WsView[] {
+  return items.filter((ws) => containsPath(ws.path, folder))
+}
+
+/**
+ * 规则分派：目录+命中工作区 → choose；目录未命中 → folderNew（以该文件夹为根注册新工作区，
+ * 用户确认：一律取右键的文件夹本身）；文件有会话 → fileRecent；文件无会话 → bootstrap；
+ * 路径缺失 → abort。
+ * @author ddj 2026年09月08号
+ */
+export function pickRule(kind: PathKind, matched: boolean, hasSession: boolean): OpenRule {
+  if (kind === 'missing') return 'abort'
+  if (kind === 'directory') return matched ? 'choose' : 'folderNew'
+  return hasSession ? 'fileRecent' : 'bootstrap'
+}
+
+/**
+ * 深链打开编排入口：等列表就绪 → 判型 → 规则分派 → 编排 create/open/引用/编辑器。
+ * @author ddj 2026年09月07号
+ * @param ctx 客户端根上下文（sessions/workspaces 服务）
+ * @param params 深链参数（首路径驱动规则）
+ * @param overrides 依赖覆盖（测试注入）
+ */
+export async function openDeepLink(ctx: unknown, params: OpenParams, overrides: Partial<OpenDeps> = {}): Promise<void> {
+  const deps = realDeps(ctx, overrides)
+  if (!(await waitListsReady(deps))) {
+    deps.notify('DSH 会话列表未就绪，请稍后重试')
+    return
+  }
+  const primary = params.paths[0]
+  const kind = await deps.stat(primary).catch(() => 'missing' as PathKind)
+  const sess = deps.sessions()
+  const rule = pickRule(kind, matchWorkspaces(deps.workspaces().items, primary).length > 0, Boolean(recentSession(sess.byId, sess.ids)))
+  try {
+    if (rule === 'abort') {
+      deps.notify('路径不存在：' + primary)
+      return
+    }
+    if (rule === 'choose') return await runChoose(deps, primary, params)
+    if (rule === 'folderNew') return await runFolderNew(deps, primary, params)
+    if (rule === 'fileRecent') return await runFileRecent(deps, primary, params)
+    return await runFileBootstrap(deps, primary, params)
+  } catch (error) {
+    deps.notify('打开失败：' + String((error as Error)?.message ?? error))
+  }
+}
+
+/** 等待会话与工作区列表就绪（上限 15s；超时按当前态判定）。 */
+async function waitListsReady(deps: OpenDeps): Promise<boolean> {
+  for (let waited = 0; waited < READY_TIMEOUT_MS; waited += READY_TICK_MS) {
+    if (deps.sessions().ready && deps.workspaces().ready) return true
+    await sleep(deps, READY_TICK_MS)
+  }
+  return deps.sessions().ready && deps.workspaces().ready
+}
+
+/** 规则 1：命中工作区 → 弹窗分派（取消即中止）。 */
+async function runChoose(deps: OpenDeps, folder: string, params: OpenParams): Promise<void> {
+  const matches = matchWorkspaces(deps.workspaces().items, folder)
+  const best = bestMatch(deps, matches)
+  const choice = await deps.choose(best?.title ?? '工作区', folder)
+  if (choice === null) return
+  if (choice === 'create') return runFolderNew(deps, folder, params)
+  const ws = best ?? deps.workspaces().items[0]
+  const sessionId = await spawnInWorkspace(deps, ws.workspaceId, undefined)
+  await settleRef(deps, sessionId, folder, 'folder')
+  deps.openEditor(null)
+  await openRest(deps, sessionId, params, 1)
+}
+
+/** 规则 3a：文件 → 所属工作区优先（有会话打开其最近会话；无会话新建 + 文件引用）；无匹配 → 最近对话。 */
+async function runFileRecent(deps: OpenDeps, file: string, params: OpenParams): Promise<void> {
+  const ws = pickFileWorkspace(deps, file)
+  if (ws) {
+    const anchor = recentSessionIn(deps, ws)
+    if (anchor) {
+      deps.openSession(anchor.id)
+      deps.openEditor(file, params.line, params.column)
+      await openRest(deps, anchor.id, params, 1)
+      return
+    }
+    // 文件所属工作区存在但无会话 → 在该工作区新建对话 + 文件引用
+    const sessionId = await spawnInWorkspace(deps, ws.workspaceId, undefined)
+    await settleRef(deps, sessionId, file, 'file')
+    deps.openEditor(file, params.line, params.column)
+    await openRest(deps, sessionId, params, 1)
+    return
+  }
+  const anchor = recentSession(deps.sessions().byId, deps.sessions().ids)
+  if (!anchor) return runFileBootstrap(deps, file, params)
+  deps.openSession(anchor.id)
+  deps.openEditor(file, params.line, params.column)
+  await openRest(deps, anchor.id, params, 1)
+}
+
+/**
+ * 文件所属工作区：前缀命中的工作区里，优先取有会话且最近活跃的；都无会话取路径最具体的。
+ * @author ddj 2026年09月08号
+ */
+function pickFileWorkspace(deps: OpenDeps, file: string): WsView | undefined {
+  const matches = matchWorkspaces(deps.workspaces().items, file)
+  if (!matches.length) return undefined
+  const withSessions = matches.filter((ws) => (ws.sessionIds ?? []).some((id) => Boolean(deps.sessions().byId[id])))
+  if (!withSessions.length) {
+    return [...matches].sort((a, b) => normPath(b.path).length - normPath(a.path).length)[0]
+  }
+  return withSessions.sort((a, b) => latestSessionAt(deps, b) - latestSessionAt(deps, a))[0]
+}
+
+/** 工作区内会话的最近活跃时间（无成员 → 0）。 */
+function latestSessionAt(deps: OpenDeps, ws: WsView): number {
+  const byId = deps.sessions().byId
+  return (ws.sessionIds ?? []).reduce((max, id) => Math.max(max, byId[id]?.updatedAt ?? 0), 0)
+}
+
+/** 工作区内最近一次会话（排除子代理与不在列表中的陈旧行）。 */
+function recentSessionIn(deps: OpenDeps, ws: WsView): SessionRow | undefined {
+  const byId = deps.sessions().byId
+  const rows = (ws.sessionIds ?? []).map((id) => byId[id]).filter((row) => row && row.origin !== 'subagent')
+  return rows.sort((a, b) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0))[0]
+}
+
+/** 规则 3b：文件 + 无任何会话 → 父目录注册工作区 + 新对话 + 文件引用 + 编辑器打开。 */
+async function runFileBootstrap(deps: OpenDeps, file: string, params: OpenParams): Promise<void> {
+  const ws = await deps.createWorkspace(dirnameOf(file))
+  const sessionId = await spawnInWorkspace(deps, ws.workspaceId, undefined)
+  await settleRef(deps, sessionId, file, 'file')
+  deps.openEditor(file, params.line, params.column)
+  await openRest(deps, sessionId, params, 1)
+}
+
+/** 规则 1.2：以文件夹注册新工作区 + 新对话 + 文件夹引用 + 编辑页。 */
+async function runFolderNew(deps: OpenDeps, folder: string, params: OpenParams): Promise<void> {
+  const ws = await deps.createWorkspace(folder)
+  const sessionId = await spawnInWorkspace(deps, ws.workspaceId, undefined)
+  await settleRef(deps, sessionId, folder, 'folder')
+  deps.openEditor(null)
+  await openRest(deps, sessionId, params, 1)
+}
+
+/** 在指定工作区（或回退 cwd）新建对话并置为当前；返回新会话 id。 */
+async function spawnInWorkspace(deps: OpenDeps, workspaceId: string | undefined, fallbackCwd: string | undefined): Promise<string> {
+  const sessionId = await deps.createSession(workspaceId ? { workspaceId } : fallbackCwd ? { cwd: fallbackCwd } : {})
+  deps.openSession(sessionId)
+  return sessionId
+}
+
+/** 命中工作区集中「最近」的一个（其成员会话 updatedAt 最新者优先）。 */
+function bestMatch(deps: OpenDeps, matches: WsView[]): WsView | undefined {
+  const byId = deps.sessions().byId
+  const score = (ws: WsView): number => {
+    const sessionLatest = (ws.sessionIds ?? []).reduce((max, id) => Math.max(max, byId[id]?.updatedAt ?? 0), 0)
+    return Math.max(sessionLatest, Date.parse(ws.updatedAt ?? '') || 0)
+  }
+  return [...matches].sort((a, b) => score(b) - score(a))[0]
+}
+
+/** 引用插入轮询：输入门面就绪前每 300ms 重试（appendReference 忙态已降级视为成功）。 */
+async function settleRef(deps: OpenDeps, sessionId: string, path: string, appearance: 'file' | 'folder'): Promise<void> {
+  for (let attempt = 0; attempt < REF_RETRY_MAX; attempt++) {
+    if (await deps.reference(sessionId, path, appearance)) return
+    await sleep(deps, REF_RETRY_MS)
+  }
+}
+
+/** 其余路径：文件进编辑器（步进），文件夹补文件夹引用。 */
+async function openRest(deps: OpenDeps, sessionId: string | null, params: OpenParams, from: number): Promise<void> {
+  const rest = params.paths.slice(from)
+  for (const [index, path] of rest.entries()) {
+    const kind = await deps.stat(path).catch(() => 'missing' as PathKind)
+    if (kind === 'file') {
+      deps.schedule(() => deps.openEditor(path), REST_STEP_MS * (index + 1))
+    } else if (kind === 'directory' && sessionId) {
+      await settleRef(deps, sessionId, path, 'folder')
+    }
+  }
+}
+
+/** 可注入 sleep。 */
+function sleep(deps: OpenDeps, ms: number): Promise<void> {
+  return new Promise((resolve) => deps.schedule(resolve, ms))
+}
+
+/** 真实依赖装配（全部来自 ctx 注入服务 + 既有 RPC/弹窗/编辑器入口）。 */
+function realDeps(ctx: unknown, overrides: Partial<OpenDeps> = {}): OpenDeps {
+  const service = (name: string): any => {
+    const get = (ctx as { get?: (name: string) => unknown } | undefined)?.get
+    return typeof get === 'function' ? get.call(ctx, name) : undefined
+  }
+  const add = createAddToConversation(ctx as CtxLike)
+  const base: OpenDeps = {
+    stat: async (path) => {
+      const result = await rpc('edrv.externalStat', { path })
+      return result.ok ? result.kind : 'missing'
+    },
+    workspaces: () => {
+      const snap = (service('workspaces')?.list?.getSnapshot?.() ?? {}) as { items?: WsView[]; phase?: string }
+      return { items: snap.items ?? [], ready: snap.phase === 'ready' }
+    },
+    sessions: () => {
+      const snap = (service('sessions')?.list?.getSnapshot?.() ?? {}) as { ids?: string[]; byId?: Record<string, SessionRow>; phase?: string }
+      return { ids: snap.ids ?? [], byId: snap.byId ?? {}, ready: snap.phase !== 'pending' }
+    },
+    createSession: async (opts) => await service('sessions').create(opts),
+    createWorkspace: async (path) => {
+      const ws = await service('workspaces').create({ path })
+      return { workspaceId: ws.workspaceId, title: ws.title }
+    },
+    openSession: (id) => service('sessions').open(id),
+    reference: async (sessionId, path, appearance) => {
+      const outcome: AddOutcome = await add.appendReference(sessionId, path, undefined, appearance)
+      return outcome !== 'unavailable'
+    },
+    choose: (title, folder) => chooseWorkspace(title, folder),
+    openEditor: (path, line, column) => {
+      if (path == null) {
+        openEditorView(null)
+        return
+      }
+      openEditorView(path)
+      if (line != null) setTimeout(() => emitOpenAt(path, line, column), LINE_AT_DELAY_MS)
+    },
+    schedule: (fn, ms) => setTimeout(fn, ms),
+    notify: (text) => toastDom(text),
+  }
+  return { ...base, ...overrides }
+}