zen-gitsync 2.17.20 → 2.17.22

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

@@ -0,0 +1,270 @@
+// 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.
+//
+// 「这个 job 现在在干嘛」的纯函数单测。
+//
+// 这些函数过去挂在 progressReport.js 上（只喂给主 Agent 写汇报），2026-09-29 起看板
+// 「进行中」卡片直接把它们的结果显示给人看 —— 断言重心因此变成：**卡片上那句话是不是
+// 真话**。挑错 job（拿一条早就结束的）/ 把空串渲染成"暂无" / 静默没到阈值就报"卡住了"，
+// 在界面上都是"看起来很正常"的错，只有单测挡得住。
+//
+// 前四组（tailLine / describeLastTool / describeToolMix / silentMsOf）随实现一起从
+// progressReport.test.js 搬过来，断言原样保留。
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  tailLine,
+  tailExcerpt,
+  describeLastTool,
+  describeToolMix,
+  silentMsOf,
+  buildLiveActivity,
+  pickLiveActivity,
+  TOOL_MIX_WINDOW,
+  SILENT_NOTABLE_MS,
+} from './jobActivity.js';
+
+// ── tailLine ────────────────────────────────────────────────────────────
+
+test('tailLine 取最后一行有效文本，跳过末尾空行', () => {
+  assert.equal(tailLine('第一行\n第二行\n\n   \n'), '第二行');
+});
+
+test('tailLine 把行内空白折成一个空格（多行输出里的缩进不该原样进 prompt / 卡片）', () => {
+  assert.equal(tailLine('a\n   正在   编辑\t文件   '), '正在 编辑 文件');
+});
+
+test('tailLine 截断超长行，且空 / 非字符串一律返回空串', () => {
+  assert.equal(tailLine('x'.repeat(500)).length, 160);
+  assert.equal(tailLine(''), '');
+  assert.equal(tailLine(null), '');
+  assert.equal(tailLine(undefined), '');
+});
+
+// ── tailExcerpt（跑完之后卡片上那段「最后说了什么」） ──────────────────────
+// 这段摘录要回答的是"这条已完成的任务，是不是其实在等我回话"，所以断言的重心是
+// **结尾那句必须还在**：模型收尾时那句「要 push 吗？」被截掉的话，这个功能就白做了。
+
+test('tailExcerpt 取尾部一段，压平成一行并去掉 markdown 标记', () => {
+  const out = '## 改动\n\n- **新增** `lastReply` 字段\n- 卡片上显示最后回复\n\n要 push 吗？';
+  // 标题 / 列表标记 / ** / 反引号都只是噪声；卡片上没有富文本，留着一堆符号没法读
+  assert.equal(tailExcerpt(out), '改动 新增 lastReply 字段 卡片上显示最后回复 要 push 吗？');
+});
+
+test('tailExcerpt 丢掉表格行与分隔线（压成一行后只剩一堆竖线）', () => {
+  const out = '## 验证\n\n| 项 | 结果 |\n|---|---|\n| vue-tsc | 0 错误 |\n\n已提交。要 push 吗？';
+  assert.equal(tailExcerpt(out), '验证 已提交。要 push 吗？');
+});
+
+test('tailExcerpt 真截断过才加 …（结尾那句永远保留）', () => {
+  const long = `${'前'.repeat(300)}收尾那句：要 push 吗？`;
+  const got = tailExcerpt(long);
+  assert.ok(got.startsWith('…'), '从中间开始就该有 … 标记');
+  assert.ok(got.endsWith('要 push 吗？'), '结尾那句不能被截掉 —— CSS 截的是尾巴，这是它被截的原因');
+  // 上限按"去掉 … 之后"算：… 不计入 100 字的预算
+  assert.equal(got.length, 101);
+});
+
+test('tailExcerpt 没截断就不加 …（… 是"这句话从中间开始"的标记，不能乱标）', () => {
+  assert.equal(tailExcerpt('你好！有什么可以帮你的？'), '你好！有什么可以帮你的？');
+  // 短输出连第一行一起保留：窗口没切，第一行是完整的一句，不是半截
+  assert.equal(tailExcerpt('你好！\n\n需要的话我可以读本机的看板文件。'), '你好！ 需要的话我可以读本机的看板文件。');
+});
+
+test('tailExcerpt 窗口起点落在半句中间时从下一个整行开始（摘录不以半句开头）', () => {
+  const out = `${'前'.repeat(5000)}\n完整的一行\n要 push 吗？`;
+  // 5000 字 > REPLY_WINDOW_CHARS：被切掉的首行本就是半句，丢掉而不是拼进来
+  assert.equal(tailExcerpt(out), '完整的一行 要 push 吗？');
+});
+
+test('tailExcerpt 单行超长输出也能给出尾部（窗口里没有换行可退）', () => {
+  const got = tailExcerpt(`${'字'.repeat(5000)}要 push 吗？`);
+  assert.ok(got.startsWith('…'));
+  assert.ok(got.endsWith('要 push 吗？'));
+});
+
+test('tailExcerpt 空输出 / 脏值 / 全是表格噪声时给空串（前端据此不渲染这一段）', () => {
+  assert.equal(tailExcerpt(''), '');
+  assert.equal(tailExcerpt(null), '');
+  assert.equal(tailExcerpt(undefined), '');
+  assert.equal(tailExcerpt('   \n\n   '), '');
+  assert.equal(tailExcerpt('|---|---|\n| a | b |'), '');
+});
+
+// ── describeLastTool ────────────────────────────────────────────────────
+
+test('describeLastTool 取最后一次带名字的调用，优先用 argsPreview', () => {
+  const calls = [
+    { name: 'Read', argsPreview: 'a.ts', arguments: '{"file_path":"a.ts"}' },
+    { name: 'Edit', argsPreview: 'b.ts', arguments: '{"file_path":"b.ts"}' },
+  ];
+  assert.equal(describeLastTool(calls), 'Edit b.ts');
+});
+
+test('describeLastTool 跳过没有名字的尾部记录（老数据 / 半截记录）', () => {
+  const calls = [{ name: 'Bash', argsPreview: 'npm test' }, { id: 'anon-1' }];
+  assert.equal(describeLastTool(calls), 'Bash npm test');
+});
+
+test('describeLastTool 没有 argsPreview 时退回 arguments；两者都没有就只给工具名', () => {
+  assert.equal(describeLastTool([{ name: 'Bash', arguments: 'ls -la' }]), 'Bash ls -la');
+  assert.equal(describeLastTool([{ name: 'Bash' }]), 'Bash');
+  assert.equal(describeLastTool([]), '');
+  assert.equal(describeLastTool(null), '');
+});
+
+// ── describeToolMix / silentMsOf ────────────────────────────────────────
+
+test('describeToolMix 给出最近几次调用的分布，多的在前', () => {
+  const calls = [
+    { name: 'Bash' }, { name: 'Read' }, { name: 'Bash' },
+    { name: 'Read' }, { name: 'Bash' }, { name: 'Edit' },
+  ];
+  assert.equal(describeToolMix(calls), 'Bash×3 · Read×2 · Edit');
+});
+
+test('describeToolMix 只看最近 TOOL_MIX_WINDOW 次 —— 早先的模式早被淹没了', () => {
+  // 先 30 次 Edit，再 20 次 Read：窗口内只有 Read，分布里不该冒出 Edit
+  const calls = [
+    ...Array.from({ length: 30 }, () => ({ name: 'Edit' })),
+    ...Array.from({ length: TOOL_MIX_WINDOW }, () => ({ name: 'Read' })),
+  ];
+  assert.equal(describeToolMix(calls), `Read×${TOOL_MIX_WINDOW}`);
+});
+
+test('describeToolMix 跳过没有名字的记录，但它们不占窗口名额', () => {
+  const calls = [
+    { name: 'Bash' },
+    ...Array.from({ length: TOOL_MIX_WINDOW }, () => ({ id: 'anon-1' })),
+  ];
+  assert.equal(describeToolMix(calls), 'Bash');
+});
+
+test('describeToolMix 没有调用时给空串（调用方据此不显示这一行）', () => {
+  assert.equal(describeToolMix([]), '');
+  assert.equal(describeToolMix(null), '');
+  assert.equal(describeToolMix(undefined), '');
+});
+
+test('silentMsOf 到阈值才算静默，不到 / 没这个字段一律 null', () => {
+  const at = '2026-09-28T10:00:00.000Z';
+  const base = Date.parse(at);
+  const job = { lastActivityAt: at };
+  assert.equal(silentMsOf(job, base + SILENT_NOTABLE_MS), SILENT_NOTABLE_MS);
+  assert.equal(silentMsOf(job, base + SILENT_NOTABLE_MS - 1), null);
+  // 老记录 / 别的实例上的旧版进程没有这个字段：给 null，而不是编一个 0
+  assert.equal(silentMsOf({}, base), null);
+  assert.equal(silentMsOf({ lastActivityAt: '不是时间' }, base), null);
+  assert.equal(silentMsOf(null, base), null);
+});
+
+// ── buildLiveActivity ───────────────────────────────────────────────────
+
+const START = '2026-09-28T10:00:00.000Z';
+const NOW = Date.parse('2026-09-28T10:03:20.000Z'); // 距 START 3 分 20 秒
+
+/** 一条"跑了 3 分 20 秒"的 job 模板 */
+function liveJob(over = {}) {
+  return {
+    id: 'j1',
+    taskId: 't1',
+    status: 'running',
+    agent: 'claude',
+    startedAt: START,
+    thinking: '先看现状\n这个文件的锁逻辑有问题，得先弄清楚谁在什么时候写',
+    output: '我先读一下 login.ts',
+    toolCalls: [{ name: 'Read', argsPreview: 'src/login.ts' }],
+    ...over,
+  };
+}
+
+test('buildLiveActivity：终态 / 空 job 返回 null（卡片据此不显示活动区）', () => {
+  assert.equal(buildLiveActivity(liveJob({ status: 'done' }), NOW), null);
+  assert.equal(buildLiveActivity(liveJob({ status: 'error' }), NOW), null);
+  assert.equal(buildLiveActivity(null, NOW), null);
+  // pending 也算在跑（进程刚起来还没吐字）：卡片上仍要给"已运行 0 秒"，不能空着
+  assert.equal(buildLiveActivity(liveJob({ status: 'pending' }), NOW).status, 'pending');
+});
+
+test('buildLiveActivity：把思考 / 工具 / 最新回复都抽成一句话，时长按传入的 now 算', () => {
+  const live = buildLiveActivity(liveJob(), NOW);
+  assert.equal(live.elapsedMs, 3 * 60 * 1000 + 20 * 1000);
+  assert.equal(live.agent, 'claude');
+  assert.equal(live.startedAt, START);
+  assert.equal(live.toolCallCount, 1);
+  assert.equal(live.lastTool, 'Read src/login.ts');
+  assert.equal(live.toolMix, 'Read');
+  assert.equal(live.lastThought, '这个文件的锁逻辑有问题，得先弄清楚谁在什么时候写');
+  assert.equal(live.lastLine, '我先读一下 login.ts');
+  // 没有 lastActivityAt → 静默这条不成立，给 null 而不是编个 0
+  assert.equal(live.silentMs, null);
+});
+
+test('buildLiveActivity：老记录没有 agent / toolCalls 时给出空值，不抛错', () => {
+  const live = buildLiveActivity({ id: 'j2', status: 'running', startedAt: START }, NOW);
+  assert.equal(live.agent, '');
+  assert.equal(live.toolCallCount, 0);
+  assert.equal(live.lastTool, '');
+  assert.equal(live.lastThought, '');
+  assert.equal(live.lastLine, '');
+});
+
+test('buildLiveActivity：startedAt 缺失或脏值时 elapsedMs 记 0（不显示负数 / NaN）', () => {
+  assert.equal(buildLiveActivity({ id: 'j', status: 'running' }, NOW).elapsedMs, 0);
+  assert.equal(buildLiveActivity({ id: 'j', status: 'running', startedAt: '不是时间' }, NOW).elapsedMs, 0);
+});
+
+// ── pickLiveActivity ────────────────────────────────────────────────────
+
+test('pickLiveActivity：一个任务有多条 job 时挑最近有动静的那条，不是跑得最久的', () => {
+  const live = pickLiveActivity([
+    { id: 'old', status: 'running', startedAt: '2026-09-28T09:00:00.000Z', output: '老的那条' },
+    {
+      id: 'fresh',
+      status: 'running',
+      startedAt: '2026-09-28T10:00:00.000Z',
+      lastActivityAt: '2026-09-28T10:03:00.000Z',
+      output: '刚吐过字的那条',
+    },
+  ], NOW);
+  assert.equal(live.jobId, 'fresh');
+  assert.equal(live.lastLine, '刚吐过字的那条');
+});
+
+test('pickLiveActivity：只看在跑的 —— 有终态 job 时不拿它顶替', () => {
+  const done = { id: 'done', status: 'done', startedAt: '2026-09-28T10:02:00.000Z', output: '已经结束了' };
+  assert.equal(pickLiveActivity([done], NOW), null);
+  const running = { id: 'run', status: 'running', startedAt: START, output: '还在跑' };
+  assert.equal(pickLiveActivity([done, running], NOW).jobId, 'run');
+});
+
+test('pickLiveActivity：时间戳打平时取末条（与 latestJob 同口径），空数组给 null', () => {
+  const same = [
+    { id: 'a', status: 'running', startedAt: START, output: 'a' },
+    { id: 'b', status: 'running', startedAt: START, output: 'b' },
+  ];
+  assert.equal(pickLiveActivity(same, NOW).jobId, 'b');
+  assert.equal(pickLiveActivity([], NOW), null);
+  assert.equal(pickLiveActivity(null, NOW), null);
+});
+
+test('pickLiveActivity：lastActivityAt 是脏值时退回 startedAt 比较', () => {
+  const live = pickLiveActivity([
+    { id: 'a', status: 'running', startedAt: '2026-09-28T09:00:00.000Z', lastActivityAt: '不是时间' },
+    { id: 'b', status: 'running', startedAt: '2026-09-28T08:00:00.000Z' },
+  ], NOW);
+  assert.equal(live.jobId, 'a');
+});

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

