zen-gitsync 2.18.8 → 2.18.9

package/src/ui/server/routes/workbench/agentChatExtensions.test.js

@@ -0,0 +1,290 @@
+// Web 端扩展层（Skill + MCP）接入 runAgentTurn 的回归测试。
+//
+// 钉住的行为（2026-10-12 修的问题）：MCP 广场显示"已安装"，但 Web 智能体
+// 对话/定时任务的工具列表里就是没有那些工具 —— AgentExtensions.load 原先
+// 只有 CLI 的 g ai 调。现在 Web 侧也加载，这里跑真实的 runAgentTurn，
+// 把请求体与事件抓下来逐条钉住：
+//   1) MCP 工具定义随请求下发（mcp__ 前缀），系统提示词出现 MCP 一节；
+//   2) mcp__ 调用分流到 MCP server，内置工具照常走 executeTool；
+//   3) 连接失败只降级（该 server 没工具），轮次照常完成；
+//   4) 同一 cwd 只握手一次（进程内缓存），invalidate 后按新配置重载；
+//   5) 广场安装路由走完，下一轮对话就吃得到（不等 g gui 重启）；
+//   6) 扩展摘要只进请求副本，不腌进 session.messages（老会话也吃得到）。
+//
+// 注意:必须在 import agentChat.js **之前**把 USERPROFILE/HOME 指到沙箱,否则
+// paths.js 在模块加载时用 os.homedir() 求值,会去读真实的 ~/.zen-gitsync。
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs'
+import http from 'node:http'
+import os from 'node:os'
+import path from 'node:path'
+
+const SANDBOX = mkdtempSync(path.join(os.tmpdir(), 'zen-agent-ext-'))
+process.env.USERPROFILE = SANDBOX
+process.env.HOME = SANDBOX
+delete process.env.HOMEDRIVE
+delete process.HOMEPATH
+
+const DATA_DIR = path.join(SANDBOX, '.zen-gitsync')
+const MCP_FILE = path.join(DATA_DIR, 'ai', 'mcp.json')
+
+// ── 脚手架 ────────────────────────────────────────────────────
+
+const event = data => `data: ${JSON.stringify(data)}\n\n`
+const sse = chunks => new Response(new ReadableStream({
+  start(controller) {
+    const bytes = new TextEncoder()
+    chunks.forEach(chunk => controller.enqueue(bytes.encode(chunk)))
+    controller.close()
+  },
+}), { status: 200, headers: { 'content-type': 'text/event-stream' } })
+
+const model = { model: 'test', name: 'test', baseURL: 'https://example.invalid/v1', apiKey: 'test' }
+const okStream = () => sse([event({ choices: [{ delta: { content: 'ok' }, finish_reason: 'stop' }] }), 'data: [DONE]\n\n'])
+const withSystem = () => [{ role: 'system', content: 'rules' }, { role: 'user', content: 'hi' }]
+const newSession = (sessionId, messages) => ({ sessionId, messages, cwd: process.cwd() })
+
+// 跑一轮真实的 runAgentTurn,桩掉 globalThis.fetch —— 抓住发出去的请求体与事件。
+// ⚠️ MCP 的连接也走 globalThis.fetch（HttpConnection），所以这个桩按 URL 分流：
+// 打 127.0.0.1 的（桩 server）放真 fetch 过去，其余（LLM）抓请求体 + 回灌 SSE。
+async function runWeb({ session, userMessage, respond }) {
+  const { runAgentTurn } = await import('./agentChat.js')
+  const { streamChatOnce } = await import('../../../../cli/ai/transport.js')
+  const events = []
+  let sent
+  const realFetch = globalThis.fetch
+  globalThis.fetch = async (url, init) => {
+    if (String(url).startsWith('http://127.0.0.1')) return realFetch(url, init)
+    sent = JSON.parse(init.body)
+    return respond(init)
+  }
+  try {
+    await runAgentTurn({
+      session, model, userMessage, locale: 'zh-CN', cwd: process.cwd(),
+      signal: new AbortController().signal,
+      send: e => events.push(e),
+      streamFn: opts => streamChatOnce({ ...opts, maxRetries: 0 }),
+    })
+    return { sent, events }
+  } finally {
+    globalThis.fetch = realFetch
+  }
+}
+
+// 最小 Streamable HTTP MCP server 桩：initialize / tools/list / tools/call。
+// 每个响应都带 Mcp-Session-Id，顺带覆盖 HttpConnection 的会话关闭（DELETE）路径。
+function startStubMcp({ onHandshake, onCall, onClose } = {}) {
+  const server = http.createServer((req, res) => {
+    const chunks = []
+    req.on('data', c => chunks.push(c))
+    req.on('end', () => {
+      if (req.method === 'DELETE') {
+        onClose?.()
+        res.writeHead(204)
+        res.end()
+        return
+      }
+      let msg = {}
+      try { msg = JSON.parse(Buffer.concat(chunks).toString('utf8') || '{}') } catch { /* 通知类可能没体 */ }
+      const reply = result => {
+        res.writeHead(200, {
+          'content-type': 'application/json',
+          'mcp-session-id': `sess-${Math.random().toString(36).slice(2, 8)}`,
+        })
+        res.end(JSON.stringify({ jsonrpc: '2.0', id: msg.id ?? null, result }))
+      }
+      if (msg.method === 'initialize') {
+        onHandshake?.()
+        reply({ protocolVersion: '2025-03-26', capabilities: {}, serverInfo: { name: 'stub', version: '0' } })
+      } else if (msg.method === 'tools/list') {
+        reply({ tools: [{ name: 'echo', description: '回声工具', inputSchema: { type: 'object', properties: { text: { type: 'string' } } } }] })
+      } else if (msg.method === 'tools/call') {
+        onCall?.(msg.params)
+        reply({ content: [{ type: 'text', text: `stub 收到: ${msg.params?.arguments?.text ?? ''}` }] })
+      } else {
+        reply({}) // notifications/initialized 等
+      }
+    })
+  })
+  return new Promise((resolve) => {
+    server.listen(0, '127.0.0.1', () => resolve({
+      url: `http://127.0.0.1:${server.address().port}/api/mcp`,
+      close: () => new Promise(r => server.close(r)),
+    }))
+  })
+}
+
+function writeMcpFile(url) {
+  mkdirSync(path.dirname(MCP_FILE), { recursive: true })
+  writeFileSync(MCP_FILE, JSON.stringify({ mcpServers: { stub: { name: 'Stub', type: 'http', url } } }, null, 2))
+}
+
+const hasMcpTools = sent => sent.tools.some(t => String(t.function?.name || '').startsWith('mcp__'))
+
+// 每个用例开工前清一遍：上一条用例的 finally 也该清，双保险 ——
+// 缓存是模块级的，残留一份配置会让下一条用例莫名其妙吃到 MCP。
+async function resetExtensions() {
+  rmSync(MCP_FILE, { force: true })
+  const { invalidateWebExtensions } = await import('./agentExtensions.js')
+  await invalidateWebExtensions()
+}
+
+// ── 挂载与分发 ────────────────────────────────────────────────
+
+test('MCP 工具挂进请求、按 mcp__ 名字分发到 server，内置工具不受影响', async () => {
+  let handshakes = 0
+  const stub = await startStubMcp({ onHandshake: () => handshakes++ })
+  try {
+    await resetExtensions()
+    writeMcpFile(stub.url)
+
+    // 第一轮：模型同时调一个 MCP 工具和一个内置工具 —— 分流是否正确一轮就看出来
+    const round1 = sse([event({
+      choices: [{
+        delta: { tool_calls: [
+          { index: 0, id: 'm1', function: { name: 'mcp__stub__echo', arguments: JSON.stringify({ text: '你好' }) } },
+          { index: 1, id: 'p1', function: { name: 'update_plan', arguments: JSON.stringify({ steps: [{ content: '一步', status: 'completed' }] }) } },
+        ] },
+        finish_reason: 'tool_calls',
+      }],
+    }), 'data: [DONE]\n\n'])
+    let turn = 0
+    const session = newSession('ag-ext-dispatch', withSystem())
+
+    const { sent, events } = await runWeb({
+      session, userMessage: '调用 mcp', respond: () => (turn++ === 0 ? round1 : okStream()),
+    })
+
+    // ① 请求里带着 MCP 工具定义（transport 把 extraTools 并进 tools）
+    const mcpTool = sent.tools.find(t => t.function?.name === 'mcp__stub__echo')
+    assert.ok(mcpTool, 'MCP 工具必须随请求下发')
+    assert.match(mcpTool.function.description, /回声/)
+    assert.equal(mcpTool.type, 'function')
+    // 内置工具一个没少
+    assert.ok(sent.tools.some(t => t.function?.name === 'update_plan'), '内置工具表必须还在')
+    // ② 系统提示词里出现 MCP 一节，且点名 mcp__ 前缀
+    assert.match(sent.messages[0].content, /已接入的 MCP 服务/)
+    assert.match(sent.messages[0].content, /mcp__/)
+    // ③ MCP 调用真的走到了 stub server
+    assert.equal(handshakes, 1)
+    const mcpResult = events.find(e => e.type === 'tool_result' && e.name === 'mcp__stub__echo')
+    assert.ok(mcpResult, 'MCP 调用必须产出 tool_result')
+    assert.match(mcpResult.result, /stub 收到: 你好/)
+    // ④ 同一轮里的内置工具照常执行（分流没有把内置的也吞掉）
+    const planResult = events.find(e => e.type === 'tool_result' && e.name === 'update_plan')
+    assert.match(planResult.result, /计划已更新/)
+    // ⑤ 两个结果都进了会话历史（重开会话能回放）
+    const toolNames = session.messages.filter(m => m.role === 'tool').map(m => m.name)
+    assert.deepEqual(toolNames, ['mcp__stub__echo', 'update_plan'])
+    // ⑥ 摘要只进请求副本，不写回 session.messages
+    assert.equal(session.messages[0].content, 'rules', '扩展摘要不该腌进磁盘历史')
+  } finally {
+    await resetExtensions()
+    await stub.close()
+  }
+})
+
+// ── 降级 ──────────────────────────────────────────────────────
+
+test('MCP 连接失败只降级：轮次照常完成，请求里不带 MCP 工具', async () => {
+  // 占一个端口再松开，拿一个一定没人听的地址
+  const stub = await startStubMcp()
+  const deadUrl = stub.url
+  await stub.close()
+  try {
+    await resetExtensions()
+    writeMcpFile(deadUrl)
+    const session = newSession('ag-ext-dead', withSystem())
+
+    const { sent, events } = await runWeb({ session, userMessage: 'hello', respond: okStream })
+
+    assert.ok(!events.some(e => e.type === 'error'), '连接失败不该把轮次打挂')
+    assert.equal(hasMcpTools(sent), false, '连不上的 server 不该贡献工具定义')
+    assert.doesNotMatch(sent.messages[0].content, /已接入的 MCP 服务/)
+    assert.equal(session.messages[session.messages.length - 1].content, 'ok', '轮次要正常收尾')
+  } finally {
+    await resetExtensions()
+  }
+})
+
+// ── 缓存与失效 ────────────────────────────────────────────────
+
+test('同 cwd 只握手一次（进程内缓存），invalidate 后按新配置重新加载', async () => {
+  let handshakes = 0
+  let deletes = 0
+  const stub = await startStubMcp({ onHandshake: () => handshakes++, onClose: () => deletes++ })
+  try {
+    await resetExtensions()
+    // 没配 MCP：第一轮不该有 mcp 工具，也不该发生握手
+    const s1 = newSession('ag-ext-cache-1', withSystem())
+    const r1 = await runWeb({ session: s1, userMessage: 'hello', respond: okStream })
+    assert.equal(handshakes, 0)
+    assert.equal(hasMcpTools(r1.sent), false)
+
+    // 模拟"广场装完"：写配置 + 失效（这一路正是 agentMarketplace.js 调的）
+    writeMcpFile(stub.url)
+    const { invalidateWebExtensions } = await import('./agentExtensions.js')
+    await invalidateWebExtensions()
+
+    // 第二轮：立刻吃得到，不等重启
+    const s2 = newSession('ag-ext-cache-2', withSystem())
+    const r2 = await runWeb({ session: s2, userMessage: 'hello', respond: okStream })
+    assert.equal(handshakes, 1, '失效后必须重新加载')
+    assert.equal(hasMcpTools(r2.sent), true)
+    assert.match(r2.sent.messages[0].content, /已接入的 MCP 服务/)
+
+    // 第三轮：同一 cwd 走缓存，不再握手
+    const s3 = newSession('ag-ext-cache-3', withSystem())
+    const r3 = await runWeb({ session: s3, userMessage: 'hello', respond: okStream })
+    assert.equal(handshakes, 1, '缓存生效时不能反复握手')
+    assert.equal(hasMcpTools(r3.sent), true)
+
+    // 失效时旧连接要真的关掉（HTTP 侧表现为 DELETE 到过 server）
+    await invalidateWebExtensions()
+    assert.ok(deletes >= 1, 'invalidate 必须关闭旧连接（DELETE 结束会话）')
+  } finally {
+    await resetExtensions()
+    await stub.close()
+  }
+})
+
+// ── 广场安装路由 → 对话生效（端到端） ───────────────────────────
+
+test('广场安装路由走完后，下一轮对话就挂上该 MCP（不等 g gui 重启）', async () => {
+  let handshakes = 0
+  const stub = await startStubMcp({ onHandshake: () => handshakes++ })
+  try {
+    await resetExtensions()
+    const s1 = newSession('ag-ext-mp-1', withSystem())
+    const r1 = await runWeb({ session: s1, userMessage: 'hello', respond: okStream })
+    assert.equal(hasMcpTools(r1.sent), false)
+
+    // 走真实的注册路由（harness 抄自 agentMarketplace.test.js 的打法）：
+    // 远程端点型 MCP 只写配置文件，不联网
+    const { registerAgentMarketplaceRoutes } = await import('./agentMarketplace.js')
+    const handlers = new Map()
+    const app = {
+      get: (r, h) => handlers.set(`GET ${r}`, h),
+      post: (r, h) => handlers.set(`POST ${r}`, h),
+      delete: (r, h) => handlers.set(`DELETE ${r}`, h),
+    }
+    registerAgentMarketplaceRoutes({ app, getCurrentProjectPath: () => process.cwd() })
+    let payload = null
+    const res = { status() { return this }, json(data) { payload = data; return this } }
+    await handlers.get('POST /api/agent/marketplace/install')({
+      body: { type: 'mcp', target: 'global', cwd: process.cwd(), item: { id: 'stub', name: 'Stub', remoteUrl: stub.url } },
+    }, res)
+    assert.equal(payload?.success, true, '安装路由要报成功')
+    assert.ok(payload?.item?.file, '安装结果要带回落盘路径')
+
+    // 下一轮对话：工具表里必须有它，且握手真的发生过
+    const s2 = newSession('ag-ext-mp-2', withSystem())
+    const r2 = await runWeb({ session: s2, userMessage: 'hello', respond: okStream })
+    assert.equal(handshakes, 1)
+    assert.equal(hasMcpTools(r2.sent), true, '广场装完必须立刻在对话里生效')
+  } finally {
+    await resetExtensions()
+    await stub.close()
+  }
+})

