zen-gitsync 2.17.10 → 2.17.11

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

@@ -12,17 +12,14 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 //
-// AI 指令文本持久化（生成指令 + 拆分子任务指令）。
-// 拆分自原 routes/workbench.js 57-158 行 + 958-998 行。
+// AI 指令文本持久化（生成项目架构说明的指令）。
+// 拆分自原 routes/workbench.js 57-158 行。
 //
-// 两个独立的指令文件：
-//   - ai-instruction.json         生成项目架构说明的指令
-//   - ai-subtask-instruction.json 拆分子任务的指令（支持 zh/en 多语言默认）
+// 指令文件：ai-instruction.json
 
 import fsp from 'fs/promises';
 import {
   INSTRUCTION_FILE,
-  SUBTASK_INSTRUCTION_FILE,
   ensureDataDir,
   nowIso,
 } from './shared.js';
@@ -47,91 +44,6 @@ export const DEFAULT_INSTRUCTION = `你是一名资深软件架构师。
 4. 语气专业、具体、面向接手这个项目的开发者。
 5. 只返回 JSON：{ "name": "项目名（建议：项目名+架构说明）", "summary": "架构说明正文" }。`;
 
-// ── 拆分子任务指令：默认系统指令（用户在 GUI 可编辑覆盖） ───────
-// 国际化：根据请求 Accept-Language 在 zh / en 之间选默认。
-// 中英两份都内置——用户保存到 ~/.zen-gitsync/ai-subtask-instruction.json 后覆盖。
-export 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 必须完整、合法、可解析。`;
-
-export 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 JSON in a \`\`\`json ... \`\`\` code block. Preceding analysis text is allowed, but the JSON must be complete, valid, and parseable.`;
-
-// 兼容旧引用：未保存指令文件时回退到 ZH 版本
-export const DEFAULT_SUBTASK_INSTRUCTION = DEFAULT_SUBTASK_INSTRUCTION_ZH;
-
-// 根据请求 Accept-Language 选默认（zh / en）
-export 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;
-}
-
 // ── 生成指令持久化（~/.zen-gitsync/ai-instruction.json） ───────
 export async function readInstruction() {
   try {
@@ -151,25 +63,3 @@ export async function writeInstruction(instruction) {
   await fsp.writeFile(tmp, JSON.stringify({ instruction: text, updatedAt: nowIso() }, null, 2), 'utf-8');
   await fsp.rename(tmp, INSTRUCTION_FILE);
 }
-
-// ── 拆分子任务指令持久化 ─────────────────────────────────────
-// 支持传入 req：根据 Accept-Language 选默认（zh/en）
-export 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);
-}
-
-export 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);
-}

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

