zen-gitsync 2.17.10 → 2.17.12

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

@@ -33,7 +33,6 @@ import {
 } from './projectRegistry.js';
 import { normalizeOrchestrator, buildActivityFeed, buildRunningAgents } from './orchestratorStore.js';
 
-const sub = (id, status) => ({ id, title: id, desc: '', status, promptOverride: '' });
 const job = (id, taskId, status, startedAt, endedAt = null) => ({
   id, taskId, subId: `${taskId}__${id}`, title: '', status, startedAt, endedAt,
 });
@@ -84,28 +83,25 @@ test('resolveTaskRepoPath 优先用任务自己的项目，空则回退当前项
 // ── 看板列推导 ──────────────────────────────────────────────────────
 
 test('deriveTaskColumn: 从没动过的任务在待处理', () => {
-  assert.equal(deriveTaskColumn({ subtasks: [] }, []), 'todo');
-  assert.equal(deriveTaskColumn({ subtasks: [sub('s1', 'todo')] }, []), 'todo');
+  assert.equal(deriveTaskColumn({}, []), 'todo');
 });
 
-test('deriveTaskColumn: 有 job 在跑或子任务 running 就是进行中', () => {
-  assert.equal(deriveTaskColumn({ subtasks: [] }, [job('j1', 't1', 'running', '2026-01-01T00:00:00Z')]), 'doing');
-  assert.equal(deriveTaskColumn({ subtasks: [] }, [job('j1', 't1', 'pending', '2026-01-01T00:00:00Z')]), 'doing');
-  assert.equal(deriveTaskColumn({ subtasks: [sub('s1', 'running')] }, []), 'doing');
+test('deriveTaskColumn: 有 job 在跑就是进行中', () => {
+  assert.equal(deriveTaskColumn({}, [job('j1', 't1', 'running', '2026-01-01T00:00:00Z')]), 'doing');
+  assert.equal(deriveTaskColumn({}, [job('j1', 't1', 'pending', '2026-01-01T00:00:00Z')]), 'doing');
 });
 
-test('deriveTaskColumn: 子任务全部完成才算已完成', () => {
-  assert.equal(deriveTaskColumn({ subtasks: [sub('s1', 'done'), sub('s2', 'done')] }, []), 'done');
-  // 一半完成 → 仍待处理，错误与进度由卡片标记展示
-  assert.equal(deriveTaskColumn({ subtasks: [sub('s1', 'done'), sub('s2', 'todo')] }, []), 'todo');
-  // 有子任务报错也算"需要人看一眼"
-  assert.equal(deriveTaskColumn({ subtasks: [sub('s1', 'error'), sub('s2', 'todo')] }, []), 'todo');
-});
-
-test('deriveTaskColumn: 无子任务的任务只能看执行记录', () => {
-  assert.equal(deriveTaskColumn({ subtasks: [], type: 'simple' }, [job('j1', 't1', 'done', '2026-01-01T00:00:00Z')]), 'done');
-  assert.equal(deriveTaskColumn({ subtasks: [], type: 'simple' }, [job('j1', 't1', 'cancelled', '2026-01-01T00:00:00Z')]), 'todo');
-  assert.equal(deriveTaskColumn({ subtasks: [], type: 'simple' }, [job('j1', 't1', 'error', '2026-01-01T00:00:00Z')]), 'todo');
+test('deriveTaskColumn: 看执行记录 —— 最近一条 done 才算已完成', () => {
+  assert.equal(deriveTaskColumn({}, [job('j1', 't1', 'done', '2026-01-01T00:00:00Z')]), 'done');
+  // 错误与取消都退回待处理：列表示任务是否仍待处理，错误是这一轮执行的结果
+  assert.equal(deriveTaskColumn({}, [job('j1', 't1', 'cancelled', '2026-01-01T00:00:00Z')]), 'todo');
+  assert.equal(deriveTaskColumn({}, [job('j1', 't1', 'error', '2026-01-01T00:00:00Z')]), 'todo');
+  // 最新一条失败、前面成功过 → 仍然待处理
+  const jobs = [
+    job('j1', 't1', 'done', '2026-01-01T00:00:00Z', '2026-01-01T00:01:00Z'),
+    job('j2', 't1', 'error', '2026-01-02T00:00:00Z', '2026-01-02T00:01:00Z'),
+  ];
+  assert.equal(deriveTaskColumn({}, jobs), 'todo');
 });
 
 test('latestJob 按 startedAt 取最新的一条', () => {
@@ -152,7 +148,7 @@ test('buildProjectEntries: 目录段大小写不同也是同一个项目（旧
   assert.equal(entries[0].name, 'xuze3');
   // 项目行只认这个 key 的任务，key 分叉会连带把任务计数拆到两行上去
   const stats = summarizeProjectTasks(
-    [{ id: 't1', projectPath: 'C:\\Users\\xuze3', subtasks: [] }],
+    [{ id: 't1', projectPath: 'C:\\Users\\xuze3' }],
     [],
   );
   assert.equal(stats.get('c:\\users\\xuze3').total, 1);
@@ -172,11 +168,11 @@ test('buildProjectEntries: 目录段大小写不同也是同一个项目（旧
 test('summarizeProjectTasks: 按项目汇总列数量、进度、活跃执行与最后活跃时间', () => {
   const tasks = [
     // A 项目：1 个已完成
-    { id: 'a1', projectPath: 'D:\\a', subtasks: [sub('a1s', 'done')], updatedAt: '2026-01-01T00:00:00Z' },
+    { id: 'a1', projectPath: 'D:\\a', updatedAt: '2026-01-01T00:00:00Z' },
     // A 项目：1 个在跑（job running）
-    { id: 'a2', projectPath: 'D:\\a', subtasks: [sub('a2s', 'running')], updatedAt: '2026-01-02T00:00:00Z' },
+    { id: 'a2', projectPath: 'D:\\a', updatedAt: '2026-01-02T00:00:00Z' },
     // B 项目：1 个待处理
-    { id: 'b1', projectPath: 'D:\\b', subtasks: [sub('b1s', 'todo')], updatedAt: '2026-01-03T00:00:00Z' },
+    { id: 'b1', projectPath: 'D:\\b', updatedAt: '2026-01-03T00:00:00Z' },
   ];
   const jobs = [
     job('j1', 'a2', 'running', '2026-01-04T00:00:00Z'),
@@ -204,15 +200,10 @@ test('summarizeProjectTasks: 按项目汇总列数量、进度、活跃执行与
 test('decorateTaskForBoard: 只回卡片需要的字段', () => {
   const card = decorateTaskForBoard({
     id: 't1', title: '标题', desc: '描述', projectPath: 'D:\\a',
-    subtasks: [sub('s1', 'done'), sub('s2', 'error')],
     attachments: [{ id: 'at1' }],
     createdAt: '2026-01-01T00:00:00Z', updatedAt: '2026-01-02T00:00:00Z',
   }, []);
   assert.equal(card.column, 'todo');
-  assert.equal(card.type, 'complex');
-  assert.equal(card.subtaskCount, 2);
-  assert.equal(card.subtaskDoneCount, 1);
-  assert.equal(card.subtaskErrorCount, 1);
   assert.equal(card.attachmentCount, 1);
   assert.equal(card.runningJobs, 0);
   // 没跑过就没有完成时间——看板「已完成」列的排序靠它，空值必须显式是 null
@@ -226,7 +217,7 @@ test('decorateTaskForBoard: lastJobEndedAt 取最近一条 job 的结束时间
     job('j2', 't1', 'done', '2026-01-03T00:00:00Z', '2026-01-03T00:20:00Z'),
     job('j3', 't1', 'error', '2026-01-02T00:00:00Z', '2026-01-02T00:05:00Z'),
   ];
-  const base = { id: 't1', title: '', desc: '', subtasks: [], createdAt: '2025-12-31T00:00:00Z' };
+  const base = { id: 't1', title: '', desc: '', createdAt: '2025-12-31T00:00:00Z' };
 
   // 只有 j2 是"最近"的，即使它的结束时间排在 startedAt 序里也是最后
   assert.equal(decorateTaskForBoard(base, jobs).lastJobEndedAt, '2026-01-03T00:20:00Z');
@@ -261,11 +252,7 @@ test('buildActivityFeed: job 起止合成两条记录，与人类指令一起按
     id: 'j1', taskId: 't1', subId: 's1', status: 'done', pid: 123,
     startedAt: '2026-01-01T00:00:00Z', endedAt: '2026-01-01T00:05:00Z', exitCode: 0,
   }];
-  const tasks = [{
-    id: 't1', projectPath: 'D:\\ws\\proj-a',
-    subtasks: [{ id: 's1', title: '子任务一', status: 'done' }],
-    title: '任务一',
-  }];
+  const tasks = [{ id: 't1', projectPath: 'D:\\ws\\proj-a', title: '任务一' }];
   const instructions = [{
     id: 'i1', text: '把这些重构一下', projectPath: 'D:\\ws\\proj-a',
     at: '2026-01-01T00:10:00Z', status: 'accepted',
@@ -275,7 +262,6 @@ test('buildActivityFeed: job 起止合成两条记录，与人类指令一起按
   assert.equal(feed.length, 3);
   assert.deepEqual(feed.map(r => r.kind), ['user', 'done', 'dispatch']);
   assert.equal(feed[1].taskTitle, '任务一');
-  assert.equal(feed[1].subTitle, '子任务一');
   assert.equal(feed[1].projectName, 'proj-a');
   assert.equal(feed[2].pid, 123);
   assert.equal(feed[0].instructionStatus, 'accepted');
@@ -287,7 +273,7 @@ test('buildActivityFeed: 指令带起来的起跑并进指令行，不再重复
     startedAt: '2026-01-01T00:00:01Z', endedAt: '2026-01-01T00:05:00Z',
   }];
   // 任务标题就是指令首行，所以派发行和指令行本来长得一模一样
-  const tasks = [{ id: 't1', title: '把这些重构一下', projectPath: 'D:\\ws\\proj-a', subtasks: [] }];
+  const tasks = [{ id: 't1', title: '把这些重构一下', projectPath: 'D:\\ws\\proj-a' }];
   const instructions = [{
     id: 'i1', text: '把这些重构一下', taskId: 't1', projectPath: 'D:\\ws\\proj-a',
     at: '2026-01-01T00:00:00Z', status: 'accepted',
@@ -304,7 +290,7 @@ test('buildActivityFeed: 只吸收指令后的首次起跑，手动重跑仍保
     { id: 'j1', taskId: 't1', status: 'done', startedAt: '2026-01-01T00:00:01Z', endedAt: '2026-01-01T00:05:00Z' },
     { id: 'j2', taskId: 't1', status: 'done', startedAt: '2026-01-01T00:10:00Z', endedAt: '2026-01-01T00:15:00Z' },
   ];
-  const tasks = [{ id: 't1', title: '跑一下', projectPath: 'D:\\ws\\proj-a', subtasks: [] }];
+  const tasks = [{ id: 't1', title: '跑一下', projectPath: 'D:\\ws\\proj-a' }];
   const instructions = [{
     id: 'i1', text: '跑一下', taskId: 't1', projectPath: 'D:\\ws\\proj-a',
     at: '2026-01-01T00:00:00Z', status: 'accepted',
@@ -318,7 +304,7 @@ test('buildActivityFeed: 只吸收指令后的首次起跑，手动重跑仍保
 test('buildActivityFeed: 指令还没跑起来时，起跑行照旧保留给别的 job', () => {
   // 指令建了任务但没执行（调度暂停）——此时该任务的任何起跑都不是它带起来的
   const jobs = [{ id: 'j1', taskId: 't1', status: 'done', startedAt: '2026-01-01T00:00:00Z', endedAt: '2026-01-01T00:05:00Z' }];
-  const tasks = [{ id: 't1', title: '手跑的', projectPath: 'D:\\a', subtasks: [] }];
+  const tasks = [{ id: 't1', title: '手跑的', projectPath: 'D:\\a' }];
   const instructions = [{
     id: 'i1', text: '手跑的', taskId: 't1', projectPath: 'D:\\a',
     at: '2026-01-01T00:20:00Z', status: 'created',
@@ -333,7 +319,7 @@ test('buildActivityFeed: 失败与取消分别落成 error / cancelled', () => {
     { id: 'j1', taskId: 't1', subId: 's1', status: 'error', startedAt: '2026-01-01T00:00:00Z', endedAt: '2026-01-01T00:01:00Z', error: 'boom' },
     { id: 'j2', taskId: 't1', subId: 's2', status: 'cancelled', startedAt: '2026-01-01T00:02:00Z', endedAt: '2026-01-01T00:03:00Z' },
   ];
-  const feed = buildActivityFeed({ jobs, tasks: [{ id: 't1', projectPath: 'D:\\a', subtasks: [] }] });
+  const feed = buildActivityFeed({ jobs, tasks: [{ id: 't1', projectPath: 'D:\\a' }] });
   const kinds = feed.map(r => r.kind);
   assert.ok(kinds.includes('error'));
   assert.ok(kinds.includes('cancelled'));
@@ -348,23 +334,18 @@ test('buildActivityFeed: 任务已被删除时仍能出记录（不留孤儿空
   assert.equal(feed[0].projectName, '');
 });
 
-test('buildRunningAgents: 只列活跃 job，到 job 粒度而不是任务粒度', () => {
-  const tasks = [{
-    id: 't1', projectPath: 'D:\\ws\\proj-a', subtasks: [
-      { id: 's1', title: '子任务一', status: 'running' },
-      { id: 's2', title: '子任务二', status: 'running' },
-    ],
-  }];
+test('buildRunningAgents: 只列活跃 job，按 startedAt 倒序', () => {
+  const tasks = [{ id: 't1', title: '任务一', projectPath: 'D:\\ws\\proj-a' }];
   const jobs = [
-    { id: 'j1', taskId: 't1', subId: 's1', status: 'running', pid: 111, startedAt: '2026-01-01T00:02:00Z' },
-    { id: 'j2', taskId: 't1', subId: 's2', status: 'pending', pid: 222, startedAt: '2026-01-01T00:01:00Z' },
-    { id: 'j3', taskId: 't1', subId: 's3', status: 'done', pid: 333, startedAt: '2026-01-01T00:00:00Z' },
+    { id: 'j1', taskId: 't1', subId: 't1__simple', status: 'running', pid: 111, startedAt: '2026-01-01T00:02:00Z' },
+    { id: 'j2', taskId: 't1', subId: 't1__simple__r1', status: 'pending', pid: 222, startedAt: '2026-01-01T00:01:00Z' },
+    { id: 'j3', taskId: 't1', subId: 't1__simple__r2', status: 'done', pid: 333, startedAt: '2026-01-01T00:00:00Z' },
   ];
   const running = buildRunningAgents({ jobs, tasks });
   assert.equal(running.length, 2);
   // 最新的排在前面
   assert.equal(running[0].jobId, 'j1');
-  assert.equal(running[0].subTitle, '子任务一');
+  assert.equal(running[0].taskTitle, '任务一');
   assert.equal(running[0].projectName, 'proj-a');
   assert.equal(running[1].status, 'pending');
 });
@@ -416,11 +397,7 @@ test('buildTaskDetail: 任务缺失返回 null（交路由转 404）', () => {
 });
 
 test('buildTaskDetail: lastJob 取最新一条，recentJobs 倒序且被限制条数', () => {
-  const task = {
-    id: 't1', title: '任务', desc: '', type: 'complex',
-    subtasks: [sub('s1', 'done'), sub('s2', 'running')],
-    attachments: [{ id: 'a1' }],
-  };
+  const task = { id: 't1', title: '任务', desc: '', attachments: [{ id: 'a1' }] };
   const jobs = [
     job('j1', 't1', 'done', '2026-01-01T00:00:00Z', '2026-01-01T00:01:00Z'),
     job('j3', 't1', 'running', '2026-01-01T00:02:00Z'),
@@ -439,7 +416,7 @@ test('buildTaskDetail: lastJob 取最新一条，recentJobs 倒序且被限制
 });
 
 test('buildTaskDetail: recentJobLimit 生效；无 job 时 lastJob 为 null 而不是抛错', () => {
-  const task = { id: 't2', title: '', desc: '', type: 'simple', subtasks: [] };
+  const task = { id: 't2', title: '', desc: '' };
   const jobs = [1, 2, 3, 4, 5, 6].map(i => job('j' + i, 't2', 'done', `2026-01-0${i}T00:00:00Z`));
   const d = buildTaskDetail(task, jobs, { recentJobLimit: 2 });
   assert.equal(d.recentJobs.length, 2);

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

@@ -79,7 +79,6 @@ function taskLineOf(p) {
   if (!s.total) return '任务: 无';
   const parts = [`待处理 ${s.todo || 0}`, `进行中 ${s.doing || 0}`, `已完成 ${s.done || 0}`];
   if (s.runningJobs > 0) parts.push(`正在执行 ${s.runningJobs}`);
-  if (s.errorSubtasks > 0) parts.push(`子任务报错 ${s.errorSubtasks}`);
   return `任务: ${parts.join(' / ')}`;
 }
 

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

@@ -42,7 +42,7 @@ function project(overrides = {}) {
     unstaged: 0,
     untracked: 0,
   };
-  const baseStats = { total: 0, todo: 0, doing: 0, done: 0, progress: 0, runningJobs: 0, errorSubtasks: 0 };
+  const baseStats = { total: 0, todo: 0, doing: 0, done: 0, progress: 0, runningJobs: 0 };
   const merged = {
     path: 'D:\\ws\\proj',
     key: 'd:\\ws\\proj',
@@ -112,10 +112,9 @@ test('非仓库 / 目录不存在 / 探测超时都能区分，不谎报成"干
 });
 
 test('任务进度按看板三列报出，无任务时说"无"', () => {
-  const withTasks = formatProjectList([project({ stats: { total: 9, todo: 1, doing: 2, done: 6, runningJobs: 1, errorSubtasks: 1 } })]);
+  const withTasks = formatProjectList([project({ stats: { total: 9, todo: 1, doing: 2, done: 6, runningJobs: 1 } })]);
   assert.match(withTasks, /待处理 1 \/ 进行中 2 \/ 已完成 6/);
   assert.match(withTasks, /正在执行 1/);
-  assert.match(withTasks, /子任务报错 1/);
 
   assert.match(formatProjectList([project()]), /任务: 无/);
 });

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

@@ -38,11 +38,6 @@ export const TASKS_FILE = path.join(DATA_DIR, 'tasks.json');
 export const CONFIG_FILE = path.join(DATA_DIR, 'config.json');
 export const IMAGES_DIR = path.join(DATA_DIR, 'workbench-images');
 export const INSTRUCTION_FILE = path.join(DATA_DIR, 'ai-instruction.json');
-export const SUBTASK_INSTRUCTION_FILE = path.join(DATA_DIR, 'ai-subtask-instruction.json');
-// AI 对话拆分会话存档：每个 sessionId 一个文件，重启可恢复多轮上下文
-export const SESSIONS_DIR = path.join(DATA_DIR, 'ai-split-sessions');
-export const MAX_SESSIONS = 100;     // 软上限，触发清理
-export const SESSIONS_KEEP = 50;     // 超过上限时保留最新 N 个
 // 执行日志持久化：jobs.json 是历史档案，jobs-config.json 是保留策略
 export const JOBS_FILE = path.join(DATA_DIR, 'jobs.json');
 export const JOBS_CONFIG_FILE = path.join(DATA_DIR, 'jobs-config.json');
@@ -82,7 +77,7 @@ export const MANIFEST_FILES = [
 // 真正需要小体积的是图片，由前端上传前压缩保证（见 useWorkbenchAttachments.ts），
 // 这里只做最后一道兜底，避免超大 body 把内存吃光。
 export const MAX_IMAGE_BYTES = 20 * 1024 * 1024;       // 单个附件最大 20MB
-export const MAX_ATTACHMENTS_PER_SUBTASK = 9;          // 一个子任务最多挂 9 个附件
+export const MAX_ATTACHMENTS_PER_TASK = 9;             // 一个任务最多挂 9 个附件
 
 // ── 时间 / ID 工具 ─────────────────────────────────────────
 export function nowIso() {
@@ -109,7 +104,7 @@ export async function readJson(file, fallback) {
   }
 }
 
-// 原子写：tmp + rename。避免半写状态被读到（与 sessionStore 一致）
+// 原子写：tmp + rename。避免半写状态被读到（与 jobStore 一致）
 export async function writeJson(file, data) {
   await ensureDataDir();
   const tmp = `${file}.tmp`;

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

@@ -23,12 +23,12 @@
 //   - launchClaudeInNewWindow(cwd, prompt, resumeSessionId)  spawn claude，返回 {pid, child}
 //   - launchOpencodeRun(cwd, prompt, resumeSessionId)        spawn opencode，返回 {pid, child}
 //   - normalizeTaskExecutor(value)                           非法值回落 'claude'
-//   - runTaskQueue(task, repoPath, branch, opts)             顺序执行 task.subtasks（opts.executor 透传）
-//   - runSingleSubtask(task, sub, repoPath, branch, priorOutputs, opts)  跑单个 sub
-//   - syncSubToCancelled(job)                                cancel 路径专用
-//   - persistTaskAfterRun(task)                              把 sub.status 落回 tasks.json
-//   - collectPriorOutputs(task, targetSub)                   收集前序 done sub 的输出
+//   - runSingleSubtask(task, sub, repoPath, branch, opts)    跑一次任务（sub 是运行载体，见下）
 //   - waitProcessExit(pid)                                   polling 等进程退出
+//
+// 关于 `sub`：任务不再有子任务，但执行器仍以一个「运行载体」对象作为入参 ——
+// 它携带本次要跑的 title / desc / promptOverride / attachments。路由层构造它，
+// 续聊时同一任务会造出新的载体（`{taskId}__simple__r1` 等），job.subId 记的就是它。
 
 import fs from 'fs';
 import path from 'path';
@@ -36,9 +36,7 @@ import { spawn, execFileSync } from 'child_process';
 import {
   logger,
   PROMPTS_FILE,
-  TASKS_FILE,
   readJson,
-  writeJson,
   nowIso,
   genId,
   interpolate,
@@ -49,8 +47,6 @@ import {
   jobs,
   cancelledJobs,
   publish,
-  snapshotJobs,
-  refreshJobsFromDisk,
   flushJobsSaveNow,
 } from './jobStore.js';
 
@@ -590,55 +586,13 @@ export function createOpencodeEventHandler(job, appendOutput, appendThinking, to
 }
 
 /**
- * 顺序执行一个任务下所有子任务；上一个结束再启动下一个。
- * 入参 fromIndex 指定从哪个 sub 开始(0-based,默认 0),用于"从此处开始"入口;
- * fromIndex>0 时,把 [0, fromIndex) 区间内已 done 的 sub 输出预填到 priorOutputs,
- * 这样后续 sub 仍能拿到前序上下文(跟单 sub 执行的语义保持一致)。
- *
- * 连续模式（默认）：任意 sub 终态非 done（cancelled / error）→ 整批停，后续 sub 保持 todo。
- * AI 拆出来的 sub 一般前后强依赖（前一步产出是后一步输入），出错就停下来让用户决策。
- * 关闭后回退旧行为：单个 sub 失败不影响后续 sub 继续跑。
- */
-export 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)
-    : [];
-  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, { executor: opts.executor });
-    // 逐 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 {object} task         任务对象
+ * @param {object} sub          本次运行载体：{ id, title, desc, promptOverride, attachments }
  * @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 走 --resume <id>，opencode 走 --session <id>。
@@ -646,9 +600,9 @@ export async function runTaskQueue(task, repoPath, branch, opts) {
  * @param {string} [options.executor]
  *        执行器 'claude' | 'opencode'。缺省回落 'claude'；路由层负责把
  *        "body 指定 > 配置默认"先解析好再传进来。
- * @returns {Promise<'done'|'cancelled'|'error'>} sub 的终态
+ * @returns {Promise<'done'|'cancelled'|'error'>} 本次运行的终态
  */
-export async function runSingleSubtask(task, sub, repoPath, branch, priorOutputs, options) {
+export async function runSingleSubtask(task, sub, repoPath, branch, options) {
   const opts = options || {};
   const resumeSessionId = opts.resumeSessionId || null;
   const executor = normalizeTaskExecutor(opts.executor);
@@ -662,28 +616,13 @@ export async function runSingleSubtask(task, sub, repoPath, branch, priorOutputs
     branch: branch || ''
   };
   const interpolated = interpolate(promptTemplate, ctx);
-  // 标题与描述可能逐字相同（派发建的简单任务就是），去重规则见 promptParts.js
+  // 标题与描述可能逐字相同（派发建的任务就是），去重规则见 promptParts.js
   let prompt = composePromptBody(interpolated, sub.title, sub.desc);
 
-  // ── 前序上下文：把前几个 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 末尾 ──
   // PDF 附件在服务端预提取全文(Claude CLI v2.1.x 的 pdfParse 有 bug),
   // 图片和其他文件仍列路径让 Claude CLI 直接读取。
-  // 主任务附件对所有 sub 都可见；子任务自己的附件只对该 sub 可见。
-  // 注意：run-simple 路径下 virtualSub.attachments 就是 task.attachments 的同一引用，
+  // 注意：首次执行时 sub.attachments 就是 task.attachments 的同一引用，
   // 不去重会把同一张图在 prompt 里列两遍。按 absolutePath 去重。
   const taskAtts = Array.isArray(task.attachments) ? task.attachments : [];
   const subAtts = Array.isArray(sub.attachments) ? sub.attachments : [];
@@ -703,7 +642,7 @@ ${prompt}`;
   }
 
   // ── 运行环境上下文：项目清单 + 看板概览 + 真相源文件路径 ──
-  // 拼在**最前面**、任务正文压尾，与上面 priorOutputs 的位置口径一致：
+  // 拼在**最前面**、任务正文压尾：
   // 越靠后离模型的注意力中心越近，用户真正要办的那句话必须在最后一屏。
   // task.envContext === false 可以单任务关掉（默认开 —— 老任务不迁移也一并受益）。
   if (task.envContext !== false) {
@@ -716,7 +655,8 @@ ${prompt}`;
     id: jobId,
     taskId: task.id,
     subId: sub.id,
-    title: `${task.title} / ${sub.title}`,
+    // 一条任务 = 一次会话：日志标题就用任务标题（sub 只是运行载体，标题同源）
+    title: task.title,
     status: 'pending',
     prompt,
     // 本轮用的执行器。前端日志详情按它显示助手名；简单任务续聊时
@@ -731,8 +671,6 @@ ${prompt}`;
     toolCalls: []
   };
   jobs.set(jobId, job);
-  sub.status = 'running';
-  publish('sub:update', { taskId: task.id, sub });
   publish('job:update', job);
 
   // 声明在 try 之外：启动器就抛错时 finally 也要能安全收口（见 toolTracker?.seal）
@@ -836,43 +774,28 @@ ${prompt}`;
       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。
-      sub.status = 'cancelled';
-      if (!sub.error) sub.error = '用户已停止执行';
     } else if (job.agentError) {
       // 执行器在协议层报了 error（如模型 5xx、配置缺失）。CLI 退出码可能是 0，
-      // 但不能标 done —— 那会把失败伪装成完成，后续 sub 还会拿空输出当下文继续跑。
+      // 但不能标 done —— 那会把失败伪装成完成。
       job.exitCode = 1;
       job.status = 'error';
       job.error = job.agentError;
-      sub.status = 'error';
-      sub.error = job.agentError;
-      sub.errorAt = nowIso();
       appendOutput(`\n> [${executor}] ${job.agentError}\n`);
     } 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 {
     // 工具调用收口：进程都退了，还挂在 running 的调用不会再有下文。先标终态再推 job:update，
-    // 否则前端那些工具块会一直转圈（跟 sub 终态没写回时 UI 一直 running 同一类问题）。
+    // 否则前端那些工具块会一直转圈。
     toolTracker?.seal(job.status);
     // 移除 child 引用——避免后续被 SSE 序列化到前端
     delete job.child;
     publish('job:update', job);
-    publish('sub:update', { taskId: task.id, sub });
     // 终态：await 同步落盘,确保 done/cancelled/error 全部立即归档。
     try {
       await flushJobsSaveNow();
@@ -880,94 +803,9 @@ ${prompt}`;
       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
- */
-export 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 执行"共用。 */
-export 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 等。
-    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 时,它也能拿到前序上下文。
- */
-export 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 的结论。
- */
-export async function collectPriorOutputsUpTo(task, endIdx) {
-  // 前序 sub 可能是**另一个 g ui 实例**跑完的（或者本进程重启过），只翻内存会漏，
-  // 于是"前序结论"整段丢了。刷新有 mtime 短路，队列里每个 sub 调一次也只是个 stat。
-  await refreshJobsFromDisk();
-  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;
-}
-
 // polling 等进程退出：信号 0 探测存活；30 分钟超时兜底
 export function waitProcessExit(pid) {
   return new Promise(resolve => {

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

@@ -15,17 +15,16 @@
 // 工作台后端路由入口。
 //
 // 本文件原本是 3539 行的巨型文件（含所有顶层工具函数 + 45 个路由端点）。
-// 2026-06-29 已按业务域拆分到 ./workbench/ 子目录的 9 个模块：
+// 2026-06-29 已按业务域拆分到 ./workbench/ 子目录的多个模块：
 //   - shared.js          常量 + 通用工具 (nowIso, genId, readJson, writeJson, interpolate)
-//   - jsonParse.js       JSON 解析降级链 (parseSubtaskJson 等)
+//   - jsonParse.js       从 LLM 输出里抠 JSON 的纯函数
 //   - 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 个路由）
+//   - taskRunner.js      任务执行引擎 (runSingleSubtask)
+//   - index.js           registerWorkbenchRoutes 入口聚合
 //
 // 此处保留 re-export 是为了让 src/ui/server/index.js 的 import 路径不变。