zen-gitsync 2.13.5 → 2.13.7

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

@@ -414,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();
 }
@@ -807,187 +942,209 @@ async function runTaskQueue(task, repoPath, branch) {
   const priorOutputs = []
   for (const sub of task.subtasks) {
     if (sub.status === 'done') continue;
-    const promptTemplate = sub.promptOverride || (task.promptId
-      ? (await readJson(PROMPTS_FILE, { prompts: [] })).prompts.find(p => p.id === task.promptId)?.content
-      : null) || '';
-    const ctx = {
-      task: { title: task.title, desc: task.desc || '' },
-      sub: { title: sub.title, desc: sub.desc || '' },
-      repo: { path: repoPath || '' },
-      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');
-
-    // ── 前序上下文：把前几个 done 子任务的输出摘要拼到 prompt 头部 ──
-    if (priorOutputs.length > 0) {
-      const prevBlock = priorOutputs.map((p, i) => {
-        const text = (p.output || '').slice(0, MAX_PREV_OUTPUT_CHARS)
-        const truncated = (p.output || '').length > MAX_PREV_OUTPUT_CHARS ? '\n…（前文已截断）' : ''
-        return `### [${i + 1}] ${p.title}\n${text}${truncated}`
-      }).join('\n\n')
-      prompt = `以下是同一任务下已经完成的前序子任务输出（仅作上下文参考，请基于这些结论继续当前子任务，无需重复执行它们）：
+    await runSingleSubtask(task, sub, repoPath, branch, priorOutputs)
+  }
+  // 写回 tasks.json
+  await persistTaskAfterRun(task)
+}
+
+/**
+ * 执行单个子任务。被 runTaskQueue(整批)和"单 sub 执行"endpoint 共用。
+ *
+ * @param {object} task         主任务对象
+ * @param {object} sub          要跑的子任务
+ * @param {string} repoPath     仓库路径
+ * @param {string} branch       分支名（可空）
+ * @param {Array<{title:string,output:string}>} priorOutputs
+ *        前序 done 子任务的输出摘要（in-place 追加）。用于把同一任务下
+ *        前面已完成的 sub 产物拼到当前 sub 的 prompt 头部，让 Claude
+ *        知道上下文。单独跑一个 sub 时，这个数组里只会有"前面 done 的 sub"。
+ */
+async function runSingleSubtask(task, sub, repoPath, branch, priorOutputs) {
+  const MAX_PREV_OUTPUT_CHARS = 2000
+  const promptTemplate = sub.promptOverride || (task.promptId
+    ? (await readJson(PROMPTS_FILE, { prompts: [] })).prompts.find(p => p.id === task.promptId)?.content
+    : null) || '';
+  const ctx = {
+    task: { title: task.title, desc: task.desc || '' },
+    sub: { title: sub.title, desc: sub.desc || '' },
+    repo: { path: repoPath || '' },
+    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');
+
+  // ── 前序上下文：把前几个 done 子任务的输出摘要拼到 prompt 头部 ──
+  if (priorOutputs && priorOutputs.length > 0) {
+    const prevBlock = priorOutputs.map((p, i) => {
+      const text = (p.output || '').slice(0, MAX_PREV_OUTPUT_CHARS)
+      const truncated = (p.output || '').length > MAX_PREV_OUTPUT_CHARS ? '\n…（前文已截断）' : ''
+      return `### [${i + 1}] ${p.title}\n${text}${truncated}`
+    }).join('\n\n')
+    prompt = `以下是同一任务下已经完成的前序子任务输出（仅作上下文参考，请基于这些结论继续当前子任务，无需重复执行它们）：
 
 ${prevBlock}
 
 ---
 
 ${prompt}`
-    }
+  }
 