package/src/ui/server/routes/workbench/agentEngines.js

@@ -19,15 +19,18 @@
 //   gai ── 内置。**服务端**跑循环：LLM 流式 + 服务端执行工具（src/cli/ai/tools.js），
 //          前端只渲染事件。默认引擎，历史行为。
 //
-//   claude / opencode / codex ── 外部 CLI。**CLI 自己**跑循环：它有自己的工具集、
+//   claude / opencode / codex / codebuddy ── 外部 CLI。**CLI 自己**跑循环：它有自己的工具集、
 //          自己的系统提示词、自己的权限模型。服务端退化成一根管子 —— spawn 出来、
 //          把它的 NDJSON 翻译成同一组 SSE 事件。见 runExternalTurn.js。
+//          （codebuddy = 腾讯 CodeBuddy Code CLI，即 WorkBuddy 桌面版的引擎，
+//           2026-10-12 加入；协议与 claude 的 stream-json 对齐。）
 //
-// ⚠️ 这儿**不新写一份 id 清单**：外部三家直接复用 config.js 的 TASK_EXECUTORS。
+// ⚠️ 这儿**不新写一份 id 清单**：外部四家直接复用 config.js 的 TASK_EXECUTORS。
 //   本仓库为"同一份口径在多个地方各写一遍"吃过亏（见 agentParity.test.js 的注释：
 //   提示词四处、路径归一三处，分叉的失效方式是「不报错，两个入口表现不一样」）。
