zen-gitsync 2.18.8 → 2.18.10

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';
@@ -196,6 +201,21 @@ export function registerAgentRoutes({ app, getCurrentProjectPath, configManager,
   // 不给它加缓存:agent 一轮里最多问一两次,而"项目状态"本来就要现读才准。
   const listProjects = createProjectListProvider({ configManager, getCurrentProjectPath });
 
+  // 把目录登记进「常用目录」(config.json 的 recentDirectories)。register_project 工具
+  // 与 run_command 里"建了仓库就顺手登记"那一步共用它 —— 智能体建/克隆完新项目,
+  // 用户下次在「切换工作目录」弹窗里就能直接看到,不必重启 GUI 或自己翻路径。
+  //
+  // 失败只 warn 不外抛:登记是锦上添花,不能让一条命令/一次工具调用因为写配置失败而报错。
+  const registerProject = (configManager && typeof configManager.saveRecentDirectory === 'function')
+    ? async (dir) => {
+      try {
+        await configManager.saveRecentDirectory(dir);
+      } catch (err) {
+        logger.warn(`[agent] 登记常用目录失败 ${dir}: ${err?.message || err}`);
+      }
+    }
+    : undefined;
+
   // dispatch_task 的实现 —— 与 POST /api/workbench/orchestrator/dispatch 共用**同一份**
   // 派发实现（见 dispatchInstruction.js 的文件头）：落点怎么判、预设提示词附加哪一级、
   // 指令流水记什么、执行器怎么回落，只有一套。这里只是把同一套依赖再绑一次
@@ -226,6 +246,7 @@ export function registerAgentRoutes({ app, getCurrentProjectPath, configManager,
     configManager,
     getCurrentProjectPath,
     listProjects,
+    registerProject,
     dispatchTask: scheduleDispatchTask,
     getContextBlock,
   });
@@ -294,6 +315,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 +531,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 +558,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(),
@@ -668,6 +759,7 @@ export function registerAgentRoutes({ app, getCurrentProjectPath, configManager,
           }),
           dispatchTask,
           listProjects,
+          registerProject,
           getContextBlock,
           // 每轮请求的上下文预算（解析结果）。agentChat 拿它调 prepareRequestMessages，
           // 与 CLI turn.js 同一条口径。

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

@@ -1,6 +1,7 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, readdirSync, readFileSync } from 'node:fs';
+import { mkdtempSync, mkdirSync, writeFileSync, readdirSync, readFileSync } from 'node:fs';
+import { PassThrough } from 'node:stream';
 import os from 'node:os';
 import path from 'node:path';
 
@@ -476,3 +477,142 @@ test('dispatch_task：开了 allowDispatch 才注入，且工具结果说清落
     globalThis.fetch = originalFetch;
   }
 });
