dsh-code-server-app 0.3.58 → 0.3.63

package/lib/index.js

@@ -51,6 +51,22 @@ import {
   writeBridgeConfig,
 } from './bridge.mjs';
 import { bridgeEndpointPath, startBridgeListener } from './bridge-ipc.mjs';
+// FIM(幽灵)补全(实验性):**注册一个自己的 LLM 适配器**而不是直连 —— 见 lib/fim-adapter.mjs 顶部。
+import {
+  clampDebounce,
+  compileGlobList,
+  createApiKeyResolver,
+  createFimAdapterClass,
+  createFimBudget,
+  createFimStats,
+  encodeFimRequest,
+  FIM_MAX_TOKENS,
+  FIM_MODEL,
+  FIM_PROVIDER,
+  loadFimBase,
+  matchDisabledGlob,
+  toSingleLine,
+} from './fim-adapter.mjs';
 import { registerEditorPrompt, registerEditorTools, setPromptLiveProbe } from './bridge-tools.mjs';
 import { deliverEditorPrompt } from './bridge-session.mjs';
 import { dshEntry, dshRequire } from './dsh-resolve.mjs';
@@ -120,6 +136,25 @@ export const Config = z.object({
    *  诊断、活动选区),并让编辑器里的动作能驱动 DSH。关闭后不写 bridge.json、不注册编辑器工具,
    *  扩展会休眠(它读不到配置就不做任何事)。安全模型见 lib/bridge.mjs 顶部。 */
   editorBridge: z.boolean().default(true),
+  /** fim=false(默认):**实验性**的 FIM(幽灵)补全。开启后宿主的编辑器桥多一条**有界的模型调用**
+   *  路由(`POST /complete`),编辑器里的内联补全(灰字)由它供给;宿主为此注册一个自己的 LLM
+   *  适配器路由 `dshcs-fim`(走 Completions API 的 `/beta/completions`)。
+   *
+   *  为什么默认关、为什么叫实验性:①它会把**光标附近的代码**发给模型(桥的其余部分是只读状态,
+   *  不外发内容);②模型在"不该补的位置"会硬凑(实测 2/2 复现),需要编辑器侧判据兜;
+   *  ③这条调用**不进 DSH 的 token 计量**(一次性调用不是 loop 请求,不写会话日志),
+   *  用量只在扩展状态栏与设置卡里可见。安全模型见 lib/fim-adapter.mjs 顶部。 */
+  fim: z.boolean().default(false),
+  /** 停顿多久才发一次补全请求(毫秒)。太小 ⇒ 打字过程中反复触发;太大 ⇒ 失去"补全"的意义。
+   *  取值在消费处夹到 [100, 3000](clampDebounce),设置里填什么都不至于打到链路上。 */
+  fimDebounceMs: z.number().default(250),
+  /** 是否允许多行补全(true 默认)。false ⇒ 宿主只回第一行(空首行 = 这次不补)。
+   *  关掉它是最省心的安全阀:实测模型在"不该补的位置"会硬凑,多行会把这种噪声放大。 */
+  fimMultiline: z.boolean().default(true),
+  /** 按 glob 禁用补全的文件(分号 / 逗号 / 空白 / 换行分隔;空 = 不禁用)。
+   *  语义:`*` 不跨目录、`**` 跨目录、不含 `/` 的模式只匹配文件名、`/` 结尾视作 `/**`。
+   *  两侧都会判:扩展侧先判(不发请求),宿主侧再判(防线在服务端)。 */
+  fimDisableGlobs: z.string().default(''),
 });
 
 const DEFAULT_CONFIG = {
@@ -136,6 +171,12 @@ const DEFAULT_CONFIG = {
   readyTimeoutMs: 60000,
   /** 编辑器桥(0.3.0):见 Config.editorBridge。行配置与设置文档都可关;设置卡片暂不提供行。 */
   editorBridge: true,
+  /** FIM 补全(实验性,0.3.61):见 Config.fim。默认关。 */
+  fim: false,
+  /** FIM 的三个子项(0.3.62):停顿毫秒数 / 是否多行 / 按 glob 禁用。见 Config 里的说明。 */
+  fimDebounceMs: 250,
+  fimMultiline: true,
+  fimDisableGlobs: '',
 };
 
 const LOOPBACK_HOSTS = new Set(['127.0.0.1', 'localhost', '::1']);
@@ -337,6 +378,31 @@ export function installBundledExtensions(extensionsDir, userDataDir, options = {
           }
         };
         walkDst('');
+        // 文件删完还要**收掉空目录**:0.3.59 删掉了整个 webview/ 子目录,只删文件的话会在用户的
+        // VS Code 树里留下一串空目录(实测:webview/、webview/src、webview/fonts 各 0 字节)。
+        // 自底向上收,只收"确实空了"的目录(非空的目录说明里面有别的东西,不动)。
+        const pruneEmptyDirs = (rel) => {
+          const abs = rel === '' ? dst : path.join(dst, rel);
+          let entries;
+          try {
+            entries = fs.readdirSync(abs, { withFileTypes: true });
+          } catch {
+            return;
+          }
+          for (const ent of entries) {
+            if (ent.isDirectory()) pruneEmptyDirs(rel === '' ? ent.name : `${rel}/${ent.name}`);
+          }
+          if (rel === '') return;
+          try {
+            if (fs.readdirSync(abs).length === 0) {
+              fs.rmdirSync(abs);
+              removed.push(`${rel}/`);
+            }
+          } catch {
+            // 竞态(别的东西刚写进来)或权限问题:保持原样,不影响主流程
+          }
+        };
+        pruneEmptyDirs('');
       }
       // 清理放错位置的副本:编辑器桥的旧用户级副本(0.3.11 及更早)/ dshcs-open-file 的旧用户级副本。
       const wrong = extensionTarget(extensionsDir, ext.name, ext.placement === 'builtin' ? 'user' : 'builtin', treeRoot);
@@ -590,6 +656,10 @@ function readEndpoint(config) {
   }
 }
 
