zen-gitsync 2.13.14 → 2.13.16

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

@@ -83,11 +83,12 @@ const MAX_ATTACHMENTS_PER_SUBTASK = 9;
 const DEFAULT_SUBTASK_INSTRUCTION_ZH = `你是一名任务拆分助手。
 
 【思考过程】
-在给出 JSON 之前，请先在内部仔细思考（如果模型支持，把思考放在 reasoning 中；否则可以先输出一段简短分析，再输出 JSON）：
-- 任务的真实目标是什么？用户提供的描述/图片/上下文里有哪些关键信息？
-- 涉及哪些技术栈、模块、文件、约束？是否有易被忽略的边界条件？
+在给出 JSON 之前，请先在内部仔细思考（如果模型支持，把思考放在 reasoning 中；否则可以先输出一段较长的仔细分析，再输出 JSON）。分析要覆盖足够维度，不要简短一两句话就过：
+- 任务的真实目标是什么？用户提供的描述/图片/上下文里有哪些关键信息和隐藏诉求？
+- 涉及哪些技术栈、模块、文件、约束？是否有易被忽略的边界条件、风险点？
 - 自然的执行顺序是什么？哪些步骤是前置依赖？哪些可以并行？
-- 哪些步骤可能失败、需要单独验证？
+- 哪些步骤可能失败、需要单独验证？验证方式是什么？
+- 是否需要先做调研/读现有代码的步骤，再做修改？
 
 【拆分原则】
 1. 单一职责：每个子任务只做一件事，避免"做 A 和 B"。
@@ -111,11 +112,12 @@ JSON 要用 \`\`\`json ... \`\`\` 代码块包裹，前面可以有分析文字
 const DEFAULT_SUBTASK_INSTRUCTION_EN = `You are a task breakdown assistant.
 
 [Thinking process]
-Before producing JSON, think carefully (put your thoughts in reasoning if the model supports it; otherwise output a short analysis first, then JSON):
-- What is the real goal? What key information is in the description / images / context?
-- Which stack, modules, files, constraints are involved? Any easily missed edge cases?
+Before producing JSON, think carefully (put your thoughts in reasoning if the model supports it; otherwise output a longer careful analysis first, then JSON). Cover enough dimensions — don't settle for a one-or-two-sentence summary:
+- What is the real goal? What key info and hidden needs are in the description / images / context?
+- Which stack, modules, files, constraints are involved? Any easily missed edge cases or risks?
 - What is the natural execution order? What blocks what? What can run in parallel?
-- Which steps may fail and need separate verification?
+- Which steps may fail and need separate verification? How will you verify?
+- Should a research / read-existing-code step come before the changes?
 
 [Breakdown principles]
 1. Single responsibility: each subtask does only one thing, avoid bundling "do A and B".
@@ -998,7 +1000,9 @@ function snapshotJobs() {
     startedAt: j.startedAt || null,
     endedAt: j.endedAt || null,
     exitCode: typeof j.exitCode === 'number' ? j.exitCode : null,
-    error: j.error || null
+    error: j.error || null,
+    // 续接对话用:claude --output-format stream-json 的 system.init 事件捕获到的 session_id
+    claudeSessionId: j.claudeSessionId || null
   }));
 }
 