@@ -16,7 +16,8 @@
 // 拆分自原 routes/workbench.js 814-955 行。
 //
 // 设计要点：
-//   - 写盘在流式 chunk 阶段走 1.5s debounce；终态时（finally / cancel）强制 flush
+//   - 两条落盘路径：**jobs.json 只在终态写**；**运行中只写 live-jobs/<pid>.json**
+//     （1.5s 防抖）。后者是「别的 g ui 实例也能看到进行中」的依据，见 liveJobs.js
 //   - 永不持久化 child 引用（参考 cancel 路由的浅拷贝模式）
 //   - hydrate 时把 running/pending 降级为 error：原 child 进程已不存在
 //   - enforceRetention 在每次落盘后跑，按 endedAt desc FIFO 裁剪
@@ -38,6 +39,13 @@ import {
   writeJson,
   nowIso,
 } from './shared.js';
+import {
+  projectJob,
+  toLiveRecord,
+  writeLiveJobsFile,
+  removeLiveJobsFile,
+  scanLiveJobsDir,
+} from './liveJobs.js';
 
 // 进程表：记录每个子任务的运行状态
 // jobId -> { id, taskId, subId, status, pid, startedAt, endedAt, exitCode, error, prompt, child, output, thinking, claudeSessionId, toolCalls }
