zen-gitsync 2.16.51 → 2.17.1

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

@@ -0,0 +1,178 @@
+// 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.
+//
+// 运行环境上下文（envContext.js）纯函数单测。
+//
+// 这里守的是两件事：
+//   1. 注入出去的块里**真的**有项目名/路径/计数与真相源文件路径 ——
+//      否则"Agent 知道我有哪些项目"就是空话（旧行为：prompt 里只有用户原话）；
+//   2. 计数口径与看板列一致（复用 summarizeProjectTasks，不另立一套）。
+
+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';
+
+const entry = (path) => ({
+  path,
+  key: canonicalProjectPath(path),
+  name: path.split(/[\\/]/).filter(Boolean).pop(),
+  source: 'recent',
+});
+
+const job = (id, taskId, status) => ({
+  id, taskId, subId: `${taskId}__x`, title: '', status,
+  startedAt: '2026-09-18T02:00:00.000Z',
+  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',
+};
+
+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('项目清单带名称、路径与三列计数，并标出当前项目', () => {
+  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', subtasks: [] },
+    // 进行中：有 job 处于 running
+    { id: 't2', projectPath: 'D:\\ws\\article-generator', type: 'simple', subtasks: [] },
+    // 待处理：没子任务也没执行过
+    { id: 't3', projectPath: 'D:\\ws\\article-generator', type: 'simple', subtasks: [] },
+  ];
+  const jobs = [job('j1', 't1', 'done'), job('j2', 't2', 'running')];
+
+  const block = buildEnvContextBlock({
+    currentProjectPath: 'D:\\ws\\zen-gitsync',
+    projects, tasks, jobs, ...PATHS,
+  });
+
+  assert.ok(block, '应当产出上下文块');
+  // 项目名 + 路径都在
+  assert.match(block, /zen-gitsync/);
+  assert.match(block, /article-generator/);
+  assert.match(block, /D:\\ws\\article-generator/);
+  // 三列计数：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 条，各列各一条
+  assert.match(block, /全部项目合计 3 条 —— 待处理 1 \/ 进行中 1 \/ 已完成 1/);
+  // 真相源路径：这是"够得着"的关键，缺了 Agent 还是只能猜
+  for (const p of Object.values(PATHS)) assert.ok(block.includes(p), `缺少路径 ${p}`);
+  // 明确要求它去读文件，而不是回"我看不到"
+  assert.match(block, /不要回答"我看不到\/无法访问"/);
+});
+
+test('当前项目标记必须归一化后比较（大小写不同也算同一个）', () => {
+  // 条目 key 是归一化过的（小写 + 反斜杠），而 cwd 常常是另一种写法 ——
+  // 直接拿 path 跟 key 比会永远不相等，表现为"当前项目"标记丢失。
+  const projects = [entry('C:\\Users\\xuze3'), entry('D:\\ws\\other')];
+  const block = buildEnvContextBlock({
+    // 不只盘符：目录段大小写也不一样（左栏重复项那个 bug 的同款写法差异）
+    currentProjectPath: 'c:/users/XUZE3',
+    projects, tasks: [], jobs: [], ...PATHS,
+  });
+  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;
+  for (let i = 0; i < total; i += 1) {
+    const p = `D:\\ws\\p${i}`;
+    projects.push(entry(p));
+    tasks.push({ id: `t${i}`, projectPath: p, type: 'simple', subtasks: [] });
+  }
+
+  const block = buildEnvContextBlock({
+    currentProjectPath: '', projects, tasks, jobs: [], ...PATHS,
+  });
+
+  const listed = block.split('\n').filter(l => l.startsWith('- p') && l.includes('| D:'));
+  assert.equal(listed.length, ENV_CONTEXT_MAX_PROJECTS);
+  assert.match(block, new RegExp(`共 ${total} 个`));
+  assert.match(block, /还有 5 个未列出/);
+  // 合计不受截断影响：另外 5 个也要算进去
+  assert.match(block, new RegExp(`全部项目合计 ${total} 条`));
+});
+
+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 });
+  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 });
+  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', subtasks: [] },
+    { id: 't2', projectPath: '', type: 'simple', subtasks: [] },
+  ];
+  const block = buildEnvContextBlock({ projects, tasks, jobs: [], ...PATHS });
+  // 项目行只认 key 匹配得上的那条（t1）→ 待处理 1
+  assert.match(block, /- a \| D:\\ws\\a \| 1\/0\/0/);
+  // 而合计走 NO_PROJECT_KEY 那桶一起算 → 2 条；两者不相等正是这段断言要守的
+  assert.match(block, /全部项目合计 2 条/);
+  // 无项目归属的任务不该凭空造出一行项目
+  assert.equal(block.split('\n').filter(l => l.startsWith('- ') && l.includes('|')).length, 1);
+});
+
+// ── 列数一致性：这一条是"改列别再漏一处"的守门员 ──────────────────────
+//
+// 去掉「评审中」那一轮，输出从四列变三列，但这个文件里是**逐条正则硬写的数字**，
+// 只顺手改了最显眼的一行 → 另外三处照红。下面这条不比对具体数字，只守"段数 == 看板列数"，
+// 下次增删列时它和上面几条会一起红，而不是让某一条孤零零地报一个对不上的字符串。
+test('项目行/合计的段数必须与 TASK_COLUMNS 一致，且每列都有中文标签', () => {
+  const projects = [entry('D:\\ws\\a')];
+  const tasks = [
+    { id: 't1', projectPath: 'D:\\ws\\a', type: 'simple', subtasks: [] },
+    { id: 't2', projectPath: 'D:\\ws\\a', type: 'simple', subtasks: [] },
+  ];
+  const block = buildEnvContextBlock({ projects, tasks, jobs: [], ...PATHS });
+
+  // 表头里的「待处理/进行中/已完成」：段数 = 列数，且不能有一列回落成 key 本身
+  const headerLabels = block.match(/格式: 名称 \| 路径 \| ([^）]+)/)[1].split('/');
+  assert.equal(headerLabels.length, TASK_COLUMNS.length, '表头标签数应与看板列数一致');
+  TASK_COLUMNS.forEach((key, i) => {
+    assert.notEqual(headerLabels[i], key, `列「${key}」缺中文标签（标签表里没这个名字）`);
+  });
+
+  // 项目行的计数组数
+  const rowCounts = block.match(/- a \| D:\\ws\\a \| ([^\n]+)/)[1].trim().split('/');
+  assert.equal(rowCounts.length, TASK_COLUMNS.length, '项目行的计数组数应与看板列数一致');
+
+  // 合计行的段数
+  const overview = block.match(/全部项目合计 \d+ 条 —— ([^\n]+)/)[1].split(' / ');
+  assert.equal(overview.length, TASK_COLUMNS.length, '合计行的段数应与看板列数一致');
+
+  // 两个任务都是待处理 → 第一段是 2，其余列是 0（顺序由 TASK_COLUMNS 决定，不是写死的下标）
+  assert.equal(rowCounts[TASK_COLUMNS.indexOf('todo')], '2');
+});

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