@@ -1006,16 +1010,21 @@ function snapshotJobs() {
 // 返回 { pid, child }：调用方可以监听 child.stdout/stderr 实时收集输出。
 // 不再走 cmd /k 弹窗——claude -p 是非交互模式，输出通过 stdout pipe 实时回传
 // 到前端面板展示。
-function launchClaudeInNewWindow(cwd, promptText) {
+function launchClaudeInNewWindow(cwd, promptText, resumeSessionId) {
   return new Promise((resolve, reject) => {
-    const args = [
+    const args = [];
+    // 续接历史会话:--resume 必须放在 -p 之前,确保 claude CLI 先识别 resume 上下文
+    if (resumeSessionId) {
+      args.push('--resume', String(resumeSessionId));
+    }
+    args.push(
       '-p', promptText,
       '--input-format', 'text',
       '--output-format', 'stream-json',
       '--verbose',
       '--permission-mode', 'bypassPermissions',
       '--dangerously-skip-permissions'
-    ];
+    );
     let child;
     let spawnedExe = 'claude';
     if (process.platform === 'win32') {
@@ -1061,20 +1070,35 @@ function launchClaudeInNewWindow(cwd, promptText) {
   });
 }
 
-// 顺序执行一个任务下所有子任务；上一个结束再启动下一个
-async function runTaskQueue(task, repoPath, branch) {
-  // 前序上下文：跑完一个 sub 后把它"完成态"摘要存到这里，下一个 sub 启动时
-  // 拼到 prompt 头部，让 Claude 知道前面做了什么、产出了什么。
-  // 故意不用 raw output 全文——LLM 已经习惯"摘要 + 关键结论"的格式，且不会
+/**
+ * 顺序执行一个任务下所有子任务；上一个结束再启动下一个。
+ * 入参 fromIndex 指定从哪个 sub 开始(0-based,默认 0),用于"从此处开始"入口;
+ * fromIndex>0 时,把 [0, fromIndex) 区间内已 done 的 sub 输出预填到 priorOutputs,
+ * 这样后续 sub 仍能拿到前序上下文(跟单 sub 执行的语义保持一致)。
+ */
+async function runTaskQueue(task, repoPath, branch, opts) {
+  // 前序上下文:跑完一个 sub 后把它"完成态"摘要存到这里,下一个 sub 启动时
+  // 拼到 prompt 头部,让 Claude 知道前面做了什么、产出了什么。
+  // 故意不用 raw output 全文——LLM 已经习惯"摘要 + 关键结论"的格式,且不会
   // 一次塞几 MB 进 prompt 烧 token。truncate 到每条 MAX_PREV_OUTPUT_CHARS。
   const MAX_PREV_OUTPUT_CHARS = 2000
-  const priorOutputs = []
-  for (const sub of task.subtasks) {
+  const requested = Number(opts && opts.fromIndex)
+  const fromIndex = Number.isInteger(requested) && requested >= 0 && requested < task.subtasks.length
+    ? requested
+    : 0
+  // 从 fromIndex 开始时,把前面已 done 的 sub 输出预填进 priorOutputs,
+  // 否则"从中间开始"会丢失前序上下文。
+  const priorOutputs = fromIndex > 0
+    ? await collectPriorOutputsUpTo(task, fromIndex)
+    : []
+  for (let i = fromIndex; i < task.subtasks.length; i++) {
+    const sub = task.subtasks[i]
     if (sub.status === 'done') continue;
     await runSingleSubtask(task, sub, repoPath, branch, priorOutputs)
+    // 逐 sub 落盘:之前只在队列跑完才 persistTaskAfterRun,中途崩溃会丢已完成
+    // sub 的状态。runSingleSubtask 已经把 sub.status 改完,这里补一次落盘。
+    await persistTaskAfterRun(task)
   }
-  // 写回 tasks.json
-  await persistTaskAfterRun(task)
 }
 
 /**
@@ -1088,8 +1112,15 @@ async function runTaskQueue(task, repoPath, branch) {
  *        前序 done 子任务的输出摘要（in-place 追加）。用于把同一任务下
  *        前面已完成的 sub 产物拼到当前 sub 的 prompt 头部，让 Claude
  *        知道上下文。单独跑一个 sub 时，这个数组里只会有"前面 done 的 sub"。
+ * @param {object} [options]
+ * @param {string|null} [options.resumeSessionId]
+ *        续接历史 claude 会话:传入上一轮通过 stream-json 的 system.init
+ *        事件捕获到的 session_id,本轮以 --resume <id> 启动,claude 会带着
+ *        上下文继续对话。前端"简单任务执行完成后继续聊"走的就是这条路径。
  */
-async function runSingleSubtask(task, sub, repoPath, branch, priorOutputs) {
+async function runSingleSubtask(task, sub, repoPath, branch, priorOutputs, options) {
+  const opts = options || {}
+  const resumeSessionId = opts.resumeSessionId || null
   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
@@ -1124,10 +1155,18 @@ ${prompt}`
   // claude -p 字符串模式会扫描 prompt 中出现的本地文件路径并自动
   // 识别为附件（图片 / PDF / 文本均可）。
   // 主任务附件对所有 sub 都可见；子任务自己的附件只对该 sub 可见。
-  const allAttachments = [
-    ...(Array.isArray(task.attachments) ? task.attachments : []),
-    ...(Array.isArray(sub.attachments) ? sub.attachments : [])
-  ];
+  // 注意：run-simple 路径下 virtualSub.attachments 就是 task.attachments 的同一引用，
+  // 不去重会把同一张图在 prompt 里列两遍。按 absolutePath 去重。
+  const taskAtts = Array.isArray(task.attachments) ? task.attachments : [];
+  const subAtts = Array.isArray(sub.attachments) ? sub.attachments : [];
+  const seen = new Set();
+  const allAttachments = [];
+  for (const a of [...subAtts, ...taskAtts]) {
+    if (!a || !a.absolutePath) continue;
+    if (seen.has(a.absolutePath)) continue;
+    seen.add(a.absolutePath);
+    allAttachments.push(a);
+  }
   if (allAttachments.length > 0) {
     const lines = allAttachments
       .filter(a => a && a.absolutePath)
@@ -1144,7 +1183,9 @@ ${prompt}`
     subId: sub.id,
     title: `${task.title} / ${sub.title}`,
     status: 'pending',
-    prompt
+    prompt,
+    // 续接历史会话时先填上,首条 system.init 事件回来后再用真值覆盖(通常等同)
+    claudeSessionId: resumeSessionId
   };
   jobs.set(jobId, job);
   sub.status = 'running';
@@ -1152,7 +1193,7 @@ ${prompt}`
   publish('job:update', job);
 
   try {
-    const { pid, child } = await launchClaudeInNewWindow(repoPath || process.cwd(), prompt);
+    const { pid, child } = await launchClaudeInNewWindow(repoPath || process.cwd(), prompt, resumeSessionId);
     job.pid = pid;
     // 保存 child 引用，供 cancel 接口调用 kill
     job.child = child;
@@ -1194,6 +1235,15 @@ ${prompt}`
         }
         let evt;
         try { evt = JSON.parse(trimmed) } catch { continue }
+        // 捕获 system.init 里的 session_id,供后续"续接对话"用(--resume <id>)。
+        // 一个 claude -p 调用只在首行发一次,所以仅在 job 还没记到时写入。
+        if (evt.type === 'system' && evt.subtype === 'init' && typeof evt.session_id === 'string') {
+          if (!job.claudeSessionId || job.claudeSessionId !== evt.session_id) {
+            job.claudeSessionId = evt.session_id;
+            publish('job:update', job);
+          }
+          continue;
+        }
         if (evt.type !== 'assistant') continue;
         const blocks = evt.message?.content;
         if (!Array.isArray(blocks)) continue;
@@ -1289,11 +1339,19 @@ async function persistTaskAfterRun(task) {
  * 子任务输出摘要收集起来。这样单独跑一个 sub 时,它也能拿到前序上下文。
  */
 async function collectPriorOutputs(task, targetSub) {
+  const targetIdx = task.subtasks.findIndex(s => s.id === targetSub.id)
+  if (targetIdx < 0) return []
+  return collectPriorOutputsUpTo(task, targetIdx)
+}
+
+/**
+ * 收集 [0, endIdx) 区间内已 done 的 sub 输出摘要,作为队列内 sub 的前序上下文。
+ * runTaskQueue 在 fromIndex>0 时调这个,让"从此处开始"也能拼上前序 done sub 的结论。
+ */
+async function collectPriorOutputsUpTo(task, endIdx) {
   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++) {
+  for (let i = 0; i < endIdx; i++) {
     const s = task.subtasks[i]
     if (s.status !== 'done') continue
     // 从 jobs 列表里找最近一个属于这个 sub 且 status=done 的 job,
@@ -1590,6 +1648,11 @@ ${subSummaries.map((s, i) => `\n### [${i + 1}] ${s.name} (${s.root})\n${s.summar
     const desc = String(req.body?.desc || '').trim();
     const taskId = String(req.body?.taskId || '').trim();
     const promptId = String(req.body?.promptId || '').trim();
+    // customUserBlock:用户在前端 prompt 预览页编辑过的 user prompt。非空时
+    // 直接拿它发给 LLM,跳过服务端拼装;为空时按老逻辑现拼。
+    // 注意:即便传了 customUserBlock,attachments/imageDataUrls 仍按 taskId 重新读,
+    // 因为图片要随消息发,不能跟 prompt 文本一起塞。
+    const customUserBlock = typeof req.body?.customUserBlock === 'string' ? req.body.customUserBlock : '';
     if (!title) {
       return res.status(400).json({ success: false, error: '任务标题不能为空' });
     }
@@ -1687,7 +1750,7 @@ ${subSummaries.map((s, i) => `\n### [${i + 1}] ${s.name} (${s.root})\n${s.summar
         } catch { /* 没拿到附件不影响拆分 */ }
       }
 
-      const userBlock = `${userInstruction}
+      const userBlock = customUserBlock.trim() ? customUserBlock : `${userInstruction}
 
 ---
 
@@ -1700,7 +1763,7 @@ ${desc ? `描述：${desc}` : '描述：（无）'}${attachmentBlock}${templateB
 - 项目根目录：${projectPath || '（未指定）'}
 - 主要 manifest：${manifestHint || '（未识别到）'}
 
-请先简要分析（可以放在 reasoning 中或直接写出来），然后给出 JSON。JSON 用 \`\`\`json ... \`\`\` 包裹：
+请先仔细分析（可以放在 reasoning 中或直接写出来）。仔细分析指：列出 5 个维度——任务真实目标 / 关键技术栈与边界 / 自然执行顺序 / 风险点与可能失败步骤 / 是否需要前置调研——不要简短一两句话就过；分析过后再给出 JSON。JSON 用 \`\`\`json ... \`\`\` 包裹：
 {
   "subtasks": [
     { "title": "子任务标题", "desc": "具体描述" }
@@ -1753,6 +1816,103 @@ ${desc ? `描述：${desc}` : '描述：（无）'}${attachmentBlock}${templateB
     }
   });
 
+  // POST /api/workbench/tasks/ai-split-preview
+  //   body: { title, desc?, taskId?, promptId? }
+  //   →   { success, system, user, hasImages, imageCount }
+  // "AI 拆分前预览/编辑 prompt" 用:跟 /ai-split-subtasks 做完全一样的拼装,
+  // 但**不调 LLM**,只把拼好的 system + user 返回。前端在 UI 上 textarea 展示,
+  // 用户改完按"发送给 AI"再正式调 /ai-split-subtasks 并把改过的文本作为
+  // customUserBlock 传回。这样省一次 LLM 调用,且让用户能修正提示词后再拆分。
+  app.post('/api/workbench/tasks/ai-split-preview', async (req, res) => {
+    try {
+      const title = String(req.body?.title || '').trim();
+      const desc = String(req.body?.desc || '').trim();
+      const taskId = String(req.body?.taskId || '').trim();
+      const promptId = String(req.body?.promptId || '').trim();
+      if (!title) {
+        return res.status(400).json({ success: false, error: '任务标题不能为空' });
+      }
+
+      const userInstruction = await readSubtaskInstruction(req);
+      const projectPath = typeof getCurrentProjectPath === 'function' ? getCurrentProjectPath() : '';
+      const projectName = projectPath ? path.basename(projectPath) : '（未指定项目）';
+      const manifestHint = await detectProjectManifest(projectPath);
+
+      let templateBlock = '';
+      if (promptId) {
+        try {
+          const promptData = await readJson(PROMPTS_FILE, { prompts: [] });
+          const p = (promptData.prompts || []).find(x => x.id === promptId);
+          if (p && p.content) {
+            templateBlock = `\n\n## 子任务执行模板（每个拆出的子任务最终会被这套模板包裹后送给 claude 执行；拆分时请确保子任务能让模板里的 {{sub.title}} / {{sub.desc}} 等变量填得有意义）\n模板名：${p.name || '（未命名）'}\n---\n${p.content}\n---`;
+          }
+        } catch { /* 模板读取失败不影响预览 */ }
+      }
+
+      // 附件:只列条目,不读图片二进制(preview 阶段不需要 image_data_url)
+      let attachmentBlock = '';
+      let imageCount = 0;
+      if (taskId) {
+        try {
+          const data = await readJson(TASKS_FILE, { tasks: [] });
+          const task = (data.tasks || []).find(t => t.id === taskId);
+          const atts = Array.isArray(task?.attachments) ? task.attachments : [];
+          if (atts.length > 0) {
+            const lines = [];
+            for (let i = 0; i < atts.length; i++) {
+              const a = atts[i];
+              if (!a || !a.absolutePath) continue;
+              lines.push(`  ${i + 1}. [${a.mimeType || 'application/octet-stream'}] ${a.absolutePath}`);
+              if (isImageExt(a.ext)) imageCount++;
+            }
+            if (lines.length > 0) {
+              const imgNote = imageCount > 0
+                ? `（其中 ${imageCount} 张图片已随消息一并发送，请直接基于图片内容拆分）`
+                : '';
+              attachmentBlock = `\n\n## 任务附件${imgNote}\n${lines.join('\n')}`;
+            }
+          }
+        } catch { /* 没拿到附件不影响预览 */ }
+      }
+
+      const userBlock = `${userInstruction}
+
+---
+
+## 待拆分的任务
+标题：${title}
+${desc ? `描述：${desc}` : '描述：（无）'}${attachmentBlock}${templateBlock}
+
+## 项目上下文（仅供参考，便于拆分时考虑项目特性）
+- 项目名称：${projectName}
+- 项目根目录：${projectPath || '（未指定）'}
+- 主要 manifest：${manifestHint || '（未识别到）'}
+
+请先仔细分析（可以放在 reasoning 中或直接写出来）。仔细分析指：列出 5 个维度——任务真实目标 / 关键技术栈与边界 / 自然执行顺序 / 风险点与可能失败步骤 / 是否需要前置调研——不要简短一两句话就过；分析过后再给出 JSON。JSON 用 \`\`\`json ... \`\`\` 包裹：
+{
+  "subtasks": [
+    { "title": "子任务标题", "desc": "具体描述" }
+  ]
+}
+
+**JSON 输出严格要求**（不遵守会导致解析失败、用户无法入库）：
+1. title 和 desc 内如需引用术语 / 页面名 / 状态名，**必须使用中文引号「」或『』**，禁止使用 ASCII 双引号、单引号或反引号，否则会破坏外层 JSON 结构。
+2. JSON 中不允许尾随逗号（最后一个元素后面不能跟逗号）。
+3. JSON 中不允许写注释。
+4. 所有字符串字段必须用 ASCII 双引号包裹，字符串内部如有换行用 \\n 转义。`;
+
+      res.json({
+        success: true,
+        system: userInstruction,
+        user: userBlock,
+        hasImages: imageCount > 0,
+        imageCount
+      });
+    } catch (err) {
+      res.status(500).json({ success: false, error: '生成预览失败: ' + (err?.message || String(err)) });
+    }
+  });
+
   // POST /api/workbench/tasks/parse-subtasks
   //   body: { raw: string }
   //   →   { success, subtasks, parseError, parseStage }
@@ -2168,6 +2328,40 @@ ${desc ? `描述：${desc}` : '描述：（无）'}${attachmentBlock}${templateB
     }
   });
 
+  // ── 从指定子任务开始执行 ───────────────────────────────────────────
+  // POST /api/workbench/tasks/:id/run-from
+  // 入参 body: { startSubIndex: number }
+  // 行为:
+  //   - 从 task.subtasks[startSubIndex] 开始按序执行,前面 [0, startSubIndex) 区间的
+  //     done sub 输出会自动作为前序上下文(同单 sub 执行的语义)
+  //   - 前面 error / running 的 sub 不会被自动重跑;从 startSubIndex 开始重新走队列
+  //   - 适合"中间某个 sub 失败/被取消后,从该 sub 继续"的场景
+  //   - startSubIndex 必须落在 [0, task.subtasks.length) 范围内
+  app.post('/api/workbench/tasks/:id/run-from', 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.subtasks || task.subtasks.length === 0) {
+        return res.status(400).json({ success: false, error: '任务没有子任务' });
+      }
+      const startSubIndex = Number(req.body?.startSubIndex);
+      if (!Number.isInteger(startSubIndex)
+        || startSubIndex < 0
+        || startSubIndex >= task.subtasks.length) {
+        return res.status(400).json({ success: false, error: 'startSubIndex 越界' });
+      }
+      const repoPath = typeof getCurrentProjectPath === 'function' ? getCurrentProjectPath() : '';
+      // 异步执行,立即返回(同 /run 的 fire-and-forget 模式)
+      res.json({ success: true, message: `已从第 ${startSubIndex + 1} 个子任务开始执行` });
+      runTaskQueue(task, repoPath, '', { fromIndex: startSubIndex }).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/tasks/:id/run-simple
   // 行为：
@@ -2303,6 +2497,74 @@ ${desc ? `描述：${desc}` : '描述：（无）'}${attachmentBlock}${templateB
     }
   });
 
