zen-gitsync 2.14.2 → 2.14.3

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

@@ -12,3528 +12,21 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 //
-// 工作台后端：管理预置提示词 / 任务 / 子任务，
-// 并以 bypassPermissions 模式依次 spawn claude CLI 执行子任务（每次新窗口）。
-// 数据存到用户主目录 ~/.zen-gitsync/，跨项目共享。
-
-import fs from 'fs';
-import logger from '../utils/logger.js'
-import fsp from 'fs/promises';
-import path from 'path';
-import os from 'os';
-import { spawn, execFileSync, execFile } from 'child_process';
-import { EventEmitter } from 'events';
-import express from 'express';
-
-const DATA_DIR = path.join(os.homedir(), '.zen-gitsync');
-const PROMPTS_FILE = path.join(DATA_DIR, 'prompts.json');
-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');
-// AI 对话拆分会话存档:每个 sessionId 一个文件,重启可恢复多轮上下文
-const SESSIONS_DIR = path.join(DATA_DIR, 'ai-split-sessions');
-const MAX_SESSIONS = 100;     // 软上限,触发清理
-const SESSIONS_KEEP = 50;      // 超过上限时保留最新 N 个
-// 执行日志持久化：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([
-  'node_modules', 'dist', 'build', '.next', '.nuxt', '__pycache__',
-  'target', 'out', 'coverage', 'vendor', '.git', '.svn', '.hg',
-  '.idea', '.vscode', '.gradle', '.terraform', '.cache', '.parcel-cache',
-  '.turbo', '.svelte-kit', 'storybook-static'
-]);
-
-// 默认生成指令：用户首次使用时作为可编辑指令的初始值
-const DEFAULT_INSTRUCTION = `你是一名资深软件架构师。
-
-【探索步骤】
-1. 先识别项目结构：扫描根目录是否包含 .git 目录，以及 package.json / pyproject.toml / go.mod / Cargo.toml / pom.xml / build.gradle{,.kts} / composer.json / Gemfile / pubspec.yaml 这 9 种 manifest。
-2. 如果根目录含 manifest，就把整个根目录视为一个子项目。
-3. 如果根目录不含 manifest、但子目录（含一层 .git 或上述 manifest）形成多个子项目，对每个子项目分别探索。
-4. 对每个子项目，重点读取：
-   - 所有识别到的 manifest（限制单文件 20KB）
-   - README.md（限制 8KB）
-   - 入口文件：package.json 的 main / scripts / workspaces 字段；pyproject.toml 的 [project.scripts]；go.mod 的 module；Cargo.toml 的 [[bin]]；pom.xml 的 <modules>
-   - 2 层目录树（最多 200 行）
-
-【输出要求】
-1. 给出一段中文「项目架构说明」，长度不限，模型自行决定篇幅与详尽程度，能写多详细就多详细。覆盖：项目整体定位、技术栈、模块划分、核心流程、关键设计决策。
-2. 必须引用子项目里实际存在的文件路径、目录名、依赖名，不要编造。
-3. 多个子项目时：先逐个说明，最后输出一段「整体架构」总结它们之间的关系。
-4. 语气专业、具体、面向接手这个项目的开发者。
-5. 只返回 JSON：{ "name": "项目名（建议：项目名+架构说明）", "summary": "架构说明正文" }。`;
-
-// 单个附件最大 5MB；与 Anthropic Messages API 文档约束一致
-const MAX_IMAGE_BYTES = 5 * 1024 * 1024;
-// 一个子任务最多挂 9 个附件
-const MAX_ATTACHMENTS_PER_SUBTASK = 9;
-
-// AI 拆分子任务：默认系统指令（用户在 GUI 可编辑覆盖）。
-// 国际化：根据请求 Accept-Language 在 zh / en 之间选默认。
-// 中英两份都内置——用户保存到 ~/.zen-gitsync/ai-subtask-instruction.json 后覆盖。
-const DEFAULT_SUBTASK_INSTRUCTION_ZH = `你是一名任务拆分助手。
-
-【绝对禁止】
-- 不要进入任何"plan 模式"、"plan 阶段"或"先写 plan 再执行"。
-- 不要输出"我要进入 plan / 准备 / 探索 / 调研"之类的元叙述。
-- 不要写"Plan 文件已写入 xxx"或"等用户批准后开始"这种"声明意图"的话。
-- 你只做一件事:把用户给的任务拆成可独立执行的子任务清单,直接输出 JSON。中间任何"我要做什么"的描述都属于错误输出。
-- 你的输出会被另一个程序读取,该程序只看最终 JSON,所有非 JSON 文字会被丢弃——所以不要把"执行步骤"写进 analysis 段,只写在 JSON 的 desc 字段里。
-
-【思考过程】
-在给出 JSON 之前，请先在内部仔细思考（如果模型支持，把思考放在 reasoning 中；否则可以先输出一段较长的仔细分析，再输出 JSON）。分析要覆盖足够维度，不要简短一两句话就过：
-- 任务的真实目标是什么？用户提供的描述/图片/上下文里有哪些关键信息和隐藏诉求？
-- 涉及哪些技术栈、模块、文件、约束？是否有易被忽略的边界条件、风险点？
-- 自然的执行顺序是什么？哪些步骤是前置依赖？哪些可以并行？
-- 哪些步骤可能失败、需要单独验证？验证方式是什么？
-- 是否需要先做调研/读现有代码的步骤，再做修改？
-
-【拆分原则】
-1. 单一职责：每个子任务只做一件事，避免"做 A 和 B"。
-2. 粒度适中：单个子任务应当能在一次会话里完成（既不要"实现整个登录功能"这么大，也不要"打印 hello"这么琐碎）。
-3. 顺序合理：子任务按依赖关系和执行顺序排列（先准备、后实现、最后验证）。
-4. 可验证：每个子任务都有明确的完成标志（"输出文件 xxx"、"通过测试 yyy"、"控制台打印 zzz"）。
-5. 数量：不设上限。任务很简单时 1-2 个就够，复杂时按需拆成 10 个、20 个甚至更多子任务都行，直到覆盖所有可独立验证的步骤。
-6. 描述具体：desc 字段要写清楚"要做什么、参考什么、产出什么"，不要只是把 title 改写一遍。
-7. 如果任务里附带了图片，必须基于图片的实际内容拆分（例如指出图片中的哪个区域、哪个元素需要改），而不是泛泛而谈。
-
-【输出要求】
-最后必须输出 JSON，结构：
-{
-  "subtasks": [
-    { "title": "子任务标题", "desc": "子任务的具体描述，包含要做什么、输入是什么、输出/验证标志是什么" }
-  ]
-}
-
-JSON 要用 \`\`\`json ... \`\`\` 代码块包裹，前面可以有分析文字，但 JSON 必须完整、合法、可解析。`;
-
-const DEFAULT_SUBTASK_INSTRUCTION_EN = `You are a task breakdown assistant.
-
-[ABSOLUTE PROHIBITIONS]
-- Do NOT enter any "plan mode" / "planning phase" / "I'll write a plan first, then execute".
-- Do NOT output meta-narration like "I'm entering plan / preparing / exploring / researching".
-- Do NOT write "Plan file written to xxx" or "waiting for user approval" style intent-declaration text.
-- You only do one thing: split the user's task into an independently executable subtask list and output JSON directly. Any "what I'm going to do" description in the middle is an error.
-- Your output is consumed by another program that only reads the final JSON. All non-JSON text is discarded — so put execution steps in the desc field of JSON, not in the analysis section.
-
-[Thinking process]
-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? 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".
-2. Right granularity: a subtask should finish in one Claude session (not as big as "implement the whole login flow", not as trivial as "print hello").
-3. Sensible order: arrange subtasks by dependency / execution order (prepare first, implement, then verify).
-4. Verifiable: every subtask has a clear completion signal (e.g. "produce file xxx", "pass test yyy", "log zzz to console").
-5. Quantity: no hard limit. Very simple tasks need only 1-2; complex tasks can be split into 10, 20 or more subtasks until every independently verifiable step is covered.
-6. Concrete desc: write what to do, what to reference, what to produce — don't just paraphrase the title.
-7. If the task includes images, the breakdown must reference the actual image content (which region, which element to change), not just generic talk.
-
-[Output requirements]
-End with JSON, structure:
-{
-  "subtasks": [
-    { "title": "subtask title", "desc": "concrete description: what to do, what the input is, what the output / verification signal is" }
-  ]
-}
-
-Wrap the JSON in \`\`\`json ... \`\`\`. Analysis text before it is allowed, but the JSON must be complete and parseable.`;
-
-// 兼容旧引用
-const DEFAULT_SUBTASK_INSTRUCTION = DEFAULT_SUBTASK_INSTRUCTION_ZH
-
-// 根据请求 Accept-Language 选默认（zh / en）
-function pickDefaultSubtaskInstruction(req) {
-  const al = String(req?.headers?.['accept-language'] || '').toLowerCase()
-  if (al.startsWith('en')) return DEFAULT_SUBTASK_INSTRUCTION_EN
-  return DEFAULT_SUBTASK_INSTRUCTION_ZH
-}
-
-// ── AI 对话拆分: session 持久化层 ────────────────────────────
-// 文件命名: {sessionId}.json
-// 内容: { version, sessionId, title, desc, taskId, promptId, createdAt, updatedAt,
-//         messages: [{role, content}], latestSubtasks, latestRaw, latestParseStage }
-// 写入用临时文件 + rename 原子替换(与 workbench 现有 writeJson 模式一致),
-// 避免半写状态被读到。并发安全: 单进程内同一 session 串行调用,
-// 跨端点并发写同 session 概率极低,丢失只会是最后一次 user/assistant pair,可重发。
-function genSessionId() {
-  // 16 字符: 时间戳后 8 位 + 随机 8 位 base36,既可读也基本不冲突
-  return `${Date.now().toString(36).slice(-8)}-${Math.random().toString(36).slice(2, 10)}`
-}
-
-async function readSessionFile(sessionId) {
-  if (!/^[a-z0-9-]{4,32}$/i.test(sessionId)) {
-    const err = new Error('非法 sessionId'); err.statusCode = 400; throw err
-  }
-  const file = path.join(SESSIONS_DIR, `${sessionId}.json`)
-  try {
-    return JSON.parse(await fsp.readFile(file, 'utf-8'))
-  } catch (err) {
-    if (err.code === 'ENOENT') {
-      const e = new Error('会话不存在'); e.statusCode = 404; throw e
-    }
-    throw err
-  }
-}
-
-async function writeSessionFile(sessionId, data) {
-  await fsp.mkdir(SESSIONS_DIR, { recursive: true })
-  const file = path.join(SESSIONS_DIR, `${sessionId}.json`)
-  const tmp = `${file}.tmp.${process.pid}.${Date.now()}`
-  await fsp.writeFile(tmp, JSON.stringify(data, null, 2), 'utf-8')
-  await fsp.rename(tmp, file)
-}
-
-async function deleteSessionFile(sessionId) {
-  if (!/^[a-z0-9-]{4,32}$/i.test(sessionId)) {
-    const err = new Error('非法 sessionId'); err.statusCode = 400; throw err
-  }
-  const file = path.join(SESSIONS_DIR, `${sessionId}.json`)
-  try {
-    await fsp.unlink(file)
-  } catch (err) {
-    if (err.code === 'ENOENT') {
-      const e = new Error('会话不存在'); e.statusCode = 404; throw e
-    }
-    throw err
-  }
-}
-
-// 列表只读 metadata 不读 messages 内容,启动无需预加载
-async function listSessionsMeta() {
-  await fsp.mkdir(SESSIONS_DIR, { recursive: true })
-  const files = await fsp.readdir(SESSIONS_DIR)
-  const list = []
-  for (const f of files) {
-    if (!f.endsWith('.json')) continue
-    const sid = f.slice(0, -5)
-    try {
-      const file = path.join(SESSIONS_DIR, f)
-      const stat = await fsp.stat(file)
-      const data = JSON.parse(await fsp.readFile(file, 'utf-8'))
-      list.push({
-        sessionId: data.sessionId || sid,
-        title: data.title || '(无标题)',
-        taskId: data.taskId || '',
-        createdAt: data.createdAt || '',
-        updatedAt: data.updatedAt || '',
-        messageCount: Array.isArray(data.messages) ? data.messages.length : 0,
-        latestSubtaskCount: Array.isArray(data.latestSubtasks) ? data.latestSubtasks.length : 0,
-        size: stat.size
-      })
-    } catch { /* 跳过坏文件 */ }
-  }
-  list.sort((a, b) => (b.updatedAt || '').localeCompare(a.updatedAt || ''))
-  return list
-}
-
-// 容量控制: 超过 MAX_SESSIONS 时按 mtime 删旧的,保留最新 SESSIONS_KEEP 个
-async function enforceSessionsRetention() {
-  const files = await fsp.readdir(SESSIONS_DIR).catch(() => [])
-  const jsonFiles = files.filter(f => f.endsWith('.json'))
-  if (jsonFiles.length < MAX_SESSIONS) return
-  const stats = await Promise.all(jsonFiles.map(async f => {
-    const full = path.join(SESSIONS_DIR, f)
-    const s = await fsp.stat(full)
-    return { file: full, mtime: s.mtimeMs }
-  }))
-  stats.sort((a, b) => b.mtime - a.mtime)
-  const toDelete = stats.slice(SESSIONS_KEEP)
-  await Promise.all(toDelete.map(s => fsp.unlink(s.file).catch(() => {})))
-  if (toDelete.length > 0) {
-    logger.info(`[workbench] ai-split sessions: cleaned up ${toDelete.length} old files`)
-  }
-}
-// 白名单后缀：图片 + 常见文档（PDF / 纯文本 / Markdown）
-const IMAGE_EXTS = new Set(['png', 'jpg', 'jpeg', 'gif', 'webp', 'bmp', 'svg']);
-const DOC_EXTS = new Set(['pdf', 'txt', 'md', 'markdown', 'csv', 'json', 'log']);
-const ALLOWED_EXTS = new Set([...IMAGE_EXTS, ...DOC_EXTS]);
-
-// mime → 文件后缀；与前端 el-upload accept 对齐
-const MIME_TO_EXT = {
-  'image/png': 'png',
-  'image/jpeg': 'jpg',
-  'image/jpg': 'jpg',
-  'image/gif': 'gif',
-  'image/webp': 'webp',
-  'image/bmp': 'bmp',
-  'image/svg+xml': 'svg',
-  'image/x-icon': 'ico',
-  'image/vnd.microsoft.icon': 'ico',
-  'application/pdf': 'pdf',
-  'text/plain': 'txt',
-  'text/markdown': 'md',
-  'text/x-markdown': 'md',
-  'text/csv': 'csv',
-  'application/json': 'json',
-  'text/json': 'json',
-  'text/x-log': 'log',
-};
-
-function sanitizeExt(name, fallback = 'bin') {
-  if (typeof name !== 'string') return fallback;
-  const m = name.toLowerCase().match(/\.([a-z0-9]+)$/);
-  if (!m) return fallback;
-  return ALLOWED_EXTS.has(m[1]) ? m[1] : fallback;
-}
-
-function isImageExt(ext) {
-  return IMAGE_EXTS.has(String(ext || '').toLowerCase());
-}
-
-async function ensureImagesDir() {
-  await fsp.mkdir(IMAGES_DIR, { recursive: true });
-}
-
-// 把 mime 或文件名规范成统一后缀；遇到不在白名单的情况返回 null
-function resolveExt({ originalName, mime }) {
-  if (mime && MIME_TO_EXT[mime.toLowerCase()]) {
-    return MIME_TO_EXT[mime.toLowerCase()];
-  }
-  const fromName = sanitizeExt(originalName, '');
-  if (fromName) return fromName;
-  return null;
-}
-
-// 解析 manifest 文件名（按优先级）
-const MANIFEST_FILES = [
-  'package.json', 'pyproject.toml', 'go.mod', 'Cargo.toml',
-  'pom.xml', 'build.gradle', 'build.gradle.kts', 'composer.json',
-  'Gemfile', 'pubspec.yaml'
-];
-
-// 轻量级：仅告诉 LLM 项目的主 manifest 是什么（用于 AI 拆分时让 LLM 知道项目类型）。
-// 不读内容，只 stat 存在性——拆分子任务不需要细节。
-async function detectProjectManifest(projectPath) {
-  if (!projectPath) return ''
-  for (const f of MANIFEST_FILES) {
-    try {
-      const stat = await fsp.stat(path.join(projectPath, f))
-      if (stat.isFile()) return f
-    } catch { /* 不存在，继续 */ }
-  }
-  return ''
-}
-
-async function readProjectManifest(projectPath) {
-  const out = {};
-  for (const f of MANIFEST_FILES) {
-    const p = path.join(projectPath, f);
-    try {
-      const stat = await fsp.stat(p);
-      if (!stat.isFile()) continue;
-      // 限制大小，避免巨型 pom.xml 把上下文打爆
-      const content = stat.size > 20000
-        ? (await safeReadFile(p, 20000))
-        : (await fsp.readFile(p, 'utf8'));
-      out[f] = content;
-    } catch { /* 不存在就跳过 */ }
-  }
-  return out;
-}
-
-async function safeReadFile(filePath, maxBytes = 200000) {
-  try {
-    const stat = await fsp.stat(filePath);
-    if (stat.size > maxBytes) {
-      const buf = Buffer.alloc(maxBytes);
-      const fd = await fsp.open(filePath, 'r');
-      await fd.read(buf, 0, maxBytes, 0);
-      await fd.close();
-      return buf.toString('utf8').slice(0, maxBytes);
-    }
-    return await fsp.readFile(filePath, 'utf8');
-  } catch {
-    return '';
-  }
-}
-
-async function listDirTree(projectPath, maxDepth = 2, maxEntries = 400) {
-  const lines = [];
-  async function walk(dir, depth) {
-    if (depth > maxDepth || lines.length >= maxEntries) return;
-    let entries;
-    try { entries = await fsp.readdir(dir, { withFileTypes: true }); }
-    catch { return; }
-    const filtered = entries.filter(e => {
-      if (e.name.startsWith('.')) return false;
-      if (['node_modules', 'dist', 'build', '.next', '.nuxt', '__pycache__', 'target', 'out', 'coverage', 'vendor'].includes(e.name)) return false;
-      return true;
-    });
-    const indent = '  '.repeat(depth);
-    for (const e of filtered) {
-      if (lines.length >= maxEntries) return;
-      if (e.isDirectory()) {
-        lines.push(`${indent}${e.name}/`);
-        await walk(path.join(dir, e.name), depth + 1);
-      } else if (e.isFile()) {
-        lines.push(`${indent}${e.name}`);
-      }
-    }
-  }
-  await walk(projectPath, 0);
-  return lines.join('\n');
-}
-
-// 剥离 LLM 输出的 思考块、```json``` 代码块围栏，以及首尾说明文字。
-// 原贪婪正则 /({[\s\S]*})/ 会把 思考块（内含未配对花括号或字符串）一起吞进 JSON.parse，
-// 在 DeepSeek 等会输出 推理链的模型上偶发 "Unterminated string in JSON"。
-function stripThinkingBlocks(content) {
-  let s = String(content || '');
-  // 1) 显式 思考块（成对标签）
-  s = s.replace(/<think(?:ing)?>[\s\S]*?<\/think(?:ing)?>/gi, '');
-  // 2) 某些 provider 流式结尾会留下裸 <think>...</think> 之外的残段（无结束标签时被截断）
-  s = s.replace(/<think(?:ing)?>[\s\S]*$/gi, '');
-  // 3) ```json ... ``` 代码块围栏（保留内部 JSON）
-  s = s.replace(/```json\s*/gi, '').replace(/```/g, '');
-  return s;
-}
-
-// 在剥离 思考块 的文本里定位第一个「平衡花括号对象」的起点/终点。
-// 跳过字符串内的 {/}（含转义）以及 Jinja {{ }} 模板占位符；
-// 同时只在「JSON 特征显著」的 { 处起算 —— 即该 { 之后不远处出现 " 字符串。
-// 这能避免把 LLM 思考文本里的裸 { ... }（如 "see { views, stores }"）误当 JSON 起点。
-function extractFirstJsonObject(content) {
-  const s = String(content || '');
-  let depth = 0;
-  let inStr = false;
-  let escape = false;
-  let start = -1;
-  for (let i = 0; i < s.length; i++) {
-    const ch = s[i];
-    if (inStr) {
-      if (escape) { escape = false; continue; }
-      if (ch === '\\') { escape = true; continue; }
-      if (ch === '"') { inStr = false; }
-      continue;
-    }
-    if (ch === '"') { inStr = true; continue; }
-    // 跳过 Jinja {{ }} 占位符（提示词模板常用，勿当 JSON）
-    if (ch === '{' && s[i + 1] === '{') { i++; continue; }
-    if (ch === '}' && s[i - 1] === '}') { continue; }
-    if (ch === '{') {
-      if (depth === 0) {
-        // 启发式判断「这看起来像 JSON 起点」：
-        // 1. { 之前紧邻「真正的语义字符」(字母/数字/中文/下划线) → 不是 JSON 起点（散文里的花括号）
-        //    但接受 . , ; : 等句末标点（LLM 经常以「总结：{...}」直接开头 JSON）
-        // 2. { 之后跳过空白第一个字符必须是 " 或 }（空对象）
-        const before = i > 0 ? s[i - 1] : '';
-        if (/[A-Za-z0-9_一-龥]/.test(before)) continue;
-        let j = i + 1;
-        while (j < s.length && /\s/.test(s[j])) j++;
-        const firstNonWs = s[j];
-        if (firstNonWs !== '"' && firstNonWs !== '}') continue;
-        start = i;
-      }
-      depth++;
-    } else if (ch === '}') {
-      if (depth > 0) depth--;
-      if (depth === 0 && start !== -1) {
-        return s.slice(start, i + 1);
-      }
-    }
-  }
-  // 兜底：找不到平衡对象时返回原文（让上层 JSON.parse 报清晰错误）
-  return s;
-}
-
-async function callLlmJson(model, prompt, opts = {}) {
-  const { timeoutMs = 60000, images = [] } = opts;
-  const { default: fetch } = await import('node-fetch').catch(() => ({ default: globalThis.fetch }));
-  const url = `${String(model.baseURL || '').replace(/\/$/, '')}/chat/completions`;
-  const headers = { 'Content-Type': 'application/json' };
-  if (model.apiKey) headers['Authorization'] = `Bearer ${model.apiKey}`;
-
-  // 有图片时改用 OpenAI multimodal content 数组（text + image_url）。
-  // 非多模态模型遇到 image_url 会忽略图片块，相当于退化成纯文本，不会报错。
-  let userContent;
-  if (Array.isArray(images) && images.length > 0) {
-    userContent = [
-      { type: 'text', text: prompt },
-      ...images.map(img => ({ type: 'image_url', image_url: { url: img } }))
-    ];
-  } else {
-    userContent = prompt;
-  }
-
-  const body = JSON.stringify({
-    model: model.model,
-    messages: [{ role: 'user', content: userContent }],
-    temperature: 0.4,
-    response_format: { type: 'json_object' },
-    stream: false,
-  });
-
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    const resp = await fetch(url, { method: 'POST', headers, body, signal: controller.signal });
-    const data = await resp.json().catch(() => ({}));
-    if (!resp.ok) throw new Error(data?.error?.message || `HTTP ${resp.status}`);
-    const content = data?.choices?.[0]?.message?.content || '';
-    if (!content.trim()) {
-      throw new Error('LLM 返回内容为空');
-    }
-    try {
-      const cleaned = stripThinkingBlocks(content);
-      return JSON.parse(extractFirstJsonObject(cleaned));
-    } catch (err) {
-      const snippet = content.length > 500 ? content.slice(0, 500) + '…' : content;
-      throw new Error(`LLM 返回非 JSON 或被截断：${err.message}；原始内容片段：${snippet}`);
-    }
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-async function callLlmJsonWithRetry(model, prompt, opts = {}, retries = 1) {
-  let lastErr;
-  for (let i = 0; i <= retries; i++) {
-    try {
-      return await callLlmJson(model, prompt, opts);
-    } catch (err) {
-      lastErr = err;
-      if (i < retries) {
-        await new Promise(r => setTimeout(r, 800 * (i + 1)));
-      }
-    }
-  }
-  throw lastErr;
-}
-
-/**
- * 流式调用 OpenAI 兼容 LLM。每收到一个 chunk 调 onDelta 回调。
- * onDelta 接收 { thinking?: string, content?: string }，二选一。
- *   - reasoning_content / reasoning：部分模型（如 deepseek）放在 delta.reasoning_content
- *   - reasoning / reasoning_text：openai o1 风格
- *   - content：普通输出
- * 返回完整 content 字符串。
- *
- * input 支持两种形态(判别 union):
- *   - string: 旧模式,拼成单条 user message,支持 opts.images 多模态
- *   - ChatMsg[]: 新模式(对话拆分),直接作为 messages 发送;opts.images/systemPrompt 忽略
- */
-function cloneMsgContent(c) {
-  if (typeof c === 'string') return c
-  if (Array.isArray(c)) return c.map(p => ({ ...p }))
-  return c
-}
-
-async function callLlmStream(model, input, onDelta, opts = {}) {
-  const { maxTokens = 2000, timeoutMs = 600000, signal, images = [], systemPrompt } = opts
-  const { default: fetch } = await import('node-fetch').catch(() => ({ default: globalThis.fetch }))
-  const url = `${String(model.baseURL || '').replace(/\/$/, '')}/chat/completions`
-  const headers = { 'Content-Type': 'application/json' }
-  if (model.apiKey) headers['Authorization'] = `Bearer ${model.apiKey}`
-
-  // 判别 input: string(旧,直接拆分)或 messages 数组(新,对话拆分)
-  let messages
-  if (Array.isArray(input)) {
-    // messages 模式: 深拷贝避免外部 mutation 污染 LLM 请求
-    // images / systemPrompt opts 在 messages 模式下不生效(由 caller 自管)
-    messages = input.map(m => ({ role: m.role, content: cloneMsgContent(m.content) }))
-  } else {
-    // 旧模式: string prompt 拼成单条 user message,支持多模态
-    const text = String(input || '')
-    let userContent
-    if (Array.isArray(images) && images.length > 0) {
-      userContent = [
-        { type: 'text', text },
-        ...images.map(img => ({ type: 'image_url', image_url: { url: img } }))
-      ]
-    } else {
-      userContent = text
-    }
-    messages = []
-    if (systemPrompt) messages.push({ role: 'system', content: String(systemPrompt) })
-    messages.push({ role: 'user', content: userContent })
-  }
-
-  const body = JSON.stringify({
-    model: model.model,
-    messages,
-    max_tokens: maxTokens,
-    temperature: 0.4,
-    // 注意：stream: true 模式下不能同时使用 response_format:{type:'json_object'}，
-    // 部分 provider 会在收到两个一起时报错/静默卡住。改在 prompt 里约束 JSON 输出即可。
-    stream: true,
-  })
-
-  const controller = new AbortController()
-  const timer = setTimeout(() => controller.abort(), timeoutMs)
-  // 允许外部 signal 触发取消（用户在 GUI 点停止）
-  const onAbort = () => controller.abort()
-  if (signal) {
-    if (signal.aborted) controller.abort()
-    else signal.addEventListener('abort', onAbort)
-  }
-
-  let fullContent = ''
-  let aborted = false
-  try {
-    const resp = await fetch(url, { method: 'POST', headers, body, signal: controller.signal })
-    if (!resp.ok || !resp.body) {
-      const errText = await resp.text().catch(() => '')
-      throw new Error(errText || `HTTP ${resp.status}`)
-    }
-
-    // SSE 格式：每行 "data: {...}"，最后 "data: [DONE]"
-    const decoder = new TextDecoder('utf-8')
-    let buf = ''
-    for await (const chunk of resp.body) {
-      buf += decoder.decode(chunk, { stream: true })
-      const lines = buf.split('\n')
-      buf = lines.pop() ?? ''
-      for (const line of lines) {
-        const trimmed = line.trim()
-        if (!trimmed || !trimmed.startsWith('data:')) continue
-        const payload = trimmed.slice(5).trim()
-        if (payload === '[DONE]') continue
-        try {
-          const evt = JSON.parse(payload)
-          const delta = evt.choices?.[0]?.delta || {}
-          // thinking 在不同 provider 字段名不同，全部尝试
-          const thinkingChunk = delta.reasoning_content
-            || delta.reasoning
-            || delta.reasoning_text
-            || ''
-          const contentChunk = delta.content || ''
-          if (thinkingChunk) onDelta({ thinking: thinkingChunk })
-          if (contentChunk) {
-            fullContent += contentChunk
-            onDelta({ content: contentChunk })
-          }
-        } catch { /* 跳过无法解析的行 */ }
-      }
-    }
-  } catch (err) {
-    if (err?.name === 'AbortError' || controller.signal.aborted) {
-      aborted = true
-      // 中断不算错误——上层会决定怎么处理
-    } else {
-      throw err
-    }
-  } finally {
-    clearTimeout(timer)
-    if (signal) signal.removeEventListener('abort', onAbort)
-  }
-  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) {
-  let src = String(content || '');
-  if (!src.trim()) {
-    return { parsed: null, parseError: '模型未返回任何内容', parseStage: 'empty' };
-  }
-
-  // 预处理：剥离 deepseek-r1 / QwQ 等模型在 content 前输出的 <think>...</think> 思考块。
-  // 思考块通常跨行、可能多段，也可能自闭合 <think/>。剥离后下面的 JSON 扫描
-  // 才能命中真正的 subtasks JSON 块，避免贪婪正则把整段 think 包进 candidates。
-  src = src.replace(/<think>[\s\S]*?<\/think>/gi, '').replace(/<think\s*\/>/gi, '').trim();
-
-  const candidates = [];
-  const fenced = src.match(/```json\s*([\s\S]*?)```/i) || src.match(/```\s*([\s\S]*?)```/);
-  if (fenced) candidates.push(fenced[1]);
-  // 平衡花括号扫描：避免贪婪正则把多段 JSON / 散落的 { } 全包进去
-  const balancedFirst = extractBalancedJson(src);
-  if (balancedFirst) candidates.push(balancedFirst);
-  // 兜底：整段当 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();
-}
-
-function genId() {
-  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
-}
-
-async function ensureDataDir() {
-  await fsp.mkdir(DATA_DIR, { recursive: true });
-}
-
-async function readJson(file, fallback) {
-  try {
-    const buf = await fsp.readFile(file, 'utf-8');
-    return JSON.parse(buf);
-  } catch (err) {
-    if (err && err.code === 'ENOENT') return fallback;
-    throw err;
-  }
-}
-
-async function writeJson(file, data) {
-  await ensureDataDir();
-  const tmp = `${file}.tmp`;
-  await fsp.writeFile(tmp, JSON.stringify(data, null, 2), 'utf-8');
-  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 => logger.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 静默覆盖用户数据
-    logger.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) { logger.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;
-  return template.replace(/\{\{\s*([\w.]+)\s*\}\}/g, (_, key) => {
-    const parts = key.split('.');
-    let cur = ctx;
-    for (const p of parts) {
-      if (cur == null) return '';
-      cur = cur[p];
-    }
-    return cur == null ? '' : String(cur);
-  });
-}
-
-// ── 进程表：记录每个子任务的运行状态 ──────────────────────────────────────
-const bus = new EventEmitter();
-const jobs = new Map(); // jobId -> { id, taskId, subId, status, pid, startedAt, endedAt, exitCode, error, prompt }
-// 被用户主动取消的 jobId 集合——runTaskQueue 在 waitProcessExit 之后检查这个集合
-// 来决定把 job 标为 'cancelled' 还是 'done'。
-// 用 Set 而不是 job.cancelled 标志，是为了在 SIGTERM 发出后到 child 真正退出之间
-// 有一个简洁的"待回收"窗口。
-const cancelledJobs = new Set();
-// 启动时从磁盘拉回历史 job（陈旧 running/pending 自动降级 error）
-hydrateJobs().catch(err => logger.warn('[workbench] hydrate jobs failed:', err.message))
-
-// ── 生成指令持久化（~/.zen-gitsync/ai-instruction.json） ────────────────────
-async function readInstruction() {
-  try {
-    const buf = await fsp.readFile(INSTRUCTION_FILE, 'utf-8');
-    const obj = JSON.parse(buf);
-    if (obj && typeof obj.instruction === 'string' && obj.instruction.trim()) {
-      return obj.instruction;
-    }
-  } catch { /* 文件不存在或解析失败 */ }
-  return DEFAULT_INSTRUCTION;
-}
-
-async function writeInstruction(instruction) {
-  await ensureDataDir();
-  const text = String(instruction || '').trim() || DEFAULT_INSTRUCTION;
-  const tmp = `${INSTRUCTION_FILE}.tmp`;
-  await fsp.writeFile(tmp, JSON.stringify({ instruction: text, updatedAt: nowIso() }, null, 2), 'utf-8');
-  await fsp.rename(tmp, INSTRUCTION_FILE);
-}
-
-// AI 拆分子任务的指令：与生成项目架构说明的指令分开持久化，
-// 因为它面向的输出形态（subtask 列表）和任务粒度完全不同。
-// 支持传入 req：根据 Accept-Language 选默认（zh/en）
-async function readSubtaskInstruction(req) {
-  try {
-    const buf = await fsp.readFile(SUBTASK_INSTRUCTION_FILE, 'utf-8');
-    const obj = JSON.parse(buf);
-    if (obj && typeof obj.instruction === 'string' && obj.instruction.trim()) {
-      return obj.instruction;
-    }
-  } catch { /* 文件不存在或解析失败 */ }
-  return pickDefaultSubtaskInstruction(req);
-}
-async function writeSubtaskInstruction(instruction) {
-  await ensureDataDir();
-  // 写入时如果与当前 locale 默认一致，不写文件——这样前端"isDefault"判定永远准确
-  const text = String(instruction || '').trim() || DEFAULT_SUBTASK_INSTRUCTION_ZH;
-  const tmp = `${SUBTASK_INSTRUCTION_FILE}.tmp`;
-  await fsp.writeFile(tmp, JSON.stringify({ instruction: text, updatedAt: nowIso() }, null, 2), 'utf-8');
-  await fsp.rename(tmp, SUBTASK_INSTRUCTION_FILE);
-}
-
-// ── 子项目识别：递归找 .git / manifest；A 是 B 的祖先时只保留 B ─────────────
-async function findSubProjects(projectPath, opts = {}) {
-  const { maxDepth = 4 } = opts;
-  const candidates = [];
-
-  async function walk(dir, depth) {
-    if (depth > maxDepth) return;
-    let entries;
-    try { entries = await fsp.readdir(dir, { withFileTypes: true }); }
-    catch { return; }
-
-    let hasManifest = false;
-    let hasGit = false;
-    const subDirs = [];
-    for (const e of entries) {
-      if (!e.isDirectory() && !e.isFile()) continue;
-      if (e.name.startsWith('.')) {
-        if (e.name === '.git' && e.isDirectory()) hasGit = true;
-        continue;
-      }
-      if (e.isDirectory()) {
-        if (SKIP_DIRS.has(e.name)) continue;
-        subDirs.push(path.join(dir, e.name));
-      } else if (e.isFile() && MANIFEST_FILES.includes(e.name)) {
-        hasManifest = true;
-      }
-    }
-    if (hasManifest || hasGit) {
-      candidates.push(dir);
-      return; // 子目录里若还有 manifest，会被自己发现；这里不再下钻避免冗余
-    }
-    if (depth >= maxDepth) return;
-    for (const sub of subDirs) {
-      await walk(sub, depth + 1);
-    }
-  }
-
-  await walk(projectPath, 0);
-
-  // 去重：若 candidates 里 A 是 B 的祖先，只保留更深一级的 B
-  candidates.sort((a, b) => a.length - b.length);
-  const kept = [];
-  for (const c of candidates) {
-    let dominated = false;
-    for (const k of kept) {
-      if (c === k || c.startsWith(k + path.sep)) { dominated = true; break; }
-    }
-    if (!dominated) kept.push(c);
-  }
-
-  // 收集每个子项目的关键文件
-  const result = [];
-  for (const root of kept) {
-    const manifests = {};
-    for (const m of MANIFEST_FILES) {
-      const p = path.join(root, m);
-      try {
-        const stat = await fsp.stat(p);
-        if (stat.isFile()) {
-          manifests[m] = stat.size > 20000
-            ? await safeReadFile(p, 20000)
-            : await fsp.readFile(p, 'utf8');
-        }
-      } catch { /* 不存在就跳过 */ }
-    }
-    let readme = '';
-    try {
-      const stat = await fsp.stat(path.join(root, 'README.md'));
-      if (stat.isFile()) readme = await safeReadFile(path.join(root, 'README.md'), 8000);
-    } catch { /* 不存在就跳过 */ }
-    const dirTree = await listDirTree(root, 2, 200);
-    result.push({
-      root,
-      name: path.basename(root) || path.basename(projectPath),
-      manifests,
-      readme,
-      dirTree
-    });
-  }
-  return result;
-}
-
-function publish(event, payload) {
-  bus.emit('event', { event, payload, ts: nowIso() });
-}
-
-function snapshotJobs() {
-  return Array.from(jobs.values()).map(j => ({
-    id: j.id,
-    taskId: j.taskId,
-    subId: j.subId,
-    title: j.title,
-    status: j.status,
-    prompt: j.prompt || '',
-    output: j.output || '',
-    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 --output-format stream-json 的 system.init 事件捕获到的 session_id
-    claudeSessionId: j.claudeSessionId || null
-  }));
-}
-
-// 用 detached 进程跑 claude；进程退出时回填状态。
-// 返回 { pid, child }：调用方可以监听 child.stdout/stderr 实时收集输出。
-// 不再走 cmd /k 弹窗——claude -p 是非交互模式，输出通过 stdout pipe 实时回传
-// 到前端面板展示。
-function launchClaudeInNewWindow(cwd, promptText, resumeSessionId) {
-  return new Promise((resolve, reject) => {
-    const args = [];
-    // 续接历史会话:--resume 必须放在 -p 之前,确保 claude CLI 先识别 resume 上下文
-    if (resumeSessionId) {
-      args.push('--resume', String(resumeSessionId));
-    }
-    args.push(
-      // -p '-' 让 claude CLI 从 stdin 读取 prompt —— 避免 Windows 命令行 32K 长度上限
-      // (spawn argv 会拼成 cmdline 给 CreateProcess,长 prompt 直接 ENAMETOOLONG)
-      '-p', '-',
-      '--output-format', 'stream-json',
-      '--verbose',
-      '--permission-mode', 'bypassPermissions',
-      '--dangerously-skip-permissions'
-    );
-    let child;
-    let spawnedExe = 'claude';
-    if (process.platform === 'win32') {
-      // 直接 spawn claude.exe（npm 全局 @anthropic-ai/claude-code 里的真实二进制），
-      // 避开两件事：
-      //  1. Node 23 在 Windows 上拒绝 spawn .cmd/.bat（EINVAL）
-      //  2. shell:true 会把 argv 拼成命令行交给 cmd 解释，prompt 里的 \n 被切成多段
-      // 用 `where claude` 找到 claude.cmd，再从 cmd 内容推断对应 .exe 路径。
-      let claudeExe = 'claude.exe';
-      try {
-        const cmdShim = execFileSync('where', ['claude'], { encoding: 'utf8' })
-          .split(/\r?\n/).map(s => s.trim()).find(s => /\.cmd$/i.test(s));
-        if (cmdShim) {
-          const txt = fs.readFileSync(cmdShim, 'utf8');
-          if (/%dp0%\\node_modules\\@anthropic-ai\\claude-code\\bin\\claude\.exe/i.test(txt)) {
-            claudeExe = path.join(path.dirname(cmdShim), 'node_modules', '@anthropic-ai', 'claude-code', 'bin', 'claude.exe');
-          }
-        }
-      } catch { /* fallback */ }
-      spawnedExe = claudeExe;
-      child = spawn(claudeExe, args, {
-        cwd,
-        stdio: ['pipe', 'pipe', 'pipe'],
-        windowsHide: false,
-        env: { ...process.env, LANG: 'zh_CN.UTF-8' }
-      });
-    } else {
-      // macOS / Linux：直接 spawn claude（Node spawn 不走 shell，
-      // prompt 中的引号 / 反斜杠无需手动 escape）
-      child = spawn('claude', args, {
-        cwd,
-        detached: true,
-        stdio: ['pipe', 'pipe', 'pipe'],
-        env: { ...process.env, LANG: 'zh_CN.UTF-8' }
-      });
-    }
-    child.on('error', reject);
-    child.on('spawn', () => {
-      // unref 让 claude 独立于父进程事件循环；返回 child 引用让调用方继续读 stdout。
-      child.unref();
-      // 长 prompt 通过 stdin 喂入(避开 Windows CreateProcess 32K 命令行上限)。
-      // 必须在 spawn 事件回调里 write,而不是 resolve 前同步 write——因为 spawn
-      // 返回时 child.stdin 句柄可能尚未绑定到真正的 pipe fd。
-      // write 完成后必须 end(),否则 claude CLI 会一直阻塞在读 stdin 上 → hang。
-      try {
-        child.stdin.write(promptText, () => {
-          try { child.stdin.end() } catch { /* 子进程已关闭,忽略 */ }
-        });
-      } catch (err) {
-        // stdin 写入失败不要让 spawn 整体 reject —— 让 child 自然以错误状态收尾,
-        // 后面的 stdout/stderr 监听会捕获到 LLM 端反馈。
-        logger.warn('[workbench] stdin write failed:', err && err.message || err);
-      }
-      resolve({ pid: child.pid, child });
-    });
-  });
-}
-
-/**
- * 顺序执行一个任务下所有子任务；上一个结束再启动下一个。
- * 入参 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 知道前面做了什么、产出了什么。
-  // 现在 LLM 都是百万 token 上下文窗口,完整透传 raw output,不做截断——
-  // 关键产物(生成的代码块、JSON、结论)在中间被砍掉反而会让后续 sub 失去依据。
-  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)
-    : []
-  // 连续模式（默认）：任意 sub 终态非 done（cancelled / error）→ 整批停，后续 sub 保持 todo。
-  // AI 拆出来的 sub 一般前后强依赖（前一步产出是后一步输入），出错就停下来让用户决策。
-  // 关闭后回退旧行为：单个 sub 失败不影响后续 sub 继续跑。
-  const sequential = task.sequential !== false
-  for (let i = fromIndex; i < task.subtasks.length; i++) {
-    const sub = task.subtasks[i]
-    if (sub.status === 'done') continue;
-    const outcome = await runSingleSubtask(task, sub, repoPath, branch, priorOutputs)
-    // 逐 sub 落盘:之前只在队列跑完才 persistTaskAfterRun,中途崩溃会丢已完成
-    // sub 的状态。runSingleSubtask 已经把 sub.status 改完,这里补一次落盘。
-    await persistTaskAfterRun(task)
-    if (sequential && outcome !== 'done') {
-      // cancelled / error → 后续 sub 全部保持 todo，不再继续
-      break
-    }
-  }
-}
-
-/**
- * 执行单个子任务。被 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"。
- * @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, options) {
-  const opts = options || {}
-  const resumeSessionId = opts.resumeSessionId || null
-  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) => {
-      return `### [${i + 1}] ${p.title}\n${p.output || ''}`
-    }).join('\n\n')
-    prompt = `以下是同一任务下已经完成的前序子任务输出（仅作上下文参考，请基于这些结论继续当前子任务，无需重复执行它们）：
-
-${prevBlock}
-
----
-
-${prompt}`
-  }
-
-  // ── 附件：合并 sub.attachments + task.attachments 后拼到 prompt 末尾 ──
-  // claude -p 字符串模式会扫描 prompt 中出现的本地文件路径并自动
-  // 识别为附件（图片 / PDF / 文本均可）。
-  // 主任务附件对所有 sub 都可见；子任务自己的附件只对该 sub 可见。
-  // 注意：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)
-      .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,
-    // 续接历史会话时先填上,首条 system.init 事件回来后再用真值覆盖(通常等同)
-    claudeSessionId: resumeSessionId
-  };
-  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, resumeSessionId);
-    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 / 错误信息）
-          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 }
-        // 捕获 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;
-        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;
-          }
-        }
-      }
-      // 一批 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（cancel 接口的 syncSubToCancelled 改了磁盘 task
-      // 引用，但 runSingleSubtask 形参里的 sub 是另一份内存引用）。否则 finally publish sub:update
-      // 会用 status='running' 覆盖掉前端已渲染的 cancelled 状态，导致 UI 反复跳回 running。
-      // 同时 sequential=true 时 runTaskQueue 会看到 outcome='cancelled'，break 不再跑后续 sub。
-      sub.status = 'cancelled';
-      if (!sub.error) sub.error = '用户已停止执行';
-    } else {
-      job.exitCode = 0;
-      job.status = 'done';
-      sub.status = 'done';
-      // 把这个 sub 的输出累积到前序上下文，喂给下一个 sub
-      if (priorOutputs) priorOutputs.push({ title: sub.title, output: job.output || '' })
-    }
-  } catch (err) {
-    const errMsg = err && err.message ? err.message : String(err);
-    job.error = errMsg;
-    job.status = 'error';
-    sub.status = 'error';
-    sub.error = errMsg;
-    sub.errorAt = nowIso();
-  } finally {
-    // 移除 child 引用——避免后续被 SSE 序列化到前端
-    delete job.child
-    publish('job:update', job);
-    publish('sub:update', { taskId: task.id, sub });
-    // 终态：await 同步落盘,确保 done/cancelled/error 全部立即归档。
-    // 历史上这里用 fire-and-forget(`.catch(err => ...)`) → runSingleSubtask 返回时
-    // flushJobsSaveNow 还在写盘 microtask 里 → runTaskQueue 进入下一个 sub →
-    // 如果用户此时调了 clearJobsByTask / 切页面 / 后端退出 → 写盘未完成就丢 job
-    // (但 sub.status=done 已经被 publish 出去 → 磁盘状态 = "sub done 但无 job",
-    //  跟用户截图里的"6 个 done 但 jobs.json 全空"现象吻合)。
-    // 改 await 后:runSingleSubtask 返回时,本 sub 的 job 已经落盘 → 安全。
-    // 出错也只是 log warn,不会抛出影响后续 sub 的执行。
-    try {
-      await flushJobsSaveNow()
-    } catch (err) {
-      logger.warn('[workbench] flushJobsSaveNow failed (job id=' + job.id + ', status=' + job.status + '):', err && err.message || err)
-    }
-  }
-  // 把 sub 的终态返回给 runTaskQueue，用于「连续模式」判断要不要 break 整批队列
-  return job.status  // 'done' | 'cancelled' | 'error'
-}
-
-/**
- * 把被取消的 sub 同步置 'cancelled' 并落盘。
- * cancelJob 路径专用：前端 taskIsRunning/sub.is-running 都看 sub.status，不改就会出现
- * "主任务黄点 + sub running 动效 + 右侧执行完成"三处不一致。
- *
- * 简单任务的虚拟 subId 不在 tasks.json 里（task.subtasks 是 complex 才有），所以这里
- * 找不到 sub 时静默返回；简单任务的 running 状态由 job 数组单独维护（见 taskIsRunning）。
- *
- * @returns {{ taskId: string, sub: object } | null}  找到并更新时返回新 sub，否则 null
- */
-async function syncSubToCancelled(job) {
-  if (!job || !job.taskId || !job.subId) return null
-  const data = await readJson(TASKS_FILE, { tasks: [] })
-  const task = (data.tasks || []).find(x => x.id === job.taskId)
-  if (!task || !Array.isArray(task.subtasks)) return null
-  const sub = task.subtasks.find(s => s && s.id === job.subId)
-  if (!sub) return null
-  if (sub.status === 'cancelled') return { taskId: task.id, sub }  // 已置过，幂等返回
-  sub.status = 'cancelled'
-  sub.error = '用户已停止执行'
-  sub.errorAt = nowIso()
-  task.updatedAt = nowIso()
-  await writeJson(TASKS_FILE, data)
-  publish('sub:update', { taskId: task.id, sub })
-  publish('task:update', task)
-  return { taskId: task.id, sub }
-}
-
-/** 把 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) {
-    // 仅同步 status 之外的 error/errorAt 字段，避免覆盖用户编辑过的 title/desc 等。
-    // 历史 subtasks 持久化只写 status → 失败信息丢，hover "执行出错" 标签看不到原因。
-    const newMap = new Map(task.subtasks.map(s => [s.id, s]));
-    t.subtasks = (t.subtasks || []).map(old => {
-      const fresh = newMap.get(old.id);
-      if (!fresh) return old;
-      return {
-        ...old,
-        status: fresh.status ?? old.status,
-        error: fresh.error ?? old.error,
-        errorAt: fresh.errorAt ?? old.errorAt,
-      };
-    });
-    t.updatedAt = nowIso();
-    await writeJson(TASKS_FILE, data);
-    publish('task:update', t);
-  }
-}
-
-/**
- * 构建单 sub 执行时的 priorOutputs：把同一 task 下"排在当前 sub 之前"且已 done 的
- * 子任务输出摘要收集起来。这样单独跑一个 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 prior = []
-  for (let i = 0; i < endIdx; 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
-    prior.push({ title: s.title, output: job.output || '' })
-  }
-  return prior
-}
-
-function waitProcessExit(pid) {
-  return new Promise(resolve => {
-    let exited = false;
-    const tryCheck = () => {
-      if (exited) return;
-      try {
-        process.kill(pid, 0); // 信号 0 = 探测存活
-      } catch (err) {
-        // 只在进程真的消失（ESRCH / EPERM）时才 resolve；
-        // 其他错误（比如参数类型）保留 polling 状态，由超时兜底。
-        if (err && (err.code === 'ESRCH' || err.code === 'EPERM')) {
-          exited = true;
-          resolve();
-          return;
-        }
-      }
-      setTimeout(tryCheck, 1500);
-    };
-    tryCheck();
-    // 兜底：30 分钟超时自动结束
-    setTimeout(() => { if (!exited) { exited = true; resolve(); } }, 30 * 60 * 1000);
-  });
-}
-
-export function registerWorkbenchRoutes({ app, getCurrentProjectPath, getProjectRoomId, io, configManager }) {
-  // ── AI 生成提示词（基于当前项目） ─────────────────────────────────────
-  app.post('/api/workbench/prompts/ai-generate', async (req, res) => {
-    try {
-      const projectPath = typeof getCurrentProjectPath === 'function' ? getCurrentProjectPath() : '';
-      if (!projectPath) {
-        return res.status(400).json({ success: false, error: '未选中项目' });
-      }
-      let stat;
-      try { stat = await fsp.stat(projectPath); }
-      catch { return res.status(400).json({ success: false, error: '项目路径不存在' }); }
-      if (!stat.isDirectory()) {
-        return res.status(400).json({ success: false, error: '项目路径不是目录' });
-      }
-
-      // 取模型
-      let model;
-      try {
-        if (!configManager) throw new Error('configManager 不可用');
-        const rawConfig = await configManager.readRawConfigFile();
-        const models = Array.isArray(rawConfig.models) ? rawConfig.models : [];
-        model = models.find(m => m.isDefault) || models[0];
-      } catch (err) {
-        return res.status(500).json({ success: false, error: '读取 AI 配置失败: ' + err.message });
-      }
-      if (!model) {
-        return res.status(400).json({ success: false, error: '未配置 AI 模型，请先在通用设置中添加模型' });
-      }
-
-      // 读取用户可编辑的生成指令；没存就用默认
-      const userInstruction = await readInstruction();
-
-      // 递归识别多子项目
-      const subProjects = await findSubProjects(projectPath);
-      if (subProjects.length === 0) {
-        // 没识别到任何子项目：回退到根目录本身
-        const fallbackTree = await listDirTree(projectPath, 2, 400);
-        const fallbackManifest = await readProjectManifest(projectPath);
-        const fallbackReadme = await safeReadFile(path.join(projectPath, 'README.md'), 8000);
-        subProjects.push({
-          root: projectPath,
-          name: path.basename(projectPath),
-          manifests: fallbackManifest,
-          readme: fallbackReadme,
-          dirTree: fallbackTree
-        });
-      }
-
-      const projectName = path.basename(projectPath);
-      const LLM_OPTS = { timeoutMs: 1200000 };
-
-      // ── 第一阶段：基于可编辑指令 + 根目录概览，生成「可复用的提示词模板」 ──
-      const overviewBlock = subProjects.map(sp =>
-        `### 子项目 ${sp.name} (${sp.root})\n目录：\n${sp.dirTree || '（无）'}`
-      ).join('\n\n');
-
-      const firstPrompt = `${userInstruction}
-
----
-
-以下是你需要分析的项目（请先生成「可复用的提示词模板」，不要直接给总结）：
-
-项目根目录：${projectPath}
-项目名称：${projectName}
-子项目数：${subProjects.length}
-
-## 子项目概览
-${overviewBlock || '（无）'}
-
-## 各子项目 manifest 与 README
-${subProjects.map(sp => {
-  const manifestBlock = Object.entries(sp.manifests)
-    .map(([n, c]) => `\n--- ${n} ---\n${c}`)
-    .join('\n');
-  return `\n### ${sp.name}\n${manifestBlock || '（无 manifest）'}\n\nREADME（前 8KB）：\n${sp.readme || '（无）'}`;
-}).join('\n')}
-
-只返回 JSON：
-{
-  "name": "项目名（建议：项目名+架构说明，可根据实际项目特征调整）",
-  "template": "可复用的提示词模板，长度不限，请充分覆盖 {{task.title}} / {{task.desc}} / {{sub.title}} / {{sub.desc}} / {{repo.path}} / {{branch}} 这 6 个变量的用法与上下文"
-}`;
-
-      const first = await callLlmJsonWithRetry(model, firstPrompt, LLM_OPTS);
-      const templateName = String(first.name || '').trim() || `${projectName}架构说明`;
-      const template = String(first.template || '').trim();
-
-      // ── 第二阶段：为每个子项目分别生成总结（单子项目 = 现在的行为） ──
-      async function summarizeOneSub(sp) {
-        const manifestBlock = Object.entries(sp.manifests)
-          .map(([n, c]) => `\n--- ${n} ---\n${c}`)
-          .join('\n');
-        const subPrompt = `${template}
-
----
-
-以下是你需要分析的一个子项目（请直接基于这些数据输出该子项目的架构说明）：
-
-子项目根目录：${sp.root}
-子项目名称：${sp.name}
-
-## 目录结构（前 2 层）
-${sp.dirTree || '（无）'}
-
-## manifest
-${manifestBlock || '（无）'}
-
-## README
-${sp.readme || '（无）'}
-
-只返回 JSON：
-{
-  "summary": "该子项目的架构说明，长度不限，模型自行决定篇幅与详尽程度，能写多详细就多详细"
-}`;
-        const r = await callLlmJsonWithRetry(model, subPrompt, LLM_OPTS);
-        return { name: sp.name, root: sp.root, summary: String(r.summary || '').trim() };
-      }
-
-      // 串行执行,避免并发触发 provider 限流(429)导致整批失败
-      const subSummaries = [];
-      for (const sp of subProjects) {
-        subSummaries.push(await summarizeOneSub(sp));
-      }
-
-      // ── 第三阶段：仅多子项目时合并（单子项目直接拿它的 summary） ──
-      let finalSummary = '';
-      let finalName = templateName;
-
-      if (subSummaries.length === 1) {
-        finalSummary = subSummaries[0].summary;
-      } else {
-        const mergePrompt = `你是项目架构师。下列是同一仓库下 N 个子项目的架构说明，请合并输出**单一**的「项目架构说明」，长度不限，模型自行决定篇幅与详尽程度。覆盖：项目整体定位、技术栈、模块划分、子项目间关系、核心流程、关键设计决策。
-子项目之间用清晰的小标题或编号分隔。最后输出一段「整体架构」总结它们如何协同。
-只引用实际出现的子项目名 / 文件路径 / 依赖名，不要编造。只返回 JSON：
-
-{
-  "name": "项目名（建议：项目名+架构说明）",
-  "summary": "合并后的架构说明"
-}
-
-## 子项目说明
-${subSummaries.map((s, i) => `\n### [${i + 1}] ${s.name} (${s.root})\n${s.summary || '（空）'}`).join('\n')}`;
-
-        const merged = await callLlmJsonWithRetry(model, mergePrompt, LLM_OPTS);
-        finalSummary = String(merged.summary || '').trim()
-          || subSummaries.map(s => `### ${s.name}\n${s.summary}`).join('\n\n');
-        finalName = String(merged.name || '').trim() || templateName;
-      }
-
-      // 名称始终固定为「<项目名>架构说明」，不信任模型返回的 name 字段
-      finalName = `${projectName}架构说明`;
-
-      if (!finalSummary) {
-        return res.status(502).json({
-          success: false,
-          error: '模型返回为空，请稍后重试'
-        });
-      }
-
-      // 顶层 request 已经自带 20 分钟（1200s）超时；
-      // 这里在 express 处理器内部不再额外加整体超时。
-      res.json({
-        success: true,
-        name: finalName,
-        template,
-        result: finalSummary,
-        content: finalSummary
-      });
-    } catch (err) {
-      res.status(500).json({ success: false, error: err.message });
-    }
-  });
-
-  // ── 生成指令：读 / 写（用户可在弹窗里自定义） ───────────────────────
-  app.get('/api/workbench/prompts/ai-instruction', async (_req, res) => {
-    try {
-      const instruction = await readInstruction();
-      res.json({ success: true, instruction, isDefault: instruction === DEFAULT_INSTRUCTION });
-    } catch (err) {
-      res.status(500).json({ success: false, error: err.message });
-    }
-  });
-
-  app.put('/api/workbench/prompts/ai-instruction', async (req, res) => {
-    try {
-      const text = req.body && typeof req.body.instruction === 'string'
-        ? req.body.instruction.trim()
-        : '';
-      if (!text) {
-        return res.status(400).json({ success: false, error: '指令不能为空' });
-      }
-      if (text.length > 500000) {
-        return res.status(413).json({ success: false, error: '指令过长（最多 500000 字符）' });
-      }
-      await writeInstruction(text);
-      res.json({ success: true });
-    } catch (err) {
-      res.status(500).json({ success: false, error: err.message });
-    }
-  });
-
-  // ── AI 拆分子任务：独立的指令文件、独立的端点 ───────────────────────
-  // GET /api/workbench/tasks/ai-subtask-instruction
-  //   →  { success, instruction, isDefault }
-  // PUT /api/workbench/tasks/ai-subtask-instruction
-  //   body: { instruction: string }
-  //   →  { success }
-  app.get('/api/workbench/tasks/ai-subtask-instruction', async (req, res) => {
-    try {
-      const def = pickDefaultSubtaskInstruction(req);
-      const instruction = await readSubtaskInstruction(req);
-      // isDefault：当前 instruction 和 locale 默认完全一致
-      res.json({ success: true, instruction, isDefault: instruction === def });
-    } catch (err) {
-      res.status(500).json({ success: false, error: err.message });
-    }
-  });
-
-  app.put('/api/workbench/tasks/ai-subtask-instruction', async (req, res) => {
-    try {
-      const text = req.body && typeof req.body.instruction === 'string'
-        ? req.body.instruction.trim()
-        : '';
-      if (!text) {
-        return res.status(400).json({ success: false, error: '指令不能为空' });
-      }
-      if (text.length > 500000) {
-        return res.status(413).json({ success: false, error: '指令过长（最多 500000 字符）' });
-      }
-      // 如果保存的文本正好等于当前 locale 的默认——不写文件，保持 fallback 行为
-      const def = pickDefaultSubtaskInstruction(req);
-      if (text === def) {
-        // 删除已存在的自定义文件
-        try { await fsp.unlink(SUBTASK_INSTRUCTION_FILE) } catch {}
-        return res.json({ success: true, isDefault: true });
-      }
-      await writeSubtaskInstruction(text);
-      res.json({ success: true, isDefault: false });
-    } catch (err) {
-      res.status(500).json({ success: false, error: err.message });
-    }
-  });
-
-  // POST /api/workbench/tasks/ai-split-subtasks
-  //   body: { title, desc, taskId? }
-  //   →  SSE 流：
-  //        data:{"type":"meta","prompt":{system,user}}\n\n
-  //        data:{"type":"thinking","delta":"..."}\n\n   （多次）
-  //        data:{"type":"content","delta":"..."}\n\n    （多次）
-  //        data:{"type":"done","subtasks":[...],"raw":"..."}\n\n
-  //        data:{"type":"error","error":"..."}\n\n      （失败时）
-  //
-  // 走流式是为了让用户看到模型真实的 reasoning_content（如果模型支持），
-  // 而不是前端用 setInterval 假装"打字机"——拆分质量也会因为给了模型
-  // 充分的思考空间而显著提升。
-  app.post('/api/workbench/tasks/ai-split-subtasks', async (req, res) => {
-    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();
-    // 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: '任务标题不能为空' });
-    }
-
-    // 建立 SSE
-    res.set({
-      'Content-Type': 'text/event-stream',
-      'Cache-Control': 'no-cache, no-transform',
-      'Connection': 'keep-alive',
-      'X-Accel-Buffering': 'no'
-    });
-    res.flushHeaders?.();
-    const send = (obj) => {
-      try { res.write(`data: ${JSON.stringify(obj)}\n\n`); } catch {}
-    };
-
-    const abortController = new AbortController();
-    let finished = false; // 标记响应是否已正常结束
-    // 客户端真实断开：监听 socket close，而不是 req.close。
-    // Node 22+ 的 req 'close' 事件会在 HTTP keep-alive socket 池回收时过早触发，
-    // 导致正常请求中途被 abort。这里改用 socket 真实断开事件，
-    // 并只在响应还没 end 时才取消上游 LLM。
-    const onSocketClose = () => {
-      if (!finished) abortController.abort()
-    };
-    if (req.socket) {
-      req.socket.once('close', onSocketClose);
-    }
-
-    try {
-      let model;
-      try {
-        if (!configManager) throw new Error('configManager 不可用');
-        const rawConfig = await configManager.readRawConfigFile();
-        const models = Array.isArray(rawConfig.models) ? rawConfig.models : [];
-        model = models.find(m => m.isDefault) || models[0];
-      } catch (err) {
-        send({ type: 'error', error: '读取 AI 配置失败: ' + err.message });
-        finished = true;
-        return res.end();
-      }
-      if (!model) {
-        send({ type: 'error', error: '未配置 AI 模型，请先在通用设置中添加模型' });
-        finished = true;
-        return res.end();
-      }
-
-      const userInstruction = await readSubtaskInstruction(req);
-      const projectPath = typeof getCurrentProjectPath === 'function' ? getCurrentProjectPath() : '';
-      const projectName = projectPath ? path.basename(projectPath) : '（未指定项目）';
-      const manifestHint = await detectProjectManifest(projectPath);
-
-      // 取绑定的预置模板（promptId）：模板内容作为"执行模板"提示
-      // 让 LLM 拆分时知道：每个 sub 最终都会被这套模板包裹后送进 claude
-      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 { /* 模板读取失败不影响拆分 */ }
-      }
-
-      // 取任务附件
-      let attachmentBlock = '';
-      const imageDataUrls = [];
-      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)) {
-                try {
-                  const buf = await fsp.readFile(a.absolutePath);
-                  const mime = a.mimeType || 'image/png';
-                  imageDataUrls.push(`data:${mime};base64,${buf.toString('base64')}`);
-                } catch { /* 文件丢失就跳过这张图 */ }
-              }
-            }
-            if (lines.length > 0) {
-              const imgNote = imageDataUrls.length > 0
-                ? `（其中 ${imageDataUrls.length} 张图片已随消息一并发送，请直接基于图片内容拆分）`
-                : '';
-              attachmentBlock = `\n\n## 任务附件${imgNote}\n${lines.join('\n')}`;
-            }
-          }
-        } catch { /* 没拿到附件不影响拆分 */ }
-      }
-
-      const userBlock = customUserBlock.trim() ? customUserBlock : `${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 转义。`;
-
-      // 先把 prompt 元信息推给前端
-      send({ type: 'meta', prompt: { system: userInstruction, user: userBlock } });
-
-      // 流式调用 LLM，把 thinking / content 实时回传
-      const { content, aborted } = await callLlmStream(
-        model,
-        userBlock,
-        (delta) => {
-          if (delta.thinking) send({ type: 'thinking', delta: delta.thinking });
-          if (delta.content) send({ type: 'content', delta: delta.content });
-        },
-        { maxTokens: 32000, timeoutMs: 600000, images: imageDataUrls, signal: abortController.signal }
-      );
-
-      if (aborted) {
-        send({ type: 'error', error: '已取消' });
-        finished = true;
-        return res.end();
-      }
-
-      // 解析 JSON：兼容 ```json ... ``` 代码块或裸 JSON，多级降级
-      const { parsed, parseError, parseStage } = parseSubtaskJson(content);
-      const list = Array.isArray(parsed?.subtasks) ? parsed.subtasks : [];
-      const subtasks = list
-        .map(s => ({
-          title: String(s?.title || '').trim(),
-          desc: String(s?.desc || '').trim()
-        }))
-        .filter(s => s.title);
-
-      send({ type: 'done', subtasks, raw: content, parseError, parseStage });
-      finished = true;
-      res.end();
-    } catch (err) {
-      send({ type: 'error', error: 'AI 拆分失败: ' + (err?.message || String(err)) });
-      finished = true;
-      res.end();
-    }
-  });
-
-  // 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 }
-  // 让前端在 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(),
-          desc: String(s?.desc || '').trim()
-        }))
-        .filter(s => s.title);
-      res.json({ success: true, subtasks, parseError, parseStage });
-    } catch (err) {
-      res.status(500).json({ success: false, error: err?.message || String(err) });
-    }
-  });
-
-  // ── AI 对话拆分: 多轮 SSE 端点 ───────────────────────────────────────
-  // POST /api/workbench/tasks/ai-chat-split  (SSE)
-  //   body: { sessionId?, title, desc?, taskId?, promptId?, userMessage }
-  //   →   meta / user_echo / thinking / content / done / error
-  // 第一轮可省略 sessionId,后端会新建;后续轮带 sessionId 继续追加 messages。
-  // 历史对话持久化在 SESSIONS_DIR,前端可从 GET 列表/GET 详情恢复。
-  app.post('/api/workbench/tasks/ai-chat-split', async (req, res) => {
-    const userMessage = String(req.body?.userMessage || '').trim();
-    const sessionIdInput = String(req.body?.sessionId || '').trim();
-    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();
-
-    // SSE 头
-    res.set({
-      'Content-Type': 'text/event-stream',
-      'Cache-Control': 'no-cache, no-transform',
-      'Connection': 'keep-alive',
-      'X-Accel-Buffering': 'no'
-    });
-    res.flushHeaders?.();
-    const send = (obj) => {
-      try { res.write(`data: ${JSON.stringify(obj)}\n\n`); } catch {}
-    };
-    const abortController = new AbortController();
-    let finished = false;
-    if (req.socket) req.socket.once('close', () => { if (!finished) abortController.abort(); });
-
-    try {
-      // 加载或新建 session
-      let session, isNew = false;
-      if (sessionIdInput) {
-        try {
-          session = await readSessionFile(sessionIdInput);
-        } catch (err) {
-          if (err.statusCode === 404) {
-            send({ type: 'error', error: '会话不存在' });
-            return res.end();
-          }
-          throw err;
-        }
-      } else {
-        if (!title) {
-          send({ type: 'error', error: '新建会话时必须提供 title' });
-          return res.end();
-        }
-        session = {
-          version: 1,
-          sessionId: genSessionId(),
-          title, desc, taskId, promptId,
-          createdAt: nowIso(),
-          updatedAt: nowIso(),
-          messages: [],
-          latestSubtasks: [],
-          latestRaw: '',
-          latestParseStage: ''
-        };
-        isNew = true;
-      }
-
-      if (!userMessage) {
-        send({ type: 'error', error: '消息内容不能为空' });
-        return res.end();
-      }
-
-      // 拼 system message(只在第一轮)
-      if (session.messages.length === 0) {
-        const userInstruction = await readSubtaskInstruction(req);
-        // 第一轮时把任务上下文拼到 system message 末尾,让 LLM 一开始就知道要拆哪个任务。
-        // 直接拆分端点把 title/desc 拼在 user prompt 里同样达到此效果;对话模式因 user 消息
-        // 可能只是「拆一下」这种简短追问,必须把上下文放在 system 里 LLM 才不会反问。
-        // 后续轮次不再追加,避免任务变更(切换 taskId)时影响已建立的多轮上下文。
-        const ctxLines = [];
-        if (title) ctxLines.push(`【任务标题】${title}`);
-        if (desc) ctxLines.push(`【任务描述】${desc}`);
-        const sysContent = ctxLines.length
-          ? `${userInstruction}\n\n${ctxLines.join('\n')}`
-          : userInstruction;
-        session.messages.push({ role: 'system', content: sysContent });
-      }
-
-      // 追加 user message
-      session.messages.push({ role: 'user', content: userMessage });
-
-      // 推 meta + user_echo
-      send({
-        type: 'meta',
-        sessionId: session.sessionId,
-        isNew,
-        prompt: { system: session.messages[0].content, user: userMessage }
-      });
-      send({ type: 'user_echo', userMessage });
-
-      // 加载 model
-      let model;
-      try {
-        if (!configManager) throw new Error('configManager 不可用');
-        const rawConfig = await configManager.readRawConfigFile();
-        const models = Array.isArray(rawConfig.models) ? rawConfig.models : [];
-        model = models.find(m => m.isDefault) || models[0];
-      } catch (err) {
-        send({ type: 'error', error: '读取 AI 配置失败: ' + err.message });
-        finished = true;
-        return res.end();
-      }
-      if (!model) {
-        send({ type: 'error', error: '未配置 AI 模型' });
-        finished = true;
-        return res.end();
-      }
-
-      // 流式调用(messages 模式)
-      const { content, aborted } = await callLlmStream(
-        model,
-        session.messages,
-        (delta) => {
-          if (delta.thinking) send({ type: 'thinking', delta: delta.thinking });
-          if (delta.content) send({ type: 'content', delta: delta.content });
-        },
-        { maxTokens: 32000, timeoutMs: 600000, signal: abortController.signal }
-      );
-
-      if (aborted) {
-        session.updatedAt = nowIso();
-        await writeSessionFile(session.sessionId, session).catch(() => {});
-        enforceSessionsRetention().catch(() => {});
-        send({ type: 'error', error: '已取消' });
-        finished = true;
-        return res.end();
-      }
-
-      // 解析 + 写盘
-      const { parsed, parseError, parseStage } = parseSubtaskJson(content);
-      const subtasks = Array.isArray(parsed?.subtasks)
-        ? parsed.subtasks
-            .map(s => ({
-              title: String(s?.title || '').trim(),
-              desc: String(s?.desc || '').trim()
-            }))
-            .filter(s => s.title)
-        : [];
-
-      session.messages.push({ role: 'assistant', content });
-      session.latestSubtasks = subtasks;
-      session.latestRaw = content;
-      session.latestParseStage = parseStage;
-      session.updatedAt = nowIso();
-      await writeSessionFile(session.sessionId, session);
-      enforceSessionsRetention().catch(() => {});
-
-      send({ type: 'done', subtasks, raw: content, parseError, parseStage });
-      finished = true;
-      res.end();
-    } catch (err) {
-      send({ type: 'error', error: '对话拆分失败: ' + (err?.message || String(err)) });
-      finished = true;
-      res.end();
-    }
-  });
-
-  // GET /api/workbench/tasks/ai-chat-sessions
-  //   →   { success, sessions: [{ sessionId, title, taskId, createdAt, updatedAt, messageCount, latestSubtaskCount, size }] }
-  // 列表只读 metadata,启动时无需预加载
-  app.get('/api/workbench/tasks/ai-chat-sessions', async (_req, res) => {
-    try {
-      const sessions = await listSessionsMeta();
-      res.json({ success: true, sessions });
-    } catch (err) {
-      res.status(500).json({ success: false, error: err?.message || String(err) });
-    }
-  });
-
-  // GET /api/workbench/tasks/ai-chat-sessions/:sessionId
-  //   →   { success, session: { ...完整,含 messages } }
-  app.get('/api/workbench/tasks/ai-chat-sessions/:sessionId', async (req, res) => {
-    try {
-      const session = await readSessionFile(req.params.sessionId);
-      res.json({ success: true, session });
-    } catch (err) {
-      const code = err.statusCode || 500;
-      res.status(code).json({ success: false, error: err.message });
-    }
-  });
-
-  // DELETE /api/workbench/tasks/ai-chat-sessions/:sessionId
-  //   →   { success: true }  (硬删文件)
-  app.delete('/api/workbench/tasks/ai-chat-sessions/:sessionId', async (req, res) => {
-    try {
-      await deleteSessionFile(req.params.sessionId);
-      res.json({ success: true });
-    } catch (err) {
-      const code = err.statusCode || 500;
-      res.status(code).json({ success: false, error: err.message });
-    }
-  });
-
-  // SSE 事件流
-  app.get('/api/workbench/events', (req, res) => {
-    res.set({
-      'Content-Type': 'text/event-stream',
-      'Cache-Control': 'no-cache, no-transform',
-      'Connection': 'keep-alive',
-      'X-Accel-Buffering': 'no'
-    });
-    res.flushHeaders?.();
-    const send = (data) => {
-      res.write(`data: ${JSON.stringify(data)}\n\n`);
-    };
-    // 初始快照
-    send({ event: 'hello', payload: { jobs: snapshotJobs() }, ts: nowIso() });
-    const handler = (evt) => send(evt);
-    bus.on('event', handler);
-    const ka = setInterval(() => res.write(`: keep-alive\n\n`), 15000);
-    req.on('close', () => {
-      clearInterval(ka);
-      bus.off('event', handler);
-    });
-  });
-
-  // ── 提示词 CRUD ─────────────────────────────────────────────────────
-  app.get('/api/workbench/prompts', async (_req, res) => {
-    try {
-      const data = await readJson(PROMPTS_FILE, { prompts: [] });
-      res.json({ success: true, prompts: data.prompts || [] });
-    } catch (err) {
-      res.status(500).json({ success: false, error: err.message });
-    }
-  });
-
-  app.post('/api/workbench/prompts', async (req, res) => {
-    try {
-      const { id, name, content, projectPath } = req.body || {};
-      if (!name || typeof content !== 'string') {
-        return res.status(400).json({ success: false, error: 'name 和 content 必填' });
-      }
-      const data = await readJson(PROMPTS_FILE, { prompts: [] });
-      const prompts = data.prompts || [];
-      const now = nowIso();
-      // projectPath 规范化:undefined / '' / 非法类型 → '' (全局)
-      // 留空字符串 = 全局提示词(所有项目都能看到);非空 = 归属具体项目
-      const normalizedProjectPath = typeof projectPath === 'string' ? projectPath.trim() : '';
-      if (id) {
-        const i = prompts.findIndex(p => p.id === id);
-        if (i < 0) return res.status(404).json({ success: false, error: '提示词不存在' });
-        prompts[i] = {
-          ...prompts[i],
-          name,
-          content,
-          projectPath: normalizedProjectPath,
-          updatedAt: now
-        };
-        await writeJson(PROMPTS_FILE, { prompts });
-        return res.json({ success: true, prompt: prompts[i] });
-      }
-      const prompt = {
-        id: genId(),
-        name,
-        content,
-        projectPath: normalizedProjectPath,
-        createdAt: now,
-        updatedAt: now
-      };
-      prompts.push(prompt);
-      await writeJson(PROMPTS_FILE, { prompts });
-      res.json({ success: true, prompt });
-    } catch (err) {
-      res.status(500).json({ success: false, error: err.message });
-    }
-  });
-
-  app.delete('/api/workbench/prompts/:id', async (req, res) => {
-    try {
-      const data = await readJson(PROMPTS_FILE, { prompts: [] });
-      const prompts = (data.prompts || []).filter(p => p.id !== req.params.id);
-      await writeJson(PROMPTS_FILE, { prompts });
-      res.json({ success: true });
-    } catch (err) {
-      res.status(500).json({ success: false, error: err.message });
-    }
-  });
-
-  // ── 任务 CRUD ───────────────────────────────────────────────────────
-  app.get('/api/workbench/tasks', async (_req, res) => {
-    try {
-      const data = await readJson(TASKS_FILE, { tasks: [] });
-      res.json({ success: true, tasks: data.tasks || [] });
-    } catch (err) {
-      res.status(500).json({ success: false, error: err.message });
-    }
-  });
-
-  // 当前选中的项目路径（侧边栏按项目分组时要用）
-  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 });
-    }
-  });
-
-  // 任务排序：拖动落盘。body: { orderedIds: string[], groupPath?: string }
-  // - orderedIds 是同组内所有任务的 id，按新顺序排列（必须完整，不能遗漏）
-  // - groupPath 标识目标分组（projectPath），后端据此做完整性校验
-  // - 仅重排该组任务的相对位置，其他组/其他任务保持原位
-  // - 成功后 publish('tasks:reordered', { tasks: 新顺序数组 }) 给所有 SSE 客户端。
-  app.put('/api/workbench/tasks/reorder', async (req, res) => {
-    try {
-      const orderedIds = Array.isArray(req.body && req.body.orderedIds) ? req.body.orderedIds : null;
-      const groupPath = typeof (req.body && req.body.groupPath) === 'string' ? req.body.groupPath.trim() || null : null;
-      if (!orderedIds || orderedIds.length === 0) {
-        return res.status(400).json({ success: false, error: 'orderedIds 不能为空' });
-      }
-      if (!orderedIds.every((x) => typeof x === 'string' && x.length > 0)) {
-        return res.status(400).json({ success: false, error: 'orderedIds 必须是字符串数组' });
-      }
-      if (new Set(orderedIds).size !== orderedIds.length) {
-        return res.status(400).json({ success: false, error: 'orderedIds 包含重复 id' });
-      }
-      const data = await readJson(TASKS_FILE, { tasks: [] });
-      const tasks = data.tasks || [];
-      const idIndex = new Map();
-      for (let i = 0; i < tasks.length; i++) idIndex.set(tasks[i].id, i);
-      const missing = orderedIds.filter((id) => !idIndex.has(id));
-      if (missing.length > 0) {
-        return res.status(400).json({ success: false, error: `id 不存在: ${missing.slice(0, 3).join(',')}` });
-      }
-
-      // 如果传了 groupPath，校验 orderedIds 是否完整包含了该组的所有任务
-      if (groupPath) {
-        const groupKey = groupPath || '__no_project__';
-        const groupTasks = tasks.filter(t => ((t.projectPath || '').trim() || '__no_project__') === groupKey);
-        if (groupTasks.length > 0 && orderedIds.length !== groupTasks.length) {
-          return res.status(400).json({
-            success: false,
-            error: `orderedIds 不完整：该组有 ${groupTasks.length} 个任务，但只传了 ${orderedIds.length} 个 id`
-          });
-        }
-        // 额外校验：所有 orderedIds 确实都属于该组
-        const nonGroupIds = orderedIds.filter(id => {
-          const t = tasks.find(x => x.id === id);
-          return !t || ((t.projectPath || '').trim() || '__no_project__') !== groupKey;
-        });
-        if (nonGroupIds.length > 0) {
-          return res.status(400).json({
-            success: false,
-            error: `以下 id 不属于指定分组: ${nonGroupIds.slice(0, 3).join(',')}`
-          });
-        }
-      }
-
-      // 安全的重排算法：用 Map 按序取，确保每个 orderedId 对应的 task 都被保留
-      const orderedSet = new Set(orderedIds);
-      const byId = new Map(tasks.map(t => [t.id, t]));
-      const reordered = [];
-      let ptr = 0;
-      for (const t of tasks) {
-        if (orderedSet.has(t.id)) {
-          // 用 ptr 从 orderedIds 取下一个 id，从 byId 查找对应 task
-          if (ptr < orderedIds.length) {
-            const target = byId.get(orderedIds[ptr++]);
-            if (target) {
-              reordered.push(target);
-              continue; // 成功匹配，跳过下面的 fallback
-            }
-          }
-          // fallback：如果有序列错乱导致没匹配上，仍保留原 task（防御性）
-          reordered.push(t);
-        } else {
-          reordered.push(t);
-        }
-      }
-      // 最终校验：输出数量必须等于输入数量（绝对不能丢任务）
-      if (reordered.length !== tasks.length) {
-        console.error('[reorder] 数据丢失风险！原始 %d 个，重排后 %d 个', tasks.length, reordered.length);
-        return res.status(500).json({ success: false, error: '内部错误：重排结果数量不一致' });
-      }
-      data.tasks = reordered;
-      await writeJson(TASKS_FILE, data);
-      publish('tasks:reordered', { tasks: reordered });
-      res.json({ success: true, tasks: reordered });
-    } 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, type: rawType, simpleOverride, sequential: rawSequential } = req.body || {};
-      // title 非必填：允许空字符串，UI 层会用"未命名任务"占位
-      const safeTitle = typeof title === 'string' ? title.trim() : '';
-      // type 归一化:仅接受 'simple' | 'complex'，缺省/未知一律按 complex
-      const taskType = rawType === 'simple' ? 'simple' : 'complex';
-      // sequential 归一化：仅接受 boolean，缺省/非布尔一律 true（连续模式），
-      // 旧任务没字段时也是 true，保留连续默认行为
-      const sequential = rawSequential === false ? false : true;
-      const safeOverride = typeof simpleOverride === 'string' ? simpleOverride.slice(0, 8000) : '';
-      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: '任务不存在' });
-        tasks[i] = {
-          ...tasks[i],
-          title: safeTitle,
-          desc: desc || '',
-          promptId: promptId || null,
-          type: taskType,
-          // 复杂任务可显式关闭连续模式；简单任务无意义，固定 true
-          sequential: taskType === 'complex' ? sequential : true,
-          simpleOverride: taskType === 'simple' ? safeOverride : '',
-          subtasks: Array.isArray(subtasks) ? subtasks.map(s => ({
-            id: s.id || genId(),
-            title: s.title || '',
-            desc: s.desc || '',
-            status: s.status || 'todo',
-            promptOverride: s.promptOverride || '',
-            // 保留失败信息：编辑已 error 的 sub 时不能丢 context，否则 hover popover 看不到原因
-            error: typeof s.error === 'string' ? s.error : undefined,
-            errorAt: typeof s.errorAt === 'string' ? s.errorAt : undefined,
-            // 保留附件元数据（仅保留基础字段，丢弃客户端临时字段）
-            attachments: Array.isArray(s.attachments) ? s.attachments.map(a => ({
-              id: a.id,
-              originalName: a.originalName,
-              mimeType: a.mimeType,
-              size: a.size,
-              ext: a.ext,
-              storedName: a.storedName,
-              absolutePath: a.absolutePath,
-              createdAt: a.createdAt
-            })) : (tasks[i].subtasks.find(x => x.id === s.id)?.attachments || [])
-          })) : tasks[i].subtasks,
-          updatedAt: now
-        };
-        await writeJson(TASKS_FILE, { tasks });
-        return res.json({ success: true, task: tasks[i] });
-      }
-      const task = {
-        id: genId(),
-        title: safeTitle,
-        desc: desc || '',
-        promptId: promptId || null,
-        type: taskType,
-        // 新建任务：简单任务固定 true，复杂任务用传入值（默认 true）
-        sequential: taskType === 'complex' ? sequential : true,
-        simpleOverride: taskType === 'simple' ? safeOverride : '',
-        projectPath: currentProjectPath || '',
-        subtasks: Array.isArray(subtasks) ? subtasks.map(s => ({
-          id: s.id || genId(),
-          title: s.title || '',
-          desc: s.desc || '',
-          status: s.status || 'todo',
-          promptOverride: s.promptOverride || '',
-          error: typeof s.error === 'string' ? s.error : undefined,
-          errorAt: typeof s.errorAt === 'string' ? s.errorAt : undefined,
-          attachments: Array.isArray(s.attachments) ? s.attachments : []
-        })) : [],
-        status: 'todo',
-        createdAt: now,
-        updatedAt: now
-      };
-      tasks.push(task);
-      await writeJson(TASKS_FILE, { tasks });
-      res.json({ success: true, task });
-    } catch (err) {
-      res.status(500).json({ success: false, error: err.message });
-    }
-  });
-
-  // DELETE /api/workbench/tasks/:id
-  // 行为：
-  //   - 该 task 下有 running/pending 的 job 时拒绝（避免误杀正在跑的实例）
-  //   - 同步清理磁盘上的图片/附件目录，避免孤儿文件:
-  //     1) 主任务附件 IMAGES_DIR/_task-<id>/
-  //     2) 每个子任务附件 IMAGES_DIR/<subId>/
-  //   - 从 tasks.json 中删除 task 条目
-  // 前端 sidebar 已用 v-if="!taskIsRunning(t)" 隐藏执行中的删除按钮,这里兜底
-  // 防 DevTools / curl / 第三方脚本绕过。
-  app.delete('/api/workbench/tasks/:id', async (req, res) => {
-    try {
-      const taskId = req.params.id;
-      const data = await readJson(TASKS_FILE, { tasks: [] });
-      const allTasks = data.tasks || [];
-      const task = allTasks.find(t => t.id === taskId);
-      if (!task) return res.status(404).json({ success: false, error: '任务不存在' });
-
-      // 1) 检查活跃 job —— 有 running/pending 直接拒绝
-      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 正在执行,请先停止` });
-      }
-
-      // 2) 清理磁盘上的图片目录(force: true 让目录不存在也不抛错)
-      //    失败只 warn 不阻断 —— 元数据删除优先,孤儿文件是次要问题
-      try {
-        await fsp.rm(path.join(IMAGES_DIR, '_task-' + taskId), { recursive: true, force: true });
-      } catch (e) {
-        console.warn(`[workbench] failed to remove task image dir for ${taskId}:`, e.message);
-      }
-      if (Array.isArray(task.subtasks)) {
-        for (const sub of task.subtasks) {
-          if (!sub || !sub.id) continue;
-          try {
-            await fsp.rm(path.join(IMAGES_DIR, sub.id), { recursive: true, force: true });
-          } catch (e) {
-            console.warn(`[workbench] failed to remove sub image dir for ${sub.id}:`, e.message);
-          }
-        }
-      }
-
-      // 3) 从 tasks.json 中删除
-      const tasks = allTasks.filter(t => t.id !== taskId);
-      await writeJson(TASKS_FILE, { tasks });
-      res.json({ success: true });
-    } catch (err) {
-      res.status(500).json({ success: false, error: err.message });
-    }
-  });
-
-  // ── 执行任务 ────────────────────────────────────────────────────────
-  app.post('/api/workbench/tasks/:id/run', 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 repoPath = typeof getCurrentProjectPath === 'function' ? getCurrentProjectPath() : '';
-      // 异步执行，立即返回
-      res.json({ success: true, message: '已开始执行' });
-      runTaskQueue(task, 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/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
-  // 行为：
-  //   - 适用于 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 断了也能拉） ────────────────────────────
-  // 合并内存 jobs Map（当前进程的活跃 job）+ jobs.json 落盘历史。
-  // 之前只走 snapshotJobs()：进程重启后内存清空，新开页签就看不到旧 job 的输出。
-  // WorkbenchView 在 onMounted 调一次，靠这个接口把历史 job 重新塞回 jobs.value，
-  // 才能用 jobOf(subId) 找到对应记录渲染 JobLogDetails。
-  // 文件里的字段已经是落盘时 serialize 过的精简形态，跟 snapshotJobs() 同 schema，
-  // 直接合并即可，不需要再走 serializeJob 补 taskTitle/subTitle（WorkbenchView 不用）。
-  app.get('/api/workbench/jobs', async (_req, res) => {
-    try {
-      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 = snapshotJobs().filter(j => !fileIds.has(j.id))
-      res.json({ success: true, jobs: [...fileJobs, ...liveOnly] })
-    } catch (err) {
-      // 读取失败兜底：只返内存的，UI 至少能看到当前活跃 job
-      res.json({ success: true, jobs: snapshotJobs() })
-    }
-  });
-
-  // ── 取消正在执行的 job ───────────────────────────────────────────
-  // POST /api/workbench/jobs/:id/cancel
-  // 行为：
-  //   - 找到正在运行的 job，调 child.kill() 终止 claude 进程
-  //   - Windows 下用 taskkill /T /F 杀进程树（claude 进程可能 fork 出子进程）
-  //   - 加入 cancelledJobs 集合，runTaskQueue 退出循环后会把 job 标为 'cancelled'
-  //   - 同步把 sub.status 改为 'cancelled' 并 publish sub:update，
-  //     否则前端 sub 列表/任务头黄点会一直显示 running（sub.status 没动）。
-  //     历史这里只改 job.status 导致 UI 误显示「执行中」。
-  //   - 只影响这一个 sub；同 task 后续 sub 在 sequential=false 时继续执行，
-  //     sequential=true 时由 runTaskQueue 自然 break（见 runSingleSubtask 的 cancelled 分支）
-  app.post('/api/workbench/jobs/:id/cancel', (req, res) => {
-    const job = jobs.get(req.params.id)
-    if (!job) {
-      return res.status(404).json({ success: false, error: 'job 不存在' })
-    }
-    if (job.status !== 'running' && job.status !== 'pending') {
-      return res.status(400).json({ success: false, error: `当前状态 ${job.status} 不可取消` })
-    }
-    cancelledJobs.add(job.id)
-    // 立即给前端一个状态反馈（不等 child 真正退出）
-    job.status = 'cancelled'
-    job.error = '用户已停止执行'
-    job.endedAt = nowIso()
-    publish('job:update', { ...job }) // 用浅拷贝避免序列化 child 引用
-    // 同步把 sub 也置 cancelled，否则 taskIsRunning(sub.status==='running') 一直 true
-    // → 左侧任务头黄点 + 右侧 sub 列表 running 动效都不消失
-    const subInfo = syncSubToCancelled(job)
-    // 终态：fire-and-forget 同步落盘，cancel 是显式操作，要保证不丢
-    flushJobsSaveNow().catch(err => logger.warn('[workbench] jobs save failed:', err.message))
-    const child = job.child
-    if (!child) {
-      return res.json({ success: true, message: '已标记取消，进程将尽快结束' })
-    }
-    try {
-      if (process.platform === 'win32') {
-        // Windows: child.kill(SIGTERM) 经常无效，用 taskkill 杀进程树
-        execFile('taskkill', ['/PID', String(child.pid), '/T', '/F'], (err) => {
-          if (err) {
-            logger.warn(`[workbench] taskkill ${child.pid} 失败:`, err.message)
-          }
-        })
-      } else {
-        child.kill('SIGTERM')
-      }
-      res.json({ success: true, message: '已发送停止信号' })
-    } catch (err) {
-      cancelledJobs.delete(job.id)
-      res.status(500).json({ success: false, error: '发送停止信号失败: ' + err.message })
-    }
-  });
-
-  // ── 续接简单任务对话 ────────────────────────────────────────────
-  // POST /api/workbench/jobs/:id/continue
-  // 入参 body: { userMessage: string, attachments?: Attachment[] }
-  // 行为:
-  //   - 仅用于 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)时拒绝
-  //   - 附件处理(2026-06 改):
-  //     · 默认复用 task.attachments(claude --resume 上下文里已经看过这些图,
-  //       不重复推,节省 token)
-  //     · 前端可显式传 attachments 数组做"追加"(用户续聊时新增的图片)
-  //     · 透传到 virtualSub.attachments,继续走 runSingleSubtask 的拼装逻辑
-  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;
-      // 续接轮的 attachments:
-      //   - 前端显式传 attachments:用前端值(复用 task.attachments + 续聊时新增的)
-      //   - 前端没传:回退到 task.attachments(向后兼容)
-      // 注意:本轮 attachments 不写盘,只用于拼 prompt,claude --resume 上下文已看过
-      // 大部分图(默认复用的那些),真正"新加"的图是这次对话的关键信息。
-      const bodyAtts = req.body?.attachments;
-      const carryAtts = Array.isArray(bodyAtts) && bodyAtts.length > 0
-        ? bodyAtts
-        : (Array.isArray(task.attachments) ? task.attachments : []);
-      const virtualSub = {
-        id: `${task.id}__simple__r${nextRound}`,
-        title: `续接 #${nextRound}`,
-        desc: '',
-        status: 'todo',
-        // 用户输入的续接消息直接作为本轮 prompt(走 promptOverride,不再拼模板)
-        promptOverride: userMessage,
-        // 透传:复用 task 上已有附件 + 本轮新增(如果有)
-        attachments: carryAtts
-      };
-      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 匹配吞掉。
-  //
-  // 数据来源：
-  //   - 文件 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)) })
-    }
-  })
-
-  // DELETE /api/workbench/jobs/by-task/:taskId
-  // 重新执行任务前清空该 task 下的所有旧 job(内存 + 文件双写)。
-  // 不清活跃的 running/pending,避免误杀正在跑的实例;前端启动新 run 时
-  // 应确认旧任务已结束,或在活跃态时拒绝调用本接口。
-  // ?keepDone=true 时只清 non-done 的 job(保留 done 历史的日志),用于
-  // "只跑未完成" 场景——避免偷偷清掉 done sub 的日志,让前端 jobOf(subId)
-  // 在新页签上还能找到。
-  app.delete('/api/workbench/jobs/by-task/:taskId', async (req, res) => {
-    try {
-      const taskId = req.params.taskId
-      if (!taskId) return res.status(400).json({ success: false, error: '缺少 taskId' })
-      const keepDone = String(req.query.keepDone || '').toLowerCase() === 'true'
-      const ids = []
-      for (const j of jobs.values()) {
-        if (j.taskId !== taskId) continue
-        if (j.status === 'running' || j.status === 'pending') continue
-        if (keepDone && j.status === 'done') continue
-        jobs.delete(j.id)
-        ids.push(j.id)
-      }
-      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 => {
-          if (j.taskId !== taskId) return true
-          if (keepDone && j.status === 'done') return true
-          return !ids.includes(j.id)
-        })
-        const removed = before - data.jobs.length
-        if (removed > 0) await writeJson(JOBS_FILE, data)
-        return res.json({ success: true, removed: ids.length + removed, ids })
-      }
-      res.json({ success: true, removed: ids.length, ids })
-    } catch (err) {
-      res.status(500).json({ success: false, error: '按 task 清空失败: ' + (err.message || String(err)) })
-    }
-  })
-
-  // 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)) })
-    }
-  })
-
-  // POST /api/workbench/tasks/:id/clear-subtasks
-  // 只清空 subtasks 数组(及关联的 jobs),保留 desc / attachments / promptId / projectPath。
-  // 与 reset-shell 的区别:reset-shell 把任务还原成只有标题的空壳,这个只删拆分结果。
-  // 活跃 job 拒绝,避免误杀正在跑的实例。
-  app.post('/api/workbench/tasks/:id/clear-subtasks', async (req, res) => {
-    try {
-      const taskId = req.params.id
-      if (!taskId) return res.status(400).json({ success: false, error: '缺少 taskId' })
-      // 1) 检查活跃 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 正在执行,请先停止` })
-      }
-      // 2) 清空该 task 的所有 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)
-      }
-      // 3) 更新 task:只清 subtasks,其他字段(尤其 desc / attachments / promptId)保留
-      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, removedSubs: 0, message: '任务不存在,仅清空 job' })
-      }
-      const removedSubCount = Array.isArray(task.subtasks) ? task.subtasks.length : 0
-      if (removedSubCount === 0) {
-        return res.json({ success: true, removedJobs: removedJobIds.length, removedSubs: 0, message: '没有子任务需要清空' })
-      }
-      task.subtasks = []
-      task.updatedAt = nowIso()
-      await writeJson(TASKS_FILE, tasksData)
-      publish('task:update', task)
-      res.json({
-        success: true,
-        removedJobs: removedJobIds.length,
-        removedSubs: removedSubCount,
-        message: `已清空 ${removedSubCount} 个子任务,任务描述和附件保留`
-      })
-    } 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
-  //   body:   raw binary
-  // 删除：DELETE /api/workbench/subtasks/:subId/attachments/:attId
-  // 列表：GET    /api/workbench/subtasks/:subId/attachments
-  //
-  // 文件存到 ~/.zen-gitsync/workbench-images/{subId}/{attId}.{ext}
-  // 元数据（id / originalName / mime / size / storedName）通过 sub.attachments
-  // 跟随 tasks.json 一起持久化。
-  const rawAttachment = express.raw({
-    type: '*/*',
-    limit: MAX_IMAGE_BYTES * 4 // 整体路由上限 20MB；单文件大小由业务再卡
-  });
-
-  // 共享 helper：找到一个 attachment 所在的位置（task 主附件 或 sub 附件）
-  // 返回 { owner, task, sub?, list, att, storageDir } 或 null
-  async function findAttachmentLocation(attId) {
-    const data = await readJson(TASKS_FILE, { tasks: [] });
-    for (const t of data.tasks || []) {
-      const list = Array.isArray(t.attachments) ? t.attachments : [];
-      const att = list.find(x => x.id === attId);
-      if (att) {
-        return { owner: 'task', task: t, list, att, storageDir: path.join(IMAGES_DIR, '_task-' + t.id) };
-      }
-    }
-    for (const t of data.tasks || []) {
-      for (const s of t.subtasks || []) {
-        const list = Array.isArray(s.attachments) ? s.attachments : [];
-        const att = list.find(x => x.id === attId);
-        if (att) {
-          return { owner: 'sub', task: t, sub: s, list, att, storageDir: path.join(IMAGES_DIR, s.id) };
-        }
-      }
-    }
-    return null;
-  }
-
-  // 共享 helper：写入新附件（参数化以支持 task / sub）
-  async function writeAttachmentTo({ req, target, maxCount }) {
-    if (!req.body || !(req.body instanceof Buffer) || req.body.length === 0) {
-      return { error: '请求体为空', status: 400 };
-    }
-    if (req.body.length > MAX_IMAGE_BYTES) {
-      return { error: `单文件不得超过 ${MAX_IMAGE_BYTES / 1024 / 1024}MB`, status: 413 };
-    }
-    const originalName = String(req.get('X-Original-Name') || 'attachment').slice(0, 200);
-    const mimeType = String(req.get('X-Mime-Type') || 'application/octet-stream').slice(0, 120);
-    const ext = resolveExt({ originalName, mime: mimeType });
-    if (!ext) {
-      return { error: `不支持的文件类型（仅允许 ${[...ALLOWED_EXTS].join(', ')}）`, status: 400 };
-    }
-    if (!Array.isArray(target.attachments)) target.attachments = [];
-    if (target.attachments.length >= maxCount) {
-      return { error: `附件已达上限 ${maxCount} 个`, status: 400 };
-    }
-
-    const attId = genId();
-    await fsp.mkdir(target.storageDir, { recursive: true });
-    const storedName = `${attId}.${ext}`;
-    const storedPath = path.join(target.storageDir, storedName);
-    await fsp.writeFile(storedPath, req.body);
-
-    const attachment = {
-      id: attId,
-      originalName,
-      mimeType,
-      size: req.body.length,
-      ext,
-      storedName,
-      absolutePath: storedPath,
-      createdAt: nowIso()
-    };
-    target.attachments.push(attachment);
-    target.updatedAt = nowIso();
-    return { attachment };
-  }
-
-  // 子任务附件
-  app.post('/api/workbench/subtasks/:subId/attachments', rawAttachment, async (req, res) => {
-    try {
-      const { subId } = req.params;
-      const data = await readJson(TASKS_FILE, { tasks: [] });
-      let foundSub = null;
-      for (const t of data.tasks || []) {
-        const s = (t.subtasks || []).find(x => x.id === subId);
-        if (s) { foundSub = s; break; }
-      }
-      if (!foundSub) {
-        return res.status(404).json({ success: false, error: '子任务不存在' });
-      }
-      const target = { ...foundSub, storageDir: path.join(IMAGES_DIR, subId) };
-      const result = await writeAttachmentTo({ req, target, maxCount: MAX_ATTACHMENTS_PER_SUBTASK });
-      if (result.error) return res.status(result.status).json({ success: false, error: result.error });
-      // target 是 spread 出来的浅拷贝，data 引用里的 foundSub 没改；显式 push 回去
-      const att = result.attachment;
-      foundSub.attachments = Array.isArray(foundSub.attachments) ? foundSub.attachments : [];
-      foundSub.attachments.push(att);
-      foundSub.updatedAt = nowIso();
-      await writeJson(TASKS_FILE, data);
-      res.json({ success: true, attachment: att });
-    } catch (err) {
-      res.status(500).json({ success: false, error: err.message });
-    }
-  });
-
-  app.delete('/api/workbench/subtasks/:subId/attachments/:attId', async (req, res) => {
-    try {
-      const { subId, attId } = req.params;
-      const data = await readJson(TASKS_FILE, { tasks: [] });
-      let foundSub = null;
-      for (const t of data.tasks || []) {
-        const s = (t.subtasks || []).find(x => x.id === subId);
-        if (s) { foundSub = s; break; }
-      }
-      if (!foundSub) return res.status(404).json({ success: false, error: '子任务不存在' });
-      const list = Array.isArray(foundSub.attachments) ? foundSub.attachments : [];
-      const i = list.findIndex(a => a.id === attId);
-      if (i < 0) return res.status(404).json({ success: false, error: '附件不存在' });
-      const [removed] = list.splice(i, 1);
-      try {
-        await fsp.unlink(path.join(IMAGES_DIR, subId, removed.storedName));
-      } catch { /* 文件可能已不存在 */ }
-      foundSub.updatedAt = nowIso();
-      await writeJson(TASKS_FILE, data);
-      res.json({ success: true });
-    } catch (err) {
-      res.status(500).json({ success: false, error: err.message });
-    }
-  });
-
-  // 主任务附件
-  app.post('/api/workbench/tasks/:taskId/attachments', rawAttachment, async (req, res) => {
-    try {
-      const { taskId } = req.params;
-      const data = await readJson(TASKS_FILE, { tasks: [] });
-      const task = (data.tasks || []).find(t => t.id === taskId);
-      if (!task) return res.status(404).json({ success: false, error: '任务不存在' });
-      const target = { ...task, storageDir: path.join(IMAGES_DIR, '_task-' + taskId) };
-      const result = await writeAttachmentTo({ req, target, maxCount: MAX_ATTACHMENTS_PER_SUBTASK });
-      if (result.error) return res.status(result.status).json({ success: false, error: result.error });
-      const att = result.attachment;
-      task.attachments = Array.isArray(task.attachments) ? task.attachments : [];
-      task.attachments.push(att);
-      task.updatedAt = nowIso();
-      await writeJson(TASKS_FILE, data);
-      res.json({ success: true, attachment: att });
-    } catch (err) {
-      res.status(500).json({ success: false, error: err.message });
-    }
-  });
-
-  app.delete('/api/workbench/tasks/:taskId/attachments/:attId', async (req, res) => {
-    try {
-      const { taskId, attId } = req.params;
-      const data = await readJson(TASKS_FILE, { tasks: [] });
-      const task = (data.tasks || []).find(t => t.id === taskId);
-      if (!task) return res.status(404).json({ success: false, error: '任务不存在' });
-      const list = Array.isArray(task.attachments) ? task.attachments : [];
-      const i = list.findIndex(a => a.id === attId);
-      if (i < 0) return res.status(404).json({ success: false, error: '附件不存在' });
-      const [removed] = list.splice(i, 1);
-      try {
-        await fsp.unlink(path.join(IMAGES_DIR, '_task-' + taskId, removed.storedName));
-      } catch { /* 文件可能已不存在 */ }
-      task.updatedAt = nowIso();
-      await writeJson(TASKS_FILE, data);
-      res.json({ success: true });
-    } catch (err) {
-      res.status(500).json({ success: false, error: err.message });
-    }
-  });
+// 本文件原本是 3539 行的巨型文件（含所有顶层工具函数 + 45 个路由端点）。
+// 2026-06-29 已按业务域拆分到 ./workbench/ 子目录的 9 个模块：
+//   - shared.js          常量 + 通用工具 (nowIso, genId, readJson, writeJson, interpolate)
+//   - jsonParse.js       JSON 解析降级链 (parseSubtaskJson 等)
+//   - llmClient.js       LLM 客户端 (callLlmJson, callLlmStream)
+//   - projectScan.js     子项目识别 (findSubProjects, detectProjectManifest)
+//   - attachmentUtils.js 附件白名单 (sanitizeExt, resolveExt, MIME_TO_EXT)
+//   - sessionStore.js    AI 对话拆分会话持久化
+//   - instructionStore.js AI 指令读写
+//   - jobStore.js        jobs Map + bus + 持久化 + retention
+//   - taskRunner.js      任务执行引擎 (runTaskQueue, runSingleSubtask)
+//   - index.js           registerWorkbenchRoutes 入口聚合（45 个路由）
+//
+// 此处保留 re-export 是为了让 src/ui/server/index.js 的 import 路径不变。
 
-  // 附件原文件读取（前端 <img> 缩略图用）—— 支持 task 和 sub 两种归属
-  app.get('/api/workbench/attachments/:attId/raw', async (req, res) => {
-    try {
-      const { attId } = req.params;
-      const loc = await findAttachmentLocation(attId);
-      if (!loc) return res.status(404).json({ success: false, error: '附件不存在' });
-      const filePath = path.join(loc.storageDir, loc.att.storedName);
-      try {
-        const stat = await fsp.stat(filePath);
-        res.set('Content-Type', loc.att.mimeType || 'application/octet-stream');
-        res.set('Content-Length', String(stat.size));
-        res.set('Cache-Control', 'private, max-age=3600');
-        const stream = (await import('fs')).createReadStream(filePath);
-        stream.on('error', () => res.end());
-        stream.pipe(res);
-      } catch {
-        res.status(404).json({ success: false, error: '文件已丢失' });
-      }
-    } catch (err) {
-      res.status(500).json({ success: false, error: err.message });
-    }
-  });
-}
+export { registerWorkbenchRoutes } from './workbench/index.js';