+
+// ── 正文内嵌图片端点（2026-10-12） ────────────────────────────────────────
+//
+// 模型"展示一张图"的写法是在正文里贴一条本机路径，而对话流是 markdown 渲染 ——
+// 浏览器里那条地址永远是裂图。前端把路径重写成
+// GET /api/agent/sessions/:id/image?path=...（utils/localImageSrc.ts 的
+// resolveAgentImages），这里守服务端那一半：
+//   · 根 = 会话自己的 cwd；没有 cwd 的老会话退回当前项目路径
+//   · 后缀白名单 / root 内 / 防穿越（jobImage.js 的纯函数，与任务对话端点同一份）
+//   · realpath 双校验、单文件上限、nosniff + CSP 响应头
+const { agentSessionStore } = await import('./agentSessionStore.js');
+
+/**
+ * 最小 res：PassThrough 是真流（stream.pipe 直接可用），外加路由用到的
+ * set / status / json。字节经 'data' 收齐，收尾等 'finish'。
+ */
+function makeImageRes() {
+  const chunks = [];
+  const headers = {};
+  const res = new PassThrough();
+  res.headers = headers;
+  res.statusCode = 200;
+  res.jsonBody = undefined;
+  res.set = (k, v) => { headers[String(k).toLowerCase()] = v; };
+  res.status = (code) => { res.statusCode = code; return res; };
+  res.json = (v) => { res.jsonBody = v; res.end(); };
+  res.on('data', (c) => chunks.push(Buffer.from(c)));
+  res.bodyText = () => Buffer.concat(chunks).toString('utf-8');
+  return res;
+}
+
+const IMAGE_FINISH = (res) => new Promise((resolve) => res.on('finish', resolve));
+
+/** 注册路由并取出图片端点的 handler（fake app 只认这一条） */
+function captureImageHandler(projectPath) {
+  let handler;
+  const app = {
+    get(route, h) { if (route === '/api/agent/sessions/:sessionId/image') handler = h; },
+    post() {}, put() {}, delete() {}
+  };
+  registerAgentRoutes({
+    app,
+    getCurrentProjectPath: () => projectPath,
+    configManager: null,
+    snapshotter: STUB_SNAPSHOTTER
+  });
+  return handler;
+}
+
+const PNG_BYTES = Buffer.from('not-a-real-png-but-ext-is-whitelisted');
+
+test('会话图片端点：按会话 cwd 读盘，响应带 nosniff + CSP', async () => {
+  const repo = mkdtempSync(path.join(SANDBOX, 'img-repo-'));
+  mkdirSync(path.join(repo, 'docs'), { recursive: true });
+  writeFileSync(path.join(repo, 'docs', 'a.png'), PNG_BYTES);
+
+  const sessionId = 'ag-imgtest-0001';
+  await agentSessionStore.write(sessionId, { sessionId, cwd: repo, messages: [] });
+
+  const handler = captureImageHandler(path.resolve('active-project'));
+  const res = makeImageRes();
+  const finished = IMAGE_FINISH(res);
+  await handler({ params: { sessionId }, query: { path: 'docs/a.png' } }, res);
+  await finished;
+
+  assert.equal(res.statusCode, 200);
+  assert.equal(res.headers['content-type'], 'image/png');
+  assert.equal(res.headers['x-content-type-options'], 'nosniff');
+  assert.match(res.headers['content-security-policy'], /sandbox/);
+  assert.equal(res.bodyText(), PNG_BYTES.toString('utf-8'));
+});
+
+test('会话图片端点：绝对路径也认，但必须落在会话 cwd 内', async () => {
+  const repo = mkdtempSync(path.join(SANDBOX, 'img-repo2-'));
+  writeFileSync(path.join(repo, 'a.png'), PNG_BYTES);
+  const outside = path.join(SANDBOX, 'outside-a.png');
+  writeFileSync(outside, PNG_BYTES);
+
+  const sessionId = 'ag-imgtest-0002';
+  await agentSessionStore.write(sessionId, { sessionId, cwd: repo, messages: [] });
+  const handler = captureImageHandler(path.resolve('active-project'));
+
+  // cwd 内的绝对路径 → 200
+  const ok = makeImageRes();
+  const okFinished = IMAGE_FINISH(ok);
+  await handler({ params: { sessionId }, query: { path: path.join(repo, 'a.png') } }, ok);
+  await okFinished;
+  assert.equal(ok.statusCode, 200);
+  assert.equal(ok.bodyText(), PNG_BYTES.toString('utf-8'));
+
+  // cwd 外的绝对路径 → 403（`..` 穿越与盘符外路径都走这条）
+  const bad = makeImageRes();
+  const badFinished = IMAGE_FINISH(bad);
+  await handler({ params: { sessionId }, query: { path: outside } }, bad);
+  await badFinished;
+  assert.equal(bad.statusCode, 403);
+  assert.match(bad.jsonBody.error, /仓库内/);
+});
+
+test('会话图片端点：坏后缀 415、文件不存在 404、会话不存在 404', async () => {
+  const repo = mkdtempSync(path.join(SANDBOX, 'img-repo3-'));
+  writeFileSync(path.join(repo, 'notes.txt'), 'hello');
+  const sessionId = 'ag-imgtest-0003';
+  await agentSessionStore.write(sessionId, { sessionId, cwd: repo, messages: [] });
+  const handler = captureImageHandler(path.resolve('active-project'));
+
+  const call = async (params, query) => {
+    const res = makeImageRes();
+    const finished = IMAGE_FINISH(res);
+    await handler({ params, query }, res);
+    await finished;
+    return res;
+  };
+
+  const badExt = await call({ sessionId }, { path: 'notes.txt' });
+  assert.equal(badExt.statusCode, 415);
+
+  const missing = await call({ sessionId }, { path: 'docs/a.png' });
+  assert.equal(missing.statusCode, 404);
+
+  const noSession = await call({ sessionId: 'ag-imgtest-9999' }, { path: 'a.png' });
+  assert.equal(noSession.statusCode, 404);
+});
+
+test('没有 cwd 的老会话：根退回当前项目路径（与列表可见性的包容口径一致）', async () => {
+  const proj = mkdtempSync(path.join(SANDBOX, 'img-proj-'));
+  writeFileSync(path.join(proj, 'b.png'), PNG_BYTES);
+  const sessionId = 'ag-imgtest-0004';
+  await agentSessionStore.write(sessionId, { sessionId, cwd: '', messages: [] });
+
+  const handler = captureImageHandler(proj);
+  const res = makeImageRes();
+  const finished = IMAGE_FINISH(res);
+  await handler({ params: { sessionId }, query: { path: 'b.png' } }, res);
+  await finished;
+
+  assert.equal(res.statusCode, 200);
+  assert.equal(res.headers['content-type'], 'image/png');
+});

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