@@ -44,7 +44,9 @@ import {
   fsp,
   PROMPTS_FILE,
   TASKS_FILE,
+  CONFIG_FILE,
   JOBS_FILE,
+  ORCHESTRATOR_FILE,
   IMAGES_DIR,
   SUBTASK_INSTRUCTION_FILE,
   MAX_IMAGE_BYTES,
@@ -63,7 +65,18 @@ import {
   listDirTree,
   safeReadFile,
 } from './projectScan.js';
-import { isImageExt, resolveExt, ALLOWED_EXTS, ensureImagesDir } from './attachmentUtils.js';
+import {
+  isImageExt,
+  resolveExt,
+  ALLOWED_EXTS,
+  ensureImagesDir,
+  DISPATCH_STAGING_DIR,
+  isSafeAttId,
+  mimeForExt,
+  stagingPath,
+  findStagingFile,
+  cleanupDispatchStaging,
+} from './attachmentUtils.js';
 import { sessionStore } from './sessionStore.js';
 import {
   DEFAULT_INSTRUCTION,
@@ -96,6 +109,7 @@ import {
   collectPriorOutputs,
   collectPriorOutputsUpTo,
   waitProcessExit,
+  setEnvContextProvider,
 } from './taskRunner.js';
 import {
   listProjects,
@@ -103,7 +117,10 @@ import {
   decorateTaskForBoard,
   resolveTaskRepoPath,
   buildTaskDetail,
+  buildProjectEntries,
 } from './projectRegistry.js';
+import { buildEnvContextBlock } from './envContext.js';
+import { resolveInstructionTarget } from './targetResolver.js';
 import {
   readOrchestrator,
   setOrchestratorActive,
@@ -1729,6 +1746,45 @@ ${desc ? `描述：${desc}` : '描述：（无）'}${attachmentBlock}${templateB
     return { projects, tasks: boardTasks, currentProjectPath };
   }
 
+  /**
+   * 注册「运行环境上下文」的提供者 —— 执行引擎（taskRunner）拼 prompt 时会回调它。
+   *
+   * 为什么在这一层注册：只有这里同时拿得到 configManager（最近目录）与 jobStore
+   * 的 job 快照；taskRunner 两个都没有，放它那儿就得再造一条「读最近目录」的路径，
+   * 也就是又一次口径分叉。
+   *
+   * 复用 buildProjectEntries + summarizeProjectTasks（与看板同一套口径），
+   * 但**刻意不走** listProjects：那是给看板用的，会去 spawn git 探状态。
+   * 分支、改动数这类信息 Agent 在自己的 cwd 里一条 git 命令就有，
+   * 不值得为它在这里每次执行都多探一轮。
+   */
+  setEnvContextProvider(async ({ repoPath } = {}) => {
+    const data = await readJson(TASKS_FILE, { tasks: [] });
+    const tasks = data.tasks || [];
+
+    let recentDirs = [];
+    try {
+      if (configManager && typeof configManager.getRecentDirectories === 'function') {
+        recentDirs = (await configManager.getRecentDirectories()) || [];
+      }
+    } catch (err) {
+      // 与 loadBoardPayload 同一处理：读不到最近目录就退化成"只按任务里出现过的项目"
+      logger.warn('[workbench] 注入运行环境上下文时读取最近目录失败，退化为仅按任务路径:', err.message);
+    }
+
+    const projects = buildProjectEntries({ recentDirs, tasks });
+    return buildEnvContextBlock({
+      currentProjectPath: repoPath || '',
+      projects,
+      tasks,
+      jobs: snapshotJobs(),
+      tasksFile: TASKS_FILE,
+      jobsFile: JOBS_FILE,
+      orchestratorFile: ORCHESTRATOR_FILE,
+      configFile: CONFIG_FILE,
+    });
+  });
+
   app.get('/api/workbench/projects', asyncRoute(async (_req, res) => {
     const payload = await loadBoardPayload();
     res.json({ success: true, ...payload });
@@ -1785,7 +1841,8 @@ ${desc ? `描述：${desc}` : '描述：（无）'}${attachmentBlock}${templateB
   /**
    * 派发一条指令。
    * body: { text, projectPath?, autoRun? }
-   *   - projectPath 缺省 = 当前项目
+   *   - projectPath 缺省 -> 交给 targetResolver 判断落到哪个项目（显式指定 > 指令里点名
+   *     > 主 Agent 判断 > 应用当前项目）。用户不必先选项目，落点会如实记进指令流水
    *   - autoRun 默认 true；调度暂停时只建任务不执行（指令记录里会写明原因）
    *
    * 指令一律落成目标项目下的**简单任务**（一句话交给 claude 跑一轮），
@@ -1798,8 +1855,43 @@ ${desc ? `描述：${desc}` : '描述：（无）'}${attachmentBlock}${templateB
 
     const fallbackPath = typeof getCurrentProjectPath === 'function' ? getCurrentProjectPath() : '';
     const bodyPath = typeof req.body?.projectPath === 'string' ? req.body.projectPath.trim() : '';
-    const targetPath = bodyPath || fallbackPath;
-    if (!targetPath) throw new HttpError(400, '未选中项目，无法派发');
+
+    // 先把任务与项目清单读出来：解析落点要用它们。
+    // 清单复用 buildProjectEntries（与看板 / 运行环境上下文同一套口径），
+    // 刻意**不走** listProjects —— 那会 spawn git，派发不值得为它多等一轮。
+    const data = await readJson(TASKS_FILE, { tasks: [] });
+    const tasks = data.tasks || [];
+
+    let recentDirs = [];
+    try {
+      if (configManager && typeof configManager.getRecentDirectories === 'function') {
+        recentDirs = (await configManager.getRecentDirectories()) || [];
+      }
+    } catch (err) {
+      logger.warn('[workbench] 派发时读取最近目录失败，落点解析退化为仅按任务路径:', err.message);
+    }
+
+    const target = await resolveInstructionTarget({
+      text,
+      projects: buildProjectEntries({ recentDirs, tasks }),
+      explicitPath: bodyPath,
+      defaultPath: fallbackPath,
+      // 懒取模型：只有「指令里没点名、也没被显式指定」时才会真的读 config 去问模型
+      getModel: async () => {
+        if (!configManager) return null;
+        const rawConfig = await configManager.readRawConfigFile();
+        const models = Array.isArray(rawConfig.models) ? rawConfig.models : [];
+        return models.find(m => m.isDefault) || models[0] || null;
+      },
+      onAgentError: (err) => {
+        logger.warn('[workbench] 主 Agent 判断指令落点失败，退到默认项目:', err.message);
+      },
+    });
+
+    const targetPath = target.path;
+    if (!targetPath) {
+      throw new HttpError(400, '没能识别出目标项目，也没有默认项目可用 —— 先在左侧打开或选一个项目');
+    }
 
     // 目标目录必须真的存在：跑在不存在的工作区上只会拿到一堆无意义的报错
     let stat = null;
@@ -1810,6 +1902,7 @@ ${desc ? `描述：${desc}` : '描述：（无）'}${attachmentBlock}${templateB
         projectPath: targetPath,
         status: 'rejected',
         reason: '项目目录不存在',
+        targetSource: target.source,
       });
       publish('orchestrator:instruction', rejected);
       throw new HttpError(400, `项目目录不存在：${targetPath}`);
@@ -1818,11 +1911,69 @@ ${desc ? `描述：${desc}` : '描述：（无）'}${attachmentBlock}${templateB
     const autoRun = req.body?.autoRun !== false;
     const schedulingActive = await isSchedulingActive();
 
-    const data = await readJson(TASKS_FILE, { tasks: [] });
-    const tasks = data.tasks || [];
+    // ── 附件：前端只回传 { id, ext, originalName }，服务端按 id 回暂存区找文件 ──
+    // 路径完全由服务端拼（stagingPath 会同时校验 id 形状与 ext 白名单），
+    // 所以不存在"前端指定任意路径"这回事 —— 比"信任 absolutePath 再校验前缀"干净。
+    // 数量与文件存在性在这里统一校验：上传时服务端是无状态的，压根不知道前端一共攒了几个。
+    const rawAttachments = Array.isArray(req.body?.attachments) ? req.body.attachments : [];
+    if (rawAttachments.length > MAX_ATTACHMENTS_PER_SUBTASK) {
+      throw new HttpError(400, `附件最多 ${MAX_ATTACHMENTS_PER_SUBTASK} 个`);
+    }
+    const staged = [];
+    for (const item of rawAttachments) {
+      const attId = typeof item?.id === 'string' ? item.id : '';
+      const ext = typeof item?.ext === 'string' ? item.ext : '';
+      const from = stagingPath(attId, ext);
+      if (!from) throw new HttpError(400, '附件参数不合法');
+      let attStat = null;
+      try { attStat = await fsp.stat(from); } catch { /* 下面统一报错 */ }
+      if (!attStat || !attStat.isFile()) throw new HttpError(400, '附件已失效，请重新添加');
+      staged.push({
+        id: attId,
+        ext,
+        from,
+        size: attStat.size,
+        originalName: String(item?.originalName || `attachment.${ext}`).slice(0, 200),
+      });
+    }
+
+    // tasks / data 已在上面读好（落点解析要用），这里不再重复读一遍
     const now = nowIso();
+    const taskId = genId();
+
+    // 附件从暂存区搬进任务自己的目录（`_task-{id}/`），这样删除任务时会被一并清掉
+    const attachmentDir = path.join(IMAGES_DIR, '_task-' + taskId);
+    const attachments = [];
+    if (staged.length > 0) {
+      await fsp.mkdir(attachmentDir, { recursive: true });
+      for (const s of staged) {
+        const storedName = `${s.id}.${s.ext}`;
+        const dest = path.join(attachmentDir, storedName);
+        try {
+          await fsp.rename(s.from, dest);
+        } catch {
+          // 极端情况（跨卷等）退化成复制 + 删除；仍失败就跳过这个附件，
+          // 而不是让整条指令派发不出去 —— 指令本身是好的，不该被一个文件拖死。
+          try {
+            await fsp.copyFile(s.from, dest);
+            await fsp.unlink(s.from);
+          } catch { continue; }
+        }
+        attachments.push({
+          id: s.id,
+          originalName: s.originalName,
+          mimeType: mimeForExt(s.ext),
+          size: s.size,
+          ext: s.ext,
+          storedName,
+          absolutePath: dest,
+          createdAt: now,
+        });
+      }
+    }
+
     const task = {
-      id: genId(),
+      id: taskId,
       // 标题取指令首行并截断：看板卡片只占一行，整段指令塞进标题会把卡片撑爆
       title: text.split('\n')[0].slice(0, 120),
       desc: text,
@@ -1831,6 +1982,7 @@ ${desc ? `描述：${desc}` : '描述：（无）'}${attachmentBlock}${templateB
       sequential: true,
       simpleOverride: '',
       projectPath: targetPath,
+      attachments,
       subtasks: [],
       status: 'todo',
       createdAt: now,
@@ -1846,6 +1998,9 @@ ${desc ? `描述：${desc}` : '描述：（无）'}${attachmentBlock}${templateB
       taskId: task.id,
       status: willRun ? 'accepted' : 'created',
       reason: autoRun && !schedulingActive ? '调度已暂停，只建了任务未执行' : '',
+      // 落点是怎么定下来的（explicit / mention / agent / default），
+      // 记下来才能在流水里回答用户那句"为什么派到这儿了"
+      targetSource: target.source,
     });
 
     publish('task:created', { task });
@@ -1866,6 +2021,53 @@ ${desc ? `描述：${desc}` : '描述：（无）'}${attachmentBlock}${templateB
       });
     }
 
-    res.json({ success: true, task, instruction: record, ran: willRun, schedulingActive });
+    res.json({ success: true, task, instruction: record, ran: willRun, schedulingActive, target });
+  }));
+
+  /**
+   * 派发前把附件落到暂存区。
+   *
+   * 为什么需要这一层：§17 的上传端点都要求 taskId / subId 当挂载点，而派发这一刻
+   * 任务还不存在。所以先写进 `_dispatch/`，**不写任何 JSON** —— 附件记录回给前端持有，
+   * 派发时再按 id 搬进任务目录。
+   * 代价是服务端在这里无状态：它不知道前端一共攒了几个，附件数上限只能在派发时统一卡。
+   */
+  app.post('/api/workbench/orchestrator/attachments', rawAttachment, asyncRoute(async (req, res) => {
+    await fsp.mkdir(DISPATCH_STAGING_DIR, { recursive: true });
+    const target = { attachments: [], storageDir: DISPATCH_STAGING_DIR };
+    const att = await writeAttachmentTo({ req, target, maxCount: MAX_ATTACHMENTS_PER_SUBTASK });
+    res.json({ success: true, attachment: att });
+  }));
+
+  /** 撤掉一个还没派发的附件（用户点了 ×）。id 形状不合法一律 404，不做路径拼接。 */
+  app.delete('/api/workbench/orchestrator/attachments/:attId', asyncRoute(async (req, res) => {
+    const full = await findStagingFile(req.params.attId);
+    if (!full) throw new HttpError(404, '附件不存在');
+    try { await fsp.unlink(full); } catch { /* 文件可能已不在 */ }
+    res.json({ success: true });
   }));
+
+  /** 暂存附件的缩略图 / 预览。与 §17 的 raw 端点同形，只是从暂存区取 */
+  app.get('/api/workbench/orchestrator/attachments/:attId/raw', asyncRoute(async (req, res) => {
+    const full = await findStagingFile(req.params.attId);
+    if (!full) throw new HttpError(404, '附件不存在');
+    const ext = path.extname(full).slice(1).toLowerCase();
+    try {
+      const st = await fsp.stat(full);
+      res.set('Content-Type', mimeForExt(ext));
+      res.set('Content-Length', String(st.size));
+      res.set('Cache-Control', 'private, max-age=3600');
+      const stream = fs.createReadStream(full);
+      stream.on('error', () => res.end());
+      stream.pipe(res);
+    } catch {
+      throw new HttpError(404, '文件已丢失');
+    }
+  }));
+
+  // 暂存区兜底清理：粘了图却没派发就关页面的痕迹，不该永久占着磁盘。
+  // 不上定时器 —— 暂存区的生命周期本来就是"几分钟内被派发掉"，启动清一次足够。
+  cleanupDispatchStaging().catch(err => {
+    logger.warn('[workbench] 清理派发附件暂存区失败:', err.message);
+  });
 }

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

@@ -36,6 +36,7 @@ import {
   genId,
 } from './shared.js';
 import { projectName } from './projectRegistry.js';
+import { TARGET_SOURCES } from './targetResolver.js';
 
 /** 活动流最多返回多少条（前端只渲染最近的一屏，多的不传） */
 export const MAX_ACTIVITY_ENTRIES = 120;
@@ -57,6 +58,9 @@ function normalizeInstruction(raw) {
     // accepted=已建任务 / rejected=被拒绝（暂停调度、项目不存在等）/ created=只建了草稿没执行
     status: ['accepted', 'rejected', 'created'].includes(it.status) ? it.status : 'created',
     reason: typeof it.reason === 'string' ? it.reason : '',
+    // 落点是怎么定下来的（explicit / mention / agent / default）。
+    // 老记录没有这个字段 —— 留空串，别硬塞一个默认值冒充"当时就是这么判断的"。
+    targetSource: TARGET_SOURCES.includes(it.targetSource) ? it.targetSource : '',
   };
 }
 
