zen-gitsync 2.16.49 → 2.16.51

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

@@ -0,0 +1,339 @@
+// 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.
+//
+// 多项目编排台的纯函数单测：任务列推导、项目合并去重、执行目录解析、活动流拼装。
+// 这些规则前后端只实现一次（后端），所以口径漂移的代价全压在这里的断言上。
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  canonicalProjectPath,
+  projectName,
+  resolveTaskRepoPath,
+  deriveTaskColumn,
+  latestJob,
+  summarizeProjectTasks,
+  buildProjectEntries,
+  decorateTaskForBoard,
+  OUTPUT_TAIL_CHARS,
+  trimJobForDetail,
+  buildTaskDetail,
+} from './projectRegistry.js';
+import { normalizeOrchestrator, buildActivityFeed, buildRunningAgents } from './orchestratorStore.js';
+
+const sub = (id, status) => ({ id, title: id, desc: '', status, promptOverride: '' });
+const job = (id, taskId, status, startedAt, endedAt = null) => ({
+  id, taskId, subId: `${taskId}__${id}`, title: '', status, startedAt, endedAt,
+});
+
+// ── 路径归一 ────────────────────────────────────────────────────────
+
+test('canonicalProjectPath: 盘符转大写 + Windows 斜杠归一（与前端同口径）', () => {
+  assert.equal(canonicalProjectPath('e:\\workspace\\x'), 'E:\\workspace\\x');
+  assert.equal(canonicalProjectPath('  D:/ws/y  '), 'D:\\ws\\y');
+  // 同一目录的两种斜杠写法必须落到同一个 key，否则项目列表里出现重复项
+  // （实测 article-generator 就同时存在于 D:/... 与 D:\... 两种常用目录里）
+  assert.equal(canonicalProjectPath('D:/ws/y'), canonicalProjectPath('D:\\ws\\y'));
+  // POSIX 路径原样返回，不能被改写成反斜杠
+  assert.equal(canonicalProjectPath('/home/me/proj'), '/home/me/proj');
+  assert.equal(canonicalProjectPath('/home/me/proj/nested'), '/home/me/proj/nested');
+  assert.equal(canonicalProjectPath(''), '');
+  assert.equal(canonicalProjectPath(null), '');
+});
+
+test('projectName 取末级目录名，空路径返回空串', () => {
+  assert.equal(projectName('D:\\ws\\zen-gitsync'), 'zen-gitsync');
+  assert.equal(projectName('/home/me/proj/'), 'proj');
+  assert.equal(projectName(''), '');
+});
+
+// ── 执行目录 ────────────────────────────────────────────────────────
+
+test('resolveTaskRepoPath 优先用任务自己的项目，空则回退当前项目', () => {
+  assert.equal(resolveTaskRepoPath({ projectPath: 'D:\\proj-a' }, 'D:\\proj-b'), 'D:\\proj-a');
+  assert.equal(resolveTaskRepoPath({ projectPath: '   ' }, 'D:\\proj-b'), 'D:\\proj-b');
+  assert.equal(resolveTaskRepoPath({}, 'D:\\proj-b'), 'D:\\proj-b');
+  // 目录不存在也不回退：宁可执行报错，也不能把改动悄悄落到另一个仓库
+  assert.equal(resolveTaskRepoPath({ projectPath: 'Z:\\gone' }, 'D:\\proj-b'), 'Z:\\gone');
+});
+
+// ── 看板列推导 ──────────────────────────────────────────────────────
+
+test('deriveTaskColumn: 从没动过的任务在待处理', () => {
+  assert.equal(deriveTaskColumn({ subtasks: [] }, []), 'todo');
+  assert.equal(deriveTaskColumn({ subtasks: [sub('s1', 'todo')] }, []), 'todo');
+});
+
+test('deriveTaskColumn: 有 job 在跑或子任务 running 就是进行中', () => {
+  assert.equal(deriveTaskColumn({ subtasks: [] }, [job('j1', 't1', 'running', '2026-01-01T00:00:00Z')]), 'doing');
+  assert.equal(deriveTaskColumn({ subtasks: [] }, [job('j1', 't1', 'pending', '2026-01-01T00:00:00Z')]), 'doing');
+  assert.equal(deriveTaskColumn({ subtasks: [sub('s1', 'running')] }, []), 'doing');
+});
+
+test('deriveTaskColumn: 子任务全部完成才算已完成', () => {
+  assert.equal(deriveTaskColumn({ subtasks: [sub('s1', 'done'), sub('s2', 'done')] }, []), 'done');
+  // 一半完成 → 跑过但没收尾，落在评审中
+  assert.equal(deriveTaskColumn({ subtasks: [sub('s1', 'done'), sub('s2', 'todo')] }, []), 'review');
+  // 有子任务报错也算"需要人看一眼"
+  assert.equal(deriveTaskColumn({ subtasks: [sub('s1', 'error'), sub('s2', 'todo')] }, []), 'review');
+});
+
+test('deriveTaskColumn: 无子任务的任务只能看执行记录', () => {
+  assert.equal(deriveTaskColumn({ subtasks: [], type: 'simple' }, [job('j1', 't1', 'done', '2026-01-01T00:00:00Z')]), 'done');
+  assert.equal(deriveTaskColumn({ subtasks: [], type: 'simple' }, [job('j1', 't1', 'cancelled', '2026-01-01T00:00:00Z')]), 'review');
+  assert.equal(deriveTaskColumn({ subtasks: [], type: 'simple' }, [job('j1', 't1', 'error', '2026-01-01T00:00:00Z')]), 'review');
+});
+
+test('latestJob 按 startedAt 取最新的一条', () => {
+  const list = [
+    job('j1', 't1', 'error', '2026-01-01T00:00:00Z', '2026-01-01T00:01:00Z'),
+    job('j2', 't1', 'done', '2026-01-02T00:00:00Z', '2026-01-02T00:01:00Z'),
+  ];
+  assert.equal(latestJob(list).id, 'j2');
+  assert.equal(latestJob([]), null);
+});
+
+// ── 项目合并去重 ────────────────────────────────────────────────────
+
+test('buildProjectEntries: 最近目录与任务路径取并集去重，盘符大小写归一', () => {
+  const entries = buildProjectEntries({
+    recentDirs: ['e:\\ws\\proj-a', 'D:\\ws\\proj-b'],
+    tasks: [
+      { id: 't1', projectPath: 'E:\\ws\\proj-a' }, // 与最近目录同一项目（盘符大小写不同）
+      { id: 't2', projectPath: 'D:\\ws\\proj-c' }, // 只在任务里出现
+      { id: 't3', projectPath: '' },               // 未关联项目，不进清单
+    ],
+  });
+  const byKey = new Map(entries.map(e => [e.key, e]));
+  assert.equal(entries.length, 3);
+  assert.equal(byKey.get('E:\\ws\\proj-a').source, 'both');
+  assert.equal(byKey.get('D:\\ws\\proj-b').source, 'recent');
+  assert.equal(byKey.get('D:\\ws\\proj-c').source, 'task');
+  assert.equal(byKey.get('D:\\ws\\proj-c').name, 'proj-c');
+});
+
+test('summarizeProjectTasks: 按项目汇总列数量、进度、活跃执行与最后活跃时间', () => {
+  const tasks = [
+    // A 项目：1 个已完成
+    { id: 'a1', projectPath: 'D:\\a', subtasks: [sub('a1s', 'done')], updatedAt: '2026-01-01T00:00:00Z' },
+    // A 项目：1 个在跑（job running）
+    { id: 'a2', projectPath: 'D:\\a', subtasks: [sub('a2s', 'running')], updatedAt: '2026-01-02T00:00:00Z' },
+    // B 项目：1 个待处理
+    { id: 'b1', projectPath: 'D:\\b', subtasks: [sub('b1s', 'todo')], updatedAt: '2026-01-03T00:00:00Z' },
+  ];
+  const jobs = [
+    job('j1', 'a2', 'running', '2026-01-04T00:00:00Z'),
+    job('j2', 'a1', 'done', '2026-01-01T01:00:00Z', '2026-01-01T01:30:00Z'),
+  ];
+  const stats = summarizeProjectTasks(tasks, jobs);
+
+  const a = stats.get('D:\\a');
+  assert.equal(a.total, 2);
+  assert.equal(a.done, 1);
+  assert.equal(a.doing, 1);
+  assert.equal(a.progress, 50);
+  assert.equal(a.runningJobs, 1);
+  // 最后活跃时间要把 job 的起止也算进来（任务体本身可能很久没改）
+  assert.equal(a.lastActiveAt, '2026-01-04T00:00:00Z');
+
+  const b = stats.get('D:\\b');
+  assert.equal(b.total, 1);
+  assert.equal(b.todo, 1);
+  assert.equal(b.progress, 0);
+  assert.equal(b.runningJobs, 0);
+  assert.equal(b.lastActiveAt, '2026-01-03T00:00:00Z');
+});
+
+test('decorateTaskForBoard: 只回卡片需要的字段', () => {
+  const card = decorateTaskForBoard({
+    id: 't1', title: '标题', desc: '描述', projectPath: 'D:\\a',
+    subtasks: [sub('s1', 'done'), sub('s2', 'error')],
+    attachments: [{ id: 'at1' }],
+    createdAt: '2026-01-01T00:00:00Z', updatedAt: '2026-01-02T00:00:00Z',
+  }, []);
+  assert.equal(card.column, 'review');
+  assert.equal(card.type, 'complex');
+  assert.equal(card.subtaskCount, 2);
+  assert.equal(card.subtaskDoneCount, 1);
+  assert.equal(card.subtaskErrorCount, 1);
+  assert.equal(card.attachmentCount, 1);
+  assert.equal(card.runningJobs, 0);
+});
+
+// ── 编排状态与活动流 ────────────────────────────────────────────────
+
+test('normalizeOrchestrator: 缺字段/脏数据都要能起来', () => {
+  const fresh = normalizeOrchestrator(null);
+  assert.equal(fresh.active, true); // 缺省是"调度中"
+  assert.deepEqual(fresh.instructions, []);
+
+  assert.equal(normalizeOrchestrator({ active: false }).active, false);
+  assert.equal(normalizeOrchestrator({ active: 'no' }).active, true); // 只有显式 false 才算暂停
+
+  const withJunk = normalizeOrchestrator({ instructions: [null, 5, { text: 'hi' }] });
+  assert.equal(withJunk.instructions.length, 1);
+  assert.equal(withJunk.instructions[0].text, 'hi');
+  assert.equal(withJunk.instructions[0].status, 'created');
+});
+
+test('buildActivityFeed: job 起止合成两条记录，与人类指令一起按时间倒序', () => {
+  const jobs = [{
+    id: 'j1', taskId: 't1', subId: 's1', status: 'done', pid: 123,
+    startedAt: '2026-01-01T00:00:00Z', endedAt: '2026-01-01T00:05:00Z', exitCode: 0,
+  }];
+  const tasks = [{
+    id: 't1', projectPath: 'D:\\ws\\proj-a',
+    subtasks: [{ id: 's1', title: '子任务一', status: 'done' }],
+    title: '任务一',
+  }];
+  const instructions = [{
+    id: 'i1', text: '把这些重构一下', projectPath: 'D:\\ws\\proj-a',
+    at: '2026-01-01T00:10:00Z', status: 'accepted',
+  }];
+
+  const feed = buildActivityFeed({ jobs, tasks, instructions });
+  assert.equal(feed.length, 3);
+  assert.deepEqual(feed.map(r => r.kind), ['user', 'done', 'dispatch']);
+  assert.equal(feed[1].taskTitle, '任务一');
+  assert.equal(feed[1].subTitle, '子任务一');
+  assert.equal(feed[1].projectName, 'proj-a');
+  assert.equal(feed[2].pid, 123);
+  assert.equal(feed[0].instructionStatus, 'accepted');
+});
+
+test('buildActivityFeed: 失败与取消分别落成 error / cancelled', () => {
+  const jobs = [
+    { id: 'j1', taskId: 't1', subId: 's1', status: 'error', startedAt: '2026-01-01T00:00:00Z', endedAt: '2026-01-01T00:01:00Z', error: 'boom' },
+    { id: 'j2', taskId: 't1', subId: 's2', status: 'cancelled', startedAt: '2026-01-01T00:02:00Z', endedAt: '2026-01-01T00:03:00Z' },
+  ];
+  const feed = buildActivityFeed({ jobs, tasks: [{ id: 't1', projectPath: 'D:\\a', subtasks: [] }] });
+  const kinds = feed.map(r => r.kind);
+  assert.ok(kinds.includes('error'));
+  assert.ok(kinds.includes('cancelled'));
+  assert.equal(feed.find(r => r.kind === 'error').error, 'boom');
+});
+
+test('buildActivityFeed: 任务已被删除时仍能出记录（不留孤儿空白）', () => {
+  const jobs = [{ id: 'j1', taskId: 'gone', subId: 's1', status: 'done', startedAt: '2026-01-01T00:00:00Z', endedAt: '2026-01-01T00:01:00Z' }];
+  const feed = buildActivityFeed({ jobs, tasks: [] });
+  assert.equal(feed.length, 2);
+  assert.equal(feed[0].taskTitle, '');
+  assert.equal(feed[0].projectName, '');
+});
+
+test('buildRunningAgents: 只列活跃 job，到 job 粒度而不是任务粒度', () => {
+  const tasks = [{
+    id: 't1', projectPath: 'D:\\ws\\proj-a', subtasks: [
+      { id: 's1', title: '子任务一', status: 'running' },
+      { id: 's2', title: '子任务二', status: 'running' },
+    ],
+  }];
+  const jobs = [
+    { id: 'j1', taskId: 't1', subId: 's1', status: 'running', pid: 111, startedAt: '2026-01-01T00:02:00Z' },
+    { id: 'j2', taskId: 't1', subId: 's2', status: 'pending', pid: 222, startedAt: '2026-01-01T00:01:00Z' },
+    { id: 'j3', taskId: 't1', subId: 's3', status: 'done', pid: 333, startedAt: '2026-01-01T00:00:00Z' },
+  ];
+  const running = buildRunningAgents({ jobs, tasks });
+  assert.equal(running.length, 2);
+  // 最新的排在前面
+  assert.equal(running[0].jobId, 'j1');
+  assert.equal(running[0].subTitle, '子任务一');
+  assert.equal(running[0].projectName, 'proj-a');
+  assert.equal(running[1].status, 'pending');
+});
+
+// ── 任务详情（点卡片弹窗用） ────────────────────────────────────────
+
+test('trimJobForDetail: 丢 prompt/thinking，output 只留尾部并标记被截断', () => {
+  const big = 'x'.repeat(OUTPUT_TAIL_CHARS + 500) + 'END';
+  const j = {
+    id: 'j1', taskId: 't1', subId: 's1', title: '跑一下', status: 'done',
+    prompt: 'P'.repeat(10000), thinking: 'T'.repeat(10000),
+    output: big, pid: 42, startedAt: '2026-01-01T00:00:00Z', endedAt: '2026-01-01T00:01:00Z',
+    exitCode: 0, error: '',
+  };
+  const t = trimJobForDetail(j);
+  assert.equal(t.outputTail.length, OUTPUT_TAIL_CHARS);
+  assert.equal(t.outputTruncated, true);
+  assert.equal(t.hasOutput, true);
+  // 保留的是尾部，不是头部
+  assert.equal(t.outputTail.endsWith('END'), true);
+  assert.equal(t.outputTruncated === true && t.outputTail.startsWith('x'), true);
+  // 大字段必须被丢掉，否则弹窗会把整份日志搬进 DOM
+  assert.equal('prompt' in t, false);
+  assert.equal('thinking' in t, false);
+  assert.equal(t.pid, 42);
+  assert.equal(t.exitCode, 0);
+});
+
+test('trimJobForDetail: 短输出原样保留且不谎报截断', () => {
+  const t = trimJobForDetail({ id: 'j1', status: 'error', output: 'boom', error: '炸了' });
+  assert.equal(t.outputTail, 'boom');
+  assert.equal(t.outputTruncated, false);
+  assert.equal(t.error, '炸了');
+  assert.equal(t.pid, null);
+  assert.equal(t.exitCode, null);
+});
+
+test('trimJobForDetail: null / 无 output 不炸', () => {
+  assert.equal(trimJobForDetail(null), null);
+  const t = trimJobForDetail({ id: 'j2', status: 'pending' });
+  assert.equal(t.outputTail, '');
+  assert.equal(t.outputTruncated, false);
+  assert.equal(t.hasOutput, false);
+});
+
+test('buildTaskDetail: 任务缺失返回 null（交路由转 404）', () => {
+  assert.equal(buildTaskDetail(null, []), null);
+  assert.equal(buildTaskDetail({}, []), null);
+});
+
+test('buildTaskDetail: lastJob 取最新一条，recentJobs 倒序且被限制条数', () => {
+  const task = {
+    id: 't1', title: '任务', desc: '', type: 'complex',
+    subtasks: [sub('s1', 'done'), sub('s2', 'running')],
+    attachments: [{ id: 'a1' }],
+  };
+  const jobs = [
+    job('j1', 't1', 'done', '2026-01-01T00:00:00Z', '2026-01-01T00:01:00Z'),
+    job('j3', 't1', 'running', '2026-01-01T00:02:00Z'),
+    job('j2', 't1', 'done', '2026-01-01T00:01:00Z', '2026-01-01T00:02:00Z'),
+  ];
+  const d = buildTaskDetail(task, jobs);
+  assert.equal(d.task.id, 't1');
+  assert.equal(d.jobCount, 3);
+  // 最新的是 j3（有 startedAt 无 endedAt，时间戳取 startedAt）
+  assert.equal(d.lastJob.id, 'j3');
+  assert.equal(d.recentJobs[0].id, 'j3');
+  assert.equal(d.recentJobs[1].id, 'j2');
+  assert.equal(d.recentJobs[2].id, 'j1');
+  // 有 job 在跑 → 进行中
+  assert.equal(d.column, 'doing');
+});
+
+test('buildTaskDetail: recentJobLimit 生效；无 job 时 lastJob 为 null 而不是抛错', () => {
+  const task = { id: 't2', title: '', desc: '', type: 'simple', subtasks: [] };
+  const jobs = [1, 2, 3, 4, 5, 6].map(i => job('j' + i, 't2', 'done', `2026-01-0${i}T00:00:00Z`));
+  const d = buildTaskDetail(task, jobs, { recentJobLimit: 2 });
+  assert.equal(d.recentJobs.length, 2);
+  assert.equal(d.jobCount, 6);
+  assert.equal(d.lastJob.id, 'j6');
+
+  const empty = buildTaskDetail(task, []);
+  assert.equal(empty.lastJob, null);
+  assert.deepEqual(empty.recentJobs, []);
+  assert.equal(empty.jobCount, 0);
+  assert.equal(empty.column, 'todo');
+});

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