+  // ── 续接简单任务对话 ────────────────────────────────────────────
+  // POST /api/workbench/jobs/:id/continue
+  // 入参 body: { userMessage: string }
+  // 行为:
+  //   - 仅用于 type==='simple' 的任务,基于上一轮 job 捕获到的 claudeSessionId,
+  //     用 claude --resume <id> 续接历史对话,**新一轮 = 新 job**
+  //   - 新 job 的 subId 形如 `${task.id}__simple__r${n}`,跟首轮 `${task.id}__simple`
+  //     区分;前端按 subId 前缀聚合渲染对话流
+  //   - 上一轮还在 pending/running 时拒绝(避免 session 并发跑乱)
+  //   - 上一轮未捕获到 session_id(claude 在 init 前就 crash)时拒绝
+  app.post('/api/workbench/jobs/:id/continue', async (req, res) => {
+    try {
+      const userMessage = String(req.body?.userMessage || '').trim();
+      if (!userMessage) {
+        return res.status(400).json({ success: false, error: 'userMessage 不能为空' });
+      }
+      const prevJob = jobs.get(req.params.id);
+      if (!prevJob) {
+        return res.status(404).json({ success: false, error: 'job 不存在' });
+      }
+      if (prevJob.status === 'running' || prevJob.status === 'pending') {
+        return res.status(400).json({ success: false, error: '上一轮还在执行,请等结束后再续接' });
+      }
+      if (!prevJob.claudeSessionId) {
+        return res.status(400).json({ success: false, error: '无法续接:会话标识未捕获' });
+      }
+      const data = await readJson(TASKS_FILE, { tasks: [] });
+      const task = (data.tasks || []).find(t => t.id === prevJob.taskId);
+      if (!task) {
+        return res.status(404).json({ success: false, error: '所属任务不存在' });
+      }
+      if (task.type !== 'simple') {
+        return res.status(400).json({ success: false, error: '仅支持简单任务的续接' });
+      }
+      // 计算续接轮次号:扫所有同 task 下的 __simple / __simple__rN job,取最大 N + 1
+      const subIdPrefix = `${task.id}__simple`;
+      let maxRound = 0;
+      for (const j of jobs.values()) {
+        if (j.taskId !== task.id) continue;
+        if (j.subId === subIdPrefix) continue;
+        const m = j.subId && j.subId.match(/__simple__r(\d+)$/);
+        if (m) {
+          const n = parseInt(m[1], 10);
+          if (!isNaN(n) && n > maxRound) maxRound = n;
+        }
+      }
+      const nextRound = maxRound + 1;
+      const virtualSub = {
+        id: `${task.id}__simple__r${nextRound}`,
+        title: `续接 #${nextRound}`,
+        desc: '',
+        status: 'todo',
+        // 用户输入的续接消息直接作为本轮 prompt(走 promptOverride,不再拼模板)
+        promptOverride: userMessage,
+        // 续接轮不带附件,避免重复推附件给 claude(已在首轮 prompt 里)
+        attachments: []
+      };
+      const repoPath = typeof getCurrentProjectPath === 'function' ? getCurrentProjectPath() : '';
+      res.json({ success: true, message: '已加入续接队列' });
+      runSingleSubtask(task, virtualSub, repoPath, '', [], { resumeSessionId: prevJob.claudeSessionId })
+        .catch(err => {
+          publish('task:error', { taskId: task.id, error: err.message });
+        });
+    } catch (err) {
+      res.status(500).json({ success: false, error: err.message });
+    }
+  });
+
   // ── 执行日志管理 API（持久化 + 清理） ────────────────────────────
   // 路径都在 /api/workbench/jobs/* 下；/list、/config、/batch-delete、/clear
   // 是字面路径，必须排在 :id 路由之前注册，避免被 :id 匹配吞掉。
