zen-gitsync 2.16.49 → 2.16.51

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

@@ -97,6 +97,21 @@ import {
   collectPriorOutputsUpTo,
   waitProcessExit,
 } from './taskRunner.js';
+import {
+  listProjects,
+  groupJobsByTask,
+  decorateTaskForBoard,
+  resolveTaskRepoPath,
+  buildTaskDetail,
+} from './projectRegistry.js';
+import {
+  readOrchestrator,
+  setOrchestratorActive,
+  appendInstruction,
+  isSchedulingActive,
+  buildActivityFeed,
+  buildRunningAgents,
+} from './orchestratorStore.js';
 
 const { genSessionId, read: readSessionFile, write: writeSessionFile, delete: deleteSessionFile, listMeta: listSessionsMeta, enforceRetention: enforceSessionsRetention } = sessionStore;
 
@@ -897,6 +912,9 @@ ${desc ? `描述：${desc}` : '描述：（无）'}${attachmentBlock}${templateB
     const taskType = rawType === 'simple' ? 'simple' : 'complex';
     const sequential = rawSequential === false ? false : true;
     const safeOverride = typeof simpleOverride === 'string' ? simpleOverride.slice(0, 8000) : '';
+    // 显式指定的归属项目（多项目编排台传选中项目）；不传则沿用当前项目。
+    // 只影响**新建**，更新分支一律保留任务原有的 projectPath（否则编辑一次就会把任务挪到当前项目去）。
+    const bodyProjectPath = typeof req.body?.projectPath === 'string' ? req.body.projectPath.trim() : '';
     const data = await readJson(TASKS_FILE, { tasks: [] });
     const tasks = data.tasks || [];
     const now = nowIso();
@@ -944,7 +962,7 @@ ${desc ? `描述：${desc}` : '描述：（无）'}${attachmentBlock}${templateB
       type: taskType,
       sequential: taskType === 'complex' ? sequential : true,
       simpleOverride: taskType === 'simple' ? safeOverride : '',
-      projectPath: currentProjectPath || '',
+      projectPath: bodyProjectPath || currentProjectPath || '',
       subtasks: Array.isArray(subtasks) ? subtasks.map(s => ({
         id: s.id || genId(),
         title: s.title || '',
@@ -1013,7 +1031,7 @@ ${desc ? `描述：${desc}` : '描述：（无）'}${attachmentBlock}${templateB
     if (!task.subtasks || task.subtasks.length === 0) {
       throw new HttpError(400, '任务没有子任务');
     }
-    const repoPath = typeof getCurrentProjectPath === 'function' ? getCurrentProjectPath() : '';
+    const repoPath = resolveTaskRepoPath(task, typeof getCurrentProjectPath === 'function' ? getCurrentProjectPath() : '');
     // 异步执行，立即返回
     res.json({ success: true, message: '已开始执行' });
     runTaskQueue(task, repoPath, '').catch(err => {
@@ -1032,7 +1050,7 @@ ${desc ? `描述：${desc}` : '描述：（无）'}${attachmentBlock}${templateB
     if (!Number.isInteger(startSubIndex) || startSubIndex < 0 || startSubIndex >= task.subtasks.length) {
       throw new HttpError(400, 'startSubIndex 越界');
     }
-    const repoPath = typeof getCurrentProjectPath === 'function' ? getCurrentProjectPath() : '';
+    const repoPath = resolveTaskRepoPath(task, typeof getCurrentProjectPath === 'function' ? getCurrentProjectPath() : '');
     res.json({ success: true, message: `已从第 ${startSubIndex + 1} 个子任务开始执行` });
     runTaskQueue(task, repoPath, '', { fromIndex: startSubIndex }).catch(err => {
       publish('task:error', { taskId: task.id, error: err.message });
@@ -1046,7 +1064,7 @@ ${desc ? `描述：${desc}` : '描述：（无）'}${attachmentBlock}${templateB
     if (task.type !== 'simple') {
       throw new HttpError(400, '该任务不是简单任务,请使用普通执行接口');
     }
-    const repoPath = typeof getCurrentProjectPath === 'function' ? getCurrentProjectPath() : '';
+    const repoPath = resolveTaskRepoPath(task, typeof getCurrentProjectPath === 'function' ? getCurrentProjectPath() : '');
     const virtualSub = {
       id: `${task.id}__simple`,
       title: task.title,
@@ -1076,7 +1094,7 @@ ${desc ? `描述：${desc}` : '描述：（无）'}${attachmentBlock}${templateB
     // 兜底:即便磁盘状态是 todo,如果磁盘里还没归档的 job 还在跑(进程被孤儿),也拦一下
     const liveJob = snapshotJobs().find(j => j.subId === subId && (j.status === 'running' || j.status === 'pending'));
     if (liveJob) throw new HttpError(400, '该子任务已有正在执行的 job');
-    const repoPath = typeof getCurrentProjectPath === 'function' ? getCurrentProjectPath() : '';
+    const repoPath = resolveTaskRepoPath(foundTask, typeof getCurrentProjectPath === 'function' ? getCurrentProjectPath() : '');
     res.json({ success: true, message: `已开始执行子任务：${foundSub.title || subId}` });
     (async () => {
       try {
@@ -1667,4 +1685,187 @@ ${desc ? `描述：${desc}` : '描述：（无）'}${attachmentBlock}${templateB
       throw new HttpError(404, '文件已丢失');
     }
   }));
+
+  // ════════════════════════════════════════════════════════════════════════
+  // §16. 多项目编排台（L1 看板 + 主 Agent 控制台）
+  //   GET  /api/workbench/projects               项目清单 + 看板任务
+  //   GET  /api/workbench/orchestrator           调度开关 + 指令存档 + 活动流
+  //   POST /api/workbench/orchestrator/state     暂停 / 恢复调度
+  //   POST /api/workbench/orchestrator/dispatch  派发一条人类干预指令
+  //
+  // 「暂停调度」的实际语义：只拦**自动派发**（dispatch 里带 autoRun），
+  // 手动点执行 / 子任务执行一概不受影响 —— 暂停的是主 Agent 的自主行为，
+  // 不是把用户的手也一起绑住。
+  // ════════════════════════════════════════════════════════════════════════
+
+  /**
+   * 组装「项目清单 + 看板任务」。
+   *
+   * 要探测 Git 状态的路径全部来自**服务端可信来源** —— configManager 的最近目录
+   * 与 tasks.json 里已有的 projectPath。本路由不接受任何客户端传入的路径，
+   * 因此不会被当成「任意路径 git 探测」的口子（口径同 /api/recent_directories/git-state）。
+   */
+  async function loadBoardPayload() {
+    const data = await readJson(TASKS_FILE, { tasks: [] });
+    const tasks = data.tasks || [];
+    const jobsSnap = snapshotJobs();
+
+    let recentDirs = [];
+    try {
+      if (configManager && typeof configManager.getRecentDirectories === 'function') {
+        recentDirs = (await configManager.getRecentDirectories()) || [];
+      }
+    } catch (err) {
+      // 最近目录读不到不该让整个看板挂掉：退化成"只按任务里出现过的项目"生成清单
+      logger.warn('[workbench] 读取最近目录失败，项目清单退化为仅按任务路径生成:', err.message);
+    }
+
+    const currentProjectPath = typeof getCurrentProjectPath === 'function' ? getCurrentProjectPath() : '';
+    // Git 探测自带 15s TTL 缓存（directoryGitState.js），看板 5s 轮询里有 2/3 是命中缓存，
+    // 实际 spawn 频率被自然限制在 15s 一次，不需要再给这个接口加"跳过一次探测"的开关。
+    const projects = await listProjects({ recentDirs, tasks, jobs: jobsSnap, currentProjectPath });
+    const jobsByTask = groupJobsByTask(jobsSnap);
+    const boardTasks = tasks.map(t => decorateTaskForBoard(t, jobsByTask.get(t.id) || []));
+    return { projects, tasks: boardTasks, currentProjectPath };
+  }
+
+  app.get('/api/workbench/projects', asyncRoute(async (_req, res) => {
+    const payload = await loadBoardPayload();
+    res.json({ success: true, ...payload });
+  }));
+
+  /**
+   * 单个任务的详情 —— 点看板卡片弹出的那个框用它。
+   *
+   * 为什么不把详情并进 /projects：那个接口是 5s 轮询的，只该发摘要
+   * （decorateTaskForBoard）。把子任务描述、报错、执行输出一起推，
+   * 十几条任务每 5 秒来一遍，纯属浪费带宽和解析时间。
+   * 这里按需取一次，且 output 由 trimJobForDetail 在服务端截尾。
+   *
+   * 注册位置：字面量路径 /tasks/ai-* 都在上面且只有一段，
+   * :id/detail 是两段，不会互相抢匹配。
+   */
+  app.get('/api/workbench/tasks/:id/detail', asyncRoute(async (req, res) => {
+    const id = req.params.id;
+    const data = await readJson(TASKS_FILE, { tasks: [] });
+    const task = (data.tasks || []).find(t => t && t.id === id);
+    if (!task) throw new HttpError(404, '任务不存在');
+
+    // loadAllJobs 已经把「文件里归档的 + 内存里还活着的」合并过（含 taskTitle/subTitle）
+    const allJobs = await loadAllJobs();
+    const detail = buildTaskDetail(task, allJobs.filter(j => j && j.taskId === id));
+    if (!detail) throw new HttpError(404, '任务不存在');
+
+    res.json({ success: true, ...detail });
+  }));
+
+  app.get('/api/workbench/orchestrator', asyncRoute(async (_req, res) => {
+    const state = await readOrchestrator();
+    const data = await readJson(TASKS_FILE, { tasks: [] });
+    const tasks = data.tasks || [];
+    const jobsSnap = snapshotJobs();
+    res.json({
+      success: true,
+      active: state.active,
+      updatedAt: state.updatedAt,
+      instructions: state.instructions,
+      activity: buildActivityFeed({ jobs: jobsSnap, tasks, instructions: state.instructions }),
+      running: buildRunningAgents({ jobs: jobsSnap, tasks }),
+    });
+  }));
+
+  app.post('/api/workbench/orchestrator/state', asyncRoute(async (req, res) => {
+    const active = req.body?.active;
+    if (typeof active !== 'boolean') throw new HttpError(400, 'active 必须是布尔值');
+    const state = await setOrchestratorActive(active);
+    publish('orchestrator:state', { active: state.active, updatedAt: state.updatedAt });
+    res.json({ success: true, active: state.active, updatedAt: state.updatedAt });
+  }));
+
+  /**
+   * 派发一条指令。
+   * body: { text, projectPath?, autoRun? }
+   *   - projectPath 缺省 = 当前项目
+   *   - autoRun 默认 true；调度暂停时只建任务不执行（指令记录里会写明原因）
+   *
+   * 指令一律落成目标项目下的**简单任务**（一句话交给 claude 跑一轮），
+   * 而不是造一个没有子任务的复杂任务 —— 后者连执行入口都没有，只会变成看板上的死卡。
+   */
+  app.post('/api/workbench/orchestrator/dispatch', asyncRoute(async (req, res) => {
+    const text = typeof req.body?.text === 'string' ? req.body.text.trim() : '';
+    if (!text) throw new HttpError(400, '指令内容不能为空');
+    if (text.length > 4000) throw new HttpError(400, '指令过长（上限 4000 字）');
+
+    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, '未选中项目，无法派发');
+
+    // 目标目录必须真的存在：跑在不存在的工作区上只会拿到一堆无意义的报错
+    let stat = null;
+    try { stat = await fsp.stat(targetPath); } catch { /* 下面统一报错 */ }
+    if (!stat || !stat.isDirectory()) {
+      const rejected = await appendInstruction({
+        text,
+        projectPath: targetPath,
+        status: 'rejected',
+        reason: '项目目录不存在',
+      });
+      publish('orchestrator:instruction', rejected);
+      throw new HttpError(400, `项目目录不存在：${targetPath}`);
+    }
+
+    const autoRun = req.body?.autoRun !== false;
+    const schedulingActive = await isSchedulingActive();
+
+    const data = await readJson(TASKS_FILE, { tasks: [] });
+    const tasks = data.tasks || [];
+    const now = nowIso();
+    const task = {
+      id: genId(),
+      // 标题取指令首行并截断：看板卡片只占一行，整段指令塞进标题会把卡片撑爆
+      title: text.split('\n')[0].slice(0, 120),
+      desc: text,
+      promptId: null,
+      type: 'simple',
+      sequential: true,
+      simpleOverride: '',
+      projectPath: targetPath,
+      subtasks: [],
+      status: 'todo',
+      createdAt: now,
+      updatedAt: now,
+    };
+    tasks.push(task);
+    await writeJson(TASKS_FILE, { tasks });
+
+    const willRun = autoRun && schedulingActive;
+    const record = await appendInstruction({
+      text,
+      projectPath: targetPath,
+      taskId: task.id,
+      status: willRun ? 'accepted' : 'created',
+      reason: autoRun && !schedulingActive ? '调度已暂停，只建了任务未执行' : '',
+    });
+
+    publish('task:created', { task });
+    publish('orchestrator:instruction', record);
+
+    // 与 POST /tasks/:id/run-simple 走同一条执行路径，避免出现第二套执行入口
+    if (willRun) {
+      const virtualSub = {
+        id: `${task.id}__simple`,
+        title: task.title,
+        desc: task.desc || '',
+        status: 'todo',
+        promptOverride: '',
+        attachments: [],
+      };
+      runSingleSubtask(task, virtualSub, targetPath, '', []).catch(err => {
+        publish('task:error', { taskId: task.id, error: err.message });
+      });
+    }
+
+    res.json({ success: true, task, instruction: record, ran: willRun, schedulingActive });
+  }));
 }

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

@@ -0,0 +1,260 @@
+// 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.
+//
+// 主 Agent 编排台的状态存储 + 活动流拼装。
+//
+// 两件事：
+//   1. 调度开关（active）+ 人类干预指令存档，持久化到 ~/.zen-gitsync/orchestrator.json。
+//      「暂停调度」是服务端强制的：暂停期间自动派发会被拒绝（手动点执行不受影响）。
+//   2. buildActivityFeed —— 把 job 的起止事实与人类指令合成一条时间倒序的活动流。
+//
+// 活动流为什么不在服务端拼好文案：
+//   UI 文案统一走前端 i18n（lang/{zh,en}），服务端只回**结构化事实**
+//   （kind + taskTitle + projectName + 时间），句子由前端 $t() 渲染。
+//   后端一旦写死中文，英文界面就会漏出中文。
+//
+// 指令存档只是"我说过什么"的流水，不参与执行逻辑；进它不算成功，出它也不算失败，
+// 失败原因记在单条指令的 status/reason 上（前端照着渲染）。
+
+import {
+  ORCHESTRATOR_FILE,
+  MAX_ORCHESTRATOR_INSTRUCTIONS,
+  readJson,
+  writeJson,
+  nowIso,
+  genId,
+} from './shared.js';
+import { projectName } from './projectRegistry.js';
+
+/** 活动流最多返回多少条（前端只渲染最近的一屏，多的不传） */
+export const MAX_ACTIVITY_ENTRIES = 120;
+
+/** 默认状态：新装 / 升级后直接是「调度中」，要停由用户自己去点暂停 */
+function defaultState() {
+  return { version: 1, active: true, updatedAt: null, instructions: [] };
+}
+
+/** 单条指令归一：老数据/半损坏数据都要能渲染，不能让整份状态读不出来 */
+function normalizeInstruction(raw) {
+  const it = raw && typeof raw === 'object' ? raw : {};
+  return {
+    id: typeof it.id === 'string' && it.id ? it.id : genId(),
+    text: typeof it.text === 'string' ? it.text : '',
+    projectPath: typeof it.projectPath === 'string' ? it.projectPath : '',
+    at: typeof it.at === 'string' ? it.at : null,
+    taskId: typeof it.taskId === 'string' && it.taskId ? it.taskId : null,
+    // accepted=已建任务 / rejected=被拒绝（暂停调度、项目不存在等）/ created=只建了草稿没执行
+    status: ['accepted', 'rejected', 'created'].includes(it.status) ? it.status : 'created',
+    reason: typeof it.reason === 'string' ? it.reason : '',
+  };
+}
+
+/** 归一化磁盘内容；文件缺失、损坏、字段缺失都必须能起来（编排台不能因为存档坏了就打不开） */
+export function normalizeOrchestrator(raw) {
+  const state = raw && typeof raw === 'object' ? raw : {};
+  const base = defaultState();
+  const instructions = Array.isArray(state.instructions) ? state.instructions : [];
+  return {
+    version: 1,
+    // 只有显式 false 才算暂停；其余（缺字段 / 脏值）一律当调度中
+    active: state.active === false ? false : true,
+    updatedAt: typeof state.updatedAt === 'string' ? state.updatedAt : base.updatedAt,
+    instructions: instructions
+      .filter(x => x && typeof x === 'object')
+      .slice(-MAX_ORCHESTRATOR_INSTRUCTIONS)
+      .map(normalizeInstruction),
+  };
+}
+
+/**
+ * 读-改-写串行化。
+ * 指令是"点一下就写一条"的高频小写操作，并发的两次读写会互相覆盖
+ * （后写的把前一条指令整个吞掉）。这里用一条 Promise 链把写操作排成队。
+ */
+let writeChain = Promise.resolve();
+function serialize(task) {
+  const next = writeChain.then(task, task);
+  // 吞掉链上的异常，避免一次失败让后续所有写操作都被拒绝
+  writeChain = next.catch(() => {});
+  return next;
+}
+
+export async function readOrchestrator() {
+  return normalizeOrchestrator(await readJson(ORCHESTRATOR_FILE, null));
+}
+
+async function persist(state) {
+  await writeJson(ORCHESTRATOR_FILE, state);
+  return state;
+}
+
+/** 暂停 / 恢复调度 */
+export async function setOrchestratorActive(active) {
+  return serialize(async () => {
+    const state = await readOrchestrator();
+    state.active = !!active;
+    state.updatedAt = nowIso();
+    return persist(state);
+  });
+}
+
+/** 追加一条人类干预指令记录，返回写入后的那条记录 */
+export async function appendInstruction(entry) {
+  return serialize(async () => {
+    const state = await readOrchestrator();
+    const record = normalizeInstruction({ id: genId(), at: nowIso(), ...entry });
+    state.instructions.push(record);
+    if (state.instructions.length > MAX_ORCHESTRATOR_INSTRUCTIONS) {
+      state.instructions = state.instructions.slice(-MAX_ORCHESTRATOR_INSTRUCTIONS);
+    }
+    await persist(state);
+    return record;
+  });
+}
+
+/** 回填某条指令的执行结果（建完任务后补 taskId / status） */
+export async function updateInstruction(id, patch) {
+  return serialize(async () => {
+    const state = await readOrchestrator();
+    const i = state.instructions.findIndex(x => x.id === id);
+    if (i < 0) return null;
+    state.instructions[i] = normalizeInstruction({ ...state.instructions[i], ...patch });
+    await persist(state);
+    return state.instructions[i];
+  });
+}
+
+export async function clearInstructions() {
+  return serialize(async () => {
+    const state = await readOrchestrator();
+    state.instructions = [];
+    state.updatedAt = nowIso();
+    return persist(state);
+  });
+}
+
+/**
+ * 正在执行的执行体清单（看板左栏「执行监控」用）。
+ *
+ * 一行 = 一个活跃 job（不是任务）：一个任务并行跑 3 个子任务就是三行，
+ * 因为"谁在跑什么"只有到 job 粒度才说得清。job 只是执行进程，
+ * 所以文案上叫「执行」而不是「Agent」—— 不要把正在跑的 claude 进程
+ * 渲染成一个并不存在的"智能体集群"。
+ *
+ * @param {{ jobs?: object[], tasks?: object[] }} input
+ */
+export function buildRunningAgents({ jobs = [], tasks = [] } = {}) {
+  const taskMap = new Map((Array.isArray(tasks) ? tasks : []).map(t => [t && t.id, t]));
+  return (Array.isArray(jobs) ? jobs : [])
+    .filter(j => j && (j.status === 'running' || j.status === 'pending'))
+    .map(j => {
+      const task = taskMap.get(j.taskId) || null;
+      const subs = task && Array.isArray(task.subtasks) ? task.subtasks : [];
+      const sub = subs.find(s => s && s.id === j.subId) || null;
+      const projectPath = (task && task.projectPath) || '';
+      return {
+        jobId: j.id,
+        taskId: j.taskId || null,
+        subId: j.subId || null,
+        taskTitle: (task && task.title) || '',
+        subTitle: (sub && sub.title) || '',
+        status: j.status,
+        pid: j.pid || null,
+        startedAt: j.startedAt || null,
+        projectPath,
+        projectName: projectName(projectPath),
+      };
+    })
+    .sort((a, b) => String(b.startedAt || '').localeCompare(String(a.startedAt || '')));
+}
+
+/** 供派发路由判断"现在能不能自动执行" */
+export async function isSchedulingActive() {
+  const state = await readOrchestrator();
+  return state.active;
+}
+
+/**
+ * 拼装活动流：job 的起止事实 + 人类指令，按时间倒序取前 MAX_ACTIVITY_ENTRIES 条。
+ *
+ * 一条 job 产出两条记录（派发 / 收尾），这是它的真实生命周期：
+ *   dispatch   ← startedAt 存在
+ *   done / error / cancelled ← endedAt 存在，按 status 分
+ * 只回结构化字段，句子交给前端 i18n。
+ *
+ * @param {{ jobs?: object[], tasks?: object[], instructions?: object[] }} input
+ */
+export function buildActivityFeed({ jobs = [], tasks = [], instructions = [] } = {}) {
+  const taskMap = new Map((Array.isArray(tasks) ? tasks : []).map(t => [t && t.id, t]));
+  const rows = [];
+
+  const projectOf = (task) => {
+    const p = (task && task.projectPath) || '';
+    return { projectPath: p, projectName: projectName(p) };
+  };
+
+  for (const j of Array.isArray(jobs) ? jobs : []) {
+    if (!j || !j.id) continue;
+    const task = taskMap.get(j.taskId) || null;
+    const subs = task && Array.isArray(task.subtasks) ? task.subtasks : [];
+    const sub = subs.find(s => s && s.id === j.subId) || null;
+    const base = {
+      jobId: j.id,
+      taskId: j.taskId || null,
+      subId: j.subId || null,
+      taskTitle: (task && task.title) || '',
+      subTitle: (sub && sub.title) || '',
+      jobStatus: j.status || '',
+      pid: j.pid || null,
+      ...projectOf(task),
+    };
+
+    if (j.startedAt) {
+      rows.push({ id: `job:${j.id}:start`, kind: 'dispatch', at: j.startedAt, ...base });
+    }
+    if (j.endedAt) {
+      const kind = j.status === 'done' ? 'done'
+        : j.status === 'cancelled' ? 'cancelled'
+          : 'error';
+      rows.push({
+        id: `job:${j.id}:end`,
+        kind,
+        at: j.endedAt,
+        exitCode: typeof j.exitCode === 'number' ? j.exitCode : null,
+        error: j.error || '',
+        ...base,
+      });
+    }
+  }
+
+  for (const it of Array.isArray(instructions) ? instructions : []) {
+    if (!it || !it.id) continue;
+    rows.push({
+      id: `ins:${it.id}`,
+      kind: 'user',
+      at: it.at,
+      instructionId: it.id,
+      text: it.text || '',
+      taskId: it.taskId || null,
+      instructionStatus: it.status || 'created',
+      reason: it.reason || '',
+      projectPath: it.projectPath || '',
+      projectName: projectName(it.projectPath || ''),
+    });
+  }
+
+  // 时间缺失的排最后（排序键用空串，天然沉底）
+  rows.sort((a, b) => String(b.at || '').localeCompare(String(a.at || '')));
+  return rows.slice(0, MAX_ACTIVITY_ENTRIES);
+}