@@ -0,0 +1,51 @@
+// 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.
+//
+// 任务 prompt 正文的拼装规则（纯函数，无副作用）。
+//
+// 为什么单独成一个文件：taskRunner.js 顶层 import 了 jobStore.js，而后者在**模块加载时**
+// 就调用 hydrateJobs() 并回写 ~/.zen-gitsync/jobs.json（还会把陈旧的 running/pending 降级为
+// error 后落盘）。单测若直接 import taskRunner 就会碰到真实用户数据 ——
+// 所以把"纯拼装"这一小块剥出来，测试只碰它。
+
+/**
+ * 拼任务 prompt 的正文 = 提示词模板 + 子任务标题 + 子任务描述。
+ *
+ * 去重规则只作用于「标题 / 描述」这一对：
+ *   主 Agent 派发（POST /api/workbench/orchestrator/dispatch）建的简单任务里
+ *   `title = text.split('\n')[0].slice(0, 120)`、`desc = text` —— 单行指令时两者逐字相同，
+ *   直接拼会得到「帮我拉取一下代码\n\n帮我拉取一下代码」：白烧 token，而且让 prompt
+ *   看起来像谁把话说了两遍。首行超过 120 字时 title 是首行的**前缀**，所以用
+ *   startsWith 兜住这个截断情形（判定重复只要求"标题已被描述完整包含"，不丢信息）。
+ *
+ * 模板（interpolated）刻意不参与去重：那是用户显式配置的提示词，
+ * 与标题撞车与否该由用户决定，代码不擅自删。
+ *
+ * @param {string} template 已插值的提示词模板，可为空
+ * @param {string} title    子任务标题
+ * @param {string} desc     子任务描述
+ * @returns {string} 用空行分隔的非空段落
+ */
+export function composePromptBody(template, title, desc) {
+  const t = (title || '').trim();
+  const d = (desc || '').trim();
+  // 描述首行 —— title 由它截断而来，这是判定"重复"的依据
+  const firstLine = d.split('\n')[0];
+  const titleRedundant = !!t && (t === d || firstLine.startsWith(t));
+
+  // 判定用 trim 后的值，但拼进 prompt 的仍是**原值**：
+  // 只删掉重复的那一段，其余一个字符都不动（缩进、结尾换行都保持原样）。
+  const body = titleRedundant ? [desc] : [title, desc];
+  return [template, ...body].filter(s => s && s.trim()).join('\n\n');
+}

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

