zen-gitsync 2.18.7 → 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/agentChatShared.test.js

@@ -12,7 +12,7 @@
 // configManager / agentSessionStore 会去读真实的 ~/.zen-gitsync。
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
-import { mkdtempSync } from 'node:fs'
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync } from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
 
@@ -61,7 +61,7 @@ const longSession = () => {
 // streamFn：传输层现在默认会自动重试（最多 10 次、指数退避，见 cli/ai/transport.js）。
 // 这一组用例关心的是"失败时怎么收场"，不是"重试几次" —— 真等退避会让一个用例跑到分钟级。
 // 所以统一注入 maxRetries: 0 的那一份；重试自身的口径在 cli/ai/runtime.test.js 里逐条钉。
-async function runWeb({ session, userMessage, respond, locale = 'zh-CN', signal, onEvent, resume = false, streamFn }) {
+async function runWeb({ session, userMessage, respond, locale = 'zh-CN', signal, onEvent, resume = false, streamFn, promptSection }) {
   const { runAgentTurn } = await import('./agentChat.js')
   const { streamChatOnce } = await import('../../../../cli/ai/transport.js')
   const events = []
@@ -75,6 +75,8 @@ async function runWeb({ session, userMessage, respond, locale = 'zh-CN', signal,
       send: e => { events.push(e); onEvent?.(e) },
       resume,
       streamFn: streamFn ?? (opts => streamChatOnce({ ...opts, maxRetries: 0 })),
+      // 不传 = 让 runAgentTurn 自己读沙箱里的配置（要验默认取数时就别传）
+      ...(promptSection === undefined ? {} : { promptSection }),
     })
     return { sent, events, result }
   } finally {
@@ -264,6 +266,8 @@ test('400 且正文提到 tool/function 时提示换模型,而不是甩网关 JS
 //   · argsPreview —— 收起态那一行副标题，故意截到 200 字。
 // 计划类工具的 steps 也在 arguments 里（不再单独开一条透传路径）。
 test('tool_call_start 每种工具都带完整 arguments,argsPreview 仍是截断摘要', async () => {
+  // 桩的 write_file 落点：沙箱里（见 round 里的说明）。用完删掉，不留 tmp 垃圾。
+  const stubWritePath = path.join(SANDBOX, 'stub-write-target.js')
   const planArgs = JSON.stringify({
     steps: [
       { content: '读代码', status: 'completed' },
@@ -275,7 +279,12 @@ test('tool_call_start 每种工具都带完整 arguments,argsPreview 仍是截
     sse([event({
       choices: [{ delta: { tool_calls: [
         { index: 0, id: 'p1', function: { name: 'update_plan', arguments: planArgs } },
-        { index: 1, id: 'p2', function: { name: 'write_file', arguments: JSON.stringify({ path: 'a.js', content: 'x'.repeat(50) }) } }
+        // ⚠️ 这个桩会走**真实** executeTool 落盘（这一层跑的是真 runAgentTurn，
+        // 不是解析 Mock）—— 路径必须指到沙箱。曾经这里写的是相对路径 'a.js'：
+        // resolvePath 按 process.cwd() 解析，于是每次跑测试都在当前目录留一个
+        // 50 字节的 a.js（仓库根跑留根目录、routes/workbench 跑留那里），
+        // 全组用例还都是绿的，只能靠 git status 发现。
+        { index: 1, id: 'p2', function: { name: 'write_file', arguments: JSON.stringify({ path: stubWritePath, content: 'x'.repeat(50) }) } }
       ] } }, { finish_reason: 'tool_calls' }],
     }), 'data: [DONE]\n\n']),
     okStream(),
@@ -283,29 +292,35 @@ test('tool_call_start 每种工具都带完整 arguments,argsPreview 仍是截
   let turn = 0
   const session = newSession('ag-sandbox-plan', withSystem())
 
-  const { events } = await runWeb({
-    session,
-    userMessage: '把这个功能做出来',
-    respond: () => round[turn++] || okStream(),
-  })
+  try {
+    const { events } = await runWeb({
+      session,
+      userMessage: '把这个功能做出来',
+      respond: () => round[turn++] || okStream(),
+    })
 
-  const starts = events.filter(e => e.type === 'tool_call_start')
-  assert.equal(starts.length, 2)
-  const planStart = starts.find(e => e.name === 'update_plan')
-  const writeStart = starts.find(e => e.name === 'write_file')
-
-  // 计划：全文必须一字不差地带到前端（前端靠它渲染清单）
-  assert.equal(planStart.arguments, planArgs)
-  assert.match(planStart.argsPreview, /1\/2|1 完成/)
-  // 其他工具：展开态同样要看到原文，不再只给摘要
-  assert.equal(writeStart.arguments, JSON.stringify({ path: 'a.js', content: 'x'.repeat(50) }))
-  assert.ok(writeStart.argsPreview.length < writeStart.arguments.length, '摘要仍应是截断过的')
-
-  const planResult = events.find(e => e.type === 'tool_result' && e.name === 'update_plan')
-  assert.match(planResult.result, /计划已更新/)
-  // 计划也要进会话记录 —— 重新打开会话时前端靠历史里的 arguments 复原清单
-  const assistantWithPlan = session.messages.find(m => m.role === 'assistant' && m.tool_calls?.some(t => t.function.name === 'update_plan'))
-  assert.equal(assistantWithPlan.tool_calls[0].function.arguments, planArgs)
+    const starts = events.filter(e => e.type === 'tool_call_start')
+    assert.equal(starts.length, 2)
+    const planStart = starts.find(e => e.name === 'update_plan')
+    const writeStart = starts.find(e => e.name === 'write_file')
+
+    // 计划：全文必须一字不差地带到前端（前端靠它渲染清单）
+    assert.equal(planStart.arguments, planArgs)
+    assert.match(planStart.argsPreview, /1\/2|1 完成/)
+    // 其他工具：展开态同样要看到原文，不再只给摘要
+    assert.equal(writeStart.arguments, JSON.stringify({ path: stubWritePath, content: 'x'.repeat(50) }))
+    assert.ok(writeStart.argsPreview.length < writeStart.arguments.length, '摘要仍应是截断过的')
+    // 顺带证明桩调用真的执行了、且只落在沙箱（这条红了 = 有人把路径改成会污染仓库的）
+    assert.ok(existsSync(stubWritePath), '桩的 write_file 应真实落在沙箱里')
+
+    const planResult = events.find(e => e.type === 'tool_result' && e.name === 'update_plan')
+    assert.match(planResult.result, /计划已更新/)
+    // 计划也要进会话记录 —— 重新打开会话时前端靠历史里的 arguments 复原清单
+    const assistantWithPlan = session.messages.find(m => m.role === 'assistant' && m.tool_calls?.some(t => t.function.name === 'update_plan'))
+    assert.equal(assistantWithPlan.tool_calls[0].function.arguments, planArgs)
+  } finally {
+    rmSync(stubWritePath, { force: true })
+  }
 })
 
 // ── 重试与续跑（2026-10-09）────────────────────────────────────
@@ -372,35 +387,111 @@ test('每次 LLM 请求前发一条 attempt（前端靠它记重试断点），
   assert.ok(order.indexOf('attempt') < order.indexOf('content'), 'attempt 要在正文之前')
   assert.ok(order.indexOf('content') < order.indexOf('retry'), 'retry 落在被丢弃的那段正文之后')
 })
-
-test('对跑完的一轮点「重新生成」：把尾巴那条 assistant 摘掉再问一次', async () => {
-  // 会话尾巴是一条没有工具调用的 assistant = 上一轮已经答完了。
-  // 留着它的话模型会顺着自己的答案往下说，重开会话还会看到两条连着的 assistant。
-  const session = newSession('ag-sandbox-regen', [
-    { role: 'system', content: 'rules' },
-    { role: 'user', content: 'hi' },
-    { role: 'assistant', content: '旧答案' },
-  ])
-
-  const { sent } = await runWeb({ session, userMessage: '', resume: true, respond: okStream })
-
-  assert.deepEqual(sent.messages.map(m => m.content), ['rules', 'hi'], '旧答案必须从请求里消失')
-  assert.equal(session.messages.filter(m => m.role === 'assistant').length, 1, '只剩这一次新生成的')
-  assert.equal(session.messages[session.messages.length - 1].content, 'ok')
-})
-
-test('对中途失败的一轮点「重试」：工具结果留在尾巴上，一条都不摘', async () => {
-  // 失败发生在工具循环中途时，尾巴是 assistant(tool_calls) + 一批 tool 结果 ——
-  // 这些是这一轮真干过的事，摘掉就等于让模型把工具再跑一遍。
-  const session = newSession('ag-sandbox-resume-tools', [
-    { role: 'system', content: 'rules' },
-    { role: 'user', content: 'hi' },
-    { role: 'assistant', content: null, tool_calls: [call(0)] },
-    { role: 'tool', tool_call_id: 'call0', content: 'file contents' },
-  ])
-
-  const { sent } = await runWeb({ session, userMessage: '', resume: true, respond: okStream })
-
-  assert.deepEqual(sent.messages.map(m => m.role), ['system', 'user', 'assistant', 'tool'])
-  assert.equal(sent.messages[3].content, 'file contents', '已经跑完的工具结果必须原样带上')
-})
+
+test('对跑完的一轮点「重新生成」：把尾巴那条 assistant 摘掉再问一次', async () => {
+  // 会话尾巴是一条没有工具调用的 assistant = 上一轮已经答完了。
+  // 留着它的话模型会顺着自己的答案往下说，重开会话还会看到两条连着的 assistant。
+  const session = newSession('ag-sandbox-regen', [
+    { role: 'system', content: 'rules' },
+    { role: 'user', content: 'hi' },
+    { role: 'assistant', content: '旧答案' },
+  ])
+
+  const { sent } = await runWeb({ session, userMessage: '', resume: true, respond: okStream })
+
+  assert.deepEqual(sent.messages.map(m => m.content), ['rules', 'hi'], '旧答案必须从请求里消失')
+  assert.equal(session.messages.filter(m => m.role === 'assistant').length, 1, '只剩这一次新生成的')
+  assert.equal(session.messages[session.messages.length - 1].content, 'ok')
+})
+
+test('对中途失败的一轮点「重试」：工具结果留在尾巴上，一条都不摘', async () => {
+  // 失败发生在工具循环中途时，尾巴是 assistant(tool_calls) + 一批 tool 结果 ——
+  // 这些是这一轮真干过的事，摘掉就等于让模型把工具再跑一遍。
+  const session = newSession('ag-sandbox-resume-tools', [
+    { role: 'system', content: 'rules' },
+    { role: 'user', content: 'hi' },
+    { role: 'assistant', content: null, tool_calls: [call(0)] },
+    { role: 'tool', tool_call_id: 'call0', content: 'file contents' },
+  ])
+
+  const { sent } = await runWeb({ session, userMessage: '', resume: true, respond: okStream })
+
+  assert.deepEqual(sent.messages.map(m => m.role), ['system', 'user', 'assistant', 'tool'])
+  assert.equal(sent.messages[3].content, 'file contents', '已经跑完的工具结果必须原样带上')
+})
+
+// ── 用户固定提示词（g ai 默认提示词 + 派发提示词）────────────────
+// 智能体视图「设置」Tab 配的两块提示词，和 g ai 对话时每轮都要注入。
+// 这是**纯 prompt 注入**的能力：没有按钮、没有状态、界面上看不出对错 ——
+// 改 agentChat.js / chatPrompts.js 的人（哪怕只是把一段挪个位置）会无声地把它弄掉。
+// 所以这里跑真实的 runAgentTurn，把发出去的请求体抓下来逐条钉住。
+//
+// 沙箱里写真实文件（config.json / orchestrator.json）：这一层要验的正是
+// "默认取数真的接到了配置上"，用注入口反而绕过了要验的那一段。
+// 每个用例 finally 里删干净 —— 同文件其它用例断言的是精确的 messages 列表，
+// 残留一份提示词就会让它们莫名其妙地红。
+
+const DATA_DIR = path.join(SANDBOX, '.zen-gitsync')
+
+function writeSandboxFile(name, obj) {
+  mkdirSync(DATA_DIR, { recursive: true })
+  writeFileSync(path.join(DATA_DIR, name), JSON.stringify(obj, null, 2))
+}
+
+function clearSandboxFile(name) {
+  rmSync(path.join(DATA_DIR, name), { force: true })
+}
+
+test('两块提示词都注入请求副本：g ai 默认提示词 + 派发提示词（含项目级）', async () => {
+  const { canonicalProjectPath } = await import('./projectRegistry.js')
+  const projectKey = canonicalProjectPath(process.cwd())
+  try {
+    writeSandboxFile('config.json', { agentDefaultPrompt: '【g ai 默认提示词】回答用中文' })
+    writeSandboxFile('orchestrator.json', {
+      version: 1,
+      active: true,
+      defaultPrompt: '【全局派发提示词】改完就提交',
+      projectPrompts: { [projectKey]: { path: process.cwd(), prompt: '【本项目派发提示词】包管理器用 pnpm' } },
+    })
+
+    const session = newSession('ag-sandbox-user-prompt', withSystem())
+    const { sent } = await runWeb({ session, userMessage: 'hello', respond: okStream })
+
+    const sys = sent.messages.find(m => m.role === 'system')
+    assert.match(sys.content, /【g ai 默认提示词】回答用中文/, 'g ai 默认提示词必须进请求')
+    assert.match(sys.content, /【全局派发提示词】改完就提交/, '全局派发提示词必须进请求')
+    assert.match(sys.content, /【本项目派发提示词】包管理器用 pnpm/,
+      '项目级那条要按本轮 cwd 生效（与派发时"按落点项目解析"同一口径）')
+    // 规则在前、现场在后：固定提示词是每轮都成立的约束，不该排在工作区快照后面
+    assert.ok(sys.content.indexOf('【g ai 默认提示词】') < sys.content.indexOf('【全局派发提示词】'),
+      'g ai 那段排在派发那段之前')
+    // 落盘口径：会话里那条 system 一个字节都不许变 —— 否则改设置后老会话永远带着旧规则
+    assert.equal(session.messages[0].content, 'rules', '注入只作用于请求副本，不写回 session.messages')
+  } finally {
+    clearSandboxFile('config.json')
+    clearSandboxFile('orchestrator.json')
+  }
+})
+
+test('没配就不注入（连一节标题都不出现）—— 这也是其它用例能断言精确 messages 的前提', async () => {
+  const session = newSession('ag-sandbox-user-prompt-empty', withSystem())
+
+  const { sent } = await runWeb({ session, userMessage: 'hello', respond: okStream })
+
+  assert.deepEqual(sent.messages.map(m => m.content), ['rules', 'hi', 'hello'])
+})
+
+test('调用方显式传 promptSection 时不再自己读配置（定时任务 / agentRoutes 走这条路）', async () => {
+  try {
+    // 磁盘上有一份提示词，但调用方传了 ''：意思是"这一轮确定不带"，不是"没传、你去读"
+    writeSandboxFile('config.json', { agentDefaultPrompt: '【不该出现】' })
+    const session = newSession('ag-sandbox-user-prompt-explicit', withSystem())
+
+    const { sent } = await runWeb({ session, userMessage: 'hello', respond: okStream, promptSection: '' })
+
+    assert.doesNotMatch(sent.messages[0].content, /【不该出现】/)
+    assert.deepEqual(sent.messages.map(m => m.content), ['rules', 'hi', 'hello'])
+  } finally {
+    clearSandboxFile('config.json')
+  }
+})

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) {