+/** 仅测试用:最近一次 apply() 装好的桥分发器(消费方是文件末尾的 bridgeRequestForTests)。
+ *  运行时代码**不读它** —— 它存在的唯一目的是让回归不必经过命名管道,原因见那个函数的注释。 */
+let activeBridgeDispatch = null;
+
 export async function apply(ctx, config) {
   const cfg = { ...DEFAULT_CONFIG, ...(config ?? {}) };
 
@@ -607,6 +677,12 @@ export async function apply(ctx, config) {
   let fullscreenOnOpen = true; // 客户端"打开标签即全屏右侧栏"(0.2.9)
   /** 编辑器桥开关(0.3.0):行配置 cfg.editorBridge 是种子,设置文档里可改并实时生效。 */
   let bridgeSetting = cfg.editorBridge !== false;
+  /** FIM 补全开关(实验性,0.3.61):行配置 cfg.fim 是种子,设置文档里可改并实时生效。默认关。 */
+  let fimSetting = cfg.fim === true;
+  /** FIM 的三个子项(0.3.62):停顿毫秒数 / 是否多行 / 按 glob 禁用(原始文本,消费时解析)。 */
+  let fimDebounceMs = clampDebounce(cfg.fimDebounceMs);
+  let fimMultiline = cfg.fimMultiline !== false;
+  let fimDisableGlobs = typeof cfg.fimDisableGlobs === 'string' ? cfg.fimDisableGlobs : '';
   if (settingsSvc !== undefined && typeof settingsSvc.register === 'function') {
     try {
       const scope = settingsSvc.register(SETTINGS_NS, Config);
@@ -620,6 +696,10 @@ export async function apply(ctx, config) {
           : DEFAULT_CLAIM_EXTENSIONS;
         fullscreenOnOpen = resolved && typeof resolved.fullscreenOnOpen === 'boolean' ? resolved.fullscreenOnOpen : true;
         bridgeSetting = resolved && typeof resolved.editorBridge === 'boolean' ? resolved.editorBridge : bridgeSetting;
+        fimSetting = resolved && typeof resolved.fim === 'boolean' ? resolved.fim : fimSetting;
+        fimDebounceMs = clampDebounce(resolved && resolved.fimDebounceMs !== undefined ? resolved.fimDebounceMs : fimDebounceMs);
+        fimMultiline = resolved && typeof resolved.fimMultiline === 'boolean' ? resolved.fimMultiline : fimMultiline;
+        fimDisableGlobs = resolved && typeof resolved.fimDisableGlobs === 'string' ? resolved.fimDisableGlobs : fimDisableGlobs;
       }
       scope.watch((next) => {
         if (next != null && (next.serve === 'dsh' || next.serve === 'loopback')) {
@@ -646,6 +726,36 @@ export async function apply(ctx, config) {
             }
           }
         }
+        // FIM(实验性):开 → 注册我们自己的 LLM 适配器路由(编辑器补全要靠它);
+        // 关 → 注销。翻转立刻生效,不需要重启宿主(扩展侧下一趟 /sync 就会看到 enabled 变了)。
+        if (next != null && typeof next.fim === 'boolean') {
+          if (next.fim !== fimSetting) {
+            fimSetting = next.fim;
+            console.log(`[code-server] fim updated: ${fimSetting}(实验性 FIM 补全)`);
+            void ensureFimAdapter();
+          }
+        }
+        // FIM 的三个子项(0.3.62):都**即时生效**,不需要重启宿主 —— 扩展每趟 /sync 都会拿到新值
+        // (停顿与 glob 是扩展侧行为,多行由宿主在返回前裁)。改动只打一行日志,便于事后对齐现场。
+        if (next != null && next.fimDebounceMs !== undefined) {
+          const clamped = clampDebounce(next.fimDebounceMs);
+          if (clamped !== fimDebounceMs) {
+            fimDebounceMs = clamped;
+            console.log(`[code-server] fimDebounceMs updated: ${fimDebounceMs}ms`);
+          }
+        }
+        if (next != null && typeof next.fimMultiline === 'boolean') {
+          if (next.fimMultiline !== fimMultiline) {
+            fimMultiline = next.fimMultiline;
+            console.log(`[code-server] fimMultiline updated: ${fimMultiline}`);
+          }
+        }
+        if (next != null && typeof next.fimDisableGlobs === 'string') {
+          if (next.fimDisableGlobs !== fimDisableGlobs) {
+            fimDisableGlobs = next.fimDisableGlobs;
+            console.log(`[code-server] fimDisableGlobs updated: ${compileGlobList(fimDisableGlobs).length} 条`);
+          }
+        }
         if (next != null && typeof next.keepResident === 'boolean') {
           keepResident = next.keepResident;
           console.log(`[code-server] keepResident updated: ${keepResident}`);
@@ -755,22 +865,19 @@ export async function apply(ctx, config) {
   const bridgeApprovalBoard = createApprovalBoard();
   /**
    * 谁在"看着这个会话" —— 授权拦截据此决定要不要抢答(没人看就直接交给官方链路):
-   *   - `ids`:编辑器扩展面板声明要看的会话(每趟 /sync 上报);
    *   - `dialogIds`:DSH 页面里的对话框(0.3.24)声明要看的会话;
-   *   - `at`:最近一次声明的时间(超过 5s 视为没人看)。
+   *   - `at`:最近一次声明的时间(诊断用)。
+   *
+   * 0.3.59:编辑器扩展的 webview 面板退役后只剩对话框一路 —— 以前还有 `ids`(扩展每趟 /sync 上报的
+   * 观看列表),两个来源求并集、还要按心跳新鲜度区分,现在都不需要了。
    */
-  const bridgeWatch = { ids: [], dialogIds: [], at: 0 };
-  /** 上次回给扩展的对话流修订号(0.3.27:没变化就不重传整份快照)。 */
-  let bridgeThreadRevSent = -1;
+  const bridgeWatch = { dialogIds: [], at: 0 };
   /** 上次记录过的"有没有人在看"(0.3.30:状态翻转才写诊断日志)。 */
   let bridgeWatchLogged = false;
   /** 首帧是否已写过诊断(0.3.31:"一直没人看"也要留下证据)。 */
   let bridgeWatchWroteFirst = false;
   /** 上次写过的 hasPanel 判据原文(变了才写,避免每 600ms 刷屏)。 */
   let bridgeHasPanelLine = '';
-  /** 客户端(self-declared)是否能把授权卡片画出来(0.3.30)。 */
-  let bridgeApprovalsUi = false;
-  let bridgeApprovalsUiLogged = false;
 
   /**
    * 授权/看护状态的**诊断日志**(0.3.30):写到 <home>/.dsh/code-server/bridge-approval.log。
@@ -795,36 +902,30 @@ export async function apply(ctx, config) {
 
   /** 当前所有"在看"的会话(去重)。 */
   function watchedSessions() {
-    const all = [...bridgeWatch.ids, ...bridgeWatch.dialogIds];
-    return [...new Set(all.filter((id) => typeof id === 'string' && id !== ''))].slice(0, 4);
+    return [...new Set(bridgeWatch.dialogIds.filter((id) => typeof id === 'string' && id !== ''))].slice(0, 4);
   }
   /** 现在有没有人在看(授权拦截的唯一判据)。 */
   function hasWatcher() {
-    const sessions = watchedSessions();
-    if (sessions.length === 0) return false;
-    // **对话框是宿主侧状态**(只在 /ask/close 时消失):不拿轮询新鲜度去判它 ——
-    // 浏览器把后台标签的定时器节流到分钟级时,900ms 的心跳一断、5 秒窗口就过期,
+    // 0.3.59 起只有对话框一路。**对话框是宿主侧状态**(只在 /ask/close 时消失),所以不拿轮询新鲜度
+    // 去判它 —— 浏览器把后台标签的定时器节流到分钟级时,900ms 的心跳一断、5 秒窗口就过期,
     // 我们会误判"没人看"而放弃拦截(用户实测:授权卡片因此跑到 DSH 界面)。
-    if (bridgeWatch.dialogIds.length > 0) return true;
-    // 编辑器面板靠 /sync 的 600ms 心跳;窗口放宽到 60 秒(正常心跳远小于它)。
-    return Date.now() - bridgeWatch.at < 60000;
+    return watchedSessions().length > 0;
   }
 
   const bridgeApproval = createApprovalInterceptor({
     board: bridgeApprovalBoard,
     holdMs: DEFAULT_HOLD_MS,
-    // **只在客户端能画卡片时才抢答**(0.3.30):面板/对话框在看 **且** 它自己声明 approvalsUi。
+    // **只在对话框真的能显示卡片时才抢答**(0.3.30 / 0.3.59 收紧)。
     // 反例(用户实测):面板处于"宿主没有对话流能力"的坏状态时我们仍然抢答 ⇒ 官方卡片不出现、
     // 面板也不画 ⇒ 用户看到的是"没弹出授权",请求在宿主里干等 5 分钟。
-    // 客户端能画卡片 = 编辑器面板自报可以的 **或** 对话框开着且有会话(0.3.33)。
-    // "活着"由 /ask/state 轮询证明)。0.3.31 的日志给出了反例:用户从**对话框**提问 ⇒
-    // 编辑器面板是 null ⇒ 旧判据误判成"画不出卡片",授权被让给了 DSH 界面。
+    // 0.3.59 起编辑器面板退役,"能显示卡片"只剩**对话框开着 + 有人看 + 客户端半部在轮询**一条路
+    // (客户端自己声明 approvalsUi 那条也随面板一起删了 —— 声明者已经不存在)。
     hasPanel: () => {
       const watcher = hasWatcher();
       const dialogCapable = askDialogLive();
-      const verdict = watcher && (bridgeApprovalsUi || dialogCapable);
+      const verdict = watcher && dialogCapable;
       // 判据的**原始值**一起落日志(0.3.35):只记结论的话,出问题还是只能猜。
-      const line = 'hasPanel -> ' + verdict + ' (hasWatcher=' + watcher + ' approvalsUi=' + bridgeApprovalsUi
+      const line = 'hasPanel -> ' + verdict + ' (hasWatcher=' + watcher
         + ' dialogLive=' + dialogCapable + ' polls=' + askDialog.polls + ' open=' + askDialog.open
         + ' session=' + String(askDialog.sessionId) + ')';
       if (line !== bridgeHasPanelLine) { bridgeHasPanelLine = line; bridgeDiag(line); }
@@ -839,11 +940,15 @@ export async function apply(ctx, config) {
   /**
    * 「问 DSH」对话框的宿主侧状态(0.3.24)。
    *
-   * 对话渲染从编辑器的 webview 面板搬到了 **DSH 页面里的浮动对话框**(client 半部,见 lib/client.js):
-   * 面板是编辑器里的一个 tab/一列,而用户要的是"像 DSH 那样的对话框"。host 这边只负责:
+   * 对话只有一个宿主:**DSH 页面里的浮动对话框**(client 半部,见 lib/client.js)。host 这边只负责:
    *   - 打开/关闭状态(编辑器扩展右键 → 桥 `/event` 上报 `ask-open`);
    *   - 状态与动作的 HTTP 面(`/api/code-server/ask/*`,与 DSH 同源、吃它的 cookie/Origin 校验);
-   *   - 把面板产物(thread.js / thread.css)交给对话框注入(Lib 版本与 DSH 界面同版本,见 build-webview.mjs)。
+   *   - 把"被看的会话"投影成有界条目流(见 lib/bridge-thread.mjs)与待决授权快照。
+   *
+   * **0.3.59 起不再往页面里送产物,也不再服务编辑器面板**:面板就在 `lib/client.js` 里,渲染器走
+   * DSH 页面的模块表(`react-dom/client` + `@deepseek-ai/dsh-client-ui-primitives`);
+   * `/ask/bundle` 路由、`askBundle()` 与编辑器里的 webview 面板在同一版里一起删掉
+   * (thread.js / thread.css / build-webview.mjs / esbuild 那一整套)。
    */
   const askDialog = { open: false, armed: false, mode: 'selection', at: 0, sessionId: null, polls: 0, lastPollAt: 0 };
 
@@ -852,8 +957,8 @@ export async function apply(ctx, config) {
    *
    * 0.3.24 的教训:宿主无条件报 `askDialog: true`,扩展于是不再开编辑器面板;而客户端半部只要没跑起来
    * (浏览器还缓存着旧 bundle / 没硬刷新),就**没有任何一方在看这个会话** ⇒ 授权悄悄落到 DSH 界面的
-   * 官方卡片,用户在编辑器里什么都看不到。现在只有**真的收到过 `/ask/state` 轮询**(5 秒内)才算有
-   * 这个能力;否则扩展退回编辑器面板 —— 那是验证过、能看能点的 UI。
+   * 官方卡片,用户在编辑器里什么都看不到。现在只有**真的收到过 `/ask/state` 轮询**(10 分钟内)才算有
+   * 这个能力;0.3.59 起不满足时扩展也不再退编辑器面板(那一半已退役),而是明确提示用户刷新/打开页面。
    */
   function askDialogLive() {
     // 对话框每 900ms 问一次 /ask/state —— 那就是"活跃心跳"。心跳一旦建立,在 TTL 内
@@ -922,7 +1027,8 @@ export async function apply(ctx, config) {
       statusText: '',
       error: null,
       sessionId: snapshot.sessionId ?? askDialog.sessionId ?? null,
-      uiVersion: uiVersion(),
+      // 0.3.59:`uiVersion` 只服务过"面板内置渲染器与界面版本比对"那行告警 —— 面板退役后删掉。
+      // `dshVersion` 留着:诊断时一眼看出这套宿主跑在哪个 DSH 上。
       dshVersion: dshVersion(),
     };
   }
@@ -932,10 +1038,12 @@ export async function apply(ctx, config) {
     return bridgeThread.rev(watchedSessions()) * 8 + bridgeApprovalBoard.rev() * 8 + (askDialog.open ? 1 : 0) + (askDialog.mode === 'file' ? 2 : 0);
   }
 
-  /** 对话框刷新它的"我在看"时间戳(每趟 /state 都算一次)。 */
+  /** 对话框刷新它的"我在看"时间戳(每趟 /state 都算一次)。
+   *  0.3.59 起这里也负责对齐会话流订阅:以前是扩展每 600ms 的 `/sync` 顺带做的。 */
   function refreshDialogWatch() {
     bridgeWatch.dialogIds = askDialog.open && askDialog.sessionId !== null ? [askDialog.sessionId] : [];
     bridgeWatch.at = Date.now();
+    bridgeThread.sync(watchedSessions());
   }
 
   /**
@@ -952,29 +1060,6 @@ export async function apply(ctx, config) {
     return { status: ok ? 200 : 409, body: { ok, outcome: ok ? outcome : null } };
   }
 
-  /** 面板产物(thread.js / thread.css):对话框把它们注入 DSH 页面,所以由 host 读盘给文本。 */
-  let askBundleCache = null;
-  function askBundle() {
-    if (askBundleCache !== null) return askBundleCache;
-    const dir = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'assets', 'extensions', 'dshcs-editor-bridge', 'webview');
-    const read = (name) => {
-      try {
-        return fs.readFileSync(path.join(dir, name), 'utf8');
-      } catch {
-        return null;
-      }
-    };
-    const js = read('thread.js');
-    const css = read('thread.css');
-    // 产物缺失(打包漏了 build:webview)→ 明确报出来,不返回半个面板。
-    if (js === null || css === null) {
-      console.warn(`[code-server] 「问 DSH」对话框的产物缺失:${dir}(请在源码里跑 pnpm run build:webview)`);
-      return null;
-    }
-    askBundleCache = { js, css };
-    return askBundleCache;
-  }
-
 
   /** 本部署的 DSH 版本(诊断用;面板要的是下面那个"界面版本")。 */
   function dshVersion() {
@@ -988,36 +1073,6 @@ export async function apply(ctx, config) {
     }
   }
 
-  /**
-   * 本部署**界面**的版本(0.3.22)。
-   *
-   * 面板里的 markdown 渲染器是从 `@deepseek-ai/dsh-client-ui-primitives` 打包进去的,而那份
-   * 渲染器就装在 `@deepseek-ai/dsh-web-frontend` 里(DSH Web 的前端包)。面板拿这个版本和
-   * 自己打包时的版本比一比,不一致就在面板顶部显示一行提示 —— 版本错配的排版差异不许静默。
-   */
-  function uiVersion() {
-    try {
-      const entry = dshEntry();
-      if (entry === undefined || entry === null) return null;
-      const dir = path.dirname(entry);
-      const candidates = [
-        path.join(dir, 'node_modules', '@deepseek-ai', 'dsh-web-frontend', 'package.json'),
-        path.join(dir, '..', 'dsh-web-frontend', 'package.json'),
-      ];
-      for (const candidate of candidates) {
-        try {
-          const manifest = JSON.parse(fs.readFileSync(candidate, 'utf8'));
-          if (typeof manifest.version === 'string') return manifest.version;
-        } catch {
-          // 下一个候选
-        }
-      }
-      return null;
-    } catch {
-      return null;
-    }
-  }
-
   /** 本次启动生成的新桥令牌;null = 本实例没有令牌(adopt 旧实例时会回读 bridge.json)。 */
   let bridgeToken = null;
   /** 桥的本机 IPC 监听口(0.3.13)。null = 未起(未启用/起失败)。*/
@@ -1084,15 +1139,20 @@ export async function apply(ctx, config) {
 
   /** 桥的路由(后缀 → Fetch 风格 handler)。做成函数而非常量:handler 声明在文件后段,
    *  函数声明会提升,而常量在挂载时可能还在 TDZ。
-   *  `/approve` 是唯一的非只读路由(只回答既有授权请求,见 handleBridgeApprove)。 */
+   *
+   *  **四条只读路由 + 一条有界的模型调用**(0.3.61 起):/health 探活、/sync 上报状态+取事件、
+   *  /old 取写前原文、/event 上报意图;/complete 是**唯一的例外** —— 它把光标前后的两段文本
+   *  交给模型换回一段补全文本(实验性 FIM,设置里默认关;安全不变量见 handleBridgeComplete)。
+   *  (请宿主打开对话框等)。提问与授权**不在这里** —— 它们走 DSH 同源的
+   *  `/api/code-server/ask/{send,approve}`,调用方是 DSH 页面里的插件客户端(client 半部),
+   *  吃 DSH 自己的 cookie/Origin 校验。 */
   function bridgeRouteTable() {
     return [
       { suffix: '/health', methods: ['GET'], fetch: handleBridgeHealth },
       { suffix: '/sync', methods: ['POST'], fetch: handleBridgeSync },
       { suffix: '/old', methods: ['GET'], fetch: handleBridgeOld },
-      { suffix: '/ask', methods: ['POST'], fetch: handleBridgeAsk },
       { suffix: '/event', methods: ['POST'], fetch: handleBridgeEvent },
-      { suffix: '/approve', methods: ['POST'], fetch: handleBridgeApprove },
+      { suffix: '/complete', methods: ['POST'], fetch: handleBridgeComplete },
     ];
   }
 
@@ -1136,6 +1196,11 @@ export async function apply(ctx, config) {
     return route.fetch(request);
   }
 
+  // 仅测试用:把分发器交给模块级钩子(见 bridgeRequestForTests)。沙箱里**连接**命名管道 EPERM
+  // ⇒ 走 IPC 的用例会全体 SKIP,"本地全绿"里就没有桥的状态码断言了(0.3.63 的 /complete 403
+  // 就是这么假绿到 runner 才红的)。有了它,断言在任何机器上都能真跑。
+  activeBridgeDispatch = dispatchBridge;
+
   /** 桥是否启用(行配置为种子,设置文档里可实时改)。 */
   function bridgeEnabled() {
     return bridgeSetting !== false;
@@ -1145,6 +1210,10 @@ export async function apply(ctx, config) {
    *  所以在 IDE 从未启动的部署里它也只是一段空注册,不产生任何提示词开销。 */
   setPromptLiveProbe(() => bridgeMeta !== null);
   bridgePromptDispose = registerEditorPrompt(ctx);
+  // FIM(实验性)的适配器注册**不在这里**:它的状态声明(fimStats/fimAdapterDispose…)在文件后段,
+  // 这里调用会撞 `Cannot access 'fimAdapterDispose' before initialization`(TDZ)——
+  // async 函数声明会提升,但它读的 `let` 还没初始化,异常会直接把整个插件加载打挂
+  // (与 0.3.6 的 `ctx.systemPrompt` 事故同一类)。真正的调用点在 FIM 运行时声明之后。
   if (bridgePromptDispose === null && bridgeEnabled()) {
     console.warn('[code-server] 编辑器桥:systemPrompt 服务不可用,提示词段落未注册(工具仍可用)');
   }
@@ -1159,12 +1228,12 @@ export async function apply(ctx, config) {
   });
 
   // 会话流与授权拦截都是**按会话**建立的(在 /ask 成功时 watch + intercept),
-  // 这里只登记卸载钩子:面板关掉 / IDE 停掉时把订阅与 pending 授权一起收干净。
+  // 这里只登记卸载钩子:对话框关掉 / IDE 停掉时把订阅与 pending 授权一起收干净。
   bridgeAnswerDispose = () => {
     bridgeThread.dispose();
     bridgeApproval.dispose();
     bridgeApprovalBoard.clear();
-    bridgeWatch.ids = [];
+    bridgeWatch.dialogIds = [];
     bridgeWatch.at = 0;
   };
 
@@ -1958,6 +2027,172 @@ export async function apply(ctx, config) {
     return jsonResponse({ ok: false, error: reason }, 503);
   }
 
+  // ---------------------------------------------------------------- FIM(幽灵)补全(实验性,0.3.61)
+
+  /** 用量与调用计数:这是**唯一**的可见处(状态栏 + 设置卡)。一次性插件调用不是 loop 请求、
+   *  不写会话日志 ⇒ DSH 的 token-meter 看不到它(见 lib/fim-adapter.mjs 顶部"计量会落在哪")。 */
+  const fimStats = createFimStats();
+  /** 速率/并发闸:这条链路由击键触发,任何一处无界都会变成"打字时把宿主/账号打满"。 */
+  const fimBudget = createFimBudget();
+  /** 已注册的适配器句柄(null = 未注册)。 */
+  let fimAdapterDispose = null;
+  /** 消息构造器(从 DSH 解析;拿不到就不启用 —— 手搓 message 对象容易缺字段,不值得赌)。 */
+  let fimCreateUserMessage = null;
+  /** 不可用的原因(状态栏与设置卡要能说清"为什么没反应")。 */
+  let fimUnavailable = '未启用';
+
+  /**
+   * 按设置注册/注销适配器路由。
+   *
+   * 为什么是**适配器**而不是直连 fetch:这样这条调用仍然走 DSH 的 LLM 服务 —— 取消、超时、
+   * 终态 chunk、稳定错误码都按服务契约走(见 lib/fim-adapter.mjs 顶部)。解析不到 llm 服务或
+   * LlmAdapter 时**不报错、只是不可用**:FIM 是可选能力,不该让插件在缺服务的部署里出问题。
+   */
+  async function ensureFimAdapter() {
+    if (fimAdapterDispose !== null) {
+      try { fimAdapterDispose(); } catch { /* 已被 fiber 回收 */ }
+      fimAdapterDispose = null;
+    }
+    if (!fimSetting) {
+      fimUnavailable = '设置里未开启';
+      return false;
+    }
+    const llm = (() => { try { return ctx.get('llm'); } catch { return undefined; } })();
+    if (llm === undefined || llm === null || typeof llm.registerAdapter !== 'function') {
+      fimUnavailable = '这个 DSH 没有 llm 服务';
+      console.warn('[code-server] FIM 补全:ctx.llm 不可用,补全保持关闭');
+      return false;
+    }
+    const base = await loadFimBase();
+    if (base === null || base.createUserMessage === null) {
+      fimUnavailable = '解析不到 @deepseek-ai/dsh-llm 的 LlmAdapter/createUserMessage';
+      console.warn(`[code-server] FIM 补全:${fimUnavailable};补全保持关闭`);
+      return false;
+    }
+    try {
+      const Adapter = createFimAdapterClass(base.Base, {
+        resolveApiKey: createApiKeyResolver(ctx),
+        attributionHeaders: base.attributionHeaders,
+        assertUsableApiKey: base.assertUsableApiKey,
+        log: (message) => console.log(`[code-server] FIM:${message}`),
+      });
+      const handle = llm.registerAdapter([FIM_PROVIDER], new Adapter());
+      fimAdapterDispose = typeof handle === 'function' ? handle : () => {};
+      fimCreateUserMessage = base.createUserMessage;
+      fimUnavailable = null;
+      console.log(`[code-server] FIM 补全(实验性)已注册适配器路由:${FIM_PROVIDER}/${FIM_MODEL}`);
+      return true;
+    } catch (error) {
+      fimUnavailable = error && error.message ? error.message : String(error);
+      console.warn(`[code-server] FIM 补全:注册适配器失败(${fimUnavailable})`);
+      return false;
+    }
+  }
+
+  /** 给客户端(/sync)看的快照:开关状态 + 可用性 + 用量。 */
+  function fimSnapshot() {
+    const stats = fimStats.snapshot();
+    const budget = fimBudget.snapshot();
+    return {
+      enabled: fimSetting,
+      available: fimSetting && fimAdapterDispose !== null,
+      reason: fimUnavailable,
+      provider: FIM_PROVIDER,
+      model: FIM_MODEL,
+      inflight: budget.inflight,
+      callsLastMinute: budget.callsLastMinute,
+      // 三个子项(0.3.62):扩展侧靠这些值决定"等多久、要不要接受多行、这个文件要不要跳过"。
+      debounceMs: fimDebounceMs,
+      multiline: fimMultiline,
+      disableGlobs: compileGlobList(fimDisableGlobs),
+      ...stats,
+    };
+  }
+
+  /**
+   * `POST /complete` —— 桥的**第五条路由**,也是唯一一条**会发起模型调用**的路由。
+   *
+   * 安全不变量(比前四条多三条,别放宽):
+   *   (a) **只有设置里开了 FIM 才存在** —— 没开一律 403,且不会发出任何网络请求;
+   *   (b) **不写文件、不执行命令** —— 输入是两个字符串,输出是一段文本 + 用量;
+   *   (c) **有界** —— body 上限、前后缀窗口(适配器侧再裁一遍)、速率/并发闸、单次 4s 超时。
+   * 即:桥令牌泄露时,攻击面是"替用户花一点补全的 token 并读到一段补全文本",
+   * 而不是任意文件写 / 任意命令执行 —— 与前四条保持同一量级。
+   */
+  async function handleBridgeComplete(request) {
+    const denied = bridgeRejection(request);
+    if (denied !== null) return denied;
+    if (!fimSetting) return jsonResponse({ ok: false, error: 'fim-disabled' }, 403);
+    if (fimAdapterDispose === null || fimCreateUserMessage === null) {
+      return jsonResponse({ ok: false, error: 'fim-unavailable', reason: fimUnavailable }, 503);
+    }
+    let body;
+    try {
+      body = await readJsonBody(request);
+    } catch {
+      return jsonResponse({ ok: false, error: '请求体不是合法 JSON' }, 400);
+    }
+    if (!bodyWithinLimit(body)) return jsonResponse({ ok: false, error: '请求体过大' }, 413);
+    const prompt = typeof body.prompt === 'string' ? body.prompt : null;
+    const suffix = typeof body.suffix === 'string' ? body.suffix : null;
+    if (prompt === null || suffix === null) return jsonResponse({ ok: false, error: '缺少 prompt/suffix' }, 400);
+    // 按 glob 禁用(0.3.62):扩展侧先判过一遍,这里是**服务端那道**——令牌泄露也只能换来"被拒",
+    // 不会替用户在已禁用的大文件/无关目录上烧 token。
+    const blocked = matchDisabledGlob(typeof body.path === 'string' ? body.path : '', compileGlobList(fimDisableGlobs));
+    if (blocked !== null) return jsonResponse({ ok: false, error: 'disabled-by-glob', glob: blocked }, 403);
+    const gate = fimBudget.acquire();
+    if (gate !== 'ok') return jsonResponse({ ok: false, error: gate }, gate === 'busy' ? 409 : 429);
+    const started = Date.now();
+    try {
+      const llm = ctx.get('llm');
+      const message = fimCreateUserMessage({
+        content: [{ type: 'text', text: encodeFimRequest({ prompt, suffix, language: body.language, path: body.path }) }],
+      });
+      let text = '';
+      let usage = null;
+      let failure = null;
+      for await (const chunk of llm.stream({
+        provider: FIM_PROVIDER,
+        model: FIM_MODEL,
+        messages: [message],
+        maxTokens: FIM_MAX_TOKENS,
+        temperature: 0,
+      })) {
+        if (chunk === null || typeof chunk !== 'object') continue;
+        if (chunk.type === 'text-delta' && typeof chunk.text === 'string') text += chunk.text;
+        else if (chunk.type === 'usage') usage = chunk.usage ?? usage;
+        else if (chunk.type === 'finish') {
+          const kind = chunk.reason?.kind;
+          if (kind !== 'stop' && kind !== 'max-tokens') {
+            failure = chunk.reason?.failure ?? { code: String(kind ?? 'error'), message: '补全未正常结束' };
+          }
+        }
+      }
+      const ms = Date.now() - started;
+      if (failure !== null) {
+        fimStats.recordFailure(failure.code, ms);
+        return jsonResponse({ ok: false, error: failure.code, reason: failure.message, ms }, 502);
+      }
+      // "允许多行"关掉时**在返回前裁**(0.3.62):扩展侧拿到的就是最终形态,缓存里也不会存多行;
+      // 首行是空白 ⇒ 返回空串,扩展据此当作"这次不补"(与"模型没给出东西"同一处理)。
+      const finalText = fimMultiline ? text : toSingleLine(text);
+      fimStats.recordOk(usage, ms);
+      return jsonResponse({ ok: true, text: finalText, usage, ms });
+    } catch (error) {
+      const ms = Date.now() - started;
+      const message = error && error.message ? error.message : String(error);
+      fimStats.recordFailure(error && error.code ? error.code : 'ERROR', ms);
+      console.warn(`[code-server] FIM 补全失败:${message}`);
+      return jsonResponse({ ok: false, error: error && error.code ? error.code : 'ERROR', reason: message, ms }, 502);
+    } finally {
+      fimBudget.release();
+    }
+  }
+
+  // FIM 运行时的声明都已执行到这里 ⇒ 现在才能安全调用(见前面那段 TDZ 说明)。
+  // **不阻塞启动**(void):它是可选能力,解析不到就只是"补全不可用",不该拖慢插件激活。
+  void ensureFimAdapter();
+
   async function handleBridgeHealth() {
     // 无鉴权:只回一句"桥活着吗",不含任何编辑器数据(便于重启后一眼确认)。
     // 注意:bridge=true 只表示"配置已就绪",**不代表扩展在跑**(见 README 已知限制)。
@@ -2021,17 +2256,7 @@ export async function apply(ctx, config) {
     // 把当前最大 seq 一并回去:客户端据此自查"我的游标是不是跑到宿主前面去了"(跨版本升级、
     // 接管了别的宿主留下的游标文件等),发现后退回 since=0 重新对齐,免得永久失聪。
     const lastSeq = bridgeEvents.lastSeq();
-    // 面板声明它要看哪些会话(数组;空 = 关掉了)。据此对齐订阅 + 判断"面板在不在看"
-    // (授权拦截只在面板看着的时候才抢答,否则一律交给官方链路)。
-    const watch = Array.isArray(body.watch) ? body.watch.filter((id) => typeof id === 'string' && id !== '') : [];
-    bridgeWatch.ids = watch.slice(0, 4);
-    bridgeApprovalsUi = body.approvalsUi === true;
-    if (bridgeApprovalsUi !== bridgeApprovalsUiLogged) {
-      bridgeApprovalsUiLogged = bridgeApprovalsUi;
-      bridgeDiag('approvalsUi → ' + bridgeApprovalsUi + '(客户端可否显示授权卡片)');
-    }
     bridgeWatch.at = Date.now();
-    bridgeThread.sync(watchedSessions());
     // 看护状态变化就写一行;并且**首帧必写**(0.3.31:只记"翻转"会让"一直没人看"这种情况在日志里
     // 完全空白,事后无从判断 —— 上一轮就是这样被拖了一整轮)。
     const watchingNow = hasWatcher();
@@ -2039,118 +2264,33 @@ export async function apply(ctx, config) {
       bridgeWatchLogged = watchingNow;
       bridgeWatchWroteFirst = true;
       bridgeDiag('hasWatcher → ' + watchingNow
-        + ' (面板=[' + bridgeWatch.ids.join(',') + '] 对话框=[' + bridgeWatch.dialogIds.join(',') + ']'
-        + ' approvalsUi=' + bridgeApprovalsUi + ')');
+        + ' (对话框=[' + bridgeWatch.dialogIds.join(',') + '])');
     }
     // 请求过对话框、客户端半部却从没来问过 → 说清楚原因(多半是浏览器还缓存着旧的客户端 bundle)。
     if (askDialog.open && !askDialogLive() && askDialog.warned !== true) {
       askDialog.warned = true;
       console.warn('[code-server] 请求了「问 DSH」对话框,但客户端半部没有轮询 /ask/state:'
-        + '浏览器可能还在用旧的客户端 bundle(硬刷新 / 清 Code Cache)。'
-        + '此期间提问会退回编辑器面板,授权也在面板里批。');
+        + '浏览器可能还在用旧的客户端 bundle(硬刷新 / 清 Code Cache)。');
     }
-    // **对话流只在变化时回传**(0.3.27):以前每趟 /sync 都塞整份快照(≤120 条 × ≤8KB,可达 ~1MB / 600ms),
-    // 实测把 /sync 拖成 3 秒超时 —— 扩展收不到响应 ⇒ 面板看不到 approvals ⇒ 授权卡片永远不出现
-    // (卡片在宿主里干等到窗口结束才交给 DSH 界面)。现在给修订号,没变化就不重传。
-    const threadRev = bridgeThread.rev(watchedSessions());
-    const snapshot = bridgeThread.supported()
-      ? bridgeThread.snapshot(watchedSessions())
-      : { available: false, sessionId: null, cursor: null, rev: 0, entries: [], error: '宿主没有 sessionController.follow(DSH 版本过旧)' };
-    // **按"客户端已经拿到哪一版"决定发不发**(0.3.29 修):0.3.28 比的是宿主自己上次发过的版本,
-    // 于是"面板是后开的"这种情形下宿主认为没变化、什么都不发,面板手里一份快照都没有 ⇒ 旧模型把它
-    // 当成"宿主没有对话流能力"(用户实测到的那条误报)。现在由客户端用 threadRev 声明自己持有的版本;
-    // 不带这个字段的旧扩展一律收整份(不省流量,但绝不误报)。
-    const peerRev = Number.isSafeInteger(body.threadRev) ? body.threadRev : null;
-    const threadChanged = peerRev === null || peerRev !== threadRev || snapshot.available === false;
-    bridgeThreadRevSent = threadRev;
-    // 对话流走独立字段:每个会话给有界条目(见 lib/bridge-thread.mjs),
-    // 授权待决列表也一并回去(面板显示卡片)。
+    // **对话流不再经这里**(0.3.59):那是编辑器 webview 面板时代的分工 —— 面板退役后这条
+    // 每 600ms 一趟的通道上驮着 ≤1MB 的快照(0.3.27 还专门为它做过"没变化就不重传"的省流量),
+    // 现在全归 `/api/code-server/ask/state`:对话框每 900ms 只问修订号,没变化只回一个数字。
     return jsonResponse({
       ok: true,
       events,
       // 事件序号的高水位:扩展用它自查游标是否超前(超前 ⇒ 退回 since=0 重新对齐,避免永久失聪)。
       lastSeq,
-      // thread 缺省 = 没变化(扩展沿用上一份);threadRev 用来区分"没变化"与"旧宿主没有这个字段"。
-      threadRev,
-      thread: threadChanged ? snapshot : undefined,
-      approvals: bridgeApprovalBoard.snapshot(),
-      // 授权卡片要在面板上倒计时,窗口长度由 host 给(面板不猜)。
-      approvalHoldMs: DEFAULT_HOLD_MS,
-      dshVersion: dshVersion(),
-      // 界面版本:面板据此提示"内置渲染器与当前 DSH 界面版本不一致"。
-      uiVersion: uiVersion(),
-      // 能力探测(0.3.24;0.3.25 起以"客户端半部真的在轮询"为准):
-      // 只有对话框活着的时候才让扩展走 ask-open;否则扩展开编辑器面板(那里也能批授权)。
+      // 能力探测(0.3.24;0.3.25 起以"客户端半部真的在轮询 /ask/state"为准):
+      // 只有对话框活着的时候才让扩展走 ask-open;0.3.59 起不满足时扩展给一条提示(不再退编辑器面板)。
       askDialog: askDialogLive(),
       // 诊断用:请求过对话框但客户端没响应(浏览器缓存旧 bundle?)。
       askDialogRequested: askDialog.open,
+      // FIM(实验性)状态与用量:扩展据此决定要不要注册内联补全 provider,并把用量显示在状态栏。
+      // **必须每趟都带**(它是唯一能让用户看到"补全花了多少"的地方 —— 这条调用不进 DSH 的计量)。
+      fim: fimSnapshot(),
     });
   }
 
-  async function handleBridgeAsk(request) {
-    const denied = bridgeRejection(request);
-    if (denied !== null) return denied;
-    let body;
-    try {
-      body = await readJsonBody(request);
-    } catch {
-      return jsonResponse({ ok: false, error: '请求体不是合法 JSON' }, 400);
-    }
-    const text = typeof body.text === 'string' ? body.text : '';
-    if (text === '') return jsonResponse({ ok: false, error: '需要 text 字段(要问 DSH 的话)' }, 400);
-    const file = typeof body.file === 'string' && body.file !== '' ? body.file : null;
-    const lineStart = Number.isSafeInteger(body.lineStart) ? body.lineStart : null;
-    const lineEnd = Number.isSafeInteger(body.lineEnd) ? body.lineEnd : null;
-    const selection = typeof body.selection === 'string' && body.selection !== '' ? body.selection : null;
-    // 交给 bridge-session.mjs(agent 投递);它内部特性探测 agents,缺失时返回
-    // {ok:false, code:'NO_AGENT'} —— 这里原样透传,并把 NO_AGENT 映射成 409。
-    const result = await deliverEditorPrompt(ctx, {
-      text,
-      file,
-      lineStart,
-      lineEnd,
-      selection,
-      languageId: typeof body.languageId === 'string' ? body.languageId : null,
-    });
-    // 会话流 + 授权拦截都在这里建立(只针对**被问过的**那个会话,agent 作用域):
-    //   - thread:面板像 DSH 对话那样显示"新内容"(见 lib/bridge-thread.mjs);
-    //   - approval:该会话的敏感动作(工作区外写入 / 命令执行)先在面板里问一句,
-    //     8 秒没人答就交给官方链路(见 lib/bridge-approval.mjs)。
-    if (result.ok === true && typeof result.sessionId === 'string' && result.sessionId !== '') {
-      const ok = bridgeThread.watch(result.sessionId);
-      if (!ok) console.warn('[code-server] 编辑器桥:会话订阅未建立(宿主没有 sessionController.follow)');
-      bridgeApproval.intercept(result.agent, result.sessionId);
-    }
-    // `agent` 是内部句柄,不能进 JSON。
-    const { agent: _agent, ...payload } = result;
-    void _agent;
-    return jsonResponse(payload, result.ok === true ? 200 : (result.code === 'NO_AGENT' ? 409 : 200));
-  }
-
-  /**
-   * 面板对授权请求的决策(0.3.22)。
-   *
-   * **这是命名空间里唯一的非只读路由**,约束写死在实现里:
-   *   - 只能回答**本 host 发起、仍未决**的请求(单次使用,用后即废);
-   *   - outcome 只接受 `allowed-once` / `rejected`;
-   *   - 不接受任何自由文本、路径或命令参数 —— 它只能"回答问题",不能"发起动作"。
-   */
-  async function handleBridgeApprove(request) {
-    const denied = bridgeRejection(request);
-    if (denied !== null) return denied;
-    let body;
-    try {
-      body = await readJsonBody(request);
-    } catch {
-      return jsonResponse({ ok: false, error: '请求体不是合法 JSON' }, 400);
-    }
-    const verdict = answerApproval(
-      typeof body.id === 'string' ? body.id : '',
-      typeof body.outcome === 'string' ? body.outcome : '',
-    );
-    return jsonResponse(verdict.body, verdict.status);
-  }
-
   // ---------------------------------------------------------------- 「问 DSH」对话框(client 半部)
 
   /** 对话框每 900ms 问一次:给修订号,没变就只回一个数字(不重传几十 KB 的对话流)。 */
@@ -2193,6 +2333,9 @@ export async function apply(ctx, config) {
     if (text === '') return jsonResponse({ ok: false, error: '需要 text 字段(要问 DSH 的话)' }, 400);
     const mode = body.mode === 'file' ? 'file' : askDialog.mode;
     const context = askContextFromCache(mode);
+    // 投递方式(0.3.59):默认跟着 DSH 自己的设置 `ui-conversation.busyEnter` 走(见
+    // lib/bridge-session.mjs 的 pickBusyEnter)—— 面板按 Enter 与主界面按 Enter 是同一个手势,
+    // 行为必须一致。显式传 `delivery: 'queue'|'steer'` 可覆盖(测试用,或将来在面板上做"插队"按钮)。
     const result = await deliverEditorPrompt(ctx, {
       text,
       file: context === null ? null : context.file,
@@ -2200,7 +2343,7 @@ export async function apply(ctx, config) {
       lineEnd: context === null ? null : context.lineEnd,
       selection: context === null ? null : context.selection,
       languageId: context === null ? null : context.languageId,
-    });
+    }, { delivery: typeof body.delivery === 'string' ? body.delivery : undefined });
     if (result.ok === true && typeof result.sessionId === 'string' && result.sessionId !== '') {
       askDialog.sessionId = result.sessionId;
       askDialog.mode = mode;
@@ -2213,7 +2356,7 @@ export async function apply(ctx, config) {
     return jsonResponse(payload, result.ok === true ? 200 : (result.code === 'NO_AGENT' ? 409 : 200));
   }
 
-  /** 对话框回答授权(与桥的 /approve 同一套校验)。 */
+  /** 对话框回答授权(与宿主内部 answerApproval 同一套校验:白名单 outcome + 只认仍未决的 id)。 */
   async function handleAskApprove(request) {
     let body;
     try {
@@ -2239,15 +2382,6 @@ export async function apply(ctx, config) {
     return jsonResponse({ ok: true });
   }
 
-  /** 面板产物(thread.js / thread.css)给对话框注入用。 */
-  async function handleAskBundle() {
-    const bundle = askBundle();
-    if (bundle === null) {
-      return jsonResponse({ ok: false, error: '面板产物缺失:请在插件源码里跑 pnpm run build:webview,或重装插件' }, 503);
-    }
-    return jsonResponse({ ok: true, rev: askRevision(), ...bundle });
-  }
-
   async function handleBridgeEvent(request) {
     const denied = bridgeRejection(request);
     if (denied !== null) return denied;
@@ -2283,7 +2417,7 @@ export async function apply(ctx, config) {
     { path: `${API_BASE}/ask/send`, methods: ['POST'], fetch: handleAskSend },
     { path: `${API_BASE}/ask/approve`, methods: ['POST'], fetch: handleAskApprove },
     { path: `${API_BASE}/ask/close`, methods: ['POST'], fetch: handleAskClose },
-    { path: `${API_BASE}/ask/bundle`, methods: ['GET'], fetch: handleAskBundle },
+    // 0.3.59 删掉了 `/ask/bundle`(面板产物不再存在:面板本体在 lib/client.js 里,渲染器走页面模块表)。
     // ---- 编辑器桥的 4 条路由**不在 /api 下**(0.3.9 修正)----
     // 原因:Connection 给 `/api` 装了 cookie fence(无 cookie → 401),而扩展宿主是 Node 进程、
     // 永远拿不到浏览器 cookie ⇒ 挂在这里的路由根本到不了(实测:带令牌也被 401/405 挡回)。
@@ -2394,3 +2528,30 @@ export async function apply(ctx, config) {
 
   console.log(`[code-server] static plugin loaded (serve=${requestedServe()} host=${cfg.host} port=${cfg.port === 0 ? '0=随机' : cfg.port})`);
 }
+
+/**
+ * 仅测试用:把一次桥请求交给**当前实例**的桥分发器,不经过命名管道 / unix socket。
+ *
+ * 为什么需要这条钩子(2026-09-22,0.3.63 CI 红 #2 的根治):本机沙箱里**连接**命名管道会 EPERM
+ * (监听允许、连接不允许),于是 scripts/test-bridge-routes.mjs 里所有走 IPC 的用例在本机一律
+ * SKIP —— "本地 pass=30" 里**不含**桥的状态码断言,`/complete` 的 403 就是这么在本地假绿、
+ * 推到 runner 才红的。传输可以是本机的,断言不能是本机的:有了它,那些断言在任何机器上都真跑。
+ *
+ * 与真实传输**同构**(逐字段对照 nodeRouteFromFetch):同一个 dispatchBridge、body 同样收成
+ * Buffer、Response 同样摊平成 {status, headers, text}。缺的只有 socket 本身 —— 所以它**不能**
+ * 替代"监听口能起来"这条验证,那一条仍由真实运行的 IPC 覆盖(test-bridge-routes 里那条
+ * 「桥走本机 IPC」的用例走的还是真端点)。
+ */
+export async function bridgeRequestForTests({ path, method = 'GET', headers = {}, body = '' } = {}) {
+  if (activeBridgeDispatch === null) throw new Error('bridgeRequestForTests: 还没有 apply() 过,拿不到桥分发器');
+  const response = await activeBridgeDispatch(
+    new URL(path, 'http://127.0.0.1'),
+    String(method).toUpperCase(),
+    // 与 Node 的 IncomingMessage.headers 同形(键全小写):guard 读 origin 与令牌头就靠它。
+    Object.fromEntries(Object.entries(headers).map(([k, v]) => [String(k).toLowerCase(), v])),
+    Buffer.from(body ?? '', 'utf8'),
+  );
+  const flat = {};
+  response.headers.forEach((value, key) => { flat[key] = value; });
+  return { status: response.status, headers: flat, text: await response.text() };
+}