@@ -0,0 +1,82 @@
+// 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.
+//
+// prompt 正文拼装的单测。
+//
+// 回归目标：主 Agent 派发建的简单任务（title = desc 首行）曾把同一句话拼两遍进 prompt ——
+// 实测 job.prompt 是「帮我拉取一下代码\n\n帮我拉取一下代码」。
+// 这里把"什么算重复、什么不算"钉死，避免以后又把用户手填的标题误删、或漏掉截断情形。
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+
+import { composePromptBody } from './promptParts.js';
+
+test('单行指令：title 与 desc 逐字相同时只出现一次', () => {
+  const out = composePromptBody('', '帮我拉取一下代码', '帮我拉取一下代码');
+  assert.equal(out, '帮我拉取一下代码');
+  // 反例锚点：这正是修复前的产物
+  assert.notEqual(out, '帮我拉取一下代码\n\n帮我拉取一下代码');
+});
+
+test('多行描述：title 就是首行时只留描述全文（首行不重复）', () => {
+  const out = composePromptBody('', '重构登录', '重构登录\n把错误处理抽成 composable');
+  assert.equal(out, '重构登录\n把错误处理抽成 composable');
+});
+
+test('派发路径的截断：title 是超长首行的前 120 字时仍判为重复', () => {
+  const firstLine = 'A'.repeat(200);
+  const title = firstLine.slice(0, 120); // 与 dispatch 路由的 slice(0,120) 同口径
+  const desc = `${firstLine}\n第二行`;
+  assert.equal(composePromptBody('', title, desc), desc);
+});
+
+test('标题被描述完整包含（后接其它文字）也算重复 —— 描述已含标题的全部信息', () => {
+  const out = composePromptBody('', '拉取代码', '拉取代码（顺便更新依赖）');
+  assert.equal(out, '拉取代码（顺便更新依赖）');
+});
+
+test('用户手填的标题与描述不同：两段都要保留', () => {
+  const out = composePromptBody('', '修复登录白屏', '用户反馈登录页点确定后白屏，帮我定位');
+  assert.equal(out, '修复登录白屏\n\n用户反馈登录页点确定后白屏，帮我定位');
+});
+
+test('标题只是描述中间出现过的词，不算重复（不做子串匹配）', () => {
+  const out = composePromptBody('', '登录', '修复登录白屏');
+  // '修复登录白屏' 的首行不以 '登录' 开头 → 两段都在
+  assert.equal(out, '登录\n\n修复登录白屏');
+});
+
+test('模板 + 不重复的标题/描述：三段按序拼接', () => {
+  const out = composePromptBody('请用中文回答', '重构登录', '把错误处理抽成 composable');
+  assert.equal(out, '请用中文回答\n\n重构登录\n\n把错误处理抽成 composable');
+});
+
+test('模板不参与去重：与标题相同也不删', () => {
+  const out = composePromptBody('重构登录', '重构登录', '把错误处理抽成 composable');
+  assert.equal(out, '重构登录\n\n重构登录\n\n把错误处理抽成 composable');
+});
+
+test('空段一律不占位，不产生多余空行', () => {
+  assert.equal(composePromptBody('', '', '仅描述'), '仅描述');
+  assert.equal(composePromptBody('', '仅标题', ''), '仅标题');
+  assert.equal(composePromptBody('模板', '', ''), '模板');
+  assert.equal(composePromptBody('', '', ''), '');
+  assert.equal(composePromptBody('   ', '  ', '\n'), '');
+});
+
+test('判定用 trim 值，但拼进 prompt 的是原值（缩进与结尾换行保持原样）', () => {
+  const desc = '  缩进的描述\n';
+  assert.equal(composePromptBody('', '  缩进的描述\n', desc), desc);
+});

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