-//   工作台那份是任务执行器，这里是对话引擎，但**底层是同一批 CLI**，加第四家时
-//   应当只改 config.js 一处。有单测钉住这条。
+//   工作台那份是任务执行器，这里是对话引擎，但**底层是同一批 CLI**，加第五家时
+//   应当只改 config.js 一处（taskRunner.js 的运行时分发表是第二处，见那里的注释）。
+//   有单测钉住这条。
 
 import { TASK_EXECUTORS } from '../../../../config.js';
 
@@ -49,6 +52,7 @@ export const ENGINE_LABELS = {
   claude: 'Claude Code',
   opencode: 'OpenCode',
   codex: 'Codex',
+  codebuddy: 'CodeBuddy Code',
 };
 
 export function isAgentEngine(value) {

package/src/ui/server/routes/workbench/agentExtensions.js

@@ -0,0 +1,157 @@
+// Copyright 2026 xz333221
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Web 端（g ui 服务端）的扩展层（Skill 清单 + MCP 工具）加载缓存。
+//
+// 背景：AgentExtensions.load 原先只有 CLI 的 `g ai` 调（agent.js 启动时一次），
+// 而 Web 智能体面板的 runAgentTurn 与定时任务的执行体共用同一个函数却不加载
+// 扩展 —— 表现就是「MCP 广场显示已安装，对话框里就是没有那些工具」
+// （2026-10-12 用户实测：agent 只能自己读 mcp.json 按 HTTP 协议直调）。
+// 这个模块把同一份加载逻辑接到 Web 侧，并按 cwd 做进程内缓存。
+//
+// 为什么按 cwd 缓存而不是每轮加载：
+//   - MCP 握手不便宜：stdio 要起子进程（npx 首次还要下载包，实测 20s+），
+//     HTTP 也要 initialize + tools/list 两个往返。每轮都付一次的话，
+//     装了两三个 MCP 的用户每轮对话都要先等好几秒。
+//   - CLI 的口径是「进程启动时加载一次，/cwd 切换时重载」。Web 没有进程重启
+//     这个自然边界，用缓存等价实现：同一 cwd 只加载一次，配置变化靠失效。
+//
+// 缓存什么时候失效：
+//   - 广场安装/卸载（agentMarketplace.js 调 invalidateWebExtensions）——
+//     不接这一路的话，刚装的 MCP 要等 g gui 重启才在对话里生效；
+//   - 手动编辑 ~/.zen-gitsync/ai/mcp.json（不走广场的那种）—— 下次 g gui
+//     重启生效，与 CLI「下次启动时生效」一致。
+//
+// 生命周期：stdio 子进程走 cli/cleanup.js 的 trackChild，不在 g ui 自己的
+// runningProcesses 表里，shutdown 的 drainRunningProcesses 兜不到 —— 所以
+// index.js 的优雅退出里显式调 closeWebExtensions()，否则 Ctrl+C 之后会留下
+// 一堆 npx 孤儿子进程。
+
+import path from 'node:path';
+import { AgentExtensions } from '../../../../cli/ai/extensions.js';
+import { logger } from './shared.js';
+
+/** cwd(绝对路径) → { extensions: AgentExtensions } */
+const cache = new Map();
+/** cwd → 进行中的加载。同 cwd 的并发首轮只允许一次真实加载（去重）。 */
+const inflight = new Map();
+/**
+ * 加载期间被 invalidate 标记过的 cwd。任务收尾时看到自己在这张表里 →
+ * 不写回缓存、直接关掉刚建好的连接，只服务当前这一个调用方。
+ *
+ * 为什么需要它：不能改用"cache 里没有这个 key"来判断 —— 首次加载时缓存
+ * 本来就是空的，两种状态长得一模一样。2026-10-12 第一版就是这么写的，
+ * 后果是每次首轮加载完都把刚握好的 MCP 连接关掉（还不进缓存），
+ * 症状是"工具定义下发成功了、一调用就报连接已关闭"。
+ */
+const poisoned = new Set();
+
+const normalizeCwd = (cwd) => {
+  try {
+    return path.resolve(cwd || process.cwd());
+  } catch {
+    return String(cwd || process.cwd());
+  }
+};
+
+/**
+ * 取某个 cwd 的扩展层；没有则加载（同 cwd 并发只加载一次）。
+ *
+ * 失败不抛：AgentExtensions.load 内部已对 skill / MCP 各自降级，这里再包一层
+ * 是防读取路径之外的意外把整轮对话打挂 —— 扩展是增量能力，不该让用户消息发不出去。
+ *
+ * @param {{ cwd?: string, locale?: string }} [options]
+ * @returns {Promise<AgentExtensions>}
+ */
+export async function getWebExtensions({ cwd, locale } = {}) {
+  const key = normalizeCwd(cwd);
+  const hit = cache.get(key);
+  if (hit) return hit.extensions;
+  const pending = inflight.get(key);
+  if (pending) return pending;
+
+  const task = (async () => {
+    const extensions = await AgentExtensions.load({
+      cwd: key,
+      locale,
+      onWarn: (message) => logger.warn(`[agentExtensions] ${message}`),
+    }).catch((err) => {
+      logger.warn(`[agentExtensions] 加载失败(${key})，本轮按无扩展继续: ${err?.message || err}`);
+      return new AgentExtensions();
+    });
+    // 加载期间被 invalidate 过 → 不把这份刚建好的连接写回缓存（下一个调用方
+    // 会按新配置重新加载），直接关掉它，只服务当前这一个调用方。
+    // has → delete → set 之间没有 await，整段是原子的，不会被 invalidate 插进来。
+    if (poisoned.has(key)) {
+      poisoned.delete(key);
+      await extensions.mcp?.close().catch(() => {});
+    } else {
+      cache.set(key, { extensions });
+    }
+    return extensions;
+  })();
+
+  inflight.set(key, task);
+  try {
+    return await task;
+  } finally {
+    inflight.delete(key);
+  }
+}
+
+/**
+ * 让扩展缓存失效（广场安装 / 卸载后调）。
+ *
+ * 先摘缓存再关旧连接 —— 反过来会让下一轮拿到正在关闭的连接。
+ * 传 cwd 只失效那一个目录（项目级安装），不传失效全部（全局安装影响所有目录）。
+ *
+ * @param {string} [cwd]
+ */
+export async function invalidateWebExtensions(cwd) {
+  // 受影响对象 = 缓存键 + 在途加载键。只遍历缓存的话，"加载前刚被失效过
+  // （缓存已空）、又在加载中被失效"这一下会漏掉在途那个，让它把按旧配置
+  // 建好的连接写回缓存。
+  const keys = cwd ? [normalizeCwd(cwd)] : [...new Set([...cache.keys(), ...inflight.keys()])];
+  const victims = [];
+  for (const key of keys) {
+    const entry = cache.get(key);
+    if (entry) {
+      cache.delete(key);
+      victims.push(entry.extensions);
+    }
+    // 有加载在进行中 → 标记它收尾时别写回缓存（见 getWebExtensions 里的 poisonous 分支）
+    if (inflight.has(key)) poisoned.add(key);
+  }
+  await Promise.all(victims.map(async (extensions) => {
+    // 正在跑的某一轮可能还持有这份对象：它的 in-flight tools/call 会收到
+    // "连接已关闭"（以错误字符串回喂给模型，不会打挂对话）。装/卸配置与对话
+    // 并发是罕见边角，为它做代际管理不值这个复杂度。
+    try {
+      await extensions.mcp?.close();
+    } catch (err) {
+      logger.warn(`[agentExtensions] 关闭旧连接失败: ${err?.message || err}`);
+    }
+  }));
+}
+
+/**
+ * 关掉全部缓存的 MCP 连接。g gui 优雅退出时调（见 index.js 的 shutdown）。
+ */
+export async function closeWebExtensions() {
+  const all = [...cache.values()];
+  cache.clear();
+  await Promise.all(all.map(async ({ extensions }) => {
+    try { await extensions.mcp?.close(); } catch (_) {}
+  }));
+}

package/src/ui/server/routes/workbench/agentMarketplace.js

@@ -44,6 +44,10 @@ import { execFile, spawn } from 'node:child_process';
 import { promisify } from 'node:util';
 import open from 'open';
 import { asyncRoute, HttpError } from '../../utils/asyncRoute.js';
+import { logger } from './shared.js';
+// 装/卸之后让 Web 端扩展缓存失效：否则刚装的 MCP/Skill 要等 g gui 重启
+// 才在智能体对话里生效（"广场显示已安装、对话框里没有工具"就是这么来的）。
+import { invalidateWebExtensions } from './agentExtensions.js';
 import { AI_SKILLS_DIR, AI_MCP_FILE, projectSkillsDir, projectMcpFile } from '../../../../paths.js';
 
 const execFileAsync = promisify(execFile);
@@ -1097,6 +1101,11 @@ export function registerAgentMarketplaceRoutes({ app, getCurrentProjectPath }) {
 
     // 装完立刻让缓存失效,避免刚装的条目在列表里还是"未安装"
     cache.clear();
+    // 同一用意再往下一层:Web 智能体对话的扩展缓存也要失效,否则新装的
+    // MCP/Skill 要等 g gui 重启才在对话里出现。全局安装影响所有目录 → 全量失效;
+    // 项目安装只影响该目录。关旧连接是异步的,不拖慢这个响应,失败只记账。
+    invalidateWebExtensions(target === 'project' ? cwd : undefined)
+      .catch((err) => logger.warn(`[agentMarketplace] 扩展缓存失效失败: ${err?.message || err}`));
     res.json({ success: true, target, cwd, item: installed });
   }));
 
