zen-gitsync 2.17.27 → 2.17.29

package/src/ui/server/routes/fs.js

@@ -791,12 +791,19 @@ export function registerFsRoutes({
       const resolved = safe.safePath;
       const stat = await fs.stat(resolved);
       if (!stat.isFile()) throw new HttpError(400, '目标不是文件');
+      // meta=1：只回答"盘上这份还是不是客户端手上那份"，不回正文。
+      // 文件空间在窗口重新聚焦 / 切标签 / 切回本视图时用它做一次廉价比对 ——
+      // 一个 stat 就够，不必每个来回都重读整个文件（大文件尤其明显）。
+      if (req.query.meta === '1') {
+        return res.json({ success: true, mtimeMs: stat.mtimeMs, size: stat.size });
+      }
       // 超过 2MB 不读取
       if (stat.size > 2 * 1024 * 1024) {
         return res.json({ success: false, error: '文件过大（> 2 MB），暂不支持在线编辑' });
       }
       const content = await fs.readFile(resolved, 'utf-8');
-      res.json({ success: true, content });
+      // mtimeMs 随正文一起给：客户端拿它当"我手上这份对应盘上哪个版本"的基线
+      res.json({ success: true, content, mtimeMs: stat.mtimeMs });
     } catch (error) {
       res.status(500).json({ success: false, error: error.message });
     }
@@ -915,7 +922,10 @@ export function registerFsRoutes({
       const safe = await safePathInProject(filePath);
       if (!safe) throw new HttpError(403, '禁止写入工作目录以外的文件');
       await fs.writeFile(safe.safePath, content, 'utf-8');
-      res.json({ success: true });
+      // 回写后的 mtime 一并返回：客户端据此推进自己那份比对基线。
+      // 不给的话，下一次聚焦同步会把"自己刚保存的这一笔"误判成外部改动而重载一遍。
+      const after = await fs.stat(safe.safePath);
+      res.json({ success: true, mtimeMs: after.mtimeMs });
     } catch (error) {
       res.status(500).json({ success: false, error: error.message });
     }

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

@@ -40,8 +40,9 @@
 import path from 'node:path';
 import os from 'node:os';
 import { promises as fs } from 'node:fs';
-import { execFile } from 'node:child_process';
+import { execFile, spawn } from 'node:child_process';
 import { promisify } from 'node:util';
+import open from 'open';
 import { asyncRoute, HttpError } from '../../utils/asyncRoute.js';
 import { AI_SKILLS_DIR, AI_MCP_FILE } from '../../../../paths.js';
 
@@ -737,13 +738,77 @@ function npmBinary() {
   return process.platform === 'win32' ? 'npm.cmd' : 'npm';
 }
 
+/**
+ * 扫描 root 下两层内所有含 SKILL.md 的目录。
+ * 集合型仓库很常见(一个仓库十几二十个 skill),必须把全部候选都收上来再挑,
+ * 不能像以前那样"按目录顺序撞见第一个就用"。
+ *
+ * @returns {Promise<Array<{ dir: string, rel: string }>>} rel 用 / 分隔,仓库根为 ''
+ */
+async function collectSkillDirs(root) {
+  const found = [];
+  async function walk(dir, rel, depth) {
+    if (await exists(path.join(dir, 'SKILL.md'))) found.push({ dir, rel });
+    if (depth >= 2) return;
+    const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
+    for (const entry of entries) {
+      // 跳过 .git 与 .claude-plugin 这类点目录:它们不是 skill 本体
+      if (!entry.isDirectory() || entry.name.startsWith('.')) continue;
+      await walk(path.join(dir, entry.name), rel ? `${rel}/${entry.name}` : entry.name, depth + 1);
+    }
+  }
+  await walk(root, '', 0);
+  return found;
+}
+
+/** 目录名归一化:大小写、空格、下划线都抹平,`Taste Skill` 与 `taste-skill` 应当能对上。 */
+function normalizeSkillName(value) {
+  return String(value || '').trim().toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+}
+
+/**
+ * 从候选目录里挑出"用户点的那个 skill"。
+ *
+ * 为什么不能直接取第一个:仓库 `Leonxlnx/taste-skill` 的 `skills/` 下有十几个 skill,
+ * 目录顺序第一个是 `brandkit`。旧逻辑会把 brandkit 装进去,而卡片的 id 仍然记成
+ * `github-Leonxlnx-taste-skill` —— 于是广场卡片显示"已安装",已安装列表里却是
+ * `brandkit` 这个名字,用户根本对不上,只能怀疑"是不是没装成功"。
+ *
+ * @returns {{ dir: string, rel: string } | null} null = 挑不出来(并列歧义),交给调用方报错
+ */
+function pickSkillDir(candidates, { subpath = '', skillName = '' } = {}) {
+  if (!candidates.length) return null;
+  const wantSub = String(subpath || '').replace(/^\.\//, '').replace(/\/+$/, '').toLowerCase();
+  const wantName = normalizeSkillName(skillName);
+
+  const rank = ({ rel }) => {
+    const norm = String(rel).toLowerCase();
+    const base = normalizeSkillName(norm.split('/').pop());
+    if (wantSub && norm === wantSub) return 0;                                    // 条目自己给的就是这个子目录
+    if (wantName && base === wantName) return 1;                                  // 目录名就是用户点的名字
+    if (!rel) return 2;                                                          // 仓库根就是一份 SKILL.md
+    // 名字沾边(如 taste-skill-v1 / taste-skill)。必须卡在 - 边界上:
+    // 用裸 includes 的话,目录 `a` 会被判成 `whatever` 的变体,短名一律乱匹配。
+    if (wantName && base && (
+      base.startsWith(`${wantName}-`) || base.endsWith(`-${wantName}`)
+      || wantName.startsWith(`${base}-`) || wantName.endsWith(`-${base}`)
+    )) return 3;
+    return 4;
+  };
+
+  const ranked = candidates.map(item => ({ ...item, rank: rank(item) })).sort((a, b) => a.rank - b.rank);
+  // 首选并列 → 宁可报错让用户自己说清是哪一个,也不要悄悄装错
+  if (ranked.length > 1 && ranked[1].rank === ranked[0].rank) return null;
+  return ranked[0];
+}
+
 /**
  * 只拉取仓库里的某个子目录。
  * 用 --filter=blob:none --sparse 是为了对付 monorepo ——
  * 直接 --depth 1 全量克隆一个几万文件的仓库只为拿一个 skill 太浪费。
  * sparse 不被支持(旧版 git / 服务端限制)时回落到普通浅克隆。
  */
-async function cloneSubdirectory({ repository, subpath, dest }) {
+async function cloneSubdirectory({ repository, subpath, dest, skillName = '' }) {
   const temp = await fs.mkdtemp(path.join(os.tmpdir(), 'zen-gitsync-skill-'));
   const url = `https://github.com/${repository}.git`;
   try {
@@ -767,29 +832,17 @@ async function cloneSubdirectory({ repository, subpath, dest }) {
       await execFileAsync(gitBinary(), ['clone', '--depth', '1', url, temp], { timeout: CLONE_TIMEOUT_MS, windowsHide: true });
     }
 
-    const requested = subpath ? path.join(temp, subpath) : '';
-    const candidates = [requested, path.join(temp, 'skills'), temp].filter(Boolean);
-    let source = null;
-    for (const candidate of candidates) {
-      if (await exists(path.join(candidate, 'SKILL.md'))) { source = candidate; break; }
+    const candidates = await collectSkillDirs(temp);
+    const picked = pickSkillDir(candidates, { subpath, skillName });
+    if (!picked) {
+      if (!candidates.length) throw new HttpError(422, `仓库 ${repository} 里没有找到 SKILL.md`);
+      const names = candidates.slice(0, 8).map(item => item.rel || '仓库根').join('、');
+      const more = candidates.length > 8 ? ` 等 ${candidates.length} 个` : '';
+      throw new HttpError(422, `仓库 ${repository} 里有多个 skill,且没有一个跟「${skillName || repository}」对得上(${names}${more}),请从具体子目录再装`);
     }
-    // 再退一步:找仓库里任意一层含 SKILL.md 的目录(只扫两层,避免在 monorepo 里乱窜)
-    if (!source) {
-      const top = await fs.readdir(temp, { withFileTypes: true }).catch(() => []);
-      for (const dir of top.filter(entry => entry.isDirectory() && entry.name !== '.git')) {
-        if (await exists(path.join(temp, dir.name, 'SKILL.md'))) { source = path.join(temp, dir.name); break; }
-        const inner = await fs.readdir(path.join(temp, dir.name), { withFileTypes: true }).catch(() => []);
-        let hit = null;
-        for (const sub of inner.filter(entry => entry.isDirectory())) {
-          if (await exists(path.join(temp, dir.name, sub.name, 'SKILL.md'))) { hit = path.join(temp, dir.name, sub.name); break; }
-        }
-        if (hit) { source = hit; break; }
-      }
-    }
-    if (!source) throw new HttpError(422, `仓库 ${repository} 里没有找到 SKILL.md`);
 
     await fs.mkdir(path.dirname(dest), { recursive: true });
-    await fs.cp(source, dest, { recursive: true, force: false });
+    await fs.cp(picked.dir, dest, { recursive: true, force: false });
   } finally {
     await fs.rm(temp, { recursive: true, force: true }).catch(() => {});
   }
@@ -806,7 +859,7 @@ async function installSkill({ item, target, cwd }) {
   const repository = String(item.repository || '').trim().replace(/^https?:\/\/github\.com\//i, '').replace(/\.git$/, '');
   if (repository && SAFE_REPOSITORY.test(repository)) {
     const subpath = item.subpath && isSafeSubpath(item.subpath) ? String(item.subpath) : '';
-    await cloneSubdirectory({ repository, subpath, dest });
+    await cloneSubdirectory({ repository, subpath, dest, skillName: String(item.name || id) });
     return { id, type: 'skill', name: item.name || id, target, dir: dest, source: repository };
   }
 
@@ -893,6 +946,29 @@ async function installMcp({ item, target, cwd }) {
   return { id, type: 'mcp', name: item.name || id, target, file: paths.file, envKeys: missingEnv, warning: installWarning };
 }
 
+/**
+ * 在系统文件管理器里定位一个已安装项:
+ *   目录 → 直接打开;文件(如 .mcp.json)→ 在其中选中它。
+ * Linux 没有"选中文件"的标准接口,退化为打开所在目录。
+ * 与 /api/editor/reveal 同一套行为,只是那个接口只认工作目录以内的路径,
+ * 这里要能定位 ~/.zen-gitsync/ai 下的全局安装项。
+ */
+async function revealInFileManager(resolved) {
+  const stat = await fs.stat(resolved);
+  if (stat.isDirectory()) {
+    await open(resolved, { wait: false });
+    return;
+  }
+  if (process.platform === 'win32') {
+    // explorer.exe /select,<path>(逗号分隔,无双引号,argv 数组防二次解释)
+    spawn('explorer.exe', ['/select,', resolved], { detached: true, stdio: 'ignore' }).unref();
+  } else if (process.platform === 'darwin') {
+    spawn('open', ['-R', resolved], { detached: true, stdio: 'ignore' }).unref();
+  } else {
+    await open(path.dirname(resolved), { wait: false });
+  }
+}
+
 async function uninstall({ type, id, target, cwd }) {
   if (!SAFE_ID.test(id)) throw new HttpError(400, '参数不合法');
   const paths = targetPaths({ type, target, cwd });
@@ -987,6 +1063,33 @@ export function registerAgentMarketplaceRoutes({ app, getCurrentProjectPath }) {
     res.json({ success: true, target, cwd, item: installed });
   }));
 
+  // 在文件管理器里定位已安装项。路径由服务端用同一份 targetPaths 推导,
+  // 前端只传 id —— 不接收任意路径,天然不给出路径穿越的口子。
+  app.post('/api/agent/marketplace/reveal', asyncRoute(async (req, res) => {
+    const type = normalizeType(req.body?.type);
+    if (!type) throw new HttpError(400, '未知扩展类型');
+    const target = normalizeTarget(req.body?.target);
+    const cwd = resolveProjectPath(req.body?.cwd, getCurrentProjectPath?.());
+    const id = String(req.body?.id || '');
+    if (type === 'skill' && !SAFE_ID.test(id)) throw new HttpError(400, '参数不合法');
+    if (type === 'mcp' && id && !SAFE_ID.test(id)) throw new HttpError(400, '参数不合法');
+
+    const paths = targetPaths({ type, target, cwd });
+    let resolved;
+    if (type === 'skill') {
+      const root = path.resolve(paths.root);
+      resolved = path.resolve(root, id);
+      if (!resolved.startsWith(`${root}${path.sep}`)) throw new HttpError(400, '路径不合法');
+    } else {
+      // MCP 没有独立目录,定位到配置文件本身(在其中选中)
+      resolved = path.resolve(paths.file);
+    }
+    if (!(await exists(resolved))) throw new HttpError(404, '目标不存在');
+
+    await revealInFileManager(resolved);
+    res.json({ success: true, type, target, path: resolved });
+  }));
+
   app.delete('/api/agent/marketplace/item/:type/:id', asyncRoute(async (req, res) => {
     const type = normalizeType(req.params.type);
     if (!type) throw new HttpError(400, '未知扩展类型');
@@ -998,3 +1101,7 @@ export function registerAgentMarketplaceRoutes({ app, getCurrentProjectPath }) {
     res.json({ success: true, ...result });
   }));
 }
+
+// 给回归测试用:集合型仓库"装哪一个"的挑选逻辑必须能被单独钉住
+// (真跑一遍 git clone 要联网,测试里不现实)
+export { pickSkillDir, collectSkillDirs };

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

@@ -37,7 +37,7 @@ process.env.HOME = sandboxHome;
 delete process.env.HOMEDRIVE;
 delete process.env.HOMEPATH;
 
-const { registerAgentMarketplaceRoutes } = await import('./agentMarketplace.js');
+const { registerAgentMarketplaceRoutes, pickSkillDir, collectSkillDirs } = await import('./agentMarketplace.js');
 const { AI_SKILLS_DIR, AI_MCP_FILE } = await import('../../../../paths.js');
 
 // ── 测试脚手架:把注册的 handler 抓出来直接调 ──────────────────
@@ -336,3 +336,70 @@ test('install: 项目不存在时拒绝,不会把 .claude/skills 建到奇怪的
   assert.equal(status, 400);
   assert.match(payload.error, /项目目录不存在/);
 });
+
+// ── 集合型仓库"装哪一个" ────────────────────────────────────────
+// 踩过的坑:Leonxlnx/taste-skill 的 skills/ 下第一个是 brandkit,
+// 旧逻辑"按目录顺序撞见第一个含 SKILL.md 的就装" → 点 taste-skill 装成 brandkit。
+// 卡片 id 仍是 github-Leonxlnx-taste-skill 所以显示"已安装",
+// 已安装列表里却是 brandkit 这个名字,用户根本对不上,只能怀疑没装成功。
+
+test('pickSkillDir: 候选里挑与条目同名的那个,不取目录顺序第一个', () => {
+  const candidates = [
+    { dir: 'T/skills/brandkit', rel: 'skills/brandkit' },
+    { dir: 'T/skills/taste-skill', rel: 'skills/taste-skill' },
+    { dir: 'T/skills/taste-skill-v1', rel: 'skills/taste-skill-v1' },
+  ];
+  assert.equal(pickSkillDir(candidates, { skillName: 'taste-skill' }).rel, 'skills/taste-skill');
+});
+
+test('pickSkillDir: 条目给了子目录时以子目录为准,名字对得上也不用', () => {
+  const candidates = [
+    { dir: 'T/skills/taste', rel: 'skills/taste' },
+    { dir: 'T/skills/taste-skill', rel: 'skills/taste-skill' },
+  ];
+  assert.equal(pickSkillDir(candidates, { subpath: 'skills/taste', skillName: 'taste-skill' }).rel, 'skills/taste');
+});
+
+test('pickSkillDir: 名字对不上且候选并列时返回 null(报错,而不是猜一个)', () => {
+  const candidates = [
+    { dir: 'T/alpha', rel: 'alpha' },
+    { dir: 'T/beta', rel: 'beta' },
+  ];
+  assert.equal(pickSkillDir(candidates, { skillName: 'whatever' }), null);
+});
+
+test('pickSkillDir: 短目录名不会被裸 includes 误判成变体', () => {
+  const only = [{ dir: 'T/a', rel: 'a' }];
+  // wantName='whatever' 包含子串 'a',裸 includes 会把它当 rank 3 命中
+  assert.equal(pickSkillDir([...only, { dir: 'T/b', rel: 'b' }], { skillName: 'whatever' }), null);
+  assert.equal(pickSkillDir(only, { skillName: 'whatever' }).rel, 'a');
+});
+
+test('pickSkillDir: 仓库根就一份 SKILL.md 时优先于没名字的深层目录', () => {
+  const candidates = [
+    { dir: 'T/sub/other', rel: 'sub/other' },
+    { dir: 'T', rel: '' },
+  ];
+  assert.equal(pickSkillDir(candidates, { skillName: 'anything' }).rel, '');
+});
+
+test('pickSkillDir: 没有候选时返回 null(调用方报"仓库里没有 SKILL.md")', () => {
+  assert.equal(pickSkillDir([], { skillName: 'x' }), null);
+});
+
+test('collectSkillDirs: 收两层以内的 SKILL.md,跳过 .git 与点目录', async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'zen-mp-collect-'));
+  const write = async rel => {
+    await fs.mkdir(path.join(root, rel), { recursive: true });
+    await fs.writeFile(path.join(root, rel, 'SKILL.md'), `---\nname: ${path.basename(rel)}\n---\n`, 'utf8');
+  };
+  await write('skills/brandkit');
+  await write('skills/deep/nested/too-deep');
+  await write('.claude-plugin');
+  await fs.mkdir(path.join(root, '.git'), { recursive: true });
+  await fs.writeFile(path.join(root, '.git', 'SKILL.md'), 'not a skill', 'utf8');
+  await fs.writeFile(path.join(root, 'README.md'), '# x', 'utf8');
+
+  const rels = (await collectSkillDirs(root)).map(item => item.rel).sort();
+  assert.deepEqual(rels, ['skills/brandkit']);
+});

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

@@ -39,6 +39,25 @@
 // 不经过前端 $t()，也不会显示在界面上。反过来说，它也不该跟着界面语言变 ——
 // 中文指令配中文上下文，模型理解得更稳。
 //
+// ── 为什么续聊轮要精简（`compact`）────────────────────────────────────────
+//
+// 续接一轮对话时，prompt = [环境块][记忆块][用户这一轮说的话]。而续接走的是 CLI 自己的
+// 会话恢复（claude `--resume` / opencode `--session` / codex `exec resume`），上一轮那份
+// **完整**环境块已经在会话历史里 —— 整块再发一遍，信息上是纯重复。
+//
+// 实测（本机 jobs.json，2026-09-30）：一条续接轮的 prompt 是
+//   环境块 2118~2200 字符 + 记忆块 424 字符 + 用户原话 44 字符
+// 也就是 98% 是重发的背景。代价有两处：一是每轮多烧约两千 token，而且它在**会话尾部**
+// （不是前缀），命不中前缀缓存；二是 job.prompt 会被前端当成用户气泡渲染
+// （useWorkbenchSimpleConversation.ts）—— 聊天记录里每续一轮就多一份一模一样的项目清单，
+// 打开一条跑过多轮的任务，第一屏全是它（WorkbenchView.vue 里那条"钉到底部"的注释同源）。
+//
+// 但**不能整块砍掉**：块里有真正会变的东西（看板计数、正在执行几个、项目增减），
+// 而且会话被压缩/裁剪之后那块背景可能真的不在了。所以续聊轮发的是这个"精简刷新版"：
+// 只留 当前项目 + 合计概览 + 真相源路径，项目清单与用户偏好交给前文
+// （引导语里点名"克隆优先 SSH"，免得那条行为约定被彻底忘掉）。
+// 记忆块是同一套思路，见 taskRunner.js 的 `capture: !resumeSessionId`。
+//
 // 纯函数：只吃入参、不读文件（取数在 workbench/index.js，数据在快照里）。
 // 这样单测不用碰真实用户数据 —— 与 promptParts.js 同一个理由。
 
@@ -70,6 +89,8 @@ const columnLabels = TASK_COLUMNS.map(k => COLUMN_LABELS[k] || k);
  * @param {object}   [input.truthFiles] { tasksFile, jobsFile, orchestratorFile, configFile }
  *                                      路径口径的唯一来源见 workbench/shared.js 的 TRUTH_FILES
  * @param {number}   [input.maxProjects] 只影响列出条数，不影响合计统计
+ * @param {boolean}  [input.compact]  续聊轮的精简刷新版：只留 当前项目 + 合计概览 + 真相源，
+ *                                    项目清单与用户偏好交给会话前文（见文件头那一节）
  * @returns {string} 上下文块。**不返回 null** —— 见下面的注释。
  */
 export function buildEnvContextBlock({
@@ -77,6 +98,7 @@ export function buildEnvContextBlock({
   board = null,
   truthFiles = {},
   maxProjects = ENV_CONTEXT_MAX_PROJECTS,
+  compact = false,
 } = {}) {
   const list = Array.isArray(board?.projects) ? board.projects.filter(p => p && p.key) : [];
   const statsByKey = (board?.statsByKey && typeof board.statsByKey === 'object') ? board.statsByKey : {};
@@ -90,24 +112,33 @@ export function buildEnvContextBlock({
   const currentKey = canonicalProjectPath(currentProjectPath);
 
   const lines = [];
-  lines.push('[运行环境 · 由 zen-gitsync 多项目编排台自动注入，不是用户输入的内容]');
+  // 首行前缀 `[运行环境` 是探针的锚点（scripts/verify-workbench-env-context.mjs
+  // 断言 prompt.startsWith('[运行环境')），精简版也照旧以它开头。
+  lines.push(compact
+    ? '[运行环境 · 由 zen-gitsync 多项目编排台自动注入，不是用户输入的内容 · 续聊轮精简刷新，完整项目清单与用户偏好见本会话前文]'
+    : '[运行环境 · 由 zen-gitsync 多项目编排台自动注入，不是用户输入的内容]');
   lines.push('');
   lines.push(`当前任务所在项目（也是你的工作目录）: ${currentProjectPath || '(未指定)'}`);
   lines.push('');
 
   if (list.length > 0) {
-    const limit = Number.isFinite(maxProjects) && maxProjects > 0 ? Math.floor(maxProjects) : ENV_CONTEXT_MAX_PROJECTS;
-    const shown = list.slice(0, limit);
-    lines.push(`项目清单（共 ${list.length} 个；格式: 名称 | 路径 | ${columnLabels.join('/')}）:`);
-    for (const p of shown) {
-      const s = statsByKey[p.key] || {};
-      const mark = currentKey && p.key === currentKey ? '  ← 当前' : '';
-      lines.push(`- ${p.name || p.key} | ${p.path} | ${TASK_COLUMNS.map(k => s[k] || 0).join('/')}${mark}`);
-    }
-    if (list.length > shown.length) {
-      lines.push(`- …还有 ${list.length - shown.length} 个未列出（读下面的文件可以看全）`);
+    // 项目清单整段只在首轮发。它占这块的 90%（19 个项目 ≈ 1300 字符）却几乎不变，
+    // 续聊轮再发一遍等于把同一张表贴在对话里（见文件头）。
+    if (!compact) {
+      const limit = Number.isFinite(maxProjects) && maxProjects > 0 ? Math.floor(maxProjects) : ENV_CONTEXT_MAX_PROJECTS;
+      const shown = list.slice(0, limit);
+      lines.push(`项目清单（共 ${list.length} 个；格式: 名称 | 路径 | ${columnLabels.join('/')}）:`);
+      for (const p of shown) {
+        const s = statsByKey[p.key] || {};
+        const mark = currentKey && p.key === currentKey ? '  ← 当前' : '';
+        lines.push(`- ${p.name || p.key} | ${p.path} | ${TASK_COLUMNS.map(k => s[k] || 0).join('/')}${mark}`);
+      }
+      if (list.length > shown.length) {
+        lines.push(`- …还有 ${list.length - shown.length} 个未列出（读下面的文件可以看全）`);
+      }
+      lines.push('');
     }
-    lines.push('');
+    // 计数概览是这块里**真正会变**的部分，首轮与续聊轮都发
     lines.push(
       `看板任务概览：全部项目合计 ${total.total || 0} 条 —— ` +
       TASK_COLUMNS.map(k => `${COLUMN_LABELS[k]} ${total[k] || 0}`).join(' / ') +
@@ -122,27 +153,36 @@ export function buildEnvContextBlock({
     lines.push('');
   }
 
-  // 用户偏好（见文件头）。放在"读文件"之前、"看板概览"之后 ——
-  // 它是**行为**约定，与上面的事实清单分开；压尾的那句仍是"去读文件"，
-  // 那是整块上下文里最需要被记住的动作。
-  lines.push(
-    '用户偏好：克隆仓库 / 添加远端时**优先使用 SSH**（https 地址先换算成 ' +
-    'git@github.com:owner/repo.git，Gitee 同理 git@gitee.com:owner/repo.git —— ' +
-    '走 https 会弹凭据窗口，把任务停在半路等用户输账号密码）。' +
-    '只有 SSH 不可用（Permission denied (publickey) / Host key verification failed）' +
-    '才退回 https，并说明这次走的是 https。',
-  );
-  lines.push('');
-  lines.push('需要细节时直接读这些文件（本机绝对路径，你有读取权限，不必先问用户）:');
+  if (compact) {
+    // 引导语替掉整段用户偏好，但**点名**那条行为约定：偏好本身不重述（前文有），
+    // 可"有这么一条"得让模型看得见，否则克隆仓库时它会退回 https。
+    lines.push('需要完整项目清单 / 进展细节时（含「克隆优先 SSH」偏好），直接读这些文件（本机绝对路径，你有读取权限，不必先问用户）:');
+  } else {
+    // 用户偏好（见文件头）。放在"读文件"之前、"看板概览"之后 ——
+    // 它是**行为**约定，与上面的事实清单分开；压尾的那句仍是"去读文件"，
+    // 那是整块上下文里最需要被记住的动作。
+    lines.push(
+      '用户偏好：克隆仓库 / 添加远端时**优先使用 SSH**（https 地址先换算成 ' +
+      'git@github.com:owner/repo.git，Gitee 同理 git@gitee.com:owner/repo.git —— ' +
+      '走 https 会弹凭据窗口，把任务停在半路等用户输账号密码）。' +
+      '只有 SSH 不可用（Permission denied (publickey) / Host key verification failed）' +
+      '才退回 https，并说明这次走的是 https。',
+    );
+    lines.push('');
+    lines.push('需要细节时直接读这些文件（本机绝对路径，你有读取权限，不必先问用户）:');
+  }
   if (truthFiles.tasksFile) lines.push(`- ${truthFiles.tasksFile} —— 全部任务全文（标题/描述/子任务状态/报错/projectPath）`);
   if (truthFiles.jobsFile) lines.push(`- ${truthFiles.jobsFile} —— 历次执行记录（状态与输出）`);
   if (truthFiles.orchestratorFile) lines.push(`- ${truthFiles.orchestratorFile} —— 用户在调度台发过的指令流水`);
   if (truthFiles.configFile) lines.push(`- ${truthFiles.configFile} —— 应用配置（projects / recentDirectories）`);
-  lines.push('');
-  lines.push(
-    '用户问到"我有哪些项目""某件事进展如何"这类问题时，先读上面的文件再回答；' +
-    '不要凭当前目录猜测，也不要回答"我看不到/无法访问"。',
-  );
+  // 压尾那句"先读文件再回答"只在首轮讲：续聊轮上面那句引导语已经说了同一件事
+  if (!compact) {
+    lines.push('');
+    lines.push(
+      '用户问到"我有哪些项目""某件事进展如何"这类问题时，先读上面的文件再回答；' +
+      '不要凭当前目录猜测，也不要回答"我看不到/无法访问"。',
+    );
+  }
 
   return lines.join('\n');
 }

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

@@ -260,3 +260,71 @@ test('真相源清单来自唯一的 TRUTH_FILES（四个路径一个不落，
   assert.ok(block.includes(TRUTH_FILES.orchestratorFile));
   assert.match(block, /调度台发过的指令流水/);
 });
+
+// ── 续聊轮精简版（compact）──────────────────────────────────────────────
+//
+// 续接走的是 CLI 自己的会话恢复（claude --resume / opencode --session / codex exec resume），
+// 上一轮那份**完整**块已在会话历史里 —— 续聊轮再发一遍就是纯重复。实测一条续接轮 prompt：
+// 环境块 2118~2200 字符 + 记忆块 424 字符 + 用户原话 44 字符（本机 jobs.json，2026-09-30）。
+//
+// 这组守四件事：
+//   1. 项目清单真的不再发（它占这块 90%，且几乎不变）；
+//   2. 会变的那部分（合计概览、当前项目）还在 —— 精简不等于把刷新能力也砍了；
+//   3. 真相源路径照给：会话被压缩后靠它重新够得着数据；
+//   4. 首行锚点不变（scripts/verify-workbench-env-context.mjs 断言 startsWith('[运行环境')）。
+//
+// 数字口径一栏用"两种模式必须给出同一组计数"来守：精简是**裁剪**，不是另算一份。
+
+const richBoard = () => {
+  // 项目数刻意贴近真实规模（用户本机 19 个）：清单的"贵"是随项目数线性涨的，
+  // 只放两三个项目的夹具量不出"精简到底省了多少"（这条正是 compact 的存在理由）。
+  const recentDirs = ['D:\\ws\\zen-gitsync', 'D:\\ws\\article-generator'];
+  const tasks = [
+    { id: 't1', projectPath: 'D:\\ws\\zen-gitsync', type: 'simple' },
+    { id: 't2', projectPath: 'D:\\ws\\article-generator', type: 'simple' },
+    { id: 't3', projectPath: 'D:\\ws\\article-generator', type: 'simple' },
+  ];
+  for (let i = 0; i < 17; i += 1) recentDirs.push(`D:\\ws\\filler${i}`);
+  return boardOf({ recentDirs, tasks, jobs: [job('j1', 't1', 'done'), job('j2', 't2', 'running')] });
+};
+
+test('compact 不再发项目清单，但保留当前项目与合计概览', () => {
+  const board = richBoard();
+  const full = build({ currentProjectPath: 'D:\\ws\\zen-gitsync', board });
+  const compact = build({ currentProjectPath: 'D:\\ws\\zen-gitsync', board, compact: true });
+
+  // ① 清单行没了 —— 连"还有 N 个未列出"这种残余也不能留（模型会以为清单被截断）
+  assert.doesNotMatch(compact, /项目清单（共 \d+ 个/);
+  assert.doesNotMatch(compact, /^- .+ \| .+ \| \d+\/\d+\/\d+/m);
+  assert.doesNotMatch(compact, /还有 \d+ 个未列出/);
+  // 另一个项目（没在当前项目栏里出现过的）整体不该出现在精简块里
+  assert.ok(!compact.includes('D:\\ws\\article-generator'), '精简块不该再列其它项目');
+
+  // ② 会变的部分还在，而且数字与完整版**逐字相同**（同一次取数、两种裁剪）
+  const overview = full.match(/看板任务概览：全部项目合计 [^\n]+/)[0];
+  assert.ok(compact.includes(overview), `精简块应原样保留合计概览:\n${compact}`);
+  assert.match(compact, /全部项目合计 3 条/);
+  assert.match(compact, /正在执行 1 个/);
+  assert.match(compact, /当前任务所在项目（也是你的工作目录）: D:\\ws\\zen-gitsync/);
+
+  // ③ 真相源路径照给（会话被压缩后靠它重新够得着数据）
+  for (const p of Object.values(TRUTH_FILES)) assert.ok(compact.includes(p), `缺少路径 ${p}`);
+  // 用户偏好不重述，但要点名"有这么一条" —— 少这一句，克隆仓库时会退回 https
+  assert.match(compact, /克隆优先 SSH/);
+
+  // ④ 首行锚点（探针依赖）与完整版同前缀
+  assert.ok(compact.startsWith('[运行环境'));
+  assert.ok(full.startsWith('[运行环境'));
+
+  // ⑤ 真省：精简块不到完整版的一半
+  assert.ok(compact.length * 2 < full.length, `精简块应显著更短: compact=${compact.length} full=${full.length}`);
+});
+
+test('compact 在取不到 board 时也照给真相源（且不返回空）', () => {
+  const compact = build({ currentProjectPath: 'D:\\ws\\a', board: null, compact: true });
+  assert.ok(compact, '精简版同样不返回 null');
+  for (const p of Object.values(TRUTH_FILES)) assert.ok(compact.includes(p), `缺少路径 ${p}`);
+  assert.match(compact, /项目清单：本次未能取到/);
+  // 没有清单时更不该出现"清单行"的残影
+  assert.doesNotMatch(compact, /^- .+ \| .+ \| \d+\/\d+\/\d+/m);
+});

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

@@ -692,7 +692,12 @@ ${subSummaries.map((s, i) => `\n### [${i + 1}] ${s.name} (${s.root})\n${s.summar
       promptOverride: userMessage,
       attachments: carryAtts
     };
-    const repoPath = typeof getCurrentProjectPath === 'function' ? getCurrentProjectPath() : '';
+    // 工作目录口径必须与「执行任务」那条路一致：**任务自己的项目优先**，没有才回落当前项目
+    // （resolveTaskRepoPath）。这里以前直接用 getCurrentProjectPath()，于是"在 B 项目里打开
+    // A 项目的任务续聊"会把 CLI spawn 到 B（甚至空路径 → process.cwd()，即服务器所在的仓库）：
+    // 续接的这轮在错误的工作区里干活，而 --resume 又把上下文带过来了，症状很隐蔽。
+    // 2026-09-30 由 verify:wb-env-context 第 8 组抓到（续聊轮的 prompt 里出现的不是任务的项目）。
+    const repoPath = resolveTaskRepoPath(task, typeof getCurrentProjectPath === 'function' ? getCurrentProjectPath() : '');
     res.json({ success: true, message: '已加入续接队列' });
     // 执行器必须沿用上一轮 job 的 agent：claude 的 --resume 和 opencode 的 --session
     // 互不认对方的会话 id，串了执行器续接必然失败。
@@ -1125,13 +1130,13 @@ ${subSummaries.map((s, i) => `\n### [${i + 1}] ${s.name} (${s.root})\n${s.summar
    * 而快照生成器在服务端入口创建、注册顺序在它之前就已经建好了 —— 但两者是同一次装配，
    * 用 getter 可以避免"必须记得按某个顺序注册"这种隐性契约。
    */
-  setEnvContextProvider(async ({ repoPath } = {}) => {
+  setEnvContextProvider(async ({ repoPath, compact } = {}) => {
     const snapshotter = typeof getAiContextSnapshotter === 'function' ? getAiContextSnapshotter() : null;
 
     if (!snapshotter || typeof snapshotter.refreshSections !== 'function') {
       // 快照生成器没装配上（理论上不会发生）。至少把**不需要取数**的两样递进去：
       // 用户偏好与真相源路径 —— 前者少一次就会让任务卡在 https 凭据窗口上。
-      return buildEnvContextBlock({ currentProjectPath: repoPath || '', truthFiles: TRUTH_FILES });
+      return buildEnvContextBlock({ currentProjectPath: repoPath || '', truthFiles: TRUTH_FILES, compact });
     }
 
     try {
@@ -1155,6 +1160,8 @@ ${subSummaries.map((s, i) => `\n### [${i + 1}] ${s.name} (${s.root})\n${s.summar
       currentProjectPath: repoPath || '',
       board,
       truthFiles: TRUTH_FILES,
+      // 续聊轮走精简刷新版（调用方 taskRunner 按 resumeSessionId 判定）
+      compact,
     });
   });
 

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

@@ -69,7 +69,9 @@ let envContextProvider = null;
 
 /**
  * 注册运行环境上下文的提供者。由 routes/workbench/index.js 在注册路由时调用。
- * @param {(ctx: {repoPath: string}) => Promise<string|null>|string|null} fn
+ * @param {(ctx: {repoPath: string, compact?: boolean}) => Promise<string|null>|string|null} fn
+ *        `compact: true` = 续聊轮，只要精简刷新版（完整清单上一轮已进过 prompt）。
+ *        接不接这个字段由提供者自己决定：不接就等于每轮都发整块 —— 老行为，不会报错。
  */
 export function setEnvContextProvider(fn) {
   envContextProvider = typeof fn === 'function' ? fn : null;
@@ -78,13 +80,17 @@ export function setEnvContextProvider(fn) {
 /**
  * 取本次执行的运行环境上下文块。
  *
+ * 续聊轮（`resumeSessionId` 有值）传 `compact: true` 只要精简刷新版：完整环境块上一轮
+ * 就在 prompt 里了，CLI 的会话恢复会把它带回来，整块重发是纯重复
+ * （实测数据与理由见 envContext.js 文件头）。
+ *
  * 提供者抛错一律降级成"没有上下文"：读 tasks.json 失败、配置竞态都是可能发生的，
  * 但它们都不该让用户的指令执行不了 —— 与「读不到最近目录不该让整个看板挂掉」同一条原则。
  */
-async function resolveEnvContext(repoPath) {
+async function resolveEnvContext(repoPath, { compact = false } = {}) {
   if (!envContextProvider) return '';
   try {
-    const block = await envContextProvider({ repoPath: repoPath || '' });
+    const block = await envContextProvider({ repoPath: repoPath || '', compact: !!compact });
     return typeof block === 'string' ? block : '';
   } catch (err) {
     logger.warn(`[workbench] 运行环境上下文注入失败，本次跳过: ${err.message}`);
@@ -917,7 +923,8 @@ export async function runSingleSubtask(task, sub, repoPath, branch, options) {
   const prefixBlocks = [];
 
   if (task.envContext !== false) {
-    const envBlock = await resolveEnvContext(repoPath);
+    // 续聊轮只要精简刷新版（见 resolveEnvContext 的注释）
+    const envBlock = await resolveEnvContext(repoPath, { compact: !!resumeSessionId });
     if (envBlock) prefixBlocks.push(envBlock);
   }
 

package/src/ui/public/assets/AgentEngineSelector-BUZYAFe-.js

@@ -1,2 +0,0 @@
-import"./rolldown-runtime-C0FnF6B9.js";import{$ as e,C as t,Cn as n,Dn as r,En as i,Fr as a,Jn as o,Jr as s,K as c,Kn as l,Mn as u,Pn as d,Qn as f,Rn as p,S as m,Tn as h,Un as g,Xn as _,br as v,cr as y,ei as b,pr as x,q as S,w as C,wn as w,yn as T}from"./element-plus-AaVXaSqv.js";import{n as E,t as D}from"./_plugin-vue_export-helper-DRfZJqP7.js";import{t as O}from"./SvgIcon-22vrNtgL.js";import{t as k}from"./toolsStore-B3bFcRXP.js";import{s as A,v as j}from"./index-EJrJOx7s.js";import{c as M,d as N,l as P,u as F}from"./agentConversations-17Pw5IQJ.js";p(),x();function I(e,t=680){let r=v(0),i=null;function a(){let t=e.value;return t?(r.value=t.clientWidth,typeof ResizeObserver>`u`||(i=new ResizeObserver(e=>{let t=e[0]?.contentRect?.width;typeof t==`number`&&(r.value=t)}),i.observe(t),!0)):!1}return o(()=>{a()||g(()=>a())}),l(()=>{i?.disconnect(),i=null}),{width:r,narrow:n(()=>r.value>0&&r.value<t)}}p(),x();var L=d({__name:`AgentEngineSelector`,props:{engine:{type:String,required:!0},locked:{type:Boolean,required:!1}},emits:[`select`],setup(r,{expose:i,emit:a}){i();let o=r,s=a,l=k(),u=n(()=>F(o.engine)),d=n(()=>({gai:!0,claude:l.claudeAvailable,opencode:l.opencodeAvailable,codex:l.codexAvailable})),f=v(!1),p=v(null);function h(e){if(!o.locked){if(!d.value[e]){if(!N(e))return;p.value=e,f.value=!0;return}s(`select`,e)}}let g={props:o,emit:s,toolsStore:l,engineName:u,engineAvailability:d,installDialogVisible:f,installTool:p,onCommand:h,get $t(){return E},get ElIcon(){return c},get ElDropdown(){return m},get ElDropdownMenu(){return C},get ElDropdownItem(){return t},get ArrowDown(){return S},get Check(){return e},get AGENT_ENGINE_OPTIONS(){return M},get BUILTIN_ENGINE_ICON(){return P},get isExternalAgentEngine(){return N},SvgIcon:O,TaskExecutorIcon:A,ToolInstallDialog:j};return Object.defineProperty(g,"__isScriptSetup",{enumerable:!1,value:!0}),g}});p(),a();var R={class:`agent-engine`},z=[`disabled`,`title`,`aria-label`],B={class:`agent-engine__name`},V={class:`agent-engine__item`},H={class:`agent-engine__item-name`},U={key:3,class:`agent-engine__item-missing`};function W(e,t,n,a,o,c){return _(),r(T,null,[i(` 单根包一层：父级传下来的 class（Tab 行的 margin-left:auto、面板的 flex:none）
-       才能可靠落到这里 —— 多根组件会丢掉 fallthrough class。 `),w(`div`,R,[u(a.ElDropdown,{trigger:`click`,onCommand:a.onCommand},{dropdown:y(()=>[u(a.ElDropdownMenu,null,{default:y(()=>[(_(!0),r(T,null,f(a.AGENT_ENGINE_OPTIONS,e=>(_(),h(a.ElDropdownItem,{key:e.id,command:e.id},{default:y(()=>[w(`span`,V,[a.isExternalAgentEngine(e.id)?(_(),h(a.TaskExecutorIcon,{key:0,executor:e.id,class:`agent-engine__item-icon`},null,8,[`executor`])):(_(),h(a.SvgIcon,{key:1,"icon-class":a.BUILTIN_ENGINE_ICON,class:`agent-engine__item-icon`},null,8,[`icon-class`])),w(`span`,H,b(e.name),1),n.engine===e.id?(_(),h(a.ElIcon,{key:2,class:`agent-engine__item-check`},{default:y(()=>[u(a.Check)]),_:1})):a.engineAvailability[e.id]?i(`v-if`,!0):(_(),r(`span`,U,b(a.$t(`@42BB9:未安装`)),1))])]),_:2},1032,[`command`]))),128))]),_:1})]),default:y(()=>[w(`button`,{type:`button`,class:s([`agent-engine__btn`,{"is-locked":n.locked}]),disabled:n.locked,title:n.locked?a.$t(`@AGENT:本会话的引擎已锁定；要换引擎请新建会话`):a.$t(`@AGENT:新建会话使用的引擎`),"aria-label":a.$t(`@AGENT:智能体引擎`)},[a.isExternalAgentEngine(n.engine)?(_(),h(a.TaskExecutorIcon,{key:0,executor:n.engine,class:`agent-engine__icon`},null,8,[`executor`])):(_(),h(a.SvgIcon,{key:1,"icon-class":a.BUILTIN_ENGINE_ICON,class:`agent-engine__icon`},null,8,[`icon-class`])),w(`span`,B,b(a.engineName),1),u(a.ElIcon,{class:`agent-engine__caret`},{default:y(()=>[u(a.ArrowDown)]),_:1})],10,z)]),_:1}),u(a.ToolInstallDialog,{modelValue:a.installDialogVisible,"onUpdate:modelValue":t[0]||=e=>a.installDialogVisible=e,tool:a.installTool},null,8,[`modelValue`,`tool`])])],2112)}var G=D(L,[[`render`,W],[`__scopeId`,`data-v-c67a4d14`],[`__file`,`C:/workspace/github_workspace/xz333221/zen-gitsync/src/ui/client/src/components/AgentEngineSelector.vue`]]);export{I as n,G as t};