@@ -59,12 +67,12 @@ export const cancelledJobs = new Set();
 // 的 deriveTaskColumn),而数据其实一直在 jobs.json 里,只是没第二个进程去读它。
 //
 // 现在:凡是需要"反映别的 g ui 进程"的读取路径,先 await refreshJobsFromDisk(),
-// 再用 mergedJobs() 拿「磁盘 ∪ 内存」。**内存优先** —— 本进程跑的 job 带着最新的
-// 流式输出和终态,磁盘上的那一份还可能停在 1.5s debounce 之前的旧状态。
+// 再用 mergedJobs() 拿「内存 ∪ 运行中 ∪ 磁盘」。**内存优先** —— 本进程跑的 job 带着
+// 最新的流式输出和终态,磁盘上的那一份还可能停在 1.5s debounce 之前的旧状态。
 //
 // 同步 vs 异步:refreshJobsFromDisk() 是异步的(要 stat + 读文件),mergedJobs() /
-// snapshotJobs() 保持同步纯函数,读缓存的磁盘那一半 —— 调用点"先 await 刷新、
-// 再同步取快照"这个顺序别颠倒,否则拿到的是上一次的磁盘内容。
+// snapshotJobs() 保持同步纯函数,读缓存的两半 —— 调用点"先 await 刷新、再同步取快照"
+// 这个顺序别颠倒,否则拿到的是上一次的磁盘内容。
 //
 // 用户明确接受秒级延迟:看板本身 5s 轮询,不需要为跨实例推送再造一套 IPC/SSE。
 //