@@ -1135,6 +1144,9 @@ export function registerAgentMarketplaceRoutes({ app, getCurrentProjectPath }) {
     const id = decodeURIComponent(String(req.params.id || ''));
     const result = await uninstall({ type, id, target, cwd });
     cache.clear();
+    // 与安装同一用意:卸完也让对话侧的扩展缓存失效(口径见 install 路由里的注释)
+    invalidateWebExtensions(target === 'project' ? cwd : undefined)
+      .catch((err) => logger.warn(`[agentMarketplace] 扩展缓存失效失败: ${err?.message || err}`));
     res.json({ success: true, ...result });
   }));
 }

package/src/ui/server/routes/workbench/agentParity.test.js

@@ -181,3 +181,19 @@ test('两个入口都把推理内容写进 assistant 历史消息', () => {
     assert.match(code, /reasoning_content/, `${label} 没有把推理内容写进 assistant 历史消息`);
   }
 });
+
+test('两个入口都把扩展工具叠加进请求,并按 owns() 分流', () => {
+  // 2026-10-12：Web 侧曾经**完全不加载**扩展层 —— MCP 广场显示"已安装"，
+  // 对话框里却没有那些工具（agent 只能自己读 mcp.json 按 HTTP 直调）。
+  // 失效方式和这个文件的其它分叉一样：不报错，只是两个入口表现不一样。
+  // 所以钉住两个入口都要有：extraTools（叠加进请求）+ owns（按名字分流）。
+  // 只认代码行，注释里的提及不算。
+  for (const { label, file } of ENTRY_POINTS) {
+    const code = readFileSync(file, 'utf8')
+      .split(/\r?\n/)
+      .filter(line => !/^\s*(\/\/|\*|\/\*)/.test(line))
+      .join('\n');
+    assert.match(code, /extraTools/, `${label} 没有把扩展工具叠加进请求（extraTools）`);
+    assert.match(code, /owns/, `${label} 没有按 owns() 分流扩展工具`);
+  }
+});

