zen-gitsync 2.17.16 → 2.17.18

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

@@ -12,33 +12,37 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 //
-// 执行时注入给 Agent 的「运行环境上下文」。
+// 执行时注入给 Agent 的「运行环境上下文」——**多项目编排台视角**。
 //
 // 解决什么问题：从主 Agent 调度台发出去的指令，最终 prompt 只是用户原文
 // + 附件清单（拼装见 promptParts.js），cwd 之外的项目、看板进度、历史指令
 // 一概不在里面。于是用户问"我的项目有哪些"，Agent 只能就着当前目录猜 ——
 // 而数据其实全在本机，只是没人告诉它路径。
 //
-// 这里做三件事，缺一不可：
-//   1. 给**摘要** —— 项目清单 + 各列任务计数（顺着看板口径，一眼看到进度）；
-//   2. 给**真相源文件路径** —— 要细节自己去读；
-//   3. 给**用户偏好** —— 克隆仓库优先 SSH。这一条不是"运行环境"的事实，而是工作台任务的
-//      Agent 是外部 CLI（claude / opencode），系统提示词不归我们写 —— 这里是唯一能把偏好
-//      递进去的地方。少这一句，任务里克隆仓库就会退回 https，弹凭据窗口把任务停住。
-// 刻意不把 tasks.json 全文塞进 prompt：几十条任务、每条还挂着执行输出，
-// 既烧 token，又会把用户真正要办的那句话淹掉。
+// ── 与 aiContext 的关系（两条视图、一个口径）────────────────────────────
+//
+// 数据**不在这里取**。项目清单 / 各列计数 / 合计 / 真相源路径全部来自
+// aiContext 的 `tasks` 板块（collectors.js 的 collectWorkbenchTasks），本文件
+// 只负责把它渲染成"编排台视角"该有的样子：
+//   · 标出**当前任务属于哪个项目**（`← 当前`）—— 派发出来的任务知道自己是谁，
+//     这一点在七个板块那份视图里没有；
+//   · 带上**用户偏好**（克隆优先 SSH）；
+//   · 真相源清单里多一个 orchestrator.json（调度台指令流水）。
+//
+// 为什么不各自算一遍：以前这里自己读 tasks.json + 最近目录 + 任务分列，与
+// aiContext 的 tasks 板块是**同一份统计的第二份实现**。两份实现走同一天开始分叉：
+// 改一处漏一处不会报错，只会让 Agent 在编排台里和在智能体页里看到**不同的项目数**。
+// 现在只有 collectWorkbenchTasks 一份。
 //
 // ⚠️ 文案为什么可以是中文硬编码（与 orchestratorStore 的「服务端不写死中文」不冲突）：
 // 那一条约束针对的是**回给 UI 渲染的文案**，而这里是喂给模型的 prompt 内容，
 // 不经过前端 $t()，也不会显示在界面上。反过来说，它也不该跟着界面语言变 ——
 // 中文指令配中文上下文，模型理解得更稳。
 //
-// 纯函数：只吃入参、不读文件（文件读取在调用方 routes/workbench/index.js）。
+// 纯函数：只吃入参、不读文件（取数在 workbench/index.js，数据在快照里）。
 // 这样单测不用碰真实用户数据 —— 与 promptParts.js 同一个理由。
-// 统计口径复用 projectRegistry 的 summarizeProjectTasks：「任务算哪一列」
-// 全局只有这一个实现，看板怎么分列，这里就怎么统计。
 
-import { summarizeProjectTasks, canonicalProjectPath, TASK_COLUMNS } from './projectRegistry.js';
+import { canonicalProjectPath, TASK_COLUMNS } from './projectRegistry.js';
 
 /** 项目清单最多列几个：再多就该让 Agent 自己去读文件，而不是往 prompt 里堆 */
 export const ENV_CONTEXT_MAX_PROJECTS = 30;
@@ -60,45 +64,25 @@ const columnLabels = TASK_COLUMNS.map(k => COLUMN_LABELS[k] || k);
  *
  * @param {object}   input
  * @param {string}   input.currentProjectPath 本次任务的工作目录（= Agent 的 cwd）