@@ -72,6 +80,11 @@ export const cancelledJobs = new Set();
 // 没变就是一个 stat。
 let diskCache = { mtimeMs: -1, size: -1, jobs: [] };
 
+// 「运行中」那一半:别的 g ui 进程写的 live-jobs/<pid>.json(见 liveJobs.js)。
+// 这一半**只有 running/pending 的记录** —— 终态仍然只走 jobs.json,不存在两份口径。
+// 同样用 signature(mtime+size 拼串)做短路。
+let liveCache = { signature: null, jobs: [] };
+
 /** 磁盘记录自称 running/pending,但进程已消失、文件也已 N 秒没被写过 → 判为孤儿 */
 // 宽限期要大于 jobs 落盘的 1.5s debounce:job 刚结束时 child 已退出、终态还没 flush,
 // 那个窗口里(pid 死 + 磁盘 running)不该被误判。5s 足够跨过它,又快到用户感知不到。
@@ -104,11 +117,25 @@ function reclaimOrphan(j, fileMtimeMs) {
   };
 }
 
+/**
+ * 把 live-jobs/ 目录当前内容读进缓存（别的 g ui 进程正在跑的 job）。
+ * 目录整体没变（signature 一样）就直接返回 —— 与 jobs.json 的 mtime+size 短路同理。
+ */
+export async function refreshLiveJobs({ force = false } = {}) {
+  try {
+    const { signature, jobs: live } = await scanLiveJobsDir();
+    if (!force && signature === liveCache.signature) return;
+    liveCache = { signature, jobs: live };
+  } catch (err) {
+    logger.warn('[workbench] live-jobs 目录扫描失败，沿用上次缓存:', err?.message || err);
+  }
+}
+
 /**
  * 把 jobs.json 当前内容读进缓存。没变( mtime + size 都没动)就直接返回。
  * 读失败一律降级成"沿用上次缓存":看板请求不该因为一个坏文件而 500。
  */