-    // ── 附件：合并 sub.attachments + task.attachments 后拼到 prompt 末尾 ──
-    // claude -p 字符串模式会扫描 prompt 中出现的本地文件路径并自动
-    // 识别为附件（图片 / PDF / 文本均可）。
-    // 主任务附件对所有 sub 都可见；子任务自己的附件只对该 sub 可见。
-    const allAttachments = [
-      ...(Array.isArray(task.attachments) ? task.attachments : []),
-      ...(Array.isArray(sub.attachments) ? sub.attachments : [])
-    ];
-    if (allAttachments.length > 0) {
-      const lines = allAttachments
-        .filter(a => a && a.absolutePath)
-        .map((a, i) => `  ${i + 1}. [${a.mimeType || 'application/octet-stream'}] ${a.absolutePath}`);
-      if (lines.length > 0) {
-        prompt += `\n\n---\n本任务包含 ${lines.length} 个附件（请按文件路径读取，不要让用户重新提供）：\n${lines.join('\n')}\n---`;
-      }
+  // ── 附件：合并 sub.attachments + task.attachments 后拼到 prompt 末尾 ──
+  // claude -p 字符串模式会扫描 prompt 中出现的本地文件路径并自动
+  // 识别为附件（图片 / PDF / 文本均可）。
+  // 主任务附件对所有 sub 都可见；子任务自己的附件只对该 sub 可见。
+  const allAttachments = [
+    ...(Array.isArray(task.attachments) ? task.attachments : []),
+    ...(Array.isArray(sub.attachments) ? sub.attachments : [])
+  ];
+  if (allAttachments.length > 0) {
+    const lines = allAttachments
+      .filter(a => a && a.absolutePath)
+      .map((a, i) => `  ${i + 1}. [${a.mimeType || 'application/octet-stream'}] ${a.absolutePath}`);
+    if (lines.length > 0) {
+      prompt += `\n\n---\n本任务包含 ${lines.length} 个附件（请按文件路径读取，不要让用户重新提供）：\n${lines.join('\n')}\n---`;
     }
+  }
 
-    const jobId = genId();
-    const job = {
-      id: jobId,
-      taskId: task.id,
-      subId: sub.id,
-      title: `${task.title} / ${sub.title}`,
-      status: 'pending',
-      prompt
-    };
-    jobs.set(jobId, job);
-    sub.status = 'running';
-    publish('sub:update', { taskId: task.id, sub });
+  const jobId = genId();
+  const job = {
+    id: jobId,
+    taskId: task.id,
+    subId: sub.id,
+    title: `${task.title} / ${sub.title}`,
+    status: 'pending',
+    prompt
+  };
+  jobs.set(jobId, job);
+  sub.status = 'running';
+  publish('sub:update', { taskId: task.id, sub });
+  publish('job:update', job);
+
+  try {
+    const { pid, child } = await launchClaudeInNewWindow(repoPath || process.cwd(), prompt);
+    job.pid = pid;
+    // 保存 child 引用，供 cancel 接口调用 kill
+    job.child = child;
+    job.startedAt = nowIso();
+    job.status = 'running';
     publish('job:update', job);
 
-    try {
-      const { pid, child } = await launchClaudeInNewWindow(repoPath || process.cwd(), prompt);
-      job.pid = pid;
-      // 保存 child 引用，供 cancel 接口调用 kill
-      job.child = child;
-      job.startedAt = nowIso();
-      job.status = 'running';
-      publish('job:update', job);
-
-      // 流式 NDJSON 解析：把 stdout 当作 stream-json 协议处理
-      //   assistant.text       → job.output    （用户主要关心的内容）
-      //   assistant.thinking   → job.thinking  （折叠展示，让用户知道 Claude 在想）
-      //   其他事件（init / tool_use / result 等）忽略，避免噪声
-      // 解析失败的行原样进 output，便于排查协议异常。
-      // 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: '' };
-
-      const parseLines = (channel, buf) => {
-        const chunk = buf.toString('utf8');
-        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 / 错误信息）
+    // 流式 NDJSON 解析：把 stdout 当作 stream-json 协议处理
+    //   assistant.text       → job.output    （用户主要关心的内容）
+    //   assistant.thinking   → job.thinking  （折叠展示，让用户知道 Claude 在想）
+    //   其他事件（init / tool_use / result 等）忽略，避免噪声
+    // 解析失败的行原样进 output，便于排查协议异常。
+    // 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: '' };
+
+    const parseLines = (channel, buf) => {
+      const chunk = buf.toString('utf8');
+      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;
+        try { evt = JSON.parse(trimmed) } catch { continue }
+        if (evt.type !== 'assistant') continue;
+        const blocks = evt.message?.content;
+        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 + trimmed + '\n').slice(-MAX_OUTPUT);
-            // output 也用 delta 推送，前端按"以 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 });
-            continue;
+          } 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;
           }
-          let evt;
-          try { evt = JSON.parse(trimmed) } catch { continue }
-          if (evt.type !== 'assistant') continue;
-          const blocks = evt.message?.content;
-          if (!Array.isArray(blocks)) continue;
-          for (const b of blocks) {
+        }
+      }
+      // 一批 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));
+
+    // 等待进程退出（detached 不阻塞主进程，用 polling /proc 兜底）
+    await waitProcessExit(pid);
+    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)) {
+          for (const b of evt.message.content) {
             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 });
