zen-gitsync 2.13.4 → 2.13.6

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

@@ -30,6 +30,15 @@ const TASKS_FILE = path.join(DATA_DIR, 'tasks.json');
 const IMAGES_DIR = path.join(DATA_DIR, 'workbench-images');
 const INSTRUCTION_FILE = path.join(DATA_DIR, 'ai-instruction.json');
 const SUBTASK_INSTRUCTION_FILE = path.join(DATA_DIR, 'ai-subtask-instruction.json');
+// 执行日志持久化：jobs.json 是历史档案，jobs-config.json 是保留策略。
+// jobs Map 仍只承载当前进程产出的活跃 job；管理页直接读 jobs.json。
+const JOBS_FILE = path.join(DATA_DIR, 'jobs.json');
+const JOBS_CONFIG_FILE = path.join(DATA_DIR, 'jobs-config.json');
+// 流式 chunk 写盘会撑爆 IO；用 1.5s debounce 把高频写入折叠成一次。
+// 终态时由 flushJobsSaveNow() 强制立即落盘。
+const JOBS_SAVE_DEBOUNCE_MS = 1500;
+let jobsSaveTimer = null;
+const DEFAULT_JOBS_CONFIG = { maxCount: 500, maxSizeMB: 256 };
 
 // 子项目识别 / 文件扫描时需要跳过的目录
 const SKIP_DIRS = new Set([
@@ -405,6 +414,141 @@ async function callLlmStream(model, prompt, onDelta, opts = {}) {
   return { content: fullContent, aborted }
 }
 
+// AI 拆分子任务 JSON 多级降级解析。
+// 模型经常会犯几类格式错：在 desc 里用 ASCII 双引号引用术语 / 末尾留尾随逗号 /
+// 输出被 token 上限截断导致代码块未闭合。直接 JSON.parse 一旦失败就会让前端的
+// "确认入库" 按钮永远是 (0)，用户看不到原因。这里按"越简单越优先"的顺序尝试：
+//   ① ```json``` 代码块 / ```any``` 代码块 / 第一个完整 { ... } 范围
+//   ② 把候选片段去掉尾随逗号 + 块/行注释 再 parse
+//   ③ 用括号深度扫描，从开头找一个语法平衡的 { ... } 子串
+//   ④ 启发式转义模型夹在字符串内部的未转义 ASCII 双引号
+//      （这是实战里最常见的失败：模型用 ASCII " 引用"和书籍对话"这种术语，
+//       直接打断外层 JSON。本级在字符串中遇到 " 时往后看一个非空白字符，
+//       不是 ,}]: 就把它当作字面量，转义成 \"。）
+// 任一步成功就返回 parsed，全部失败时返回最后一次 JSON.parse 的错误，
+// 用 parseStage 告知前端"模型输出哪一步崩了"，并把原始 raw 一并回传。
+function parseSubtaskJson(content) {
+  const src = String(content || '');
+  if (!src.trim()) {
+    return { parsed: null, parseError: '模型未返回任何内容', parseStage: 'empty' };
+  }
+
+  const candidates = [];
+  const fenced = src.match(/```json\s*([\s\S]*?)```/i) || src.match(/```\s*([\s\S]*?)```/);
+  if (fenced) candidates.push(fenced[1]);
+  const bracePair = src.match(/\{[\s\S]*\}/);
+  if (bracePair) candidates.push(bracePair[0]);
+  // 兜底：整段当 JSON 试
+  candidates.push(src);
+
+  let lastErr = null;
+  for (const raw of candidates) {
+    const txt = String(raw || '').trim();
+    if (!txt) continue;
+    // ① 直 parse
+    try { return { parsed: JSON.parse(txt), parseError: '', parseStage: '' }; }
+    catch (e) { lastErr = e; }
+    // ② 清洗：去 //…/* */ 注释 + 尾随逗号
+    const cleaned = txt
+      .replace(/\/\*[\s\S]*?\*\//g, '')
+      .replace(/(^|[^:"'\\])\/\/[^\n]*/g, '$1')
+      .replace(/,(\s*[}\]])/g, '$1');
+    try { return { parsed: JSON.parse(cleaned), parseError: '', parseStage: 'cleaned' }; }
+    catch (e) { lastErr = e; }
+    // ③ 平衡花括号扫描
+    const balanced = extractBalancedJson(cleaned);
+    if (balanced && balanced !== cleaned) {
+      try { return { parsed: JSON.parse(balanced), parseError: '', parseStage: 'balanced' }; }
+      catch (e) { lastErr = e; }
+    }
+    // ④ 启发式转义字符串内的未转义双引号
+    const base = balanced || cleaned;
+    const reescaped = reescapeUnescapedQuotes(base);
+    if (reescaped && reescaped !== base) {
+      try { return { parsed: JSON.parse(reescaped), parseError: '', parseStage: 'reescaped' }; }
+      catch (e) { lastErr = e; }
+    }
+  }
+
+  return {
+    parsed: null,
+    parseError: lastErr ? (lastErr.message || String(lastErr)) : '未能从模型输出中提取出 JSON',
+    parseStage: 'failed'
+  };
+}
+
+// 从字符串中提取首个语法平衡的 { ... } 子串。
+// 跟踪字符串字面量（含转义），避免把 desc 里的 } 当成结束。
+function extractBalancedJson(text) {
+  const s = String(text || '');
+  const start = s.indexOf('{');
+  if (start < 0) return '';
+  let depth = 0;
+  let inStr = false;
+  let strCh = '';
+  let esc = false;
+  for (let i = start; i < s.length; i++) {
+    const c = s[i];
+    if (inStr) {
+      if (esc) { esc = false; continue; }
+      if (c === '\\') { esc = true; continue; }
+      if (c === strCh) { inStr = false; }
+      continue;
+    }
+    if (c === '"' || c === "'") { inStr = true; strCh = c; continue; }
+    if (c === '{') depth++;
+    else if (c === '}') {
+      depth--;
+      if (depth === 0) return s.slice(start, i + 1);
+    }
+  }
+  return '';
+}
+
+// ④ 级降级：把字符串字面量内部出现的、未转义的 ASCII 双引号自动转义。
+// 实战中模型最常见的错误是 "desc": "...用户点击"保存"按钮..." 这种—
+// 中间的 "保存" 把外层字符串截断成两段，后面变成裸文本，JSON.parse 必崩。
+//
+// 启发式判断：扫描时若处于字符串中且遇到 "，往后看第一个非空白字符：
+//   - 是 , } ] : 或文本结尾 → 这是真闭合，正常退出字符串
+//   - 否则 → 是模型乱写的字面量引号，改写为 \" 并继续留在字符串里
+// 不依赖正则、不破坏已经转义的 \"，对嵌套 / 多行字符串都安全。
+function reescapeUnescapedQuotes(text) {
+  const s = String(text || '');
+  if (!s) return '';
+  const out = [];
+  let inStr = false;
+  let strCh = '';
+  let esc = false;
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if (!inStr) {
+      out.push(c);
+      if (c === '"' || c === "'") { inStr = true; strCh = c; }
+      continue;
+    }
+    // 字符串内部
+    if (esc) { out.push(c); esc = false; continue; }
+    if (c === '\\') { out.push(c); esc = true; continue; }
+    if (c !== strCh) { out.push(c); continue; }
+    // 遇到与开闭引号相同的字符——往后看下一个非空白
+    let j = i + 1;
+    while (j < s.length && (s[j] === ' ' || s[j] === '\t')) j++;
+    const next = j < s.length ? s[j] : '';
+    if (next === '' || next === ',' || next === '}' || next === ']'
+        || next === ':' || next === '\n' || next === '\r') {
+      // 真闭合
+      out.push(c);
+      inStr = false;
+      strCh = '';
+    } else {
+      // 字面量裸引号——转义
+      out.push('\\', c);
+    }
+  }
+  return out.join('');
+}
+
 function nowIso() {
   return new Date().toISOString();
 }
@@ -434,6 +578,131 @@ async function writeJson(file, data) {
   await fsp.rename(tmp, file);
 }
 
+// ── 执行日志持久化 ────────────────────────────────────────────
+// 设计要点：
+//   - 写盘在流式 chunk 阶段走 1.5s debounce；终态时（finally / cancel）强制 flush。
+//   - 永不持久化 child 引用（参考 cancel 路由的浅拷贝模式）。
+//   - hydrate 时把 running/pending 降级为 error：原 child 进程已不存在。
+//   - enforceRetention 在每次落盘后跑，按 endedAt desc FIFO 裁剪。
+
+function serializeJob(j, taskMap) {
+  // child 是 ChildProcess 引用，序列化会爆；剥离后 size 用三字段累加预计算
+  const { child, ...rest } = j
+  const t = taskMap ? taskMap.get(rest.taskId) : null
+  const sub = t && Array.isArray(t.subtasks) ? t.subtasks.find(s => s.id === rest.subId) : null
+  const size = ((rest.prompt || '').length
+    + (rest.output || '').length
+    + (rest.thinking || '').length)
+  return {
+    ...rest,
+    taskTitle: t ? t.title : '',
+    subTitle: sub ? sub.title : '',
+    size
+  }
+}
+
+function scheduleJobsSave() {
+  if (jobsSaveTimer) clearTimeout(jobsSaveTimer)
+  jobsSaveTimer = setTimeout(() => {
+    jobsSaveTimer = null
+    flushJobsSaveNow().catch(err => console.warn('[workbench] jobs save failed:', err.message))
+  }, JOBS_SAVE_DEBOUNCE_MS)
+}
+
+async function flushJobsSaveNow() {
+  if (jobsSaveTimer) { clearTimeout(jobsSaveTimer); jobsSaveTimer = null }
+  // 读 tasks.json 给落盘 job 反范式 taskTitle/subTitle——父任务被删后管理页仍可读
+  const tasksData = await readJson(TASKS_FILE, { tasks: [] })
+  const taskMap = new Map((tasksData.tasks || []).map(t => [t.id, t]))
+  const payload = {
+    version: 1,
+    jobs: Array.from(jobs.values()).map(j => serializeJob(j, taskMap))
+  }
+  await writeJson(JOBS_FILE, payload)
+  await enforceRetention()
+}
+
+async function readJobsConfig() {
+  const cfg = await readJson(JOBS_CONFIG_FILE, null)
+  if (!cfg || typeof cfg !== 'object') return { ...DEFAULT_JOBS_CONFIG }
+  return {
+    maxCount: Number.isFinite(cfg.maxCount) ? Math.max(0, Math.floor(cfg.maxCount)) : DEFAULT_JOBS_CONFIG.maxCount,
+    maxSizeMB: Number.isFinite(cfg.maxSizeMB) ? Math.max(0, Math.floor(cfg.maxSizeMB)) : DEFAULT_JOBS_CONFIG.maxSizeMB
+  }
+}
+
+async function writeJobsConfig(cfg) {
+  // 校验：非负整数；硬上限防误填爆盘
+  const out = {}
+  if (cfg.maxCount !== undefined) {
+    const n = Math.floor(Number(cfg.maxCount))
+    if (!Number.isFinite(n) || n < 0 || n > 10000) throw new Error('maxCount 必须在 0-10000 之间')
+    out.maxCount = n
+  }
+  if (cfg.maxSizeMB !== undefined) {
+    const n = Math.floor(Number(cfg.maxSizeMB))
+    if (!Number.isFinite(n) || n < 0 || n > 10240) throw new Error('maxSizeMB 必须在 0-10240 之间')
+    out.maxSizeMB = n
+  }
+  const merged = { ...(await readJobsConfig()), ...out }
+  await writeJson(JOBS_CONFIG_FILE, merged)
+  return merged
+}
+
+// 进程启动时把磁盘上的历史拉回内存 Map；陈旧的 running/pending 强制降级。
+// 陈旧 job 的 child 进程已退出，标记为 error 方便用户识别。
+async function hydrateJobs() {
+  let data
+  try {
+    data = await readJson(JOBS_FILE, null)
+  } catch (err) {
+    // 损坏文件：改名备份避免下次 flush 静默覆盖用户数据
+    console.warn('[workbench] jobs.json 解析失败，备份原文件后重置:', err.message)
+    try { await fsp.rename(JOBS_FILE, `${JOBS_FILE}.bak-${Date.now()}`) } catch { /* 文件可能已不在 */ }
+    return
+  }
+  if (!data || !Array.isArray(data.jobs)) return
+  for (const j of data.jobs) {
+    if (j.status === 'running' || j.status === 'pending') {
+      j.status = 'error'
+      j.error = (j.error || '') + ' [重启后回收：原进程已退出]'
+      j.endedAt = j.endedAt || nowIso()
+      j.exitCode = typeof j.exitCode === 'number' ? j.exitCode : 1
+    }
+    // 旧版本可能没 size 字段；补齐以兼容历史文件
+    if (typeof j.size !== 'number') {
+      j.size = ((j.prompt || '').length + (j.output || '').length + (j.thinking || '').length)
+    }
+    jobs.set(j.id, j)
+  }
+  // 启动后也跑一遍保留策略，让历史文件立刻缩到当前配置
+  try { await enforceRetention() } catch (err) { console.warn('[workbench] 启动时 enforceRetention 失败:', err.message) }
+}
+
+// 保留策略：按 endedAt desc（fallback startedAt / id）排序，先按 maxCount 截，
+// 再按 maxSizeMB 累计裁，淘汰同步从内存 Map 删除。
+async function enforceRetention() {
+  const cfg = await readJobsConfig()
+  const data = await readJson(JOBS_FILE, { version: 1, jobs: [] })
+  if (!data || !Array.isArray(data.jobs) || data.jobs.length === 0) return
+  const sortKey = (j) => j.endedAt || j.startedAt || j.id || ''
+  data.jobs.sort((a, b) => sortKey(b).localeCompare(sortKey(a)))
+  if (cfg.maxCount > 0) data.jobs = data.jobs.slice(0, cfg.maxCount)
+  if (cfg.maxSizeMB > 0) {
+    const cap = cfg.maxSizeMB * 1024 * 1024
+    let total = data.jobs.reduce((s, j) => s + (j.size || 0), 0)
+    while (total > cap && data.jobs.length > 1) {
+      const dropped = data.jobs.pop()
+      total -= (dropped && dropped.size) || 0
+    }
+  }
+  await writeJson(JOBS_FILE, data)
+  const keepIds = new Set(data.jobs.map(j => j.id))
+  for (const id of Array.from(jobs.keys())) {
+    if (!keepIds.has(id)) jobs.delete(id)
+  }
+}
+
 // 简单的 Mustache 风格变量插值：{{task.title}} / {{task.desc}} / {{repo.path}} / {{branch}}
 function interpolate(template, ctx) {
   if (typeof template !== 'string') return template;
@@ -456,6 +725,8 @@ const jobs = new Map(); // jobId -> { id, taskId, subId, status, pid, startedAt,
 // 用 Set 而不是 job.cancelled 标志，是为了在 SIGTERM 发出后到 child 真正退出之间
 // 有一个简洁的"待回收"窗口。
 const cancelledJobs = new Set();
+// 启动时从磁盘拉回历史 job（陈旧 running/pending 自动降级 error）
+hydrateJobs().catch(err => console.warn('[workbench] hydrate jobs failed:', err.message))
 
 // ── 生成指令持久化（~/.zen-gitsync/ai-instruction.json） ────────────────────
 async function readInstruction() {
@@ -745,9 +1016,11 @@ ${prompt}`
       //   assistant.thinking   → job.thinking  （折叠展示，让用户知道 Claude 在想）
       //   其他事件（init / tool_use / result 等）忽略，避免噪声
       // 解析失败的行原样进 output，便于排查协议异常。
-      // 过长时（>256KB）只截断尾部 256KB，避免内存膨胀。
-      const MAX_OUTPUT = 256 * 1024;
-      const MAX_THINKING = 64 * 1024;
+      // thinking 几乎不做服务端截断：Claude reasoning 一般在 KB~几十 MB 之间，
+// 100MB 兜底只是为了防止内存爆炸。流式 publish 时改推增量 delta（仅新拼接的
+// 那部分），终态或重连时才随 job:update 全量同步，避免每帧重复广播整个累积文本。
+      const MAX_OUTPUT = 100 * 1024 * 1024;
+      const MAX_THINKING = 100 * 1024 * 1024;
       job.output = '';
       job.thinking = '';
       const lineBuf = { stdout: '', stderr: '' };
@@ -757,12 +1030,17 @@ ${prompt}`
         lineBuf[channel] += chunk;
         const lines = lineBuf[channel].split('\n');
         lineBuf[channel] = lines.pop() ?? ''; // 最后一段可能不完整，留给下次
+        let pendingThinkingDelta = '';
         for (const line of lines) {
           const trimmed = line.trim();
           if (!trimmed) continue;
           if (channel === 'stderr' || !trimmed.startsWith('{')) {
             // 非 stream-json 行：原样塞进 output（兼容老版本 claude / 错误信息）
+            const prevLen = job.output.length;
             job.output = (job.output + trimmed + '\n').slice(-MAX_OUTPUT);
+            // output 也用 delta 推送，前端按"以 length 为锚追加"语义合并
+            const delta = job.output.slice(prevLen);
+            if (delta) publish('job:output-delta', { id: job.id, delta });
             continue;
           }
           let evt;
@@ -772,13 +1050,22 @@ ${prompt}`
           if (!Array.isArray(blocks)) continue;
           for (const b of blocks) {
             if (b.type === 'text' && typeof b.text === 'string') {
+              const prevLen = job.output.length;
               job.output = (job.output + b.text).slice(-MAX_OUTPUT);
+              const delta = job.output.slice(prevLen);
+              if (delta) publish('job:output-delta', { id: job.id, delta });
             } else if (b.type === 'thinking' && typeof b.thinking === 'string') {
+              const prevLen = job.thinking.length;
               job.thinking = (job.thinking + b.thinking).slice(-MAX_THINKING);
+              const delta = job.thinking.slice(prevLen);
+              if (delta) pendingThinkingDelta += delta;
             }
           }
         }
-        publish('job:update', job);
+        // 一批 NDJSON 处理完后统一发一次 thinking delta，避免高频小块 socket 占用
+        if (pendingThinkingDelta) {
+          publish('job:thinking-delta', { id: job.id, delta: pendingThinkingDelta });
+        }
       };
       if (child.stdout) child.stdout.on('data', (buf) => parseLines('stdout', buf));
       if (child.stderr) child.stderr.on('data', (buf) => parseLines('stderr', buf));
@@ -788,7 +1075,10 @@ ${prompt}`
       const wasCancelled = cancelledJobs.has(jobId)
       if (wasCancelled) cancelledJobs.delete(jobId)
       // 进程退出时 stdout 可能残留最后一段未换行的 NDJSON，flush 一次
+      // flush 内部也按 delta 推送，保持与流式阶段一致
       if (lineBuf.stdout.trim()) {
+        const outPrev = job.output.length;
+        const thinkPrev = job.thinking.length;
         try {
           const evt = JSON.parse(lineBuf.stdout.trim())
           if (evt.type === 'assistant' && Array.isArray(evt.message?.content)) {
@@ -801,6 +1091,10 @@ ${prompt}`
             }
           }
         } catch { /* 不是 JSON，忽略 */ }
+        const outDelta = job.output.slice(outPrev);
+        if (outDelta) publish('job:output-delta', { id: job.id, delta: outDelta });
+        const thinkDelta = job.thinking.slice(thinkPrev);
+        if (thinkDelta) publish('job:thinking-delta', { id: job.id, delta: thinkDelta });
       }
       job.endedAt = nowIso();
       if (wasCancelled) {
@@ -824,6 +1118,8 @@ ${prompt}`
       delete job.child
       publish('job:update', job);
       publish('sub:update', { taskId: task.id, sub });
+      // 终态：fire-and-forget 同步落盘，确保 done/cancelled/error 都立即归档
+      flushJobsSaveNow().catch(err => console.warn('[workbench] jobs save failed:', err.message))
     }
   }
   // 写回 tasks.json
@@ -1233,7 +1529,13 @@ ${desc ? `描述：${desc}` : '描述：（无）'}${attachmentBlock}${templateB
   "subtasks": [
     { "title": "子任务标题（10-20字）", "desc": "具体描述" }
   ]
-}`;
+}
+
+**JSON 输出严格要求**（不遵守会导致解析失败、用户无法入库）：
+1. title 和 desc 内如需引用术语 / 页面名 / 状态名，**必须使用中文引号「」或『』**，禁止使用 ASCII 双引号、单引号或反引号，否则会破坏外层 JSON 结构。
+2. JSON 中不允许尾随逗号（最后一个元素后面不能跟逗号）。
+3. JSON 中不允许写注释。
+4. 所有字符串字段必须用 ASCII 双引号包裹，字符串内部如有换行用 \\n 转义。`;
 
       // 先把 prompt 元信息推给前端
       send({ type: 'meta', prompt: { system: userInstruction, user: userBlock } });
@@ -1255,15 +1557,8 @@ ${desc ? `描述：${desc}` : '描述：（无）'}${attachmentBlock}${templateB
         return res.end();
       }
 
-      // 解析 JSON：兼容 ```json ... ``` 代码块或裸 JSON
-      let parsed = {};
-      try {
-        const m = content.match(/```json\s*([\s\S]*?)```/i)
-          || content.match(/```\s*([\s\S]*?)```/)
-          || content.match(/(\{[\s\S]*\})/);
-        parsed = JSON.parse(m ? m[1] : content);
-      } catch { parsed = {}; }
-
+      // 解析 JSON：兼容 ```json ... ``` 代码块或裸 JSON，多级降级
+      const { parsed, parseError, parseStage } = parseSubtaskJson(content);
       const list = Array.isArray(parsed?.subtasks) ? parsed.subtasks : [];
       const subtasks = list
         .map(s => ({
@@ -1273,7 +1568,7 @@ ${desc ? `描述：${desc}` : '描述：（无）'}${attachmentBlock}${templateB
         .filter(s => s.title)
         .slice(0, 8);
 
-      send({ type: 'done', subtasks, raw: content });
+      send({ type: 'done', subtasks, raw: content, parseError, parseStage });
       finished = true;
       res.end();
     } catch (err) {
@@ -1283,6 +1578,30 @@ ${desc ? `描述：${desc}` : '描述：（无）'}${attachmentBlock}${templateB
     }
   });
 
+  // POST /api/workbench/tasks/parse-subtasks
+  //   body: { raw: string }
+  //   →   { success, subtasks, parseError, parseStage }
+  // 让前端在 AI 拆分对话框里把"原始结果"作为可编辑文本——用户手改完
+  // （比如把 ASCII 双引号改成中文「」、删尾随逗号）后直接调这个接口，
+  // 不必再发起一次 LLM 调用，省 token 也省等待。
+  app.post('/api/workbench/tasks/parse-subtasks', async (req, res) => {
+    try {
+      const raw = String(req.body?.raw || '');
+      const { parsed, parseError, parseStage } = parseSubtaskJson(raw);
+      const list = Array.isArray(parsed?.subtasks) ? parsed.subtasks : [];
+      const subtasks = list
+        .map(s => ({
+          title: String(s?.title || '').trim().slice(0, 80),
+          desc: String(s?.desc || '').trim().slice(0, 500)
+        }))
+        .filter(s => s.title)
+        .slice(0, 8);
+      res.json({ success: true, subtasks, parseError, parseStage });
+    } catch (err) {
+      res.status(500).json({ success: false, error: err?.message || String(err) });
+    }
+  });
+
   // SSE 事件流
   app.get('/api/workbench/events', (req, res) => {
     res.set({
@@ -1362,6 +1681,17 @@ ${desc ? `描述：${desc}` : '描述：（无）'}${attachmentBlock}${templateB
     }
   });
 
+  // 当前选中的项目路径（侧边栏按项目分组时要用）
+  app.get('/api/workbench/current-project', async (_req, res) => {
+    try {
+      const projectPath = typeof getCurrentProjectPath === 'function' ? getCurrentProjectPath() : '';
+      const projectName = projectPath ? projectPath.split(/[\\/]/).filter(Boolean).pop() : '';
+      res.json({ success: true, projectPath, projectName });
+    } catch (err) {
+      res.status(500).json({ success: false, error: err.message });
+    }
+  });
+
   app.post('/api/workbench/tasks', async (req, res) => {
     try {
       const { id, title, desc, promptId, subtasks } = req.body || {};
@@ -1369,6 +1699,8 @@ ${desc ? `描述：${desc}` : '描述：（无）'}${attachmentBlock}${templateB
       const data = await readJson(TASKS_FILE, { tasks: [] });
       const tasks = data.tasks || [];
       const now = nowIso();
+      // 创建任务时记录当时所属项目；编辑已有任务不覆盖（避免切换项目后老任务被改归属）
+      const currentProjectPath = typeof getCurrentProjectPath === 'function' ? getCurrentProjectPath() : '';
       if (id) {
         const i = tasks.findIndex(t => t.id === id);
         if (i < 0) return res.status(404).json({ success: false, error: '任务不存在' });
@@ -1405,6 +1737,7 @@ ${desc ? `描述：${desc}` : '描述：（无）'}${attachmentBlock}${templateB
         title,
         desc: desc || '',
         promptId: promptId || null,
+        projectPath: currentProjectPath || '',
         subtasks: Array.isArray(subtasks) ? subtasks.map(s => ({
           id: s.id || genId(),
           title: s.title || '',
@@ -1482,6 +1815,8 @@ ${desc ? `描述：${desc}` : '描述：（无）'}${attachmentBlock}${templateB
     job.error = '用户已停止执行'
     job.endedAt = nowIso()
     publish('job:update', { ...job }) // 用浅拷贝避免序列化 child 引用
+    // 终态：fire-and-forget 同步落盘，cancel 是显式操作，要保证不丢
+    flushJobsSaveNow().catch(err => console.warn('[workbench] jobs save failed:', err.message))
     const child = job.child
     if (!child) {
       return res.json({ success: true, message: '已标记取消，进程将尽快结束' })
@@ -1504,6 +1839,183 @@ ${desc ? `描述：${desc}` : '描述：（无）'}${attachmentBlock}${templateB
     }
   });
 
+  // ── 执行日志管理 API（持久化 + 清理） ────────────────────────────
+  // 路径都在 /api/workbench/jobs/* 下；/list、/config、/batch-delete、/clear
+  // 是字面路径，必须排在 :id 路由之前注册，避免被 :id 匹配吞掉。
+  //
+  // 数据来源：
+  //   - 文件 jobs.json：已落盘的历史 job（含反范式 taskTitle/subTitle）
+  //   - 内存 jobs Map：当前进程刚创建还没刷盘的（尤其是 running/pending）
+  // 合并后再过滤分页，保证管理页能看到"刚启动还没结束"的任务。
+
+  async function loadAllJobs() {
+    // 读 tasks.json 一次，给内存里没落盘的 job 反范式补 title
+    const tasksData = await readJson(TASKS_FILE, { tasks: [] })
+    const taskMap = new Map((tasksData.tasks || []).map(t => [t.id, t]))
+    const data = await readJson(JOBS_FILE, { version: 1, jobs: [] })
+    const fileJobs = (data && Array.isArray(data.jobs)) ? data.jobs : []
+    const fileIds = new Set(fileJobs.map(j => j.id))
+    // 内存里有但文件里没有：running/pending 或最近刚起还没刷盘的
+    const liveOnly = Array.from(jobs.values())
+      .filter(j => !fileIds.has(j.id))
+      .map(j => serializeJob(j, taskMap))
+    return [...fileJobs, ...liveOnly]
+  }
+
+  function applyJobsFilter(list, q) {
+    const status = (q.status || '').trim()
+    const taskId = (q.taskId || '').trim()
+    const term = (q.q || '').trim().toLowerCase()
+    return list.filter(j => {
+      if (status && j.status !== status) return false
+      if (taskId && j.taskId !== taskId) return false
+      if (term) {
+        const hay = `${j.title || ''} ${j.taskTitle || ''} ${j.subTitle || ''}`.toLowerCase()
+        if (!hay.includes(term)) return false
+      }
+      return true
+    })
+  }
+
+  // GET /api/workbench/jobs/list?status=&q=&taskId=&limit=&offset=
+  app.get('/api/workbench/jobs/list', async (req, res) => {
+    try {
+      const limit = Math.min(200, Math.max(1, parseInt(req.query.limit, 10) || 50))
+      const offset = Math.max(0, parseInt(req.query.offset, 10) || 0)
+      const all = await loadAllJobs()
+      const filtered = applyJobsFilter(all, req.query)
+      // 按 endedAt desc；没有就 startedAt desc；都没有就 id desc（id 时间戳前缀可比）
+      const sortKey = (j) => j.endedAt || j.startedAt || j.id || ''
+      filtered.sort((a, b) => sortKey(b).localeCompare(sortKey(a)))
+      const total = filtered.length
+      const page = filtered.slice(offset, offset + limit)
+      // 统计：按 status 分组 + 总 size（基于全集，给顶部条用）
+      const byStatus = {}
+      let totalSize = 0
+      for (const j of all) {
+        byStatus[j.status] = (byStatus[j.status] || 0) + 1
+        totalSize += j.size || 0
+      }
+      res.json({
+        success: true,
+        jobs: page,
+        total,
+        stats: { count: all.length, sizeMB: +(totalSize / 1024 / 1024).toFixed(2), byStatus }
+      })
+    } catch (err) {
+      res.status(500).json({ success: false, error: 'list jobs 失败: ' + (err.message || String(err)) })
+    }
+  })
+
+  // GET /api/workbench/jobs/config
+  app.get('/api/workbench/jobs/config', async (_req, res) => {
+    try {
+      res.json({ success: true, config: await readJobsConfig() })
+    } catch (err) {
+      res.status(500).json({ success: false, error: '读取配置失败: ' + err.message })
+    }
+  })
+
+  // PUT /api/workbench/jobs/config
+  app.put('/api/workbench/jobs/config', async (req, res) => {
+    try {
+      const cfg = await writeJobsConfig(req.body || {})
+      // 配置变更后立刻 enforce，让已落盘的多余记录立刻被裁掉
+      await enforceRetention()
+      res.json({ success: true, config: cfg })
+    } catch (err) {
+      res.status(400).json({ success: false, error: err.message || String(err) })
+    }
+  })
+
+  // POST /api/workbench/jobs/batch-delete
+  app.post('/api/workbench/jobs/batch-delete', async (req, res) => {
+    try {
+      const ids = Array.isArray(req.body?.ids) ? req.body.ids.filter(s => typeof s === 'string') : []
+      if (ids.length === 0) return res.json({ success: true, removed: 0 })
+      // 1) 删内存 Map
+      let removed = 0
+      for (const id of ids) {
+        if (jobs.delete(id)) removed++
+      }
+      // 2) 改写文件
+      const data = await readJson(JOBS_FILE, { version: 1, jobs: [] })
+      if (data && Array.isArray(data.jobs)) {
+        const set = new Set(ids)
+        const before = data.jobs.length
+        data.jobs = data.jobs.filter(j => !set.has(j.id))
+        removed += before - data.jobs.length
+        await writeJson(JOBS_FILE, data)
+      }
+      res.json({ success: true, removed })
+    } catch (err) {
+      res.status(500).json({ success: false, error: '批量删除失败: ' + (err.message || String(err)) })
+    }
+  })
+
+  // POST /api/workbench/jobs/clear
+  app.post('/api/workbench/jobs/clear', async (req, res) => {
+    try {
+      if (req.body?.confirm !== true) {
+        return res.status(400).json({ success: false, error: '需要 confirm: true' })
+      }
+      let removed = 0
+      for (const j of jobs.values()) {
+        // 不清当前还在跑/排队的（防止误清活跃 job；用户应逐个取消或等结束）
+        if (j.status === 'running' || j.status === 'pending') continue
+        jobs.delete(j.id)
+        removed++
+      }
+      // 写一个空 jobs.json
+      await writeJson(JOBS_FILE, { version: 1, jobs: [] })
+      res.json({ success: true, removed })
+    } catch (err) {
+      res.status(500).json({ success: false, error: '清空失败: ' + (err.message || String(err)) })
+    }
+  })
+
+  // GET /api/workbench/jobs/:id
+  app.get('/api/workbench/jobs/:id', async (req, res) => {
+    try {
+      // 优先查内存（含活跃）
+      const live = jobs.get(req.params.id)
+      if (live) {
+        const tasksData = await readJson(TASKS_FILE, { tasks: [] })
+        const taskMap = new Map((tasksData.tasks || []).map(t => [t.id, t]))
+        return res.json({ success: true, job: serializeJob(live, taskMap) })
+      }
+      // 退回文件
+      const data = await readJson(JOBS_FILE, { version: 1, jobs: [] })
+      const j = (data.jobs || []).find(x => x.id === req.params.id)
+      if (!j) return res.status(404).json({ success: false, error: 'job 不存在' })
+      res.json({ success: true, job: j })
+    } catch (err) {
+      res.status(500).json({ success: false, error: '查询失败: ' + (err.message || String(err)) })
+    }
+  })
+
+  // DELETE /api/workbench/jobs/:id
+  app.delete('/api/workbench/jobs/:id', async (req, res) => {
+    try {
+      const id = req.params.id
+      let removed = false
+      if (jobs.delete(id)) removed = true
+      const data = await readJson(JOBS_FILE, { version: 1, jobs: [] })
+      if (data && Array.isArray(data.jobs)) {
+        const before = data.jobs.length
+        data.jobs = data.jobs.filter(j => j.id !== id)
+        if (data.jobs.length !== before) {
+          removed = true
+          await writeJson(JOBS_FILE, data)
+        }
+      }
+      if (!removed) return res.status(404).json({ success: false, error: 'job 不存在' })
+      res.json({ success: true, removed: 1 })
+    } catch (err) {
+      res.status(500).json({ success: false, error: '删除失败: ' + (err.message || String(err)) })
+    }
+  })
+
   // ── 子任务附件：上传 / 删除 / 列表 ───────────────────────────────
   // 上传：POST /api/workbench/subtasks/:subId/attachments
   //   header: X-Original-Name, X-Mime-Type