package/src/ui/server/routes/workbench/agentRoutes.js

@@ -17,6 +17,7 @@
 // 路由清单:
 //   GET    /api/agent/sessions           — 列出会话(仅 metadata;?cwd= 按项目过滤,空 cwd 视为当前项目)
 //   GET    /api/agent/sessions/:id       — 获取会话详情(含完整消息)
+//   GET    /api/agent/sessions/:id/image — 正文内嵌图片(按会话 cwd 解析,判定见 jobImage.js)
 //   DELETE /api/agent/sessions/:id       — 删除会话
 //   PUT    /api/agent/sessions/:id       — 重命名会话
 //   POST   /api/agent/chat               — SSE 流式聊天(含工具调用;body.cwd 必须与服务端当前项目一致)
@@ -40,7 +41,11 @@ import { isSessionBusy, acquireSession, releaseSession } from './sessionGate.js'
 import { createScheduler } from './scheduler.js';
 import { registerScheduleRoutes } from './scheduleRoutes.js';
 import { normalizeItems, filterToRecentDirs, buildDirStatusBlock } from '../recentDirectoriesAiSummary.js';
-import { nowIso, logger } from './shared.js';
+import { nowIso, logger, fs, fsp, MAX_IMAGE_BYTES } from './shared.js';
+// 正文内嵌图片的路径判定纯函数 —— 与任务对话的图片端点（workbench/index.js 的
+// /api/workbench/jobs/:id/image）同一份：后缀白名单、root 内、防穿越。两份白名单
+// 分叉时不会报错，只会让某一类图在任务对话里能看、在 Agent 对话里裂。
+import { resolveJobImagePath, IMAGE_PATH_STATUS, IMAGE_PATH_ERRORS, isInsideRoot } from './jobImage.js';
 // 请求预算的解析公式与 CLI `g ai` 共用同一份（cli/ai/context.js），Web 侧只管把
 // 配置值喂进去、把结果传给 agentChat —— 2026-10-07 起每轮请求的字符预算可配。
 import { resolveRequestBudget } from '../../../../cli/ai/context.js';