@@ -251,6 +255,8 @@ export function buildActivityFeed({ jobs = [], tasks = [], instructions = [] } =
       reason: it.reason || '',
       projectPath: it.projectPath || '',
       projectName: projectName(it.projectPath || ''),
+      // 落点来源（'' = 本次升级前的老记录）。前端据此说明"为什么派到这儿了"
+      targetSource: it.targetSource || '',
     });
   }
 

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

@@ -0,0 +1,73 @@
+// 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.
+//
+// 前后端项目路径归一的**口径一致性**守卫。
+//
+// 为什么值得单独一个测试文件：canonicalProjectPath 在前后端各实现一遍
+// （后端 routes/workbench/projectRegistry.js、前端 utils/path.ts），
+// 而它是「同一目录算不算同一个项目」的唯一判据 —— 两侧只要差一点点，
+// 同一个目录就会在两侧落到不同 key 上，表现为项目凭空分裂成两个。
+// 这个坑在本仓库**已经踩过两次**（斜杠方向一次、目录段大小写一次），
+// 两次的原因都不是逻辑写错，而是"改了一侧忘了另一侧"。
+//
+// 所以这里不验证行为（行为由 projectRegistry.test.js 覆盖），只验证
+// **两份源码里的归一表达式长得一样**。断言故意把规则内容也钉住：
+// 谁要改规则，就得同时改两侧、并来这里把期望值一起改掉 —— 这正是想要的效果。
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const SERVER_FILE = path.join(here, 'projectRegistry.js');
+const CLIENT_FILE = path.join(here, '..', '..', '..', 'client', 'src', 'utils', 'path.ts');
+
+/**
+ * 从源码里抠出归一规则那条 `return` 语句。
+ *
+ * 只匹配到行尾就够 —— 这条规则必须是一行纯表达式。哪天有人把它写成多行，
+ * 这里会直接断言失败，比"默默不同步"好得多。
+ */
+function extractRule(file, label) {
+  const src = readFileSync(file, 'utf8');
+  const anchor = src.indexOf('export function canonicalProjectPath');
+  assert.ok(anchor >= 0, `${label}(${file}) 里找不到 canonicalProjectPath 的定义`);
+  const m = src.slice(anchor).match(/return\s+s\.replace\([^\n]*/);
+  assert.ok(m, `${label} 的 canonicalProjectPath 里找不到 return s.replace(...) 这条归一表达式`);
+  // 去掉行尾分号与多余空白，让"分号写不写"这种无关差异不参与比较
+  return m[0].replace(/;\s*$/, '').replace(/\s+/g, ' ').trim();
+}
+
+test('前后端 canonicalProjectPath 的归一规则逐字一致（两侧分叉 = 项目会分裂成两个）', () => {
+  const server = extractRule(SERVER_FILE, '后端');
+  const client = extractRule(CLIENT_FILE, '前端');
+  assert.equal(
+    client,
+    server,
+    '前端 utils/path.ts 与后端 projectRegistry.js 的归一规则必须逐字一致；\n' +
+    `  后端: ${server}\n  前端: ${client}`,
+  );
+});
+
+test('归一规则里的"大小写"那一步被钉住（两侧一起改错也是分叉）', () => {
+  const rule = extractRule(SERVER_FILE, '后端');
+  // 只钉"大小写"这一步：它是这轮新加的、也是踩过坑的那一步。
+  // 斜杠归一与 POSIX 不动这两条由 projectRegistry.test.js 的行为断言守
+  // （那边能直接验 `D:/ws/y` === `D:\ws\y` 和 `/home/Me/A` 原样返回，
+  //  比在源码文本上抠字符串可靠得多）。
+  assert.match(rule, /toLowerCase\(\)/, '必须小写化，否则 C:\\Users\\x 与 c:\\users\\x 会裂成两个项目');
+  assert.doesNotMatch(rule, /toUpperCase\(\)/, '不该再转大写（旧口径只转盘符，已证明治不住目录段）');
+});