@@ -25,7 +25,7 @@
 //
 // 这里把「读三个配置文件」这件事收口成一个模块，让前端能在选择器里直接显示。
 //
-// ── 三家配置文件的形状（这是本模块存在的全部理由）────────────────────────
+// ── 四家配置文件的形状（这是本模块存在的全部理由）────────────────────────
 //
 //   claude   ~/.claude/settings.json         JSON。模型在 env 里，且有**别名两层**：
 //            ANTHROPIC_DEFAULT_SONNET_MODEL 是 CLI 认识的名字
@@ -48,6 +48,10 @@
 //            variant（截图里那个蓝色的 max）在同文件的顶层 variant 表里。
 //            两处都没有才算"没指定"，返回值里用 source 区分（config / state）。
 //
+//   codebuddy ~/.codebuddy/settings.json      JSON。顶层 `model` 字符串
+//            （--settings '{"model":"..."}' 的落盘处；没写过就是没配，
+//             CLI 用自己的内置默认 —— 那种情况下这里如实报 null）。
+//
 // ── 三条必须守住的底线 ──────────────────────────────────────────────────────
 //
 // 1. **纯只读**：只 fs.readFile，一个字节都不写。改用户 CLI 的配置是绝对禁区。
@@ -257,25 +261,42 @@ function detectOpencode(cfgJson, stateJson) {
   return detectOpencodeConfig(cfgJson) || detectOpencodeState(stateJson);
 }
 