@@ -294,6 +299,75 @@ export function registerAgentRoutes({ app, getCurrentProjectPath, configManager,
     res.json({ success: true, session });
   }));
 
+  // GET /api/agent/sessions/:id/image?path=…  —— 正文内嵌图片（模型写 ![说明](本机路径)）
+  //
+  // 与任务对话那一个端点（workbench/index.js 的 /api/workbench/jobs/:id/image）同一目的：
+  // 智能体在本机干活，"展示一张图"最自然的写法是贴一条本机路径，而对话流是 markdown
+  // 渲染 —— `<img src="c:\ws\repo\docs\a.png">` 在浏览器里永远是裂图。前端把这类路径
+  // 重写成这个 URL（utils/localImageSrc.ts 的 resolveAgentImages，四个 g ai 对话入口共用）。
+  //
+  // 权限边界 = 「这个会话的 cwd 内的图片文件」：
+  //   · 判定复用 jobImage.js 的纯函数（后缀白名单 + root 内 + 防穿越）；
+  //   · 这里**再按 realpath 校验一次** —— lexical 判定挡不住会话目录里一个指向外部的
+  //     符号链接，而会话内容很可能是从网上 clone 来的；
+  //   · 响应带 nosniff + CSP(sandbox)：一份恶意 SVG 被直接在浏览器里打开时，它的脚本
+  //     不能跑在本应用的源上（<img> 里本来就不会执行，这里防的是直接访问）。
+  app.get('/api/agent/sessions/:sessionId/image', asyncRoute(async (req, res) => {
+    const session = await readSession(req.params.sessionId);
+    // 根 = 会话自己的 cwd（模型眼里"相对路径"的基准，就是它启动 g ai 的那个目录）。
+    // 历史存量会话没有 cwd 时退回当前项目路径 —— 与列表可见性的老会话包容口径一致
+    // （上面 sessionBelongsTo：没有 cwd 的老会话暂按当前项目可见）。
+    const root = String(session.cwd || '').trim()
+      || (typeof getCurrentProjectPath === 'function' ? getCurrentProjectPath() : '');
+
+    const resolved = resolveJobImagePath({ root, requested: req.query.path });
+    if (!resolved.ok) {
+      throw new HttpError(
+        IMAGE_PATH_STATUS[resolved.reason] || 400,
+        IMAGE_PATH_ERRORS[resolved.reason] || '图片路径不合法',
+      );
+    }
+
+    let realFile;
+    try {
+      realFile = await fsp.realpath(resolved.absPath);
+    } catch {
+      throw new HttpError(404, '图片不存在（模型给的路径在本机读不到）');
+    }
+    let realRoot;
+    try {
+      realRoot = await fsp.realpath(root);
+    } catch {
+      realRoot = root; // 根目录都没了的话，下面那次 stat 也会失败，不必在这里另报一种错
+    }
+    if (!isInsideRoot(realRoot, realFile)) {
+      throw new HttpError(IMAGE_PATH_STATUS['outside-root'], IMAGE_PATH_ERRORS['outside-root']);
+    }
+
+    let stat;
+    try {
+      stat = await fsp.stat(realFile);
+    } catch {
+      throw new HttpError(404, '图片不存在（模型给的路径在本机读不到）');
+    }
+    if (!stat.isFile()) throw new HttpError(404, '路径不是一个文件');
+    // 与附件同一个上限：正文里嵌一张 20MB 以上的图只会把页面拖死
+    if (stat.size > MAX_IMAGE_BYTES) {
+      throw new HttpError(413, `图片超过 ${MAX_IMAGE_BYTES / 1024 / 1024}MB，未加载`);
+    }
+
+    // mime 按**后缀**给（不读文件头）：后缀已过白名单，且这条内容只喂给 <img>
+    res.set('Content-Type', resolved.mime);
+    res.set('Content-Length', String(stat.size));
+    res.set('Content-Disposition', 'inline');
+    res.set('Cache-Control', 'private, max-age=300');
+    res.set('X-Content-Type-Options', 'nosniff');
+    res.set('Content-Security-Policy', "default-src 'none'; style-src 'unsafe-inline'; sandbox");
+    const stream = fs.createReadStream(realFile);
+    stream.on('error', () => res.end());
+    stream.pipe(res);
+  }));
+
   // ════════════════════════════════════════════════════════════════════════
   // §3. 删除会话
   // ════════════════════════════════════════════════════════════════════════