-export async function refreshJobsFromDisk({ force = false } = {}) {
+async function refreshJobsFile({ force = false } = {}) {
   let st;
   try {
     st = await fsp.stat(JOBS_FILE);
@@ -134,29 +161,108 @@ export async function refreshJobsFromDisk({ force = false } = {}) {
   }
 }
 
+/**
+ * 刷新两半缓存：history(jobs.json) + live(live-jobs/)。
+ *
+ * **所有"要反映别的实例"的读取路径都走这里**，所以 live 的刷新被折进来而不是
+ * 另开一个函数让调用点各自记得调 —— 忘了调不会报错，只会让「进行中」又不同步，
+ * 那正是这个 bug 的形态。jobs.json 那边的 mtime 短路不影响这里：函数入口先把
+ * 两半都刷一遍，各自内部再短路。
+ */
+export async function refreshJobsFromDisk({ force = false } = {}) {
+  await refreshLiveJobs({ force });
+  await refreshJobsFile({ force });
+}
+
 /** 本进程自己写完盘后把缓存作废,免得下一次 refresh 被 mtime 短路在旧内容上 */
 function invalidateDiskCache() {
   diskCache = { mtimeMs: -1, size: -1, jobs: [] };
+  liveCache = { signature: null, jobs: [] };
 }
 
 /**
- * 磁盘 ∪ 内存的 job 表(id -> 记录)。内存优先。
- * 同步、无 IO —— 磁盘那一半由 refreshJobsFromDisk() 预先填好。
+ * 「内存 ∪ 运行中(别的实例) ∪ 磁盘」的 job 表(id -> 记录)。
+ * 优先级:内存 > live > 磁盘 —— 内存是本进程跑的(最新),live 是别人的**在跑**记录
+ * (可能比它自己 jobs.json 里的旧终态新),磁盘是历史档案。
+ * 同步、无 IO —— 两半缓存由 refreshJobsFromDisk() 预先填好。
+ *
+ * includeLive=false 的用途:**写 jobs.json 时不要把别人的 live 记录写进去**。
+ * 那份是历史档案,而 live 记录的 output/thinking/toolCalls 是截尾的 —— 写进去等于
+ * 把一份残缺的日志永久归档,还会参与 size 计价的保留策略。别人的 job 由他自己落盘。
  */
-export function mergedJobs() {
+export function mergedJobs({ includeLive = true } = {}) {
   const map = new Map();
   for (const j of diskCache.jobs) {
     if (!j || !j.id) continue;
     if (jobs.has(j.id)) continue;                        // 本进程跑的,下面用内存里的覆盖
     map.set(j.id, reclaimOrphan(j, diskCache.mtimeMs));
   }
+  // 别的实例正在跑的:覆盖同 id 的历史记录(那条历史多半是上一次跑的终态)
+  if (includeLive) {
+    for (const j of liveCache.jobs) {
+      if (!j || !j.id) continue;
+      if (jobs.has(j.id)) continue;
+      map.set(j.id, j);
+    }
+  }
   for (const [id, j] of jobs) map.set(id, j);
   return map;
 }
 
 // ── 持久化层 ─────────────────────────────────────────────────
-// jobs.json 是历史档案；jobs Map 只承载当前进程产出的活跃 job
-let jobsSaveTimer = null;
+// 两条落盘路径，分工明确：
+//   · jobs.json（历史档案）—— **只在终态写**：一整份 7.5MB 的东西不该为了同步
+//     "还在跑"这件事被反复重写
+//   · live-jobs/<pid>.json（运行中）—— 1.5s 防抖写，几十 KB 封顶
+// jobs Map 承载当前进程产出的活跃 job（也可能是刚结束、等终态 flush 的）。
+//
+// 历史档案没有防抖定时器了：它只在终态写（以前那个 `jobsSaveTimer`/`scheduleJobsSave`
+// 是给"流式阶段也写 jobs.json"准备的，但从来没有任何调用点，2026-09-28 被 live-jobs 取代）。
+
+// 运行中那一份的防抖写。由 taskRunner 在 job 转 running/pending 与流式 chunk 时调用。
+let activeSaveTimer = null;
+// 进程内写串行化：防抖回调与终态 flush 可能挨在一起，别让两次写交错
+let activeWriteChain = Promise.resolve();
+
+/** 本进程当前**活跃**的 job（running/pending），投影 + 瘦身后用于跨实例广播 */
+function activeJobRecords() {
+  const list = [];
+  for (const j of jobs.values()) {
+    if (j && (j.status === 'running' || j.status === 'pending')) list.push(toLiveRecord(j));
+  }
+  return list;
+}
+
+/**
+ * 防抖写 live-jobs。**这是运行中 job 唯一的落盘点** —— 少了它，「进行中」就只在
+ * 跑任务的那个实例可见（2026-09-28 修的正是这个）。
+ */
+export function scheduleActiveJobsSave() {
+  if (activeSaveTimer) return;
+  activeSaveTimer = setTimeout(() => {
+    activeSaveTimer = null;
+    flushActiveJobsSave().catch(err => logger.warn('[workbench] live-jobs save failed:', err?.message || err));
+  }, JOBS_SAVE_DEBOUNCE_MS);
+}
+
+/**
+ * 立即写 live-jobs：把本进程活跃 job 写进自己的文件，没有活跃 job 就删掉文件。
+ * 终态时（flushJobsSaveNow）必须走一次，否则别的实例的看板上那条会一直转圈，
+ * 直到 owner pid 消失才被回收。
+ */
+export function flushActiveJobsSave() {
+  if (activeSaveTimer) { clearTimeout(activeSaveTimer); activeSaveTimer = null; }
+  const run = () => writeLiveJobsFile(process.pid, activeJobRecords());
+  const next = activeWriteChain.then(run, run);
+  activeWriteChain = next.catch(() => {});
+  return next;
+}
+
+/** 本进程退出时清掉自己的运行中文件（进程内其它清理路径无需感知这件事） */
+export async function clearOwnLiveJobsFile() {
+  if (activeSaveTimer) { clearTimeout(activeSaveTimer); activeSaveTimer = null; }
+  await removeLiveJobsFile(process.pid);
+}
 
 // 序列化 job 落盘：剥离 child 引用（ChildProcess 无法 JSON.stringify），
 // 反范式 taskTitle 方便管理页直接读
@@ -181,18 +287,8 @@ export function serializeJob(j, taskMap) {
   };
 }
 
-// 流式 chunk 阶段 debounce 写盘；终态时由 flushJobsSaveNow() 强制立即落盘
-export function scheduleJobsSave() {
-  if (jobsSaveTimer) clearTimeout(jobsSaveTimer);
-  jobsSaveTimer = setTimeout(() => {
-    jobsSaveTimer = null;
-    flushJobsSaveNow().catch(err => logger.warn('[workbench] jobs save failed:', err.message));
-  }, JOBS_SAVE_DEBOUNCE_MS);
-}
-
 // 立即落盘（终态调用）：把 jobs Map 当前快照写到 jobs.json，然后跑 retention
 export async function flushJobsSaveNow() {
-  if (jobsSaveTimer) { clearTimeout(jobsSaveTimer); jobsSaveTimer = null; }
   // 读 tasks.json 给落盘 job 反范式 taskTitle——父任务被删后管理页仍可读
   const tasksData = await readJson(TASKS_FILE, { tasks: [] });
   const taskMap = new Map((tasksData.tasks || []).map(t => [t.id, t]));
@@ -201,9 +297,17 @@ export async function flushJobsSaveNow() {
   await refreshJobsFromDisk();
   const payload = {
     version: 1,
-    jobs: Array.from(mergedJobs().values()).map(j => serializeJob(j, taskMap))
+    // 只并「磁盘历史 ∪ 本进程内存」:别人的 live(运行中)记录不进历史档案,见 mergedJobs 注释
+    jobs: Array.from(mergedJobs({ includeLive: false }).values()).map(j => serializeJob(j, taskMap))
   };
   await writeJson(JOBS_FILE, payload);
+  // 运行中那一份同步收口：这个 job 已经不再 running/pending，别的实例的看板
+  // 必须立刻把它从「进行中」挪走，不能干等 owner pid 消失。
+  try {
+    await flushActiveJobsSave();
+  } catch (err) {
+    logger.warn('[workbench] live-jobs flush failed:', err?.message || err);
+  }
   invalidateDiskCache();
   await enforceRetention();
 }
@@ -290,6 +394,12 @@ export async function enforceRetention() {
   invalidateDiskCache();
   const keepIds = new Set(data.jobs.map(j => j.id));
   for (const id of Array.from(jobs.keys())) {
+    const j = jobs.get(id);
+    // **运行中的 job 一律不许在这里被删掉**：它还没进过 jobs.json(或者进来的是上一轮的
+    // 终态),按 keepIds 一刀切会把它从内存里剜掉 —— 表现是任务跑到一半"消失",界面
+    // 也不再有它,而 child 进程还在。启动时 hydrateJobs 的 fire-and-forget 链路
+    // (读文件 → 跑 retention)刚好能和"启动后立刻点执行"撞上,实测能复现。
+    if (j && (j.status === 'running' || j.status === 'pending')) continue;
     if (!keepIds.has(id)) jobs.delete(id);
   }
 }
@@ -304,35 +414,15 @@ export function publish(event, payload) {
   bus.emit('event', { event, payload, ts: nowIso() });
 }
 
-// 给 SSE / 看板 / cancel / continue 路由用：返回「磁盘 ∪ 内存」的可序列化快照
+// 给 SSE / 看板 / cancel / continue 路由用：返回「磁盘 ∪ 运行中 ∪ 内存」的可序列化快照
 // 剥离 child 引用（不可序列化），只保留前端需要的字段。
 //
-// 同步函数,磁盘那一半读的是 refreshJobsFromDisk() 填好的缓存 —— 想让别的 g ui
+// 同步函数,两半缓存读的是 refreshJobsFromDisk() 填好的 —— 想让别的 g ui
 // 进程跑的 job 出现在结果里,调用前先 await 一次刷新(见文件头的说明)。
+//
+// 投影口径只有一份:liveJobs.projectJob（live-jobs 落盘也用同一个函数）。
 export function snapshotJobs() {
-  return Array.from(mergedJobs().values()).map(j => ({
-    id: j.id,
-    taskId: j.taskId,
-    subId: j.subId,
-    title: j.title,
-    status: j.status,
-    prompt: j.prompt || '',
-    output: j.output || '',
-    thinking: j.thinking || '',
-    pid: j.pid || null,
-    startedAt: j.startedAt || null,
-    endedAt: j.endedAt || null,
-    exitCode: typeof j.exitCode === 'number' ? j.exitCode : null,
-    error: j.error || null,
-    // 本轮用的执行器（claude | opencode）。前端对话区助手名 / 日志详情按它显示;
-    // 加字段时记得同步这里 —— 白名单投影会把没列出的字段静默剥掉。
-    agent: j.agent || null,
-    // 工具调用流水（{id,name,argsPreview,arguments,result,status,error}[]）。
-    // 前端靠它画工具块;刷新页面 / 换实例后仍然可见,所以必须过白名单。
-    toolCalls: Array.isArray(j.toolCalls) ? j.toolCalls : [],
-    // 续接对话用:claude --output-format stream-json 的 system.init 事件捕获到的 session_id
-    claudeSessionId: j.claudeSessionId || null
-  }));
+  return Array.from(mergedJobs().values()).map(projectJob);
 }
 
 export const jobStore = {
@@ -340,7 +430,9 @@ export const jobStore = {
   bus,
   cancelledJobs,
   serializeJob,
-  scheduleJobsSave,
+  scheduleActiveJobsSave,
+  flushActiveJobsSave,
+  clearOwnLiveJobsFile,
   flushJobsSaveNow,
   readJobsConfig,
   writeJobsConfig,
@@ -349,5 +441,6 @@ export const jobStore = {
   publish,
   snapshotJobs,
   refreshJobsFromDisk,
+  refreshLiveJobs,
   mergedJobs,
 };