+              job.output = (job.output + b.text).slice(-MAX_OUTPUT)
             } 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;
+              job.thinking = (job.thinking + b.thinking).slice(-MAX_THINKING)
             }
           }
         }
-        // 一批 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));
-
-      // 等待进程退出（detached 不阻塞主进程，用 polling /proc 兜底）
-      await waitProcessExit(pid);
-      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)) {
-            for (const b of evt.message.content) {
-              if (b.type === 'text' && typeof b.text === 'string') {
-                job.output = (job.output + b.text).slice(-MAX_OUTPUT)
-              } else if (b.type === 'thinking' && typeof b.thinking === 'string') {
-                job.thinking = (job.thinking + b.thinking).slice(-MAX_THINKING)
-              }
-            }
-          }
-        } 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) {
-        job.exitCode = 130; // 128 + SIGINT(2)，约定俗成的"用户取消"退出码
-        job.status = 'cancelled';
-        job.error = '用户已停止执行';
-        // sub 不改状态——cancelled 是 job 维度，同 task 后续 sub 仍可继续执行
-      } else {
-        job.exitCode = 0;
-        job.status = 'done';
-        sub.status = 'done';
-        // 把这个 sub 的输出累积到前序上下文，喂给下一个 sub
-        priorOutputs.push({ title: sub.title, output: job.output || '' })
-      }
-    } catch (err) {
-      job.error = err && err.message ? err.message : String(err);
-      job.status = 'error';
-      sub.status = 'error';
-    } finally {
-      // 移除 child 引用——避免后续被 SSE 序列化到前端
-      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))
+      } 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) {
+      job.exitCode = 130; // 128 + SIGINT(2)，约定俗成的"用户取消"退出码
+      job.status = 'cancelled';
+      job.error = '用户已停止执行';
+      // sub 不改状态——cancelled 是 job 维度，同 task 后续 sub 仍可继续执行
+    } else {
+      job.exitCode = 0;
+      job.status = 'done';
+      sub.status = 'done';
+      // 把这个 sub 的输出累积到前序上下文，喂给下一个 sub
+      if (priorOutputs) priorOutputs.push({ title: sub.title, output: job.output || '' })
     }