@@ -44,6 +44,11 @@ export const JOBS_CONFIG_FILE = path.join(DATA_DIR, 'jobs-config.json');
 export const JOBS_SAVE_DEBOUNCE_MS = 1500;
 export const DEFAULT_JOBS_CONFIG = { maxCount: 500, maxSizeMB: 256 };
 
+// 主 Agent 编排台：调度开关（active）+ 人类干预指令存档。
+// 指令存档是「我说过什么」的流水，不参与执行逻辑，只用于控制台日志流回放。
+export const ORCHESTRATOR_FILE = path.join(DATA_DIR, 'orchestrator.json');
+export const MAX_ORCHESTRATOR_INSTRUCTIONS = 200;
+
 // 子项目识别 / 文件扫描时需要跳过的目录
 export const SKIP_DIRS = new Set([
   'node_modules', 'dist', 'build', '.next', '.nuxt', '__pycache__',

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

@@ -38,6 +38,7 @@ import {
   interpolate,
 } from './shared.js';
 import { buildAttachmentBlock } from './pdfText.js';
+import { composePromptBody } from './promptParts.js';
 import {
   jobs,
   cancelledJobs,
@@ -211,8 +212,8 @@ export async function runSingleSubtask(task, sub, repoPath, branch, priorOutputs
     branch: branch || ''
   };
   const interpolated = interpolate(promptTemplate, ctx);
-  const parts = [interpolated, sub.title, sub.desc].filter(s => s && s.trim());
-  let prompt = parts.join('\n\n');
+  // 标题与描述可能逐字相同（派发建的简单任务就是），去重规则见 promptParts.js
+  let prompt = composePromptBody(interpolated, sub.title, sub.desc);
 
   // ── 前序上下文：把前几个 done 子任务的输出完整拼到 prompt 头部 ──
   if (priorOutputs && priorOutputs.length > 0) {

package/src/ui/server/utils/directoryGitState.js

@@ -12,14 +12,16 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 //
-// 批量探测目录的 Git 状态(是不是仓库 / 有没有未提交改动)。
+// 批量探测目录的 Git 状态(是不是仓库 / 有没有未提交改动 / 与上游差多少)。
 //
 // 用途:「最近项目」「常用目录」列表要在卡片上标出 Git 状态,列表里可能有十几个目录,
-// 因此这里做三件事:
+// 因此这里做四件事:
 //   1. 每个目录只跑**一次** git(status 成功即说明是仓库,失败即非仓库),
-//      避免 rev-parse + status 两次 spawn;
+//      并用 --branch 顺带拿到分支与领先/落后,避免额外 3 次 spawn;
 //   2. 并发上限 + 单目录超时,别让某个大仓库(或网络盘)拖死整个请求;
-//   3. 结果短 TTL 缓存,弹窗反复打开不必重复扫盘。
+//   3. 结果短 TTL 缓存,弹窗反复打开不必重复扫盘;
+//   4. 领先/落后只读**本地 remote-tracking 引用,不联网 fetch** —— 探测十几个目录
+//      去联网是不可接受的;口径与应用里那条「你的分支落后」提示一致。
 //
 // 不用 src/utils/index.js 的 execGitCommand:那个函数固定跑在当前项目 cwd,
 // 且会把每次调用写进命令历史和 socket 广播 —— 探测十几个无关目录不该污染这些。
@@ -46,14 +48,23 @@ export function normalizeDirKey(dirPath) {
 
 /** 空状态(非仓库 / 探测失败时复用),避免各处手写零值 */
 function emptyState(extra = {}) {
-  return { exists: true, isGitRepo: false, changed: 0, staged: 0, unstaged: 0, untracked: 0, ...extra };
+  return {
+    exists: true,
+    isGitRepo: false,
+    // 工作区计数
+    changed: 0, staged: 0, unstaged: 0, untracked: 0,
+    // 分支与上游跟踪
+    branch: null, upstream: null, hasUpstream: false, detached: false, ahead: 0, behind: 0,
+    ...extra,
+  };
 }
 
 /**
- * 解析 `git status --porcelain=v1` 输出 → 计数。
+ * 解析 `git status --porcelain=v1` 输出 → 工作区计数。
  * 纯函数,单测覆盖。
  *
  * 格式:`XY path`,X=暂存区状态,Y=工作区状态。
+ *   - `## ...` → 分支头(见 parseBranchTracking),**不计入改动**
  *   - `??` → 未跟踪
  *   - `!!` → 被忽略(porcelain 默认不输出,防御性跳过)
  *   - 其余非空位 → 计入暂存/未暂存(冲突如 `UU` 会同时计入两边)
@@ -63,6 +74,9 @@ export function parsePorcelainStatus(stdout) {
   const result = { changed: 0, staged: 0, unstaged: 0, untracked: 0 };
   for (const rawLine of String(stdout || '').split('\n')) {
     const line = rawLine.replace(/\r$/, '');
+    // 必须显式跳过分支头:`## main...origin/main` 的前两个字符是 `#`,
+    // 既不是 `!!` 也不是 `??`,漏掉会把它算成 1 个"已暂存 + 未暂存"的文件。
+    if (line.startsWith('##')) continue;
     if (line.length < 3) continue;
     const x = line[0];
     const y = line[1];
@@ -78,6 +92,68 @@ export function parsePorcelainStatus(stdout) {
   return result;
 }
 
+/**
+ * 解析 `git status --porcelain=v1 --branch` 的 `##` 头 → 分支与领先/落后。
+ * 纯函数,单测覆盖。
+ *
+ * 见过的几种形状:
+ *   `## main...origin/main [ahead 1, behind 2]`  有上游且有差异
+ *   `## main...origin/main`                     有上游且同步
+ *   `## main...origin/main [gone]`              上游被删了(ahead/behind 无意义)
+ *   `## main`                                   有分支但没设上游
+ *   `## HEAD (no branch)`                       分离 HEAD
+ *   `## No commits yet on main`                 空仓库(老 git 是 `## Initial commit on main`)
+ *
+ * 领先/落后取自**本地 remote-tracking 引用**,不联网 fetch —— 与应用里那条
+ * 「你的分支落后 'origin/develop' 17 个提交」同一口径(都基于上次 fetch 的结果)。
+ */
+export function parseBranchTracking(stdout) {
+  const result = { branch: null, upstream: null, hasUpstream: false, detached: false, ahead: 0, behind: 0 };
+  const headLine = String(stdout || '')
+    .split('\n')
+    .map(l => l.replace(/\r$/, ''))
+    .find(l => l.startsWith('## '));
+  if (!headLine) return result;
+
+  let head = headLine.slice(3).trim();
+  // 跟踪信息固定在末尾方括号里,先摘掉再拆分支名(分支名里不可能出现 `[`)
+  const bracket = head.match(/\s+\[(.+)\]$/);
+  let tracking = '';
+  if (bracket) {
+    tracking = bracket[1];
+    head = head.slice(0, head.length - bracket[0].length).trim();
+  }
+
+  if (/^HEAD \(no branch\)/.test(head)) {
+    result.detached = true;
+    return result;
+  }
+
+  const fresh = head.match(/^(?:No commits yet on|Initial commit on)\s+(.+)$/);
+  if (fresh) {
+    result.branch = fresh[1].trim();
+    return result;
+  }
+
+  // git 的 ref 命名规则禁止 `..`,所以 `...` 只会是分隔符
+  const sep = head.indexOf('...');
+  if (sep === -1) {
+    result.branch = head;
+  } else {
+    result.branch = head.slice(0, sep);
+    result.upstream = head.slice(sep + 3);
+    // [gone] 表示上游引用已不存在,这时不算"有上游可比较"
+    result.hasUpstream = !/gone/.test(tracking);
+  }
+
+  const ahead = tracking.match(/ahead (\d+)/);
+  const behind = tracking.match(/behind (\d+)/);
+  if (ahead) result.ahead = Number(ahead[1]);
+  if (behind) result.behind = Number(behind[1]);
+
+  return result;
+}
+
 function execFileAsync(file, args, options) {
   return new Promise((resolve, reject) => {
     execFile(file, args, options, (error, stdout, stderr) => {
@@ -114,6 +190,10 @@ export async function probeDirectoryGitState(dirPath, { timeoutMs = DEFAULT_PROB
         '--no-optional-locks',
         'status',
         '--porcelain=v1',
+        // --branch 让 status 顺带输出 `## main...origin/main [ahead 1, behind 2]`,
+        // 领先/落后就白拿 —— 否则要再起 3 个进程(symbolic-ref + rev-parse @{u} + rev-list)。
+        // 只读本地 remote-tracking 引用,**不联网**。
+        '--branch',
         // normal 会把未跟踪目录折叠成一条,大目录(node_modules 之类)下比 all 快很多,
         // 而这里只需要"有没有 / 有几项"
         '--untracked-files=normal',
@@ -129,7 +209,12 @@ export async function probeDirectoryGitState(dirPath, { timeoutMs = DEFAULT_PROB
         },
       }
     );
-    return { exists: true, isGitRepo: true, ...parsePorcelainStatus(stdout) };
+    return {
+      exists: true,
+      isGitRepo: true,
+      ...parsePorcelainStatus(stdout),
+      ...parseBranchTracking(stdout),
+    };
   } catch (error) {
     const text = `${error?.stderr || ''}\n${error?.message || ''}`;
     if (/not a git repository|not a git repo/i.test(text)) {