+/**
+ * codebuddy：~/.codebuddy/settings.json 的顶层 model。
+ *
+ * 与另三家一个重要差别：codebuddy **没有"第二处"**—— TUI 里选的模型会写回
+ * settings.json（`codebuddy config set -g model <id>`），不存在 opencode 那种
+ * "选择躺在 state 里、配置是空的"分裂。所以读一个文件就够。
+ * 没配 → null：CLI 有自己的内置默认（init 事件里能看到，如 fast-model），
+ * 但那是 CLI 的默认而不是用户的设置，按本模块的底线不猜、不报。
+ */
+function detectCodebuddy(json) {
+  const raw = json && json.model;
+  if (typeof raw === 'string' && raw.trim()) {
+    return { model: raw.trim(), display: null, provider: null, source: 'config' };
+  }
+  return null;
+}
+
 function escapeRe(s) {
   return String(s).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 
 /**
- * 探测三个执行器当前配置的模型。
+ * 探测四个执行器当前配置的模型。
  *
  * @param {object} [opts]
  * @param {string} [opts.homeDir] 测试沙箱用（默认 os.homedir()）
- * @returns {Promise<{ claude: object|null, codex: object|null, opencode: object|null }>}
+ * @returns {Promise<{ claude: object|null, codex: object|null, opencode: object|null, codebuddy: object|null }>}
  *          每项 `{ model, display, provider, source }`；该执行器没配模型时为 null。
  *          source = 'config'（配置文件里写死的）| 'state'（CLI 自己记的"上次用的"）。
  *
- * 三路并发、互不阻塞：任何一个配置文件读失败都只让**它自己**变成 null。
+ * 四路并发、互不阻塞：任何一个配置文件读失败都只让**它自己**变成 null。
  */
 export async function detectExecutorModels({ homeDir } = {}) {
   const home = homeDir || os.homedir();
 
-  const [claudeRaw, codexRaw, opencodeJsonRaw, opencodeJsoncRaw, opencodeStateRaw] = await Promise.all([
+  const [claudeRaw, codexRaw, opencodeJsonRaw, opencodeJsoncRaw, opencodeStateRaw, codebuddyRaw] = await Promise.all([
     readTextOrNull(path.join(home, '.claude', 'settings.json')),
     readTextOrNull(path.join(home, '.codex', 'config.toml')),
     // .json 优先（标准名），.jsonc 兜底。opencode 两个都认。
@@ -283,6 +304,8 @@ export async function detectExecutorModels({ homeDir } = {}) {
     readTextOrNull(path.join(home, '.config', 'opencode', 'opencode.jsonc')),
     // TUI 的"最近使用"（不写回配置文件，见 detectOpencodeState 的注释）
     readTextOrNull(path.join(home, '.local', 'state', 'opencode', 'model.json')),
+    // CodeBuddy Code CLI（与 WorkBuddy 桌面版共用的配置目录）
+    readTextOrNull(path.join(home, '.codebuddy', 'settings.json')),
   ]);
 
   const pickJson = (raw) => {
@@ -295,6 +318,7 @@ export async function detectExecutorModels({ homeDir } = {}) {
   // 于是注释里写的"jsonc 兜底"是死代码 —— 只写了 .jsonc 的机器永远显示未配置。
   const opencodeCfg = pickJson(opencodeJsonRaw) || pickJson(opencodeJsoncRaw);
   const opencodeState = pickJson(opencodeStateRaw);
+  const codebuddyCfg = pickJson(codebuddyRaw);
 
   return {
     claude: claudeCfg && typeof claudeCfg.env === 'object' && claudeCfg.env
@@ -302,6 +326,7 @@ export async function detectExecutorModels({ homeDir } = {}) {
       : null,
     codex: codexRaw ? detectCodex(codexRaw) : null,
     opencode: detectOpencode(opencodeCfg, opencodeState),
+    codebuddy: detectCodebuddy(codebuddyCfg),
   };
 }
 

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

@@ -121,12 +121,14 @@ const CODEX_TOML = [
   'model = "inner-model"',
 ].join('\n')
 const OPENCODE_JSONC = '{\n  // 注释\n  "model": "anthropic/claude-x",\n}'
+const CODEBUDDY_JSON = JSON.stringify({ model: 'deepseek-v4-1-flash-260910' })
 
-test('detectExecutorModels: 三家配置齐全时各自读出模型', async () => {
+test('detectExecutorModels: 四家配置齐全时各自读出模型', async () => {
   const home = await makeHome({
     '.claude/settings.json': CLAUDE_JSON,
     '.codex/config.toml': CODEX_TOML,
     '.config/opencode/opencode.jsonc': OPENCODE_JSONC,
+    '.codebuddy/settings.json': CODEBUDDY_JSON,
   })
   const out = await detectExecutorModels({ homeDir: home })
 
@@ -141,6 +143,15 @@ test('detectExecutorModels: 三家配置齐全时各自读出模型', async () =
   assert.deepEqual(out.opencode, {
     model: 'anthropic/claude-x', display: null, provider: null, source: 'config',
   })
+  // codebuddy：一个文件一处键，没有"第二来源"（TUI 选择会写回 settings.json）
+  assert.deepEqual(out.codebuddy, {
+    model: 'deepseek-v4-1-flash-260910', display: null, provider: null, source: 'config',
+  })
+})
+
+test('detectExecutorModels: codebuddy 没配 model 时为 null（CLI 内置默认不冒名）', async () => {
+  const home = await makeHome({ '.codebuddy/settings.json': '{"theme":"dark"}' })
+  assert.equal((await detectExecutorModels({ homeDir: home })).codebuddy, null)
 })
 
 test('detectExecutorModels: 只有 .jsonc 时 opencode 仍读得到 [回归]', async () => {
@@ -254,10 +265,10 @@ test('detectExecutorModels: claude 显式 ANTHROPIC_MODEL 优先于档位别名'
   })
 })
 
-test('detectExecutorModels: 一个配置文件都没有时三项全 null 且不抛', async () => {
+test('detectExecutorModels: 一个配置文件都没有时四项全 null 且不抛', async () => {
   const home = await makeHome()
   const out = await detectExecutorModels({ homeDir: home })
-  assert.deepEqual(out, { claude: null, codex: null, opencode: null })
+  assert.deepEqual(out, { claude: null, codex: null, opencode: null, codebuddy: null })
 })
 
 test('detectExecutorModels: 配置残缺/是目录/内容不是 JSON 时只让自己变 null', async () => {
@@ -265,9 +276,10 @@ test('detectExecutorModels: 配置残缺/是目录/内容不是 JSON 时只让
     '.claude/settings.json': '{ 这不是 JSON', // 解析失败 → null
     '.codex/config.toml': '# 只有注释，没有 model\n', // 无 model → null
     '.config/opencode/opencode.json': '{"model":""}', // 空串 → null
+    '.codebuddy/settings.json': '{"model":123}', // 非字符串 → null
   })
   const out = await detectExecutorModels({ homeDir: home })
-  assert.deepEqual(out, { claude: null, codex: null, opencode: null })
+  assert.deepEqual(out, { claude: null, codex: null, opencode: null, codebuddy: null })
 })
 
 test('detectExecutorModels: 返回值里绝不出现任何密钥', async () => {

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

@@ -548,10 +548,20 @@ export function registerWorkbenchRoutes({
   app.post('/api/workbench/jobs/:id/continue', asyncRoute(async (req, res) => {
     const userMessage = String(req.body?.userMessage || '').trim();
     if (!userMessage) throw new HttpError(400, 'userMessage 不能为空');
-    const prevJob = jobs.get(req.params.id);
+    // 内存里没有就退回「磁盘历史 ∪ 别的实例正在跑」——续接要用到的三样东西
+    // (claudeSessionId / agent / taskId)全在持久化记录里，**不依赖本进程的 child 句柄**
+    // （那是 §14 取消路径非有不可的东西，所以那条 404 是对的，这条不是）。
+    // 只认内存的话：在 A 窗口跑完、到 B 窗口接着聊，B 的看板明明列着这条记录，
+    // 一发送却弹 "job 不存在" —— 2026-10-12 用户实测就是这个（本机同时开着 4 个实例）。
+    // 与 GET /jobs/:id、/jobs/:id/image 同一个口径。
+    await refreshJobsFromDisk();
+    const prevJob = jobs.get(req.params.id) || mergedJobs().get(req.params.id);
     if (!prevJob) throw new HttpError(404, 'job 不存在');
     if (prevJob.status === 'running' || prevJob.status === 'pending') {
-      throw new HttpError(400, '上一轮还在执行,请等结束后再续接');
+      // 这一轮在**别的**实例里跑着：本进程停不了也接不上，别让用户以为是"上一轮"没结束
+      throw new HttpError(400, jobs.has(prevJob.id)
+        ? '上一轮还在执行,请等结束后再续接'
+        : '这个任务正在另一个 g ui 实例里执行，请等它结束后再续接');
     }
     if (!prevJob.claudeSessionId) {
       throw new HttpError(400, '无法续接:会话标识未捕获');
@@ -559,10 +569,12 @@ export function registerWorkbenchRoutes({
     const data = await readJson(TASKS_FILE, { tasks: [] });
     const task = (data.tasks || []).find(t => t.id === prevJob.taskId);
     if (!task) throw new HttpError(404, '所属任务不存在');
-    // 计算续接轮次号
+    // 计算续接轮次号。**必须走合并表**：轮次是跨实例共享的编号，只看本进程内存的话，
+    // 另一个实例已经续过 #1 了，这边还会再发一个 #1 出去（两条 subId 撞车，前端按 subId
+    // 归组时那两轮会混在一起）。
     const subIdPrefix = `${task.id}__simple`;
     let maxRound = 0;
-    for (const j of jobs.values()) {
+    for (const j of mergedJobs().values()) {
       if (j.taskId !== task.id) continue;
       if (j.subId === subIdPrefix) continue;
       const m = j.subId && j.subId.match(/__simple__r(\d+)$/);
@@ -1660,7 +1672,7 @@ export function registerWorkbenchRoutes({
    * 无参数、服务端不算缓存：三个文件都很小，每次实读比让前端踩脏缓存划算；
    * 前端那边（stores/toolsStore）自己按分钟级 TTL + 并发去重压请求频率。
    * 返回值里某项为 null = 那个 CLI 没在配置里写模型，前端照实显示「未在配置中指定」。
-   * key 恒为 claude / codex / opencode 三个，与 TASK_EXECUTOR_OPTIONS 对齐。
+   * key 恒为 claude / codex / opencode / codebuddy 四个，与 TASK_EXECUTOR_OPTIONS 对齐。
    */
   app.get('/api/workbench/executor-models', asyncRoute(async (_req, res) => {
     const detected = await detectExecutorModels();

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

@@ -216,7 +216,7 @@ export function jobDurationMs(job) {
 }
 
 /**
- * 本轮跑的是哪个执行器（`claude` | `opencode` | `codex`）。
+ * 本轮跑的是哪个执行器（`claude` | `opencode` | `codex` | `codebuddy`）。
  *
  * 只在**认出是已知执行器**时才回值：job.agent 来自 jobs.json（会被手工编辑、也读过
  * 别实例写的旧记录），回一个前端不认识的字符串只会让卡片上的图标位空着或显示错品牌。
@@ -224,10 +224,10 @@ export function jobDurationMs(job) {
  * 猜错的执行器比不显示更糟。
  *
  * 这里**刻意不 import taskRunner 的 TASK_EXECUTORS**：taskRunner 拉起进程、依赖一堆
- * 运行时模块，而本模块被 projectRegistry（5s 轮询的看板）直接引用，没必要为了三个
+ * 运行时模块，而本模块被 projectRegistry（5s 轮询的看板）直接引用，没必要为了四个
  * 字符串把整条执行链拖进来。新增执行器时这里和 taskRunner 一起改。
  */
-const KNOWN_EXECUTORS = ['claude', 'opencode', 'codex'];
+const KNOWN_EXECUTORS = ['claude', 'opencode', 'codex', 'codebuddy'];
 
 export function jobAgent(job) {
   const v = job && typeof job.agent === 'string' ? job.agent.trim().toLowerCase() : '';

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

@@ -181,6 +181,7 @@ test('jobAgent：认识的执行器原样返回', () => {
   assert.equal(jobAgent({ agent: 'claude' }), 'claude');
   assert.equal(jobAgent({ agent: 'opencode' }), 'opencode');
   assert.equal(jobAgent({ agent: 'codex' }), 'codex');
+  assert.equal(jobAgent({ agent: 'codebuddy' }), 'codebuddy');
 });
 
 test('jobAgent：大小写与首尾空白归一后再认（jobs.json 会被手工编辑）', () => {

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

@@ -23,18 +23,22 @@
 //
 // ⚠️ 两条不重复实现的红线（本仓库 agentParity.test.js 就是为这类分叉立的规矩）：
 //   1. **spawn 与协议解析一律复用 taskRunner.js**，绝不在这里再写一份。
-//      `createClaudeEventHandler` / `createOpencodeEventHandler` / `createCodexEventHandler`
+//      `createClaudeEventHandler` / `createOpencodeEventHandler` /
+//      `createCodexEventHandler` / `createCodebuddyEventHandler`
 //      的签名是 `(job, appendOutput, appendThinking, toolCalls)` —— 回调早已抽象好，
 //      这里只是换一组回调（推 SSE 而不是推工作台面板），所以适配层能很薄。
 //   2. **权限档不在这里决定**。taskRunner 的 launcher 已经带死了各自的档位
 //      （claude: --permission-mode bypassPermissions --dangerously-skip-permissions；
-//        opencode: --auto；codex: --dangerously-bypass-approvals-and-sandbox），
-//      与工作台任务执行保持一致。要改档位请改 launcher，别在这儿加参数。
+//        opencode: --auto；codex: --dangerously-bypass-approvals-and-sandbox；
+//        codebuddy: -y），与工作台任务执行保持一致。要改档位请改 launcher，别在这儿加参数。
 //
-// 关于 headless 权限（2026-09-28 实测，三家在非交互下的真实行为）：
+// 关于 headless 权限（2026-09-28 实测，三家在非交互下的真实行为；codebuddy 2026-10-12 补测）：
 //   claude   默认档也能跑，但不放开会挡住写操作；工作台那套是 bypassPermissions。
 //   codex    默认档是只读沙箱（写文件被拦），所以要 --dangerously-bypass-...
 //   opencode **不给 --auto 会卡死**（在等一个永远不会有人回答的交互式批准）。
+//   codebuddy 不给 -y 时写操作被拦（init 事件回传 permissionMode 可验证）；
+//             另外它每次运行自带引擎服务器，默认端口 62443 会被 WorkBuddy
+//             桌面版占着，所以 launcher 固定传 --port 0 让 OS 选空闲端口。
 //   这正是 AgentView 里没有终端、没人能点"允许"所决定的 —— 必须预设档位。
 
 import { spawn, execFile } from 'child_process';
@@ -42,27 +46,19 @@ import { logger } from './shared.js';
 import { engineLabel } from './agentEngines.js';
 import {
   createToolCallTracker,
-  createClaudeEventHandler,
-  createOpencodeEventHandler,
-  createCodexEventHandler,
-  launchClaudeInNewWindow,
-  launchOpencodeRun,
-  launchCodexExec,
+  EXECUTOR_LAUNCHERS,
+  EXECUTOR_HANDLERS,
 } from './taskRunner.js';
 
-/** 引擎 → spawn 实现。复用 taskRunner，不另写（见文件头红线 1）。 */
-export const ENGINE_LAUNCHERS = {
-  claude: launchClaudeInNewWindow,
-  opencode: launchOpencodeRun,
-  codex: launchCodexExec,
-};
+/**
+ * 引擎 → spawn 实现。直接复用 taskRunner 的运行时分发表（EXECUTOR_LAUNCHERS）——
+ * 不在这里另抄一张表：那张表已经是"执行器 → launcher"的唯一真相源，抄一份就等于
+ * 给未来某次"加了第五家只改了一处"埋雷。别名导出只为保持本模块对外的旧名字。
+ */
+export const ENGINE_LAUNCHERS = EXECUTOR_LAUNCHERS;
 
-/** 引擎 → NDJSON 事件处理器工厂。同样复用 taskRunner。 */
-export const ENGINE_HANDLERS = {
-  claude: createClaudeEventHandler,
-  opencode: createOpencodeEventHandler,
-  codex: createCodexEventHandler,
-};
+/** 引擎 → NDJSON 事件处理器工厂。同上，复用 taskRunner 的 EXECUTOR_HANDLERS。 */
+export const ENGINE_HANDLERS = EXECUTOR_HANDLERS;
 
 /** 输出片段最长保留多少字符（与前端 MAX_LOG_DISPLAY 的口径一致，防止会话文件膨胀） */
 const MAX_ACCUM = 400_000;
@@ -90,7 +86,7 @@ function killChildTree(child) {
  *
  * @param {object}   args
  * @param {object}   args.session        会话记录（会被就地更新：messages / engineSessionId）
- * @param {string}   args.engine         'claude' | 'opencode' | 'codex'
+ * @param {string}   args.engine         'claude' | 'opencode' | 'codex' | 'codebuddy'
  * @param {string}   args.userMessage    用户这一轮说的话
  * @param {string}   args.cwd            工作目录
  * @param {string}   [args.promptPrefix] 拼在用户消息**前面**的工作区状态块（见 agentRoutes）
@@ -275,8 +271,9 @@ export async function runExternalTurn({
     });
   }
 
-  // 续聊标识：三家字段名不同（claude session_id / opencode sessionID / codex thread_id），
-  // 但 taskRunner 的 handler 已经统一落到 job.claudeSessionId 上，这里只做搬运。
+  // 续聊标识：各家字段名不同（claude session_id / opencode sessionID / codex thread_id /
+  // codebuddy session_id），但 taskRunner 的 handler 已经统一落到 job.claudeSessionId 上，
+  // 这里只做搬运。
   if (job.claudeSessionId) session.engineSessionId = job.claudeSessionId;
 
   send({ type: 'done', content: aborted ? `${text}\n\n[已停止]` : text });