zen-gitsync 2.17.20 → 2.17.22

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

@@ -14,12 +14,17 @@
 //
 // 主 Agent 编排台的状态存储 + 活动流拼装。
 //
-// 三件事：
+// 四件事：
 //   1. 调度开关（active）+ 人类干预指令存档，持久化到 ~/.zen-gitsync/orchestrator.json。
 //      「暂停调度」是服务端强制的：暂停期间自动派发会被拒绝（手动点执行不受影响）。
 //   2. 派发默认提示词：一条全局的 + 每个项目一条的，同样存在 orchestrator.json。
 //      它们是「派发时自动附加的约束」，不是任务内容 —— 解析规则见 resolveDispatchPrompt。
-//   3. buildActivityFeed —— 把 job 的起止事实与人类指令合成一条时间倒序的活动流。
+//   3. 进度报告：自动报告的间隔配置存在 orchestrator.json（一个数字，跟着轮询下发），
+//      历史报告存在 orchestrator-reports.json（几 KB 一份，只在面板打开时按需取）。
+//      报告正文由 progressReport.js 生成，这里只负责"存哪、存几份、什么时候允许再生成"。
+//   4. buildActivityFeed —— 把 job 的起止事实与人类指令合成一条时间倒序的活动流。
+//      （控制台右栏的「活动日志」已换成进度报告，但这条流还在供顶栏「今日完成」计数，
+//      以及编排台接口的数据完整性 —— 别看到没人渲染就把它删了。）
 //
 // 活动流为什么不在服务端拼好文案：
 //   UI 文案统一走前端 i18n（lang/{zh,en}），服务端只回**结构化事实**
@@ -31,8 +36,12 @@
 
 import {
   ORCHESTRATOR_FILE,
+  ORCHESTRATOR_REPORTS_FILE,
   MAX_ORCHESTRATOR_INSTRUCTIONS,
   MAX_DEFAULT_PROMPT_CHARS,
+  MAX_PROGRESS_REPORTS,
+  PROGRESS_REPORT_INTERVALS_MS,
+  DEFAULT_PROGRESS_REPORT_INTERVAL_MS,
   readJson,
   writeJson,
   nowIso,
@@ -56,9 +65,20 @@ function defaultState() {
     instructions: [],
     defaultPrompt: '',
     projectPrompts: {},
+    reportIntervalMs: DEFAULT_PROGRESS_REPORT_INTERVAL_MS,
+    lastReportAt: null,
   };
 }
 
+/**
+ * 报告间隔归一。**只认白名单里的值**，其余（缺字段 / 脏值 / 手改文件写进去的 7 分钟）
+ * 一律回落到默认 10 分钟。老版本没有这个字段 —— 那正是"升级后按新默认开始报告"的语义。
+ */
+export function normalizeReportIntervalMs(value) {
+  const n = Number(value);
+  return PROGRESS_REPORT_INTERVALS_MS.includes(n) ? n : DEFAULT_PROGRESS_REPORT_INTERVAL_MS;
+}
+
 /** 单条指令归一：老数据/半损坏数据都要能渲染，不能让整份状态读不出来 */
 function normalizeInstruction(raw) {
   const it = raw && typeof raw === 'object' ? raw : {};
@@ -122,6 +142,8 @@ export function normalizeOrchestrator(raw) {
       ? state.defaultPrompt.slice(0, MAX_DEFAULT_PROMPT_CHARS)
       : '',
     projectPrompts: normalizeProjectPrompts(state.projectPrompts),
+    reportIntervalMs: normalizeReportIntervalMs(state.reportIntervalMs),
+    lastReportAt: typeof state.lastReportAt === 'string' ? state.lastReportAt : null,
   };
 }
 
@@ -258,6 +280,146 @@ export async function clearInstructions() {
   });
 }
 