+  } catch (err) {
+    job.error = err && err.message ? err.message : String(err);
+    job.status = 'error';
+    sub.status = 'error';
+  } finally {
+    // 移除 child 引用——避免后续被 SSE 序列化到前端
+    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
+}
+
+/** 把 task.subtasks 写回 tasks.json,并广播 task:update。runTaskQueue 和"单 sub 执行"共用。 */
+async function persistTaskAfterRun(task) {
   const data = await readJson(TASKS_FILE, { tasks: [] });
   const t = data.tasks.find(x => x.id === task.id);
   if (t) {
@@ -998,6 +1155,31 @@ ${prompt}`
   }
 }
 
+/**
+ * 构建单 sub 执行时的 priorOutputs：把同一 task 下"排在当前 sub 之前"且已 done 的
+ * 子任务输出摘要收集起来。这样单独跑一个 sub 时,它也能拿到前序上下文。
+ */
+async function collectPriorOutputs(task, targetSub) {
+  const MAX_PREV_OUTPUT_CHARS = 2000
+  const prior = []
+  const targetIdx = task.subtasks.findIndex(s => s.id === targetSub.id)
+  if (targetIdx < 0) return prior
+  for (let i = 0; i < targetIdx; i++) {
+    const s = task.subtasks[i]
+    if (s.status !== 'done') continue
+    // 从 jobs 列表里找最近一个属于这个 sub 且 status=done 的 job,
+    // 取其 output 作为"前序上下文摘要"
+    const job = snapshotJobs()
+      .filter(j => j.subId === s.id && j.status === 'done')
+      .sort((a, b) => (b.endedAt || '').localeCompare(a.endedAt || ''))[0]
+    if (!job) continue
+    const text = (job.output || '').slice(0, MAX_PREV_OUTPUT_CHARS)
+    const truncated = (job.output || '').length > MAX_PREV_OUTPUT_CHARS ? '\n…（前文已截断）' : ''
+    prior.push({ title: s.title, output: text + truncated })
+  }
+  return prior
+}
+
 function waitProcessExit(pid) {
   return new Promise(resolve => {
     let exited = false;
@@ -1394,7 +1576,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 } });
@@ -1416,15 +1604,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 => ({
@@ -1434,7 +1615,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) {
@@ -1444,6 +1625,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({
@@ -1536,8 +1741,11 @@ ${desc ? `描述：${desc}` : '描述：（无）'}${attachmentBlock}${templateB
 
   app.post('/api/workbench/tasks', async (req, res) => {
     try {
-      const { id, title, desc, promptId, subtasks } = req.body || {};
+      const { id, title, desc, promptId, subtasks, type: rawType, simpleOverride } = req.body || {};
       if (!title) return res.status(400).json({ success: false, error: 'title 必填' });
+      // type 归一化:仅接受 'simple' | 'complex'，缺省/未知一律按 complex
+      const taskType = rawType === 'simple' ? 'simple' : 'complex';
+      const safeOverride = typeof simpleOverride === 'string' ? simpleOverride.slice(0, 8000) : '';
       const data = await readJson(TASKS_FILE, { tasks: [] });
       const tasks = data.tasks || [];
       const now = nowIso();
@@ -1551,6 +1759,8 @@ ${desc ? `描述：${desc}` : '描述：（无）'}${attachmentBlock}${templateB
           title,
           desc: desc || '',
           promptId: promptId || null,
+          type: taskType,
+          simpleOverride: taskType === 'simple' ? safeOverride : '',
           subtasks: Array.isArray(subtasks) ? subtasks.map(s => ({
             id: s.id || genId(),
             title: s.title || '',
@@ -1579,6 +1789,8 @@ ${desc ? `描述：${desc}` : '描述：（无）'}${attachmentBlock}${templateB
         title,
         desc: desc || '',
         promptId: promptId || null,
+        type: taskType,
+        simpleOverride: taskType === 'simple' ? safeOverride : '',
         projectPath: currentProjectPath || '',
         subtasks: Array.isArray(subtasks) ? subtasks.map(s => ({
           id: s.id || genId(),
@@ -1631,6 +1843,91 @@ ${desc ? `描述：${desc}` : '描述：（无）'}${attachmentBlock}${templateB
     }
   });
 
+  // ── 执行简单任务（无子任务直接跑） ──────────────────────────────────
+  // POST /api/workbench/tasks/:id/run-simple
+  // 行为：
+  //   - 适用于 type==='simple' 的任务，无需拆分子任务
+  //   - 在内存里合成一个虚拟 sub{title=task.title, desc=task.desc,
+  //     promptOverride=task.simpleOverride, status='todo'},
+  //     复用 runSingleSubtask(同一套 prompt 拼装、附件、job 跟踪、取消、落盘)
+  //   - 不会修改 task.subtasks 持久化结构
+  app.post('/api/workbench/tasks/:id/run-simple', async (req, res) => {
+    try {
+      const data = await readJson(TASKS_FILE, { tasks: [] });
+      const task = (data.tasks || []).find(t => t.id === req.params.id);
+      if (!task) return res.status(404).json({ success: false, error: '任务不存在' });
+      if (task.type !== 'simple') {
+        return res.status(400).json({ success: false, error: '该任务不是简单任务,请使用普通执行接口' });
+      }
+      const repoPath = typeof getCurrentProjectPath === 'function' ? getCurrentProjectPath() : '';
+      // 虚拟 sub:不写回 tasks.json,只用一次
+      const virtualSub = {
+        id: `${task.id}__simple`,
+        title: task.title,
+        desc: task.desc || '',
+        status: 'todo',
+        promptOverride: task.simpleOverride || '',
+        attachments: Array.isArray(task.attachments) ? task.attachments : []
+      };
+      // 简单任务本身没有 subtasks 列表,直接调 runSingleSubtask(不再走 runTaskQueue 循环)
+      res.json({ success: true, message: '已开始执行简单任务' });
+      runSingleSubtask(task, virtualSub, repoPath, '', []).catch(err => {
+        publish('task:error', { taskId: task.id, error: err.message });
+      });
+    } catch (err) {
+      res.status(500).json({ success: false, error: err.message });
+    }
+  });
+
+  // ── 执行单个子任务 ────────────────────────────────────────────────────
+  // POST /api/workbench/subtasks/:id/run
+  // 行为：
+  //   - 仅执行指定 id 的这一个 sub，不再遍历 task 下其他 sub
+  //   - 拼 prompt 时会把"前面已 done 的 sub"输出摘要作为前序上下文塞进去,
+  //     跟整批执行的语义保持一致
+  //   - 整批"执行任务"队列和单 sub 执行共用 runSingleSubtask,所以日志/状态
+  //     /取消/落盘逻辑完全一致
+  // 限制：
+  //   - 该 sub 处于 running/pending 时拒绝(并发跑同一个 sub 会出现状态混乱)
+  app.post('/api/workbench/subtasks/:id/run', async (req, res) => {
+    try {
+      const data = await readJson(TASKS_FILE, { tasks: [] });
+      const subId = req.params.id;
+      let foundTask = null;
+      let foundSub = null;
+      for (const t of (data.tasks || [])) {
+        if (!Array.isArray(t.subtasks)) continue;
+        const s = t.subtasks.find(x => x.id === subId);
+        if (s) { foundTask = t; foundSub = s; break; }
+      }
+      if (!foundTask || !foundSub) {
+        return res.status(404).json({ success: false, error: '子任务不存在' });
+      }
+      if (foundSub.status === 'running') {
+        return res.status(400).json({ success: false, error: '该子任务正在执行中' });
+      }
+      // 兜底:即便磁盘状态是 todo,如果磁盘里还没归档的 job 还在跑(进程被孤儿),也拦一下
+      const liveJob = snapshotJobs().find(j => j.subId === subId && (j.status === 'running' || j.status === 'pending'));
+      if (liveJob) {
+        return res.status(400).json({ success: false, error: '该子任务已有正在执行的 job' });
+      }
+      const repoPath = typeof getCurrentProjectPath === 'function' ? getCurrentProjectPath() : '';
+      // 异步执行,立即返回
+      res.json({ success: true, message: `已开始执行子任务：${foundSub.title || subId}` });
+      (async () => {
+        try {
+          const priorOutputs = await collectPriorOutputs(foundTask, foundSub);
+          await runSingleSubtask(foundTask, foundSub, repoPath, '', priorOutputs);
+          await persistTaskAfterRun(foundTask);
+        } catch (err) {
+          publish('task:error', { taskId: foundTask.id, error: err.message });
+        }
+      })();
+    } catch (err) {
+      res.status(500).json({ success: false, error: err.message });
+    }
+  });
+
   // ── 进程状态查询（兜底，SSE 断了也能拉） ────────────────────────────
   app.get('/api/workbench/jobs', (_req, res) => {
     res.json({ success: true, jobs: snapshotJobs() });