- * @param {object[]} input.projects 项目条目（buildProjectEntries 的输出：{name, path, key}）
- * @param {object[]} input.tasks    tasks.json 里的全部任务
- * @param {object[]} input.jobs     执行记录（snapshotJobs() 的结果）
- * @param {string}   input.tasksFile        真相源文件绝对路径（下面几个同理）
- * @param {string}   input.jobsFile
- * @param {string}   input.orchestratorFile
- * @param {string}   input.configFile
+ * @param {object}   [input.board]    aiContext `tasks` 板块的结构化数据
+ *                                    （{ projects, statsByKey, total, runningJobs }）。
+ *                                    取不到时项目那一段整体省掉，但偏好与真相源照给。
+ * @param {object}   [input.truthFiles] { tasksFile, jobsFile, orchestratorFile, configFile }
+ *                                      路径口径的唯一来源见 workbench/shared.js 的 TRUTH_FILES
  * @param {number}   [input.maxProjects] 只影响列出条数，不影响合计统计
- * @returns {string|null} 上下文块；没有任何项目可列时返回 null（调用方据此跳过注入）
+ * @returns {string} 上下文块。**不返回 null** —— 见下面的注释。
  */
 export function buildEnvContextBlock({
   currentProjectPath = '',
-  projects = [],
-  tasks = [],
-  jobs = [],
-  tasksFile = '',
-  jobsFile = '',
-  orchestratorFile = '',
-  configFile = '',
+  board = null,
+  truthFiles = {},
   maxProjects = ENV_CONTEXT_MAX_PROJECTS,
 } = {}) {
-  const list = Array.isArray(projects) ? projects.filter(p => p && p.key) : [];
-  if (list.length === 0) return null;
-
-  const stats = summarizeProjectTasks(
-    Array.isArray(tasks) ? tasks : [],
-    Array.isArray(jobs) ? jobs : [],
-  );
+  const list = Array.isArray(board?.projects) ? board.projects.filter(p => p && p.key) : [];
+  const statsByKey = (board?.statsByKey && typeof board.statsByKey === 'object') ? board.statsByKey : {};
+  const total = board?.total || {};
+  const runningJobs = Number(board?.runningJobs) || 0;
 
-  // 合计按全部任务算（含「未关联项目」那一桶），所以不能用 list 求和
-  const total = { total: 0 };
-  for (const key of TASK_COLUMNS) total[key] = 0;
-  for (const s of stats.values()) {
-    total.total += s.total;
-    for (const key of TASK_COLUMNS) total[key] += s[key] || 0;
-  }
-
-  const limit = Number.isFinite(maxProjects) && maxProjects > 0 ? Math.floor(maxProjects) : ENV_CONTEXT_MAX_PROJECTS;
-  const shown = list.slice(0, limit);
   // 当前项目的比对**必须归一化后再比**：条目 key 是 canonicalProjectPath 的结果
   // （Windows 形式小写 + 斜杠归一如 d:\ws\x），而调用方给的 currentProjectPath 是原始写法
   // （盘符/目录段大小写都不一定一致）。直接拿 path 跟 key 比会永远不等 —— 同款口径分叉
@@ -110,22 +94,35 @@ export function buildEnvContextBlock({
   lines.push('');
   lines.push(`当前任务所在项目（也是你的工作目录）: ${currentProjectPath || '(未指定)'}`);
   lines.push('');
-  lines.push(`项目清单（共 ${list.length} 个；格式: 名称 | 路径 | ${columnLabels.join('/')}）:`);
-  for (const p of shown) {
-    const s = stats.get(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} 个未列出（读下面的文件可以看全）`);
+
+  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} 个未列出（读下面的文件可以看全）`);
+    }
+    lines.push('');
+    lines.push(
+      `看板任务概览：全部项目合计 ${total.total || 0} 条 —— ` +
+      TASK_COLUMNS.map(k => `${COLUMN_LABELS[k]} ${total[k] || 0}`).join(' / ') +
+      (runningJobs > 0 ? `，正在执行 ${runningJobs} 个` : '，当前无执行中的任务'),
+    );
+    lines.push('');
+  } else {
+    // 快照还没生成好（或 tasks 板块取数失败）。项目那一段省掉，**但偏好与真相源照给** ——
+    // 它们不需要取数，而且 SSH 那条少一次，任务就会在克隆仓库时退回 https、
+    // 弹出凭据窗口把任务停住（这正是文件头第 3 条要防的）。
+    lines.push('项目清单：本次未能取到（看板快照还没生成好）。需要时直接读下面的 tasks.json。');
+    lines.push('');
   }
-  lines.push('');
-  lines.push(
-    `看板任务概览：全部项目合计 ${total.total} 条 —— ` +
-    TASK_COLUMNS.map(k => `${COLUMN_LABELS[k]} ${total[k] || 0}`).join(' / '),
-  );
-  lines.push('');
-  // 用户偏好（见文件头第 3 条）。放在"读文件"之前、"看板概览"之后 ——
+
+  // 用户偏好（见文件头）。放在"读文件"之前、"看板概览"之后 ——
   // 它是**行为**约定，与上面的事实清单分开；压尾的那句仍是"去读文件"，
   // 那是整块上下文里最需要被记住的动作。
   lines.push(
@@ -137,10 +134,10 @@ export function buildEnvContextBlock({
   );
   lines.push('');
   lines.push('需要细节时直接读这些文件（本机绝对路径，你有读取权限，不必先问用户）:');
-  if (tasksFile) lines.push(`- ${tasksFile} —— 全部任务全文（标题/描述/子任务状态/报错/projectPath）`);
-  if (jobsFile) lines.push(`- ${jobsFile} —— 历次执行记录（状态与输出）`);
-  if (orchestratorFile) lines.push(`- ${orchestratorFile} —— 用户在调度台发过的指令流水`);
-  if (configFile) lines.push(`- ${configFile} —— 应用配置（projects / recentDirectories）`);
+  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(
     '用户问到"我有哪些项目""某件事进展如何"这类问题时，先读上面的文件再回答；' +

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

@@ -14,23 +14,32 @@
 //
 // 运行环境上下文（envContext.js）纯函数单测。
 //
-// 这里守的是两件事：
+// 这里守的是三件事：
 //   1. 注入出去的块里**真的**有项目名/路径/计数与真相源文件路径 ——
 //      否则"Agent 知道我有哪些项目"就是空话（旧行为：prompt 里只有用户原话）；
-//   2. 计数口径与看板列一致（复用 summarizeProjectTasks，不另立一套）。
+//   2. 计数口径与看板列一致 —— 而且**数据是从 aiContext 的 tasks 板块来的**
+//      （不再有第二份 buildProjectEntries + summarizeProjectTasks 实现）；
+//   3. 快照取不到时**降级但不丢关键信息**：项目清单可以没有，
+//      但"克隆优先 SSH"这条偏好必须还在。
+//
+// ⚠️ board 一律用**真实的** collectWorkbenchTasks 产出，不手搓：
+// 手搓的话，第 2 条就变成了"测试自己跟自己对"，把口径分叉放走。
 
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 
 import { buildEnvContextBlock, ENV_CONTEXT_MAX_PROJECTS } from './envContext.js';
-import { canonicalProjectPath, TASK_COLUMNS } from './projectRegistry.js';
+import { TASK_COLUMNS } from './projectRegistry.js';
+import { TRUTH_FILES } from './shared.js';
+import { collectWorkbenchTasks } from '../aiContext/collectors.js';
 
-const entry = (path) => ({
-  path,
-  key: canonicalProjectPath(path),
-  name: path.split(/[\\/]/).filter(Boolean).pop(),
-  source: 'recent',
-});
+/** 用真实的 collector 造 board —— envContext 在生产里吃到的就是它 */
+const boardOf = ({ tasks = [], jobs = [], recentDirs = [] } = {}) => {
+  const r = collectWorkbenchTasks({ tasks, jobs, recentDirs });
+  assert.equal(r.ok, true, 'collectWorkbenchTasks 应当成功');
+  assert.ok(r.data, 'tasks 板块必须带上结构化 data（envContext 的唯一数据来源）');
+  return r.data;
+};
 
 const job = (id, taskId, status) => ({
   id, taskId, subId: `${taskId}__x`, title: '', status,
@@ -38,39 +47,41 @@ const job = (id, taskId, status) => ({
   endedAt: status === 'running' ? null : '2026-09-18T02:01:00.000Z',
 });
 
-const PATHS = {
-  tasksFile: '/home/u/.zen-gitsync/tasks.json',
-  jobsFile: '/home/u/.zen-gitsync/jobs.json',
-  orchestratorFile: '/home/u/.zen-gitsync/orchestrator.json',
-  configFile: '/home/u/.zen-gitsync/config.json',
-};
+const build = (opts) => buildEnvContextBlock({ truthFiles: TRUTH_FILES, ...opts });
 
-test('没有任何项目时返回 null（不注入空块浪费 token）', () => {
-  assert.equal(buildEnvContextBlock({}), null);
-  assert.equal(buildEnvContextBlock(), null);
-  assert.equal(buildEnvContextBlock({ projects: [] }), null);
-  // 只有 key 缺项的脏条目也算没有项目
-  assert.equal(buildEnvContextBlock({ projects: [{ name: 'x', path: '' }] }), null);
+test('取不到 board 时**不返回 null**：偏好与真相源照给（项目清单整体省掉）', () => {
+  // 这一条是刻意的行为变更。老版本"没有项目就返回 null"，但块里那两条**不需要取数**
+  // 的内容（克隆优先 SSH、真相源路径）恰恰是最不该丢的 —— SSH 那条少一次，
+  // 任务克隆仓库时就会退回 https、弹出凭据窗口把自己停在半路。
+  for (const board of [null, undefined, {}, { projects: [] }, { projects: [{ name: 'x' }] }]) {
+    const block = build({ currentProjectPath: 'D:\\ws\\a', board });
+    assert.ok(block, 'board 缺失也必须产出块');
+    assert.match(block, /优先使用 SSH/);
+    for (const p of Object.values(TRUTH_FILES)) assert.ok(block.includes(p), `缺少路径 ${p}`);
+    // 但项目那段不能硬编一个空清单（模型会把"没列出来"读成"没有项目"）
+    assert.doesNotMatch(block, /项目清单（共 0 个/);
+    if (!board || !board.projects || board.projects.length === 0) {
+      assert.match(block, /项目清单：本次未能取到/);
+    }
+  }
 });
 
 test('项目清单带名称、路径与三列计数，并标出当前项目', () => {
-  const projects = [entry('D:\\ws\\zen-gitsync'), entry('D:\\ws\\article-generator')];
-  const tasks = [
-    // 已完成：simple 任务跑过一次且 job 是 done
-    { id: 't1', projectPath: 'D:\\ws\\zen-gitsync', type: 'simple' },
-    // 进行中：有 job 处于 running
-    { id: 't2', projectPath: 'D:\\ws\\article-generator', type: 'simple' },
-    // 待处理：没子任务也没执行过
-    { id: 't3', projectPath: 'D:\\ws\\article-generator', type: 'simple' },
-  ];
-  const jobs = [job('j1', 't1', 'done'), job('j2', 't2', 'running')];
-
-  const block = buildEnvContextBlock({
-    currentProjectPath: 'D:\\ws\\zen-gitsync',
-    projects, tasks, jobs, ...PATHS,
+  const board = boardOf({
+    recentDirs: ['D:\\ws\\zen-gitsync', 'D:\\ws\\article-generator'],
+    tasks: [
+      // 已完成：simple 任务跑过一次且 job 是 done
+      { id: 't1', projectPath: 'D:\\ws\\zen-gitsync', type: 'simple' },
+      // 进行中：有 job 处于 running
+      { id: 't2', projectPath: 'D:\\ws\\article-generator', type: 'simple' },
+      // 待处理：没子任务也没执行过
+      { id: 't3', projectPath: 'D:\\ws\\article-generator', type: 'simple' },
+    ],
+    jobs: [job('j1', 't1', 'done'), job('j2', 't2', 'running')],
   });
 
-  assert.ok(block, '应当产出上下文块');
+  const block = build({ currentProjectPath: 'D:\\ws\\zen-gitsync', board });
+
   // 项目名 + 路径都在
   assert.match(block, /zen-gitsync/);
   assert.match(block, /article-generator/);
@@ -78,10 +89,11 @@ test('项目清单带名称、路径与三列计数，并标出当前项目', ()
   // 三列计数：zen-gitsync 1 条已完成 → 0/0/1；article-generator 1 进行中 1 待处理 → 1/1/0
   assert.match(block, /- zen-gitsync \| D:\\ws\\zen-gitsync \| 0\/0\/1\s+← 当前/);
   assert.match(block, /- article-generator \| D:\\ws\\article-generator \| 1\/1\/0/);
-  // 合计：3 条，各列各一条
+  // 合计：3 条，各列各一条；顺带带上"正在执行 1 个"
   assert.match(block, /全部项目合计 3 条 —— 待处理 1 \/ 进行中 1 \/ 已完成 1/);
+  assert.match(block, /正在执行 1 个/);
   // 真相源路径：这是"够得着"的关键，缺了 Agent 还是只能猜
-  for (const p of Object.values(PATHS)) assert.ok(block.includes(p), `缺少路径 ${p}`);
+  for (const p of Object.values(TRUTH_FILES)) assert.ok(block.includes(p), `缺少路径 ${p}`);
   // 明确要求它去读文件，而不是回"我看不到"
   assert.match(block, /不要回答"我看不到\/无法访问"/);
 });
@@ -89,29 +101,31 @@ test('项目清单带名称、路径与三列计数，并标出当前项目', ()
 test('当前项目标记必须归一化后比较（大小写不同也算同一个）', () => {
   // 条目 key 是归一化过的（小写 + 反斜杠），而 cwd 常常是另一种写法 ——
   // 直接拿 path 跟 key 比会永远不相等，表现为"当前项目"标记丢失。
-  const projects = [entry('C:\\Users\\xuze3'), entry('D:\\ws\\other')];
-  const block = buildEnvContextBlock({
+  const board = boardOf({
+    recentDirs: ['C:\\Users\\xuze3', 'D:\\ws\\other'],
+    tasks: [],
+    jobs: [],
+  });
+  const block = build({
     // 不只盘符：目录段大小写也不一样（左栏重复项那个 bug 的同款写法差异）
     currentProjectPath: 'c:/users/XUZE3',
-    projects, tasks: [], jobs: [], ...PATHS,
+    board,
   });
   assert.match(block, /- xuze3 \| C:\\Users\\xuze3 \| 0\/0\/0\s+← 当前/);
   assert.match(block, /- other \| D:\\ws\\other \| 0\/0\/0\n/);
 });
 
 test('项目数超过上限时只列前 N 个，但合计仍按全量算', () => {
-  const projects = [];
-  const tasks = [];
   const total = ENV_CONTEXT_MAX_PROJECTS + 5;
+  const recentDirs = [];
+  const tasks = [];
   for (let i = 0; i < total; i += 1) {
     const p = `D:\\ws\\p${i}`;
-    projects.push(entry(p));
+    recentDirs.push(p);
     tasks.push({ id: `t${i}`, projectPath: p, type: 'simple' });
   }
 
-  const block = buildEnvContextBlock({
-    currentProjectPath: '', projects, tasks, jobs: [], ...PATHS,
-  });
+  const block = build({ currentProjectPath: '', board: boardOf({ recentDirs, tasks }) });
 
   const listed = block.split('\n').filter(l => l.startsWith('- p') && l.includes('| D:'));
   assert.equal(listed.length, ENV_CONTEXT_MAX_PROJECTS);
@@ -122,21 +136,23 @@ test('项目数超过上限时只列前 N 个，但合计仍按全量算', () =>
 });
 
 test('maxProjects 可覆盖，且非法值回落到默认上限', () => {
-  const projects = [entry('D:\\ws\\a'), entry('D:\\ws\\b'), entry('D:\\ws\\c')];
-  const short = buildEnvContextBlock({ projects, tasks: [], jobs: [], maxProjects: 1, ...PATHS });
+  const board = boardOf({ recentDirs: ['D:\\ws\\a', 'D:\\ws\\b', 'D:\\ws\\c'], tasks: [] });
+  const short = build({ board, maxProjects: 1 });
   assert.equal(short.split('\n').filter(l => l.startsWith('- a') || l.startsWith('- b') || l.startsWith('- c')).length, 1);
 
-  const bad = buildEnvContextBlock({ projects, tasks: [], jobs: [], maxProjects: 0, ...PATHS });
+  const bad = build({ board, maxProjects: 0 });
   assert.equal(bad.split('\n').filter(l => l.startsWith('- ') && l.includes('| D:')).length, 3);
 });
 
 test('没关联项目的任务不计入项目行，但计入合计', () => {
-  const projects = [entry('D:\\ws\\a')];
-  const tasks = [
-    { id: 't1', projectPath: 'D:\\ws\\a', type: 'simple' },
-    { id: 't2', projectPath: '', type: 'simple' },
-  ];
-  const block = buildEnvContextBlock({ projects, tasks, jobs: [], ...PATHS });
+  const board = boardOf({
+    recentDirs: ['D:\\ws\\a'],
+    tasks: [
+      { id: 't1', projectPath: 'D:\\ws\\a', type: 'simple' },
+      { id: 't2', projectPath: '', type: 'simple' },
+    ],
+  });
+  const block = build({ board });
   // 项目行只认 key 匹配得上的那条（t1）→ 待处理 1
   assert.match(block, /- a \| D:\\ws\\a \| 1\/0\/0/);
   // 而合计走 NO_PROJECT_KEY 那桶一起算 → 2 条；两者不相等正是这段断言要守的
@@ -151,12 +167,14 @@ test('没关联项目的任务不计入项目行，但计入合计', () => {
 // 只顺手改了最显眼的一行 → 另外三处照红。下面这条不比对具体数字，只守"段数 == 看板列数"，
 // 下次增删列时它和上面几条会一起红，而不是让某一条孤零零地报一个对不上的字符串。
 test('项目行/合计的段数必须与 TASK_COLUMNS 一致，且每列都有中文标签', () => {
-  const projects = [entry('D:\\ws\\a')];
-  const tasks = [
-    { id: 't1', projectPath: 'D:\\ws\\a', type: 'simple' },
-    { id: 't2', projectPath: 'D:\\ws\\a', type: 'simple' },
-  ];
-  const block = buildEnvContextBlock({ projects, tasks, jobs: [], ...PATHS });
+  const board = boardOf({
+    recentDirs: ['D:\\ws\\a'],
+    tasks: [
+      { id: 't1', projectPath: 'D:\\ws\\a', type: 'simple' },
+      { id: 't2', projectPath: 'D:\\ws\\a', type: 'simple' },
+    ],
+  });
+  const block = build({ board });
 
   // 表头里的「待处理/进行中/已完成」：段数 = 列数，且不能有一列回落成 key 本身
   const headerLabels = block.match(/格式: 名称 \| 路径 \| ([^）]+)/)[1].split('/');
@@ -177,16 +195,68 @@ test('项目行/合计的段数必须与 TASK_COLUMNS 一致，且每列都有
   assert.equal(rowCounts[TASK_COLUMNS.indexOf('todo')], '2');
 });
 
+// ── 口径同源：这一条守的是"别再长出第二份实现"────────────────────────
+//
+// 改动前 envContext 自己读 tasks.json、自己做 buildProjectEntries + summarizeProjectTasks，
+// 与 aiContext 的 tasks 板块是同一口径的两个副本。两份实现分叉时**不会报错**，
+// 只会让 Agent 在编排台里和智能体页里看到不同的项目数。这条断言把两份绑在一起：
+// envContext 渲染出来的每个数字，都必须能在 collector 的摘要里找到。
+test('口径同源：envContext 的数字必须与 tasks 板块的摘要逐项对上', () => {
+  const tasks = [
+    { id: 't1', projectPath: 'D:\\ws\\a', type: 'simple' },
+    { id: 't2', projectPath: 'D:\\ws\\a', type: 'simple' },
+    { id: 't3', projectPath: 'D:\\ws\\b', type: 'simple' },
+    { id: 't4', projectPath: '', type: 'simple' },
+  ];
+  const jobs = [job('j1', 't3', 'done')];
+  const section = collectWorkbenchTasks({ tasks, jobs, recentDirs: ['D:\\ws\\a', 'D:\\ws\\b'] });
+  const block = buildEnvContextBlock({
+    currentProjectPath: 'D:\\ws\\b',
+    board: section.data,
+    truthFiles: TRUTH_FILES,
+  });
+
+  // ① 合计那一句：collector 的 summary 里是「全部项目合计 4 条 —— 待处理 3 / 进行中 0 / 已完成 1」，
+  //    envContext 必须复现出同样的数字（前缀文案相同，直接整句比对最省事）。
+  const totals = section.summary.match(/全部项目合计 \d+ 条 —— [^，]+/)[0];
+  assert.ok(block.includes(totals), `envContext 的合计与板块摘要不一致:\n${block}`);
+
+  // ② 项目数：摘要里的项目行数与 envContext 列出的行数一致
+  const collectorRows = section.lines.filter(l => /^- .+ \| .+ \| \d+\/\d+\/\d+$/.test(l));
+  const envRows = block.split('\n').filter(l => /^- .+ \| .+ \| \d+\/\d+\/\d+/.test(l));
+  assert.equal(envRows.length, collectorRows.length, '两份视图列出的项目数应一致');
+  assert.ok(collectorRows.length > 0, '这个用例应当至少有一个项目');
+
+  // ③ 结构化 data 自己也得自洽：statsByKey 的合计 == total
+  const sum = { total: 0 };
+  for (const k of TASK_COLUMNS) sum[k] = 0;
+  for (const s of Object.values(section.data.statsByKey)) {
+    sum.total += s.total || 0;
+    for (const k of TASK_COLUMNS) sum[k] += s[k] || 0;
+  }
+  assert.equal(sum.total, section.data.total.total);
+  for (const k of TASK_COLUMNS) assert.equal(sum[k], section.data.total[k]);
+});
+
 // ── 用户偏好：克隆仓库优先 SSH ────────────────────────────────────────
 //
 // 这条只对**工作台任务**起作用（执行器是外部 CLI claude / opencode，系统提示词不归我们写，
 // envContext 是唯一能把偏好递进去的地方）。断言钉住两个平台的地址都写全 —— 用户实际踩的
 // 那个坑就是 Gitee 走 https 弹了凭据窗口；只留 GitHub 一条等于只覆盖一半场景。
 test('注入块带上「克隆优先 SSH」这条用户偏好', () => {
-  const block = buildEnvContextBlock({ projects: [entry('D:\\ws\\a')], tasks: [], jobs: [], ...PATHS });
+  const block = build({ board: boardOf({ recentDirs: ['D:\\ws\\a'], tasks: [] }) });
   assert.match(block, /优先使用 SSH/);
   assert.match(block, /git@github\.com:owner\/repo\.git/);
   assert.match(block, /git@gitee\.com:owner\/repo\.git/);
   // 退回条件也得在：没写清"什么时候可以退回"，模型会在 SSH 失败后来回重试
   assert.match(block, /Permission denied \(publickey\)/);
 });
+
+test('真相源清单来自唯一的 TRUTH_FILES（四个路径一个不落，且不多写）', () => {
+  const block = build({ board: boardOf({ recentDirs: ['D:\\ws\\a'], tasks: [] }) });
+  const listed = block.split('\n').filter(l => l.startsWith('- ') && l.includes(' —— ') && l.includes('json'));
+  assert.equal(listed.length, Object.keys(TRUTH_FILES).length);
+  // 编排台指令流水必须在这份清单里 —— 它是 envContext 相对七个板块视图**多**出来的那一条
+  assert.ok(block.includes(TRUTH_FILES.orchestratorFile));
+  assert.match(block, /调度台发过的指令流水/);
+});