+// ── 进度报告的配置与历史 ────────────────────────────────────────────────
+// 「报告时间我自己设置」的那个设置：0 = 关掉自动报告（手动「立即报告」始终可用，
+// 它不受这个开关影响 —— 关掉的是"自己隔一会儿跑一次"，不是"不许报告"）。
+
+/** 写自动报告间隔。返回写后的值（已归一） */
+export async function setReportIntervalMs(value) {
+  return serialize(async () => {
+    const state = await readOrchestrator();
+    state.reportIntervalMs = normalizeReportIntervalMs(value);
+    state.updatedAt = nowIso();
+    await persist(state);
+    return state.reportIntervalMs;
+  });
+}
+
+/**
+ * 抢占一次自动报告的"名额"：距上次报告不足 intervalMs 就返回 false。
+ *
+ * 为什么占坑要写盘而不是只放内存里一个时间戳：报告历史是**多实例共享**的
+ * （同一个 ~/.zen-gitsync 可能同时开着两个 g ui），各自跑一个定时器的话，
+ * 内存里各记各的，两边会在同一分钟各生成一份内容几乎一样的报告。
+ * 时间戳落在共享文件上，后到的那个实例读到的就是"刚报过"。
+ *
+ * 抢占发生在**生成之前**（生成要等一次模型往返，几秒到几十秒）：
+ * 等生成完再写，两个实例的窗口就大得多。代价是生成失败也要等满一个间隔才重试 ——
+ * 失败会记进报告历史（errorCode），比"同一分钟内连打两次模型"划算。
+ */
+export async function claimReportSlot(intervalMs, now = Date.now()) {
+  return serialize(async () => {
+    const state = await readOrchestrator();
+    const last = Date.parse(state.lastReportAt || '');
+    if (Number.isFinite(last) && now - last < intervalMs) return false;
+    state.lastReportAt = new Date(now).toISOString();
+    await persist(state);
+    return true;
+  });
+}
+
+/** 单份报告归一：字段缺失 / 脏数据都必须能渲染，不能让面板整个读不出来 */
+function normalizeReport(raw) {
+  const r = raw && typeof raw === 'object' ? raw : {};
+  const tasks = Array.isArray(r.tasks) ? r.tasks : [];
+  return {
+    id: typeof r.id === 'string' && r.id ? r.id : genId(),
+    at: typeof r.at === 'string' ? r.at : null,
+    trigger: r.trigger === 'auto' ? 'auto' : 'manual',
+    text: typeof r.text === 'string' ? r.text : '',
+    errorCode: typeof r.errorCode === 'string' ? r.errorCode : '',
+    errorDetail: typeof r.errorDetail === 'string' ? r.errorDetail : '',
+    tasks: tasks
+      .filter(t => t && typeof t === 'object')
+      .map(t => ({
+        taskId: typeof t.taskId === 'string' ? t.taskId : null,
+        taskTitle: typeof t.taskTitle === 'string' ? t.taskTitle : '',
+        projectName: typeof t.projectName === 'string' ? t.projectName : '',
+        startedAt: typeof t.startedAt === 'string' ? t.startedAt : null,
+        // 跑多久是**生成那一刻**的事实，跟着报告存下来：
+        // 前端拿现在的时钟去减 startedAt，"已运行 12 分钟"会随报告变旧一路涨，
+        // 历史报告就再也说不清"当时是什么情况"了。
+        elapsedMs: Number.isFinite(Number(t.elapsedMs)) ? Math.max(0, Math.floor(Number(t.elapsedMs))) : 0,
+        agent: typeof t.agent === 'string' ? t.agent : '',
+        toolCallCount: Number.isFinite(Number(t.toolCallCount)) ? Math.max(0, Math.floor(Number(t.toolCallCount))) : 0,
+        lastTool: typeof t.lastTool === 'string' ? t.lastTool : '',
+        lastLine: typeof t.lastLine === 'string' ? t.lastLine : '',
+        // 2026-09-29 补的三样：老记录里没有它们 —— 一律给"没有"（'' / null），
+        // 不要硬塞一个默认值冒充"当时它就是在思考 / 当时静默了 0 秒"
+        toolMix: typeof t.toolMix === 'string' ? t.toolMix : '',
+        lastThought: typeof t.lastThought === 'string' ? t.lastThought : '',
+        silentMs: Number.isFinite(Number(t.silentMs)) ? Math.max(0, Math.floor(Number(t.silentMs))) : null,
+      })),
+  };
+}
+
+/**
+ * 读报告历史（新的在前）。文件缺失 / 损坏一律当"还没有报告"，不抛错。
+ *
+ * **没有事实的报告不算报告**：那是一条"当时什么都没在跑"的空记录，对回头翻历史的人
+ * 零信息量，却要占掉上限 20 条里的一格，把真正有用的挤出去（用户 2026-09-29 的原话：
+ * "这种没有在执行的就不用展示了"）。
+ *
+ * 写入侧已经不再产生它们（见 routes/workbench/index.js 的 runProgressReport），
+ * 这里再挡一次是因为：老版本进程 / 另一个实例写进同一份文件的空报告，
+ * 在读取方看来同样得当成不存在 —— 面板只认这个函数给的清单。
+ * 另外 appendReport 是拿本函数的返回值重写整个文件的，所以历史遗留的空报告
+ * 会在下一次落盘时被真正从磁盘上清掉。
+ */
+export async function readReports() {
+  const data = await readJson(ORCHESTRATOR_REPORTS_FILE, null);
+  const list = data && Array.isArray(data.reports) ? data.reports : [];
+  return list
+    .map(normalizeReport)
+    .filter(r => r.tasks.length > 0)
+    .sort((a, b) => String(b.at || '').localeCompare(String(a.at || '')))
+    .slice(0, MAX_PROGRESS_REPORTS);
+}
+
+/** 两份报告"说的是同一件事"吗：同一批任务 + 同一段正文 + 同一种失败 */
+function sameReport(a, b) {
+  if (!a || !b) return false;
+  if (a.trigger !== b.trigger || a.text !== b.text) return false;
+  if (a.errorCode !== b.errorCode || a.errorDetail !== b.errorDetail) return false;
+  if (a.tasks.length !== b.tasks.length) return false;
+  return a.tasks.every((t, i) => (t.taskId || '') === (b.tasks[i].taskId || '')
+    && (t.taskTitle || '') === (b.tasks[i].taskTitle || ''));
+}
+
+/**
+ * 追加一份报告（新的在前），超出上限的旧报告直接丢掉。
+ *
+ * 窗口期内**内容一样的**只留第一份。为什么需要它：没有正文的报告（没配模型 = NO_MODEL）
+ * 是逐字节相同的 —— 「立即报告」连点两下、或两个实例各点一下，历史里就会出现两条
+ * 一模一样的记录（真实数据：2026-09-28T15:44:08.161 与 .226 两条 manual / tasks=0）。
+ * 前端那个"生成中"的防抖挡不住这种点击：空报告不叫模型，本机往返几十毫秒就返回了，
+ * 第二次点击落在防抖释放之后。
+ *
+ * 判据刻意**不含**时长 / 工具次数 / 最近输出这些每份报告都会变的字段 ——
+ * 带上它们就永远"不算重复"，等于没做这个检查。
+ */
+const REPORT_DEDUPE_WINDOW_MS = 10 * 1000;
+
+/** @returns {Promise<object>} 落盘的那一份；被判为重复时返回已在历史里的头部那条 */
+export async function appendReport(entry) {
+  return serialize(async () => {
+    const report = normalizeReport({ id: genId(), at: nowIso(), ...entry });
+    const existing = await readReports();
+    const head = existing[0];
+    const headAt = Date.parse((head && head.at) || '');
+    if (head && Number.isFinite(headAt)
+      && Date.now() - headAt < REPORT_DEDUPE_WINDOW_MS
+      && sameReport(head, report)) {
+      // 不落盘。返回头部那条而不是 null：调用方（runProgressReport）要拿它广播，
+      // 前端本来就在展示它，等于"你看到的就是刚生成的"
+      return head;
+    }
+    const reports = [report, ...existing].slice(0, MAX_PROGRESS_REPORTS);
+    await writeJson(ORCHESTRATOR_REPORTS_FILE, { version: 1, reports });
+    return report;
+  });
+}
+
 /**
  * 正在执行的执行体清单（看板左栏「执行监控」用）。
  *

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

@@ -0,0 +1,177 @@
+// 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.
+//
+
+// 进度报告**历史文件**的两条规则（读写都在 orchestratorStore 里）：
+//
+//   1. 没有事实的报告不算报告 —— 读的时候当不存在，写的时候也活不过下一次落盘。
+//      用户 2026-09-29 的原话："这种没有在执行的就不用展示了"：那 4 条
+//      "当时没有任务在执行"既零信息量，又占着 20 条上限的格子。
+//   2. 窗口期内**内容一样**的只留第一份 —— 没有正文的报告（NO_MODEL）逐字节相同，
+//      「立即报告」连点两下就会在历史里留下两条一模一样的记录
+//      （真实数据：2026-09-28T15:44:08.161 与 .226，两条都是 manual / tasks=0）。
+//
+// 隔离：必须在 import 之前把 USERPROFILE/HOME 指向 mkdtemp 沙箱，否则就是往用户真实的
+// ~/.zen-gitsync 里写报告（同 dispatchInstruction.test.js / jobStore.test.js 的做法）。
+
+import { test, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const projectRoot = path.resolve(__dirname, '../../../../..');
+
+// ---- 环境隔离:必须在 import 之前完成 ----
+const fakeHome = await fs.mkdtemp(path.join(os.tmpdir(), 'zgs-report-store-test-'));
+const savedEnv = {
+  USERPROFILE: process.env.USERPROFILE,
+  HOME: process.env.HOME,
+  HOMEDRIVE: process.env.HOMEDRIVE,
+  HOMEPATH: process.env.HOMEPATH,
+};
+process.env.USERPROFILE = fakeHome;
+process.env.HOME = fakeHome;
+delete process.env.HOMEDRIVE;
+delete process.env.HOMEPATH;
+
+const load = p => import(pathToFileURL(path.join(projectRoot, p)).href);
+const { readReports, appendReport } = await load('src/ui/server/routes/workbench/orchestratorStore.js');
+const { ORCHESTRATOR_REPORTS_FILE, readJson } = await load('src/ui/server/routes/workbench/shared.js');
+
+after(async () => {
+  for (const k of Object.keys(savedEnv)) {
+    if (savedEnv[k] === undefined) delete process.env[k];
+    else process.env[k] = savedEnv[k];
+  }
+  await fs.rm(fakeHome, { recursive: true, force: true }).catch(() => {});
+});
+
+/** 一份任务事实的最小形状（normalizeReport 认得的那几个字段） */
+const fact = (taskId, taskTitle) => ({
+  taskId,
+  taskTitle,
+  projectName: 'zen-gitsync',
+  startedAt: null,
+  elapsedMs: 1000,
+  agent: 'claude',
+  toolCallCount: 3,
+  lastTool: 'Edit src/a.ts',
+  lastLine: '正在改登录模块',
+});
+
+/** 手写历史文件：直接落盘才能构造"30 秒前"这种 appendReport 自己写不出来的时间 */
+async function seed(reports) {
+  await fs.mkdir(path.dirname(ORCHESTRATOR_REPORTS_FILE), { recursive: true });
+  await fs.writeFile(ORCHESTRATOR_REPORTS_FILE, JSON.stringify({ version: 1, reports }, null, 2), 'utf8');
+}
+
+/** 磁盘上的原始内容（不走 readReports 的过滤），用来验证"真的清掉了" */
+async function onDisk() {
+  const data = await readJson(ORCHESTRATOR_REPORTS_FILE, null);
+  return (data && Array.isArray(data.reports)) ? data.reports : [];
+}
+
+const iso = (msAgo) => new Date(Date.now() - msAgo).toISOString();
+
+const rawReport = (over = {}) => ({
+  id: 'r-' + Math.random().toString(36).slice(2, 8),
+  at: iso(0),
+  trigger: 'manual',
+  text: '',
+  errorCode: '',
+  errorDetail: '',
+  tasks: [],
+  ...over,
+});
+
+before(async () => { await seed([]); });
+
+test('空报告读不出来（"这种没有在执行的就不用展示了"）', async () => {
+  await seed([
+    rawReport({ id: 'with-facts', at: iso(60_000), tasks: [fact('t1', '有事实的任务')] }),
+    rawReport({ id: 'empty-1', at: iso(30_000) }),
+    rawReport({ id: 'empty-2', at: iso(20_000) }),
+  ]);
+  const list = await readReports();
+  assert.deepEqual(list.map(r => r.id), ['with-facts']);
+});
+
+test('空报告不再占用 20 条上限：读出来的是最近 20 条**真**报告', async () => {
+  const reports = [];
+  // 交错写：每两条真报告中间夹一条空报告，真报告共 21 条（超上限 1 条）
+  for (let i = 0; i < 21; i++) {
+    reports.push(rawReport({ id: `real-${i}`, at: iso((21 - i) * 1000), tasks: [fact(`t${i}`, `任务 ${i}`)] }));
+    reports.push(rawReport({ id: `empty-${i}`, at: iso((21 - i) * 1000 + 500) }));
+  }
+  await seed(reports);
+  const list = await readReports();
+  assert.equal(list.length, 20);
+  assert.ok(list.every(r => r.tasks.length > 0), '读出来的每一条都得有事实');
+  // 新的在前：real-20 最新，real-0 被上限挤掉
+  assert.equal(list[0].id, 'real-20');
+  assert.ok(!list.some(r => r.id === 'real-0'));
+});
+
+test('历史遗留的空报告在下一次落盘时从磁盘上清掉', async () => {
+  await seed([rawReport({ id: 'legacy-empty', at: iso(60_000) })]);
+  await appendReport(rawReport({ id: 'ignored', trigger: 'auto', tasks: [fact('t1', '任务')] }));
+  const disk = await onDisk();
+  assert.equal(disk.length, 1);
+  assert.ok(!disk.some(r => r.id === 'legacy-empty'), '空报告应该已经从文件里消失');
+});
+
+test('窗口期内内容一样的第二份不落盘（连点两下的去重）', async () => {
+  await seed([]);
+  const first = await appendReport(rawReport({ errorCode: 'NO_MODEL', tasks: [fact('t1', '任务 A')] }));
+  const second = await appendReport(rawReport({ errorCode: 'NO_MODEL', tasks: [fact('t1', '任务 A')] }));
+  assert.equal(second.id, first.id, '第二份应该被判为重复，返回已有的那份');
+  assert.equal((await onDisk()).length, 1);
+});
+
+test('同一批任务但正文不同 → 两份都留（不是"同一批任务就合并"）', async () => {
+  await seed([]);
+  const base = { tasks: [fact('t1', '任务 A')] };
+  await appendReport(rawReport({ ...base, text: '第一次汇报：正在改登录模块。' }));
+  await appendReport(rawReport({ ...base, text: '第二次汇报：已经在跑测试了。' }));
+  assert.equal((await onDisk()).length, 2);
+});
+
+test('过了去重窗口那份就不再算重复（同一分钟连点两下之外是正常的两份）', async () => {
+  // 手写一条 30 秒前的报告，再用相同内容 append —— 窗口（10s）已经过去
+  const stale = rawReport({ id: 'stale', at: iso(30_000), errorCode: 'NO_MODEL', tasks: [fact('t1', '任务 A')] });
+  await seed([stale]);
+  const saved = await appendReport(rawReport({ errorCode: 'NO_MODEL', tasks: [fact('t1', '任务 A')] }));
+  assert.notEqual(saved.id, 'stale');
+  assert.equal((await onDisk()).length, 2);
+});
+
+test('触发的来源不同（手动 vs 自动）不算重复', async () => {
+  await seed([]);
+  const tasks = [fact('t1', '任务 A')];
+  await appendReport(rawReport({ trigger: 'manual', tasks }));
+  await appendReport(rawReport({ trigger: 'auto', tasks }));
+  assert.equal((await onDisk()).length, 2);
+});
+
+test('上限仍然生效：多余的报告按时间从旧到新丢掉', async () => {
+  await seed([]);
+  for (let i = 0; i < 23; i++) {
+    // 每份正文都不同，绕开去重窗口
+    await appendReport(rawReport({ text: `第 ${i} 次汇报`, tasks: [fact('t1', '任务 A')] }));
+  }
+  assert.equal((await onDisk()).length, 20);
+});