zen-gitsync 2.18.7 → 2.18.9

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 必须与服务端当前项目一致)
@@ -32,13 +33,19 @@ import { registerAgentMarketplaceRoutes } from './agentMarketplace.js';
 import { createProjectListProvider } from './projectTool.js';
 import { createDispatcher } from './dispatchInstruction.js';
 import { createWorkspaceSnapshotter } from '../aiContext/wiring.js';
+// 用户固定提示词（g ai 默认提示词 + 派发提示词）的解析 —— 两条引擎链路共用同一份
+import { resolveChatPromptSection } from './chatPrompts.js';
 // 「同一会话同一时刻只允许一个生成中的轮次」的闸，与定时任务调度器共享
 // （见 sessionGate.js —— 拆出去是为了让调度器复用同一份判定口径）。
 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';
@@ -292,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. 删除会话
   // ════════════════════════════════════════════════════════════════════════
@@ -439,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);
@@ -465,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(),
@@ -548,6 +625,18 @@ export function registerAgentRoutes({ app, getCurrentProjectPath, configManager,
         }
       }
 
+      // 用户固定提示词（g ai 默认提示词 + 派发提示词，见 chatPrompts.js）。
+      // 在这里解析**一次**、两条引擎链路共用：内置引擎走请求副本（runAgentTurn 的
+      // promptSection），外部 CLI 引擎没有副本可注入，只能拼进 prompt 前缀。
+      // 两处各解析一次的话，改设置后两条链路生效时机就会分叉。
+      // 取不到就当没配 —— 它是锦上添花，不该让用户这条消息发不出去。
+      let promptSection = '';
+      try {
+        promptSection = await resolveChatPromptSection({ cwd, locale });
+      } catch (err) {
+        logger.warn(`[agent/chat] 取用户固定提示词失败,本轮跳过注入: ${err?.message || err}`);
+      }
+
       // 推 meta
       send({
         type: 'meta',
@@ -599,6 +688,11 @@ export function registerAgentRoutes({ app, getCurrentProjectPath, configManager,
         if (dirStatusBlock) {
           promptPrefix = promptPrefix ? `${dirStatusBlock}\n\n${promptPrefix}` : dirStatusBlock;
         }
+        // 用户固定提示词排在最前：它是每轮都成立的规则，工作区快照是这一刻的现场。
+        // 外部引擎那条链路的 system 提示词是 CLI 自己的，进不去 —— 只能靠这个前缀。
+        if (promptSection) {
+          promptPrefix = promptPrefix ? `${promptSection}\n\n${promptPrefix}` : promptSection;
+        }
         // 图片附件转成文件路径交给 CLI（它们收路径不收 base64）。走同一套落盘校验。
         const imageAttachments = images.map((u, i) => ({ name: `pasted-${i + 1}.png`, dataUrl: u }));
         const imageFiles = imageAttachments.length > 0
@@ -654,7 +748,10 @@ export function registerAgentRoutes({ app, getCurrentProjectPath, configManager,
           // 与 CLI turn.js 同一条口径。
           requestBudget,
           // 重试上一轮：不再压 user 消息，接着会话现有的尾巴跑
-          resume
+          resume,
+          // 用户固定提示词（上面已解析）。显式传 —— 不传的话 runAgentTurn 会自己再读一遍
+          // 配置文件，同一轮里读两次同一份配置纯属浪费
+          promptSection
         });
       }
 

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/chatPrompts.js

@@ -0,0 +1,115 @@
+// 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.
+//
+// 「和 g ai 对话时固定注入的两块提示词」—— 拼装规则（纯函数）+ 取数（读两处配置）。
+//
+// 两块分别来自两处，语义也不同，别混：
+//   ① g ai 智能体的默认提示词 —— config.json 的 agentDefaultPrompt，
+//      在「智能体视图 → 设置」里编辑。只喂给 g ai 自己。
+//   ② 派发任务的提示词 —— orchestrator.json 的 defaultPrompt（+ 落点项目的 projectPrompts），
+//      和工作台「预设提示词」是**同一份**（同一套读写接口，同一处解析）。
+//      它的原生用途是"派发任务时附加在指令之前"（见 orchestratorStore.resolveDispatchPrompt）；
+//      这里把同一份也喂给对话中的 g ai —— 用户在 g ai 里说的"帮我改完就提交"
+//      本来就依赖这些约束，让它在对话里也看得见。
+//
+// ⚠️ 为什么注入的是**每轮请求副本**而不是会话里的那条 system 消息：
+//   会话的 system 消息只在首轮写入并落盘，之后改设置要新开会话才生效，而且会把
+//   当时的配置永久腌进会话文件（回看历史会话时看到的是过期规则，还占上下文）。
+//   注入请求副本则每轮现读、立即生效、不落盘 —— 与工作区快照/附件路径同一套口径
+//   （见 agentChat.js 的 injectRequestContext）。
+//
+// ⚠️ 解析失败一律当作"没有配置"（返回空串），绝不抛：配置坏了不该让用户发不出消息。
+//   与 workspaceBlock 的兜底口径一致。
+
+import configManager from '../../../../config.js';
+import { logger } from './shared.js';
+import { readOrchestrator, resolveDispatchPrompt } from './orchestratorStore.js';
+
+/**
+ * 拼「用户固定提示词」这一节。
+ *
+ * 纯函数：只吃入参、不做 IO，单测不碰真实用户数据（与 promptParts.js / memoryContext.js
+ * 同一个理由）。取数在 resolveChatPromptSection。
+ *
+ * @param {object} input
+ * @param {string} [input.gaiPrompt]      g ai 默认提示词（'' = 没设）
+ * @param {string} [input.dispatchPrompt] 派发任务提示词（全局 + 落点项目，'' = 没设）
+ * @param {string} [input.locale]         'zh' | 'en' —— 与系统提示词同一套判定
+ * @returns {string} 两块都空时返回 ''（调用方据此完全跳过注入）
+ */
+export function buildChatPromptSection({ gaiPrompt = '', dispatchPrompt = '', locale = 'zh-CN' } = {}) {
+  const gai = typeof gaiPrompt === 'string' ? gaiPrompt.trim() : '';
+  const dispatch = typeof dispatchPrompt === 'string' ? dispatchPrompt.trim() : '';
+  if (!gai && !dispatch) return '';
+
+  const en = String(locale || '').startsWith('en');
+  const parts = [];
+  if (gai) parts.push(`${en ? '### g ai default prompt' : '### g ai 默认提示词'}\n${gai}`);
+  if (dispatch) {
+    // 括号里那句是给模型看的（也是给排查的人看的）：这一块的来源与工作台是同一份，
+    // 不是对话专属的又一份配置 —— 模型据此知道"这些约束在派发出去的任务里同样成立"。
+    parts.push(en
+      ? `### Dispatch prompt (same text attached to tasks dispatched from the workbench)\n${dispatch}`
+      : `### 派发任务的提示词（与工作台派发任务时附加的是同一份）\n${dispatch}`);
+  }
+
+  const head = en
+    ? 'The user configured the following standing instructions in Settings. They apply to every turn of this conversation — follow them alongside your built-in rules.'
+    : '以下是用户在「设置」里配置的固定提示词，对本轮对话生效 —— 请与你的内置规则一并遵守。';
+
+  return `${head}\n\n${parts.join('\n\n')}`;
+}
+
+/** 默认取数：config.json 的 agentDefaultPrompt（读不到 = 空） */
+async function defaultLoadAgentPrompt() {
+  const cfg = await configManager.loadConfig();
+  return typeof cfg?.agentDefaultPrompt === 'string' ? cfg.agentDefaultPrompt : '';
+}
+
+/** 默认取数：orchestrator.json 里按**落点项目**解析出的派发提示词（读不到 = 空） */
+async function defaultLoadDispatchPrompt(cwd) {
+  const state = await readOrchestrator();
+  return resolveDispatchPrompt(state, cwd).text;
+}
+
+/**
+ * 解析一次对话实际要注入的两块提示词。
+ *
+ * @param {object}   input
+ * @param {string}   [input.cwd]    本轮对话的工作目录（决定项目级那条派发提示词生不生效）
+ * @param {string}   [input.locale]
+ * @param {Function} [input.loadAgentPrompt]   注入口（单测用；生产走 config.json）
+ * @param {Function} [input.loadDispatchPrompt] 注入口（同上；生产走 orchestrator.json）
+ * @returns {Promise<string>} 拼好的正文，'' = 不注入
+ */
+export async function resolveChatPromptSection({
+  cwd = '',
+  locale = 'zh-CN',
+  loadAgentPrompt = defaultLoadAgentPrompt,
+  loadDispatchPrompt = defaultLoadDispatchPrompt,
+} = {}) {
+  let gaiPrompt = '';
+  let dispatchPrompt = '';
+  try {
+    gaiPrompt = await loadAgentPrompt();
+  } catch (err) {
+    logger.warn(`[chatPrompts] 读 g ai 默认提示词失败,本轮跳过: ${err?.message || err}`);
+  }
+  try {
+    dispatchPrompt = await loadDispatchPrompt(cwd);
+  } catch (err) {
+    logger.warn(`[chatPrompts] 读派发提示词失败,本轮跳过: ${err?.message || err}`);
+  }
+  return buildChatPromptSection({ gaiPrompt, dispatchPrompt, locale });
+}