@@ -441,10 +515,11 @@ export function registerAgentRoutes({ app, getCurrentProjectPath, configManager,
           return res.end();
         }
         // 引擎在会话**建立时就锁死**，中途不许换。
-        // 为什么：三家 CLI 的续聊标识互不通用（claude --resume / opencode --session /
-        // codex exec resume），而且历史消息格式不同（我们存的是 OpenAI chat completions
-        // 形状，喂给 claude 没有意义）。允许中途切换的表现是"看起来切了，上下文却串了"——
-        // 与工作台 taskExecutor.ts 注释里那条"续哪个执行器由上一轮 job.agent 决定"同源。
+        // 为什么：各家 CLI 的续聊标识互不通用（claude --resume / opencode --session /
+        // codex exec resume / codebuddy --resume 的 id 也互不认），而且历史消息格式不同
+        // （我们存的是 OpenAI chat completions 形状，喂给 claude 没有意义）。允许中途
+        // 切换的表现是"看起来切了，上下文却串了"—— 与工作台 taskExecutor.ts 注释里那条
+        // "续哪个执行器由上一轮 job.agent 决定"同源。
         const requestedEngine = req.body?.engine === undefined
           ? null
           : normalizeAgentEngine(req.body?.engine);
@@ -467,10 +542,10 @@ export function registerAgentRoutes({ app, getCurrentProjectPath, configManager,
           source: 'web',
           cwd: currentProjectCwd,
           model: '',
-          // 引擎：gai（内置，默认）| claude | opencode | codex
+          // 引擎：gai（内置，默认）| claude | opencode | codex | codebuddy
           engine: normalizeAgentEngine(req.body?.engine),
           // 外部 CLI 自己的续聊标识（claude session_id / opencode sessionID /
-          // codex thread_id）。g ai 用不到，留着空串。
+          // codex thread_id / codebuddy session_id）。g ai 用不到，留着空串。
           engineSessionId: '',
           createdAt: nowIso(),
           updatedAt: nowIso(),