@@ -159,11 +159,10 @@ export function mergedJobs() {
 let jobsSaveTimer = null;
 
 // 序列化 job 落盘：剥离 child 引用（ChildProcess 无法 JSON.stringify），
-// 反范式 taskTitle/subTitle 方便管理页直接读
+// 反范式 taskTitle 方便管理页直接读
 export function serializeJob(j, taskMap) {
   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;
   // size 是保留策略（maxSizeMB）的计价口径，工具调用也会占体积，必须算进去，
   // 否则一份全是工具流水的 job 会被当成"很小"而留下来。
   const toolCallsSize = Array.isArray(rest.toolCalls)
@@ -178,7 +177,6 @@ export function serializeJob(j, taskMap) {
   return {
     ...rest,
     taskTitle: t ? t.title : '',
-    subTitle: sub ? sub.title : '',
     size
   };
 }
@@ -195,7 +193,7 @@ export function scheduleJobsSave() {
 // 立即落盘（终态调用）：把 jobs Map 当前快照写到 jobs.json，然后跑 retention
 export async function flushJobsSaveNow() {
   if (jobsSaveTimer) { clearTimeout(jobsSaveTimer); jobsSaveTimer = null; }
-  // 读 tasks.json 给落盘 job 反范式 taskTitle/subTitle——父任务被删后管理页仍可读
+  // 读 tasks.json 给落盘 job 反范式 taskTitle——父任务被删后管理页仍可读
   const tasksData = await readJson(TASKS_FILE, { tasks: [] });
   const taskMap = new Map((tasksData.tasks || []).map(t => [t.id, t]));
   // **必须并上磁盘上的历史 job 再写**：别的 g ui 进程跑的记录不在本进程内存里,

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

@@ -95,7 +95,7 @@ const diskJob = (id, taskId, status, extra = {}) => ({
   ...extra,
 });
 
-const simpleTask = (id) => ({ id, title: id, type: 'simple', subtasks: [], projectPath: 'c:\\ws\\a' });
+const simpleTask = (id) => ({ id, title: id, type: 'simple', projectPath: 'c:\\ws\\a' });
 
 // ── 沙箱自检 ────────────────────────────────────────────────────────
 // 这条不是形式主义:DATA_DIR 一旦没落在沙箱里,下面每个用例都会去写用户真实的

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

@@ -12,19 +12,13 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 //
-// AI 拆分子任务 JSON 多级降级解析。
-// 拆分自原 routes/workbench.js 395-776 行。
+// 从 LLM 输出里抠 JSON 的两个纯函数。
 //
-// 模型经常会犯几类格式错：在 desc 里用 ASCII 双引号引用术语 / 末尾留尾随逗号 /
-// 输出被 token 上限截断导致代码块未闭合。直接 JSON.parse 一旦失败就会让前端的
-// "确认入库" 按钮永远是 (0)，用户看不到原因。这里按"越简单越优先"的顺序尝试：
-//   ① ```json``` 代码块 / ```any``` 代码块 / 第一个完整 { ... } 范围
-//   ② 把候选片段去掉尾随逗号 + 块/行注释 再 parse
-//   ③ 用括号深度扫描，从开头找一个语法平衡的 { ... } 子串
-//   ④ 启发式转义模型夹在字符串内部的未转义 ASCII 双引号
-// 任一步成功就返回 parsed，全部失败时返回最后一次 JSON.parse 的错误，
-// 用 parseStage 告知前端"模型输出哪一步崩了"，并把原始 raw 一并回传。
-
+// 模型经常把 JSON 包在 思考块、代码块或总结：{...}这类散文里，直接 JSON.parse 必崩。
+// 这里提供两级：
+//   ① stripThinkingBlocks —— 先剥掉 思考块 与代码块围栏
+//   ② extractFirstJsonObject —— 在剩下的文本里定位第一个「平衡花括号对象」
+// 上层的 llmClient 用它俩抠 JSON；抠不出来时由调用方决定怎么降级。
 // 剥离 LLM 输出的 思考块、```json``` 代码块围栏，以及首尾说明文字。
 // 原贪婪正则 /({[\s\S]*})/ 会把 思考块（内含未配对花括号或字符串）一起吞进 JSON.parse，
 // 在 DeepSeek 等会输出 推理链的模型上偶发 "Unterminated string in JSON"。
@@ -86,134 +80,3 @@ export function extractFirstJsonObject(content) {
   // 兜底：找不到平衡对象时返回原文（让上层 JSON.parse 报清晰错误）
   return s;
 }
-
-// 从字符串中提取首个语法平衡的 { ... } 子串。
-// 跟踪字符串字面量（含转义），避免把 desc 里的 } 当成结束。
-export 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 必崩。
-//
-// 启发式判断：扫描时若处于字符串中且遇到 "，往后看第一个非空白字符：
-//   - 是 , } ] : 或文本结尾 → 这是真闭合，正常退出字符串
-//   - 否则 → 是模型乱写的字面量引号，改写为 \" 并继续留在字符串里
-// 不依赖正则、不破坏已经转义的 \"，对嵌套 / 多行字符串都安全。
-export 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('');
-}
-
-// AI 拆分子任务 JSON 多级降级解析主入口。
-// 返回 { parsed, parseError, parseStage }：
-//   - parsed: 解析成功时的对象，失败时为 null
-//   - parseError: 失败时的错误信息
-//   - parseStage: 'empty' / '' (成功) / 'cleaned' / 'balanced' / 'reescaped' / 'failed'
-export function parseSubtaskJson(content) {
-  let src = String(content || '');
-  if (!src.trim()) {
-    return { parsed: null, parseError: '模型未返回任何内容', parseStage: 'empty' };
-  }
-
-  // 预处理：剥离 deepseek-r1 / QwQ 等模型在 content 前输出的 <think>...</think> 思考块
-  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'
-  };
-}

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

@@ -261,8 +261,7 @@ export async function clearInstructions() {
 /**
  * 正在执行的执行体清单（看板左栏「执行监控」用）。
  *
- * 一行 = 一个活跃 job（不是任务）：一个任务并行跑 3 个子任务就是三行，
- * 因为"谁在跑什么"只有到 job 粒度才说得清。job 只是执行进程，
+ * 一行 = 一个活跃 job（不是任务）：job 只是执行进程，
  * 所以文案上叫「执行」而不是「Agent」—— 不要把正在跑的 claude 进程
  * 渲染成一个并不存在的"智能体集群"。
  *
@@ -274,15 +273,12 @@ export function buildRunningAgents({ jobs = [], tasks = [] } = {}) {
     .filter(j => j && (j.status === 'running' || j.status === 'pending'))
     .map(j => {
       const task = taskMap.get(j.taskId) || null;
-      const subs = task && Array.isArray(task.subtasks) ? task.subtasks : [];
-      const sub = subs.find(s => s && s.id === j.subId) || null;
       const projectPath = (task && task.projectPath) || '';
       return {
         jobId: j.id,
         taskId: j.taskId || null,
         subId: j.subId || null,
         taskTitle: (task && task.title) || '',
-        subTitle: (sub && sub.title) || '',
         status: j.status,
         pid: j.pid || null,
         startedAt: j.startedAt || null,
@@ -317,14 +313,11 @@ export function buildActivityFeed({ jobs = [], tasks = [], instructions = [] } =
   for (const j of Array.isArray(jobs) ? jobs : []) {
     if (!j || !j.id) continue;
     const task = taskMap.get(j.taskId) || null;
-    const subs = task && Array.isArray(task.subtasks) ? task.subtasks : [];
-    const sub = subs.find(s => s && s.id === j.subId) || null;
     const base = {
       jobId: j.id,
       taskId: j.taskId || null,
       subId: j.subId || null,
       taskTitle: (task && task.title) || '',
-      subTitle: (sub && sub.title) || '',
       jobStatus: j.status || '',
       pid: j.pid || null,
       ...projectOf(task),

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

@@ -127,30 +127,17 @@ export function latestJob(jobsForTask) {
  * 把一个任务推导到看板的四列之一。纯函数，单测覆盖。
  *
  * 口径（按优先级，逐条短路）：
- *   1. 有 job 处于 running/pending，或子任务状态是 running → `doing`
- *   2. 有子任务且全部 done → `done`
- *   3. 有子任务但没全 done：
- *        - 动过（有 done 的子任务 / 执行过 / 有 error 的子任务）→ `todo`
- *        - 完全没动过 → `todo`
- *   4. 没子任务（简单任务，或还没拆分的复杂任务）：
- *        - 从没执行过 → `todo`
- *        - 最近一条 job 是 done → `done`；其余终态（error/cancelled）→ `todo`
+ *   1. 有 job 处于 running/pending → `doing`
+ *   2. 从没执行过 → `todo`
+ *   3. 最近一条 job 是 done → `done`；其余终态（error/cancelled）→ `todo`
  *
  * error/cancelled 不再单列：列表示任务是否仍待处理，错误是这一轮执行的结果，
  * 具体错误继续通过卡片标记和任务详情展示。
  */
 export function deriveTaskColumn(task, jobsForTask = []) {
-  const subs = Array.isArray(task && task.subtasks) ? task.subtasks : [];
   const jobs = Array.isArray(jobsForTask) ? jobsForTask : [];
 
   if (jobs.some(j => j && (j.status === 'running' || j.status === 'pending'))) return 'doing';
-  if (subs.some(s => s && s.status === 'running')) return 'doing';
-
-  if (subs.length > 0) {
-    const doneCount = subs.filter(s => s && s.status === 'done').length;
-    if (doneCount === subs.length) return 'done';
-    return 'todo';
-  }
 
   if (jobs.length === 0) return 'todo';
   const last = latestJob(jobs);
@@ -161,7 +148,7 @@ export function deriveTaskColumn(task, jobsForTask = []) {
 function emptyStats() {
   return {
     total: 0, todo: 0, doing: 0, done: 0,
-    progress: 0, runningJobs: 0, errorSubtasks: 0, lastActiveAt: null,
+    progress: 0, runningJobs: 0, lastActiveAt: null,
   };
 }
 
@@ -191,9 +178,6 @@ export function summarizeProjectTasks(tasks, jobs) {
     const column = deriveTaskColumn(t, jobsForTask);
     agg.total += 1;
     agg[column] += 1;
-    if (Array.isArray(t.subtasks)) {
-      agg.errorSubtasks += t.subtasks.filter(s => s && s.status === 'error').length;
-    }
     agg.lastActiveAt = laterOf(agg.lastActiveAt, t.updatedAt || t.createdAt);
     // 最后活跃时间也要把执行记录算进来：任务本身可能很久没改，但刚刚跑过
     for (const j of jobsForTask) {
@@ -316,26 +300,20 @@ export async function listProjects({
 
 /** 看板任务卡需要的精简字段（完整任务体在 /api/workbench/tasks，这里只给卡片用得到的） */
 export function decorateTaskForBoard(task, jobsForTask = []) {
-  const subs = Array.isArray(task && task.subtasks) ? task.subtasks : [];
   const jobs = Array.isArray(jobsForTask) ? jobsForTask : [];
   const last = latestJob(jobs);
   return {
     id: task.id,
     title: task.title || '',
     desc: task.desc || '',
-    type: task.type === 'simple' ? 'simple' : 'complex',
     projectPath: task.projectPath || '',
     column: deriveTaskColumn(task, jobs),
-    subtaskCount: subs.length,
-    subtaskDoneCount: subs.filter(s => s && s.status === 'done').length,
-    subtaskErrorCount: subs.filter(s => s && s.status === 'error').length,
     attachmentCount: Array.isArray(task.attachments) ? task.attachments.length : 0,
     runningJobs: jobs.filter(j => j && (j.status === 'running' || j.status === 'pending')).length,
     lastJobStatus: last ? last.status : null,
     // 最近一条 job 的结束时间 = 这张卡片"跑完"的时刻。
     // 看板的「已完成」列要按完成时间倒序排（最新完成的在最上边），而 updatedAt 撑不起这个排序：
-    // 简单任务的执行完成只写 jobs.json，tasks.json 里的 updatedAt 一直停在创建时间
-    //（见 taskRunner.persistTaskAfterRun —— 它只有复杂任务才走），
+    // 执行完成只写 jobs.json，tasks.json 里的 updatedAt 一直停在创建/编辑时间，
     // 于是十几张卡片的时间会全是创建时刻，"最新完成的"根本排不出来。
     lastJobEndedAt: last ? (last.endedAt || last.startedAt || null) : null,
     createdAt: task.createdAt || null,
@@ -368,7 +346,6 @@ export function trimJobForDetail(job) {
     id: job.id || '',
     subId: job.subId || '',
     title: job.title || '',
-    subTitle: job.subTitle || '',
     status: job.status || '',
     pid: typeof job.pid === 'number' ? job.pid : null,
     startedAt: job.startedAt || null,
@@ -384,7 +361,7 @@ export function trimJobForDetail(job) {
 /**
  * 组装单个任务的详情。纯函数，单测覆盖。
  *
- * @param {object} task           完整任务（含 subtasks / attachments）
+ * @param {object} task           完整任务（含 attachments）
  * @param {Array}  jobsForTask    属于该任务的 job（顺序不限，内部会按时间排）
  * @param {number} recentJobLimit 最多回带几条 job 明细（默认 10）
  * @returns {object|null}         task 缺失时返回 null，由路由转成 404