@@ -2467,6 +2729,144 @@ ${desc ? `描述：${desc}` : '描述：（无）'}${attachmentBlock}${templateB
     }
   })
 
+  // POST /api/workbench/tasks/:id/clear-execution
+  // 一次性清空指定 task 的所有执行痕迹:
+  //   1. 删除内存 + 磁盘 jobs.json 中该 task 的全部 job(跳过 running/pending)
+  //   2. 把 tasks.json 中该 task 的所有 subtasks status 重置为 'todo'(让"重新执行"能从头跑)
+  //   3. 同步清掉 sub 的 error 字段,broadcast task:update + 一组 sub:update
+  // 任务描述、附件、提示词模板等"内容"字段保留不动——只清"执行痕迹"。
+  // 活跃态(有 running/pending job)时拒绝,避免误杀正在跑的实例。
+  app.post('/api/workbench/tasks/:id/clear-execution', async (req, res) => {
+    try {
+      const taskId = req.params.id
+      if (!taskId) return res.status(400).json({ success: false, error: '缺少 taskId' })
+      // 检查活跃 job
+      const live = []
+      for (const j of jobs.values()) {
+        if (j.taskId !== taskId) continue
+        if (j.status === 'running' || j.status === 'pending') live.push(j.id)
+      }
+      if (live.length > 0) {
+        return res.status(400).json({ success: false, error: `有 ${live.length} 个 job 正在执行,请先停止` })
+      }
+      // 1) 清空 jobs(内存 + 磁盘)
+      const removedJobIds = []
+      for (const j of jobs.values()) {
+        if (j.taskId !== taskId) continue
+        jobs.delete(j.id)
+        removedJobIds.push(j.id)
+      }
+      const jobsData = await readJson(JOBS_FILE, { version: 1, jobs: [] })
+      if (jobsData && Array.isArray(jobsData.jobs)) {
+        const before = jobsData.jobs.length
+        jobsData.jobs = jobsData.jobs.filter(j => j.taskId !== taskId)
+        if (jobsData.jobs.length !== before) await writeJson(JOBS_FILE, jobsData)
+      }
+      // 2) 重置 subtasks.status → todo
+      const tasksData = await readJson(TASKS_FILE, { tasks: [] })
+      const task = (tasksData.tasks || []).find(t => t.id === taskId)
+      if (!task) {
+        return res.json({ success: true, removedJobs: removedJobIds.length, resetSubs: 0, message: '任务不存在,仅清空 job' })
+      }
+      let resetSubs = 0
+      if (Array.isArray(task.subtasks)) {
+        for (const s of task.subtasks) {
+          if (s.status !== 'todo') {
+            s.status = 'todo'
+            resetSubs++
+            if (s.error) delete s.error
+            publish('sub:update', { taskId, sub: s })
+          }
+        }
+        task.updatedAt = nowIso()
+        await writeJson(TASKS_FILE, tasksData)
+        publish('task:update', task)
+      }
+      res.json({
+        success: true,
+        removedJobs: removedJobIds.length,
+        resetSubs,
+        message: `已清空 ${removedJobIds.length} 条执行记录,${resetSubs} 个子任务重置为待执行`
+      })
+    } catch (err) {
+      res.status(500).json({ success: false, error: '清空执行痕迹失败: ' + (err.message || String(err)) })
+    }
+  })
+
+  // POST /api/workbench/tasks/:id/reset-shell
+  // 把 task 还原成"只有标题的空壳",清掉 desc / attachments / promptId / subtasks。
+  // 与 clear-execution 的区别:
+  //   - clear-execution 只重置 sub.status + 清 jobs(保留拆分/描述/附件)
+  //   - reset-shell 直接删除 subtasks 数组和描述/附件,任务只剩标题
+  // 同时清空该 task 的所有 job(沿用 by-task 删除语义,跳过 running/pending)。
+  // 活跃态拒绝,避免误杀正在跑的实例。
+  app.post('/api/workbench/tasks/:id/reset-shell', async (req, res) => {
+    try {
+      const taskId = req.params.id
+      if (!taskId) return res.status(400).json({ success: false, error: '缺少 taskId' })
+      // 检查活跃 job
+      const live = []
+      for (const j of jobs.values()) {
+        if (j.taskId !== taskId) continue
+        if (j.status === 'running' || j.status === 'pending') live.push(j.id)
+      }
+      if (live.length > 0) {
+        return res.status(400).json({ success: false, error: `有 ${live.length} 个 job 正在执行,请先停止` })
+      }
+      // 1) 清空 jobs(内存 + 磁盘)
+      const removedJobIds = []
+      for (const j of jobs.values()) {
+        if (j.taskId !== taskId) continue
+        jobs.delete(j.id)
+        removedJobIds.push(j.id)
+      }
+      const jobsData = await readJson(JOBS_FILE, { version: 1, jobs: [] })
+      if (jobsData && Array.isArray(jobsData.jobs)) {
+        const before = jobsData.jobs.length
+        jobsData.jobs = jobsData.jobs.filter(j => j.taskId !== taskId)
+        if (jobsData.jobs.length !== before) await writeJson(JOBS_FILE, jobsData)
+      }
+      // 2) 重置 task 字段:只留 id / title / createdAt / status / projectPath(如存在)
+      const tasksData = await readJson(TASKS_FILE, { tasks: [] })
+      const task = (tasksData.tasks || []).find(t => t.id === taskId)
+      if (!task) {
+        return res.json({ success: true, removedJobs: removedJobIds.length, message: '任务不存在,仅清空 job' })
+      }
+      const removedSubCount = Array.isArray(task.subtasks) ? task.subtasks.length : 0
+      const removedAttCount = Array.isArray(task.attachments) ? task.attachments.length : 0
+      const hadDesc = !!(task.desc && task.desc.length > 0)
+      const hadPrompt = !!task.promptId
+      // 保留字段:id / title / createdAt / status / projectPath
+      // 清理:desc / attachments / promptId / subtasks
+      const preservedProjectPath = task.projectPath
+      const preservedCreatedAt = task.createdAt
+      const preservedStatus = task.status || 'todo'
+      // 重建对象(顺序保留 title 在前,符合视觉习惯)
+      const newTask = { id: task.id, title: task.title, status: preservedStatus }
+      if (preservedProjectPath) newTask.projectPath = preservedProjectPath
+      if (preservedCreatedAt) newTask.createdAt = preservedCreatedAt
+      newTask.subtasks = []
+      newTask.attachments = []
+      newTask.updatedAt = nowIso()
+      // 用 Object.assign 替换 task 的所有自身属性,保留原型链
+      for (const k of Object.keys(task)) delete task[k]
+      Object.assign(task, newTask)
+      await writeJson(TASKS_FILE, tasksData)
+      publish('task:update', task)
+      res.json({
+        success: true,
+        removedJobs: removedJobIds.length,
+        removedSubs: removedSubCount,
+        removedAttachments: removedAttCount,
+        clearedDesc: hadDesc,
+        clearedPrompt: hadPrompt,
+        message: `已清空:删除 ${removedSubCount} 个子任务${removedAttCount ? '、' + removedAttCount + ' 个附件' : ''}${hadDesc ? '、任务描述' : ''},任务标题保留`
+      })
+    } 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 {