termdock 1.4.296 → 1.4.297

package/dist/server/agent/collaborationTaskCli.js

@@ -4,8 +4,8 @@ export async function executeTaskCommand(command, request, io) {
     const o = command.options, operation = command.operation;
     const bodyOptions = ['content', 'file', 'stdin', 'idempotency-key'];
     const allowed = {
-        list: ['group'], get: [], create: [...bodyOptions, 'group', 'title', 'constraints', 'acceptance', 'assignee', 'coordinator', 'parent', 'depends-on', 'managed', 'reviewers', 'shared-directory', 'integration'],
-        assign: [...bodyOptions, 'assignee', 'revision'], report: [...bodyOptions, 'attempt', 'status', 'evidence'], ask: [...bodyOptions, 'attempt', 'options'],
+        list: ['group'], get: [], create: [...bodyOptions, 'group', 'title', 'constraints', 'acceptance', 'assignee', 'coordinator', 'parent', 'depends-on', 'managed', 'reviewers', 'shared-directory', 'integration', 'work-type'],
+        assign: [...bodyOptions, 'assignee', 'revision'], report: [...bodyOptions, 'attempt', 'status', 'evidence', 'summary'], ask: [...bodyOptions, 'attempt', 'options'],
         plan: [...bodyOptions, 'attempt', 'evidence'], review: [...bodyOptions, 'artifact', 'evidence', 'verdict'], comment: bodyOptions,
         'request-review': [...bodyOptions, 'artifact', 'assignee', 'revision'],
         revise: [...bodyOptions, 'revision'], close: [...bodyOptions, 'revision'], reopen: [...bodyOptions, 'revision'],
@@ -40,7 +40,7 @@ export async function executeTaskCommand(command, request, io) {
         return request('POST', '/tasks', { input: { idempotencyKey, groupId: o.group, title: o.title, spec: content,
                 constraints: o.constraints, acceptance: o.acceptance, assigneeSessionId: o.assignee, coordinatorSessionId: o.coordinator,
                 parentTaskId: o.parent, dependsOn: o['depends-on'] ? String(o['depends-on']).split(',').filter(Boolean) : undefined,
-                integration: o.integration === true, managed: o.managed === true, isolated: o['shared-directory'] !== true,
+                integration: o.integration === true, managed: o.managed === true, isolated: o['shared-directory'] !== true, workType: o['work-type'],
                 reviewerSessionIds: o.reviewers ? String(o.reviewers).split(',').filter(Boolean) : undefined } });
     }
     const options = o.options ? JSON.parse(String(o.options)) : undefined;
@@ -49,6 +49,6 @@ export async function executeTaskCommand(command, request, io) {
     return request('POST', `/tasks/${encodeURIComponent(command.target)}`, { input: {
             kind: operation === 'plan' ? 'submit-plan' : operation, idempotencyKey, expectedRevision, content,
             assigneeSessionId: o.assignee, attemptId: o.attempt, status: o.status, artifactId: o.artifact, options, verdict: o.verdict,
-            evidence: o.evidence ? JSON.parse(String(o.evidence)) : undefined,
+            evidence: o.evidence ? JSON.parse(String(o.evidence)) : undefined, summary: o.summary,
         } });
 }

package/dist/server/agent/collaborationTaskStore.js

@@ -1,9 +1,19 @@
 import { randomBytes, createHash } from 'node:crypto';
 import { readFileSync, writeFileSync, mkdirSync, renameSync } from 'node:fs';
 import { dirname } from 'node:path';
+import { collaborationResultPresentation } from './collaborationResultPresentation.js';
 import { CollaborationError } from './collaborationProtocol.js';
 import { taskMemberKey } from './collaborationTaskTypes.js';
 const id = () => randomBytes(16).toString('hex');
+const codeSteps = (tasks, rootId) => tasks.filter(t => {
+    if (t.workflow?.rootTaskId !== rootId || !t.workflow.isolated || t.workflow.workType === 'read-only' || t.workflow.integration || t.status === 'closed')
+        return false;
+    const accepted = t.artifacts.find(artifact => artifact.id === t.acceptedArtifactId);
+    const commit = accepted?.evidence?.commit;
+    // The service captures the worktree commit. A reviewed HEAD equal to its base
+    // proves there is no code delta to integrate, including legacy query tasks.
+    return !(t.status === 'accepted' && t.workspace && commit === t.workspace.base);
+});
 const sameMember = (a, b) => a !== null && b !== null && taskMemberKey(a) === taskMemberKey(b);
 function text(value, name, limit = 32_000, required = false) {
     if (value !== undefined && typeof value !== 'string')
@@ -44,6 +54,8 @@ function validateSnapshot(task) {
     if (task.coordinator !== null)
         member(task.coordinator);
     if (task.workflow) {
+        if (task.workflow.workType !== undefined && (!['auto', 'code', 'read-only'].includes(task.workflow.workType) || task.workflow.workType === 'auto' && task.workflow.kind !== 'goal'))
+            invalid();
         if (!['goal', 'step'].includes(task.workflow.kind) || typeof task.workflow.paused !== 'boolean' || typeof task.workflow.isolated !== 'boolean'
             || !Array.isArray(task.workflow.reviewers) || task.workflow.reviewers.length > 32 || !Number.isInteger(task.workflow.maxRevisions)
             || task.workflow.maxRevisions < 1 || task.workflow.maxRevisions > 10 || task.workflow.rootTaskId && !validId(task.workflow.rootTaskId))
@@ -69,6 +81,10 @@ function validateSnapshot(task) {
         if (!event || !validId(event.id) || !Number.isSafeInteger(event.sequence) || event.sequence < 1 || typeof event.kind !== 'string'
             || typeof event.content !== 'string' || !time(event.createdAt) || event.attemptId !== null && !task.attempts.some(a => a.id === event.attemptId))
             invalid();
+        if (event.deliveryId !== undefined && !validId(event.deliveryId))
+            invalid();
+        if (event.source !== undefined && !['system', 'user'].includes(event.source))
+            invalid();
         if (event.actor !== null)
             member(event.actor);
         if (event.target)
@@ -85,6 +101,7 @@ function validateSnapshot(task) {
         if (!artifact || !validId(artifact.id) || !task.attempts.some(a => a.id === artifact.attemptId) || !['plan', 'result', 'review'].includes(artifact.kind)
             || typeof artifact.content !== 'string' || !time(artifact.createdAt))
             invalid();
+        text(artifact.summary, '结果摘要', 2400);
         member(artifact.actor);
         if (artifact.verdict && !['pass', 'changes', 'blocked'].includes(artifact.verdict))
             invalid();
@@ -144,9 +161,9 @@ export class CollaborationTaskStore {
             return { ...task, spec: task.spec.slice(0, 512), constraints: '', acceptance: '',
                 deliveries: task.deliveries.filter(d => d.attemptId === task.activeAttemptId && d.error).slice(-1),
                 attempts: current ? [{ ...current, report: current.report ? { ...current.report, content: '', evidence: undefined } : undefined }] : [],
-                artifacts: [plan, result, ...task.artifacts.filter(a => a.kind === 'review' && a.reviewsArtifactId === result?.id)].filter((a) => !!a).map(a => ({ ...a, content: '', evidence: undefined })),
+                artifacts: [plan, result, ...task.artifacts.filter(a => a.kind === 'review' && a.reviewsArtifactId === result?.id)].filter((a) => !!a).map(a => ({ ...a, content: '', summary: (a.summary || (a.kind === 'result' && collaborationResultPresentation(a.content).condensed ? collaborationResultPresentation(a.content).summary : undefined))?.slice(0, 800), evidence: undefined })),
                 decisions: task.decisions.filter(d => d.status === 'pending').map(d => ({ ...d, question: '', options: [] })),
-                events: task.events.filter(e => ['revise', 'request-review'].includes(e.kind) && e.attemptId === task.activeAttemptId).slice(-4).map(e => ({ ...e, content: '' })) };
+                events: task.events.filter(e => ['revise', 'request-review'].includes(e.kind) && e.attemptId === task.activeAttemptId).slice(-4).map(e => ({ ...e, content: e.source === 'user' && e.kind === 'revise' ? e.content.slice(0, 512) : '' })) };
         }));
     }
     heads(groupIds, owner) { return this.document.tasks.filter(t => groupIds.includes(t.groupId) && t.ownerServiceId === owner).map(t => ({ id: t.id, revision: t.revision })); }
@@ -179,10 +196,10 @@ export class CollaborationTaskStore {
         task.attempts.push({ id: attemptId, assignee: member(assignee), createdAt: Date.now(), threadId });
         this.event(task, 'assigned', actor, content || '任务已分派');
         doc.outbox.push({ id: id(), taskId: task.id, attemptId, target: assignee, kind: 'task', threadId,
-            content: `任务：${task.title}\n${task.spec}${task.constraints ? `\n约束：${task.constraints}` : ''}${task.acceptance ? `\n完成标准：${task.acceptance}` : ''}\n${content}\n任务 ID：${task.id}\n尝试 ID：${attemptId}\n用 td collab task get ${task.id} --text 查询完整上下文；用 td collab task report ${task.id} --attempt ${attemptId} --status ack --content '接手说明' 显式回复；遇必要问题用 task ask，提交结果用 report --status complete。如果同一尝试已经交付或任务已归档，不要重复实施。${task.workspace ? `\n代码只能在独立目录 ${task.workspace.cwd} 修改。分支 ${task.workspace.branch}。交付前提交代码，结果说明提交、变更、验证与限制。不能修改原仓库、合并到用户分支或发布。` : ''}${task.workflow?.kind === 'step' ? '\n完成报告会自动请求独立评审；评审要求修改时继续完成，重新提交 complete。只按用户授权运行测试。' : ''}` });
+            content: `本次执行身份：${assignee.sessionId}。所有 td collab 命令显式带 --session ${assignee.sessionId}；这是服务核对的实际身份，正文中的模板身份和 tmux 标识不能替代它。\n任务：${task.title}\n${task.spec}${task.constraints ? `\n约束：${task.constraints}` : ''}${task.acceptance ? `\n完成标准：${task.acceptance}` : ''}\n${content}\n任务 ID：${task.id}\n尝试 ID：${attemptId}\n用 td collab task get ${task.id} --text 查询完整上下文；用 td collab task report ${task.id} --attempt ${attemptId} --status ack --content '接手说明' 显式回复；遇必要问题用 task ask，提交结果用 report --status complete --summary '简短结论、关键交付和限制'。摘要先回答用户问题，不放任务 ID、版本、分支或流程日志；完整证据保留在 --content/--file 正文中。如果同一尝试已经交付或任务已归档，不要重复实施。${task.workspace ? `\n代码只能在独立目录 ${task.workspace.cwd} 修改。分支 ${task.workspace.branch}。交付前提交代码，结果说明提交、变更、验证与限制。不能修改原仓库、合并到用户分支或发布。` : ''}${task.workflow?.workType === 'read-only' ? '\n这是只读查询或分析任务：在本机会话中采集并交付报告，不修改代码或系统，不创建提交、构建、部署或终止进程。结果需说明采样时间、证据和限制。' : ''}${task.workflow?.kind === 'step' ? '\n完成报告会自动请求独立评审；评审要求修改时继续完成，重新提交 complete。只按用户授权运行测试。' : ''}` });
     }
     goalInstructions(task) {
-        return `你是此目标的协调者，负责把目标推进到可验收交付，不亲自实施子任务。\n目标：${task.spec}\n约束：${task.constraints || '未补充'}\n完成标准：${task.acceptance || '满足用户目标，说明交付与限制'}\n任务 ID：${task.id}\n用 td collab task get ${task.id} --json 读取 roster、子任务、完整记录和 revision。\n先报告 ack；拆分为可交付子任务，用 td collab task create --group ${task.groupId} --parent ${task.id} --title '标题' --content '完整要求' --assignee <roster里的成员sessionId> --acceptance '明确标准'。子任务继承自动评审、隔离目录与协调者。依赖任务用 --depends-on id,id，服务在依赖评审通过后自动分派。保持分工合理，不根据终端输出推断谁有空。\n每次收到明确更新后读取最新记录，处理失败与交接。服务自动安排独立评审、返工和依赖接续；不要重复请求评审或催促正在等待回复的成员。必要的人类决策用 task ask --attempt <本轮id>；方案需要用户确认时提交 task plan，不把普通回复当授权。\n代码任务需创建 --integration 的最终集成子任务，--depends-on 依赖全部实施任务；独立目录会包含依赖的提交。不得在原仓库自动合并或发布。\n结束本次协调用 td collab task coordinate ${task.id} --revision <最新版本> --content '已安排的工作和下一步'；有新事件服务会再次唤起你。所有子任务评审通过后报告 complete，汇总交付目录、分支、提交、评审结论和限制，等待用户最终验收。任何异常都要留下明确说明，不伪造完成或进度。`;
+        return `你是此目标的协调者，负责把目标推进到可验收交付，不亲自实施子任务。\n目标：${task.spec}\n约束：${task.constraints || '未补充'}\n完成标准：${task.acceptance || '满足用户目标，说明交付与限制'}\n任务 ID：${task.id}\n当前协调身份：${task.coordinator?.sessionId}；所有命令显式带 --session ${task.coordinator?.sessionId}，不使用 tmux 标识。\n用 td collab task get ${task.id} --json 读取 roster、子任务、完整记录和 revision。\n先报告 ack；拆分为可交付子任务，用 td collab task create --group ${task.groupId} --parent ${task.id} --title '标题' --content '完整要求' --assignee <roster里的成员sessionId> --acceptance '明确标准' --work-type read-only|code。先按目标明确分类：查询、检查、研究、分析用 read-only，复用现有执行成员会话，不创建 Git 目录；修改代码用 code，才创建独立目录。简单问题只建一个必要任务，不为了形式拆成采集、复述、汇总多份任务。子任务继承自动评审与协调者。依赖任务用 --depends-on id,id，服务在依赖评审通过后自动分派。保持分工合理，不根据终端输出推断谁有空。\n每次收到明确更新后读取最新记录，处理失败与交接。服务自动安排独立评审、返工和依赖接续；不要重复请求评审或催促正在等待回复的成员。必要的人类决策用 task ask --attempt <本轮id>；方案需要用户确认时提交 task plan，不把普通回复当授权。\n只有已交付代码任务实际包含相对 base 的提交变化时，才需创建 --work-type code --integration 的最终集成子任务，--depends-on 依赖全部代码实施任务；独立目录会包含依赖的提交。不得在原仓库自动合并或发布。\n结束本次协调用 td collab task coordinate ${task.id} --revision <最新版本> --content '已安排的工作和下一步'；有新事件服务会再次唤起你。所有子任务评审通过后报告 complete --summary '直接回答用户的简短结果和限制'；只读目标直接汇总已核对结果，不创建集成或重复汇总任务。正文保留证据、评审结论和限制，仅代码目标补充目录、分支和提交，等待用户最终验收。任何异常都要留下明确说明，不伪造完成或进度。`;
     }
     notifyCoordinator(doc, task, update) {
         if (!task.coordinator)
@@ -214,6 +231,10 @@ export class CollaborationTaskStore {
         if (input.managed !== undefined && typeof input.managed !== 'boolean' || input.isolated !== undefined && typeof input.isolated !== 'boolean'
             || input.integration !== undefined && typeof input.integration !== 'boolean')
             throw new CollaborationError('INVALID_WORKFLOW', '协作模式无效');
+        if (input.workType !== undefined && !['code', 'read-only'].includes(input.workType))
+            throw new CollaborationError('INVALID_WORK_TYPE', '任务类型必须是 code 或 read-only');
+        if (input.integration && input.workType === 'read-only')
+            throw new CollaborationError('INVALID_WORK_TYPE', '只读任务不需要代码集成');
         if (input.reviewers && (!Array.isArray(input.reviewers) || input.reviewers.length > 32))
             throw new CollaborationError('INVALID_REVIEWERS', '评审成员列表无效');
         input.reviewers?.forEach(member);
@@ -230,14 +251,17 @@ export class CollaborationTaskStore {
             }
             const now = Date.now();
             const parent = doc.tasks.find(t => t.id === input.parentTaskId);
+            const root = parent?.workflow?.rootTaskId ? doc.tasks.find(t => t.id === parent.workflow.rootTaskId) : parent;
+            if (parent?.workflow && !input.workType)
+                throw new CollaborationError('WORK_TYPE_REQUIRED', '请先明确子任务类型：查询、分析用 --work-type read-only；修改代码用 --work-type code');
             if (parent?.workflow && actor && !sameMember(actor, parent.coordinator))
                 throw new CollaborationError('TASK_PERMISSION_DENIED', '只有协调者可以创建此目标的子任务', 403);
             if (parent?.status !== undefined && parent.status !== 'open')
                 throw new CollaborationError('TASK_ARCHIVED', '目标已归档', 409);
             if (parent?.workflow && doc.tasks.filter(t => t.workflow?.rootTaskId === (parent.workflow?.rootTaskId ?? parent.id)).length >= 32)
                 throw new CollaborationError('GOAL_TASK_LIMIT', '单个目标最多 32 个子任务，请收敛分工或建立后续目标', 409);
-            const workflow = parent?.workflow ? { ...parent.workflow, kind: 'step', rootTaskId: parent.workflow.rootTaskId ?? parent.id, paused: false, integration: input.integration === true }
-                : input.managed ? { kind: 'goal', reviewers: input.reviewers ?? [], isolated: input.isolated !== false, paused: false, maxRevisions: 3, maxParallel: Math.min(4, input.reviewers?.length ?? 1) } : undefined;
+            const workflow = parent?.workflow ? { ...parent.workflow, kind: 'step', rootTaskId: parent.workflow.rootTaskId ?? parent.id, paused: false, integration: input.integration === true, workType: input.workType ?? 'code', isolated: input.workType === 'read-only' ? false : root?.workflow?.isolated ?? parent.workflow.isolated }
+                : input.managed ? { kind: 'goal', workType: 'auto', reviewers: input.reviewers ?? [], isolated: input.isolated !== false, paused: false, maxRevisions: 3, maxParallel: Math.min(4, input.reviewers?.length ?? 1) } : undefined;
             if (workflow?.kind === 'goal' && (!input.coordinator || workflow.reviewers.length < 1))
                 throw new CollaborationError('WORKFLOW_MEMBERS_REQUIRED', '请选择协调者和至少一位执行成员', 400);
             if (workflow?.kind === 'goal' && !workflow.reviewers.some(m => !sameMember(m, input.coordinator ?? null)))
@@ -251,7 +275,7 @@ export class CollaborationTaskStore {
             if (workflow?.rootTaskId && doc.tasks.find(t => t.id === workflow.rootTaskId)?.workflow?.paused)
                 throw new CollaborationError('WORKFLOW_PAUSED', '目标已暂停，请先继续协调');
             if (workflow?.integration) {
-                const required = doc.tasks.filter(t => t.workflow?.rootTaskId === workflow.rootTaskId && !t.workflow?.integration && t.status !== 'closed');
+                const required = codeSteps(doc.tasks, workflow.rootTaskId);
                 if (!required.length || required.some(t => !dependsOn.includes(t.id)))
                     throw new CollaborationError('INTEGRATION_DEPENDENCIES_REQUIRED', '集成任务必须依赖目标下全部实施子任务');
             }
@@ -284,6 +308,9 @@ export class CollaborationTaskStore {
     }
     apply(taskId, input, actor) {
         const content = text(input.content, '内容');
+        const summary = text(input.summary, '结果摘要', 2400);
+        if (summary && (input.kind !== 'report' || input.status !== 'complete'))
+            throw new CollaborationError('INVALID_SUMMARY', '摘要只能随完成结果提交');
         if (input.verdict !== undefined && !['pass', 'changes', 'blocked'].includes(input.verdict))
             throw new CollaborationError('INVALID_VERDICT', '评审结论无效');
         if (input.evidence !== undefined && Buffer.byteLength(JSON.stringify(input.evidence)) > 16_384)
@@ -302,12 +329,30 @@ export class CollaborationTaskStore {
                 throw new CollaborationError('USER_DECISION_REQUIRED', '回答、方案确认与验收需要用户操作', 403);
             if (!['report', 'ask', 'submit-plan', 'review', 'comment', 'answer'].includes(input.kind) && input.expectedRevision !== task.revision)
                 throw new CollaborationError('TASK_CHANGED', '任务已更新，请查看最新记录后重试', 409);
-            if (task.status !== 'open' && !['reopen', 'report'].includes(input.kind))
+            const userFollowup = actor === null && input.kind === 'revise' && !!content;
+            if (task.status !== 'open' && !['reopen', 'report'].includes(input.kind) && !(task.status === 'accepted' && userFollowup))
                 throw new CollaborationError('TASK_ARCHIVED', '任务已归档；需要继续时请重新打开', 409);
-            if (task.workflow && task.status !== 'open' && input.kind !== 'reopen')
+            if (task.workflow && task.status !== 'open' && input.kind !== 'reopen' && !(task.status === 'accepted' && userFollowup))
                 throw new CollaborationError('TASK_ARCHIVED', '自动协作的已完成版本不能追加执行报告，请先重新打开', 409);
-            if (task.workflow?.rootTaskId && doc.tasks.find(t => t.id === task.workflow.rootTaskId)?.status !== 'open')
+            const root = task.workflow?.rootTaskId ? doc.tasks.find(t => t.id === task.workflow.rootTaskId) : undefined;
+            if (root && root.status !== 'open' && !(root.status === 'accepted' && userFollowup))
                 throw new CollaborationError('GOAL_ARCHIVED', '请先重新打开所属目标，再继续子任务', 409);
+            if (userFollowup && task.status === 'accepted') {
+                task.status = 'open';
+                delete task.acceptedArtifactId;
+                delete task.completionMode;
+                this.event(task, 'reopen', null, '用户要求继续跟进，保留上一版交付');
+            }
+            if (userFollowup && root?.status === 'accepted') {
+                root.status = 'open';
+                delete root.acceptedArtifactId;
+                delete root.completionMode;
+                if (root.workflow)
+                    root.workflow.paused = false;
+                this.event(root, 'reopen', null, '用户要求继续子任务，所属目标同步重新开启');
+                root.revision++;
+                root.updatedAt = Date.now();
+            }
             const attempt = task.attempts.find(a => a.id === input.attemptId);
             if (['report', 'ask', 'submit-plan'].includes(input.kind) && (!attempt || !sameMember(actor, attempt.assignee)))
                 throw new CollaborationError('ATTEMPT_PERMISSION_DENIED', '只能对自己负责的执行尝试提交报告', 403);
@@ -357,8 +402,8 @@ export class CollaborationTaskStore {
                     || doc.tasks.some(t => t.workflow?.rootTaskId === task.id && !['accepted', 'closed'].includes(t.status))))
                     throw new CollaborationError('CHILD_TASKS_PENDING', '请先完成全部子任务的独立评审，再汇总交付', 409);
                 if (input.status === 'complete' && task.workflow?.kind === 'goal' && task.workflow.isolated) {
-                    const steps = doc.tasks.filter(t => t.workflow?.rootTaskId === task.id && !t.workflow.integration && t.status !== 'closed');
-                    if (!doc.tasks.some(t => t.workflow?.rootTaskId === task.id && t.workflow.integration && t.status === 'accepted' && steps.every(s => t.dependsOn.includes(s.id))))
+                    const steps = codeSteps(doc.tasks, task.id);
+                    if (steps.length && !doc.tasks.some(t => t.workflow?.rootTaskId === task.id && t.workflow.integration && t.status === 'accepted' && steps.every(s => t.dependsOn.includes(s.id))))
                         throw new CollaborationError('INTEGRATION_PENDING', '代码目标需要依赖全部实施任务的集成交付通过评审', 409);
                 }
                 if (input.status === 'complete') {
@@ -371,7 +416,7 @@ export class CollaborationTaskStore {
                 event.reportStatus = input.status;
                 event.evidence = input.evidence;
                 if (input.status === 'complete')
-                    task.artifacts.push({ id: id(), attemptId: attempt.id, kind: 'result', content, evidence: input.evidence, actor: actor, createdAt: event.createdAt });
+                    task.artifacts.push({ id: id(), attemptId: attempt.id, kind: 'result', content, ...(summary ? { summary } : {}), evidence: input.evidence, actor: actor, createdAt: event.createdAt });
             }
             else if (input.kind === 'ask') {
                 if (!content || input.options !== undefined && (!Array.isArray(input.options) || input.options.length > 8 || input.options.some(v => typeof v !== 'string' || !v.trim() || v.length > 500)))
@@ -437,8 +482,8 @@ export class CollaborationTaskStore {
                 if (task.workflow?.kind === 'goal' && doc.tasks.some(t => t.workflow?.rootTaskId === task.id && !['accepted', 'closed'].includes(t.status)))
                     throw new CollaborationError('CHILD_TASKS_PENDING', '子任务尚未全部完成', 409);
                 if (task.workflow?.kind === 'goal' && task.workflow.isolated) {
-                    const steps = doc.tasks.filter(t => t.workflow?.rootTaskId === task.id && !t.workflow.integration && t.status !== 'closed');
-                    if (!doc.tasks.some(t => t.workflow?.rootTaskId === task.id && t.workflow.integration && t.status === 'accepted' && steps.every(s => t.dependsOn.includes(s.id))))
+                    const steps = codeSteps(doc.tasks, task.id);
+                    if (steps.length && !doc.tasks.some(t => t.workflow?.rootTaskId === task.id && t.workflow.integration && t.status === 'accepted' && steps.every(s => t.dependsOn.includes(s.id))))
                         throw new CollaborationError('INTEGRATION_PENDING', '需要全部实施任务的集成交付通过评审');
                 }
                 if (task.dependsOn.some(dep => doc.tasks.find(t => t.id === dep)?.status !== 'accepted'))
@@ -463,11 +508,25 @@ export class CollaborationTaskStore {
             else if (input.kind === 'revise' || input.kind === 'comment') {
                 if (!content)
                     throw new CollaborationError('INVALID_COMMENT', '反馈不能为空');
-                this.event(task, input.kind, actor, content);
+                const event = this.event(task, input.kind, actor, content);
+                if (actor === null)
+                    event.source = 'user';
                 const recipient = task.attempts.find(a => a.id === task.activeAttemptId);
-                if (recipient && !sameMember(actor, recipient.assignee))
-                    doc.outbox.push({ id: id(), taskId: task.id, attemptId: recipient.id, target: recipient.assignee,
-                        kind: 'message', threadId: recipient.threadId, content: `任务「${task.title}」${input.kind === 'revise' ? '要求修改' : '补充反馈'}：\n${content}\n任务 ID：${task.id}\n尝试 ID：${recipient.id}` });
+                if (recipient && !sameMember(actor, recipient.assignee)) {
+                    event.target = recipient.assignee;
+                    event.deliveryId = id();
+                    doc.outbox.push({ id: event.deliveryId, taskId: task.id, attemptId: recipient.id, target: recipient.assignee,
+                        kind: 'message', threadId: recipient.threadId, content: `任务「${task.title}」${input.kind === 'revise' ? actor === null ? '用户要求继续跟进' : '修改要求' : '补充反馈'}：\n${content}\n任务 ID：${task.id}\n尝试 ID：${recipient.id}${task.workflow?.kind === 'goal' ? `\n本轮继续沿用此目标和已交付证据，只推进新增要求。\n${this.goalInstructions(task)}` : '\n按这次要求继续当前分派，重新提交 complete 和摘要；新版本会重新独立评审。'}` });
+                    if (task.workflow?.kind === 'goal' && task.coordination) {
+                        task.coordination.notifiedSequence = event.sequence;
+                        task.coordination.notifiedAt = Date.now();
+                    }
+                }
+                if (input.kind === 'revise') {
+                    delete task.automationIssue;
+                    if (userFollowup && task.workflow)
+                        task.workflow.paused = false;
+                }
             }
             else if (input.kind === 'close' || input.kind === 'reopen') {
                 task.status = input.kind === 'close' ? 'closed' : 'open';
@@ -535,7 +594,7 @@ export class CollaborationTaskStore {
         this.event(root, 'child-update', null, `子任务「${task.title}」(${task.id})：${content}`);
         const result = root.artifacts.filter(a => a.kind === 'result' && a.attemptId === root.activeAttemptId).at(-1);
         if (result && !root.events.some(e => e.kind === 'revise' && e.attemptId === root.activeAttemptId && e.createdAt >= result.createdAt)) {
-            this.event(root, 'revise', null, '子任务在汇总之后发生变化，请重新核对并提交最终结果');
+            this.event(root, 'revise', null, '子任务在汇总之后发生变化，请重新核对并提交最终结果').source = 'system';
         }
         root.revision++;
         root.updatedAt = Date.now();
@@ -604,7 +663,7 @@ export class CollaborationTaskStore {
                 && !['coordinate', 'request-review', 'assigned'].includes(e.kind) && !sameMember(e.actor, task.coordinator)))
                 return 'wake';
             if (!task.automationIssue && task.coordination.acknowledgedSequence < task.coordination.notifiedSequence
-                && !result && Date.now() - task.coordination.notifiedAt > 15 * 60_000)
+                && (!result || task.events.some(e => e.kind === 'revise' && e.attemptId === task.activeAttemptId && e.createdAt >= result.createdAt)) && Date.now() - task.coordination.notifiedAt > 15 * 60_000)
                 return 'coordination-timeout';
         }
         return null;
@@ -632,7 +691,7 @@ export class CollaborationTaskStore {
                         event.target = reviewer;
                         event.source = 'system';
                         doc.outbox.push({ id: id(), taskId: task.id, attemptId: task.activeAttemptId, target: reviewer, kind: 'message', threadId: attempt.threadId,
-                            content: `请独立评审「${task.title}」版本 ${result.id}。用 td collab task get ${task.id} --json 查看目标、结果和代码目录。${task.workspace ? `代码目录 ${task.workspace.cwd}，分支 ${task.workspace.branch}；只读检查此目录，不修改原仓库。` : ''}\n提交 td collab task review ${task.id} --artifact ${result.id} --verdict pass|changes|blocked --content '结论、具体问题与证据'。pass 表示符合完成标准；changes 给出可执行修改要求；blocked 留下必须处理的原因。只按用户授权运行测试，未执行不能称通过。` });
+                            content: `本次评审身份：${reviewer.sessionId}；所有命令带 --session ${reviewer.sessionId}，不使用作者或模板身份。\n请独立评审「${task.title}」版本 ${result.id}。用 td collab task get ${task.id} --json 查看目标、结果、摘要和证据；摘要必须与正文一致，遗漏关键限制或夸大结果需要求修改。${task.workspace ? `代码目录 ${task.workspace.cwd}，分支 ${task.workspace.branch}；只读检查此目录，不修改原仓库。` : ''}\n提交 td collab task review ${task.id} --artifact ${result.id} --verdict pass|changes|blocked --content '结论、具体问题与证据'。pass 表示符合完成标准；changes 给出可执行修改要求；blocked 留下必须处理的原因。只按用户授权运行测试，未执行不能称通过。` });
                     }
                     this.touchParent(doc, task, '已自动请求独立评审');
                 }
@@ -644,7 +703,8 @@ export class CollaborationTaskStore {
                     this.touchParent(doc, task, '独立评审通过，后续依赖可以接续');
                 }
                 else if (action === 'review-feedback') {
-                    const rounds = task.events.filter(e => e.kind === 'revise' && e.actor === null && e.artifactId && e.attemptId === task.activeAttemptId).length;
+                    const boundary = task.events.filter(e => e.kind === 'revise' && e.source === 'user' && e.attemptId === task.activeAttemptId).at(-1)?.sequence ?? 0;
+                    const rounds = task.events.filter(e => e.kind === 'revise' && e.actor === null && e.artifactId && e.attemptId === task.activeAttemptId && e.sequence > boundary).length;
                     const blocked = review.verdict === 'blocked' || rounds >= task.workflow.maxRevisions;
                     const event = this.event(task, blocked ? 'review-blocked' : 'revise', null, review.content);
                     event.artifactId = result.id;
@@ -659,7 +719,7 @@ export class CollaborationTaskStore {
                 else if (action === 'wake') {
                     const updates = task.events.filter(e => e.sequence > task.coordination.notifiedSequence && e.kind !== 'coordinate');
                     doc.outbox.push({ id: id(), taskId: task.id, attemptId: task.activeAttemptId, target: task.coordinator, kind: 'message', threadId: task.id,
-                        content: `目标「${task.title}」有新的明确事件，请继续协调：\n${updates.slice(-8).map(e => `${new Date(e.createdAt).toISOString()} ${e.content.slice(0, 1200)}`).join('\n')}\n用 td collab task get ${task.id} --json 读取完整上下文与子任务；安排必要下一步后 task coordinate ${task.id} --revision <最新版本> --content '协调说明'。自动评审和依赖已由服务接续，不要重复分派。最终汇总已经通过评审时等待用户验收，不要重复提交相同结果。` });
+                        content: `当前协调身份：${task.coordinator.sessionId}；命令带 --session ${task.coordinator.sessionId}。\n目标「${task.title}」有新的明确事件，请继续协调：\n${updates.slice(-8).map(e => `${new Date(e.createdAt).toISOString()} ${e.content.slice(0, 1200)}`).join('\n')}\n用 td collab task get ${task.id} --json 读取完整上下文与子任务；安排必要下一步后 task coordinate ${task.id} --revision <最新版本> --content '协调说明'。自动评审和依赖已由服务接续，不要重复分派。\n当前流程指南：查询、检查、分析必须 --work-type read-only，复用 roster 现有执行成员；只有修改代码才用 code 和独立目录。只读报告由你直接汇总，不新增仅转述的汇总子任务。已评审且 HEAD 等于 base 的交付没有代码变化，不需要集成；有代码变化才安排必要集成。用户有新要求时继续本目标，交付新版本，不重做已有采样。最终汇总通过评审且无新要求时等待用户验收，不重复提交相同结果。` });
                     task.coordination.notifiedSequence = task.events.at(-1).sequence;
                     task.coordination.notifiedAt = Date.now();
                 }
@@ -736,7 +796,9 @@ export class CollaborationTaskStore {
                 task.automationIssue = `消息投递${receipt.status === 'expired' ? '过期' : '失败'}：${receipt.error ?? '请检查成员终端后重试'}`;
                 this.touchParent(doc, task, task.automationIssue);
             }
-            else if (receipt.status === 'delivered' && task.automationIssue?.startsWith('消息投递正在重试'))
+            else if (receipt.status === 'delivered' && task.automationIssue?.startsWith('消息投递')
+                && !doc.outbox.some(o => o.taskId === task.id && o.lastError)
+                && !task.deliveries.some(d => d.attemptId === task.activeAttemptId && ['failed', 'expired'].includes(d.status)))
                 delete task.automationIssue;
         });
     }

package/dist/server/agent/collaborationTaskWorkspace.js

@@ -1,6 +1,6 @@
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
-import { mkdir, readFile, writeFile, rename, realpath } from 'node:fs/promises';
+import { mkdir, readFile, writeFile, rename, realpath, stat } from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
 const exec = promisify(execFile);
@@ -98,3 +98,68 @@ export async function captureTaskCommit(workspace) {
     const commit = await git(workspace.cwd, ['rev-parse', 'HEAD']);
     return { commit, branch: workspace.branch, cwd: workspace.cwd, base: workspace.base };
 }
+async function assertManagedWorkspace(workspace) {
+    const relative = path.relative(home, workspace.cwd);
+    if (!relative || relative.startsWith('..') || path.isAbsolute(relative)
+        || !/^termdock\/task\/[a-f0-9]{32}-[a-f0-9]{8}$/.test(workspace.branch))
+        throw new Error('目录不是 Termdock 独立执行工作区');
+    const actual = await realpath(workspace.cwd);
+    if (actual !== path.resolve(workspace.cwd) || !actual.startsWith(`${await realpath(home)}${path.sep}`)
+        || await git(actual, ['rev-parse', '--show-toplevel']) !== actual
+        || await git(actual, ['branch', '--show-current']) !== workspace.branch)
+        throw new Error('执行目录或分支发生变化，现场已保留');
+    const common = async (cwd) => realpath(path.resolve(cwd, await git(cwd, ['rev-parse', '--git-common-dir'])));
+    if (await common(actual) !== await common(workspace.repository))
+        throw new Error('执行目录不属于原仓库，现场已保留');
+}
+/** Remove only a verified, clean worktree. Keep its branch and all Git commits. */
+export async function archiveTaskWorkspace(workspace) {
+    try {
+        await assertManagedWorkspace(workspace);
+        const commit = await git(workspace.cwd, ['rev-parse', 'HEAD']);
+        if (await git(workspace.cwd, ['status', '--porcelain']) || await git(workspace.cwd, ['ls-files', '--others', '--ignored', '--exclude-standard'])) {
+            return { state: 'retained', reason: '目录含未提交或忽略的文件，已保留现场', commit };
+        }
+        await git(workspace.repository, ['worktree', 'remove', workspace.cwd]);
+        return { state: 'removed', commit };
+    }
+    catch (error) {
+        return { state: 'retained', reason: error instanceof Error ? error.message : String(error) };
+    }
+}
+export async function snapshotTaskWorkspace(workspace) {
+    await assertManagedWorkspace(workspace);
+    return git(workspace.cwd, ['rev-parse', 'HEAD']);
+}
+export async function restoreTaskWorkspace(workspace, cleanup) {
+    if (cleanup.state !== 'removed') {
+        try {
+            await assertManagedWorkspace(workspace);
+            return;
+        }
+        catch (error) {
+            if (cleanup.state !== 'pending' || error.code !== 'ENOENT')
+                throw error;
+        }
+    }
+    const relative = path.relative(home, workspace.cwd);
+    if (!relative || relative.startsWith('..') || path.isAbsolute(relative)
+        || !/^termdock\/task\/[a-f0-9]{32}-[a-f0-9]{8}$/.test(workspace.branch) || !cleanup.commit)
+        throw new Error('工作区恢复记录无效');
+    try {
+        await stat(workspace.cwd);
+        await assertManagedWorkspace(workspace);
+        return;
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    if (await git(workspace.repository, ['rev-parse', workspace.branch]) !== cleanup.commit)
+        throw new Error('归档分支已有变化，请核对后再恢复；不会重置分支');
+    await mkdir(path.dirname(workspace.cwd), { recursive: true, mode: 0o700 });
+    if (!(await realpath(path.dirname(workspace.cwd))).startsWith(`${await realpath(home)}${path.sep}`))
+        throw new Error('工作区父目录发生变化');
+    await git(workspace.repository, ['worktree', 'add', workspace.cwd, workspace.branch]);
+    await assertManagedWorkspace(workspace);
+}

package/dist/server/agent/collaborationTeam.js

@@ -0,0 +1,16 @@
+/** Provision only missing roles. Persist each member before proceeding so a
+ * failed launch, retry or server restart cannot create another full team. */
+export async function ensureTeam(options) {
+    const ids = [];
+    const labels = [`自动协调者 (${options.agentSlug})`, `自动执行与评审 (${options.agentSlug})`];
+    for (const role of labels) {
+        const members = options.members();
+        const reserved = members.find(member => member.role?.startsWith(role.split(' (')[0]));
+        if (reserved && (reserved.role !== role || reserved.cwd !== options.cwd)) {
+            throw new Error('本组已有自动配置的成员，请使用原 Agent 和目录，或在成员设置中移出后重新配置');
+        }
+        const existing = reserved ?? members.find(member => !ids.includes(member.id) && member.agentSlug === options.agentSlug && member.cwd === options.cwd);
+        ids.push(existing?.id ?? await options.spawn(role));
+    }
+    return { coordinatorSessionId: ids[0], reviewerSessionIds: [ids[1]] };
+}

package/dist/server/agent/executionArchives.js

@@ -0,0 +1,52 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { normalizePersistedAgentResumeInfo } from './resumePersistence.js';
+/** Explicit archives are durable records, independent of the recent-history cap. */
+export class ExecutionArchiveStore {
+    file;
+    entries;
+    constructor(file) {
+        this.file = file;
+        try {
+            const document = JSON.parse(fs.readFileSync(file, 'utf8'));
+            if (document.version !== 1 || !Array.isArray(document.entries))
+                throw new Error('执行归档文件格式无效');
+            this.entries = document.entries.map((entry) => {
+                const agent = normalizePersistedAgentResumeInfo(entry.agent);
+                if (!agent || !entry.sessionId || !entry.workspace?.cwd || !Array.isArray(entry.groups) || !Array.isArray(entry.taskIds))
+                    throw new Error('执行归档记录无效');
+                return { ...entry, agent };
+            });
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+            this.entries = [];
+        }
+    }
+    list() { return structuredClone(this.entries); }
+    get(id) { return this.list().find(entry => entry.sessionId === id); }
+    save(entry) {
+        if (!normalizePersistedAgentResumeInfo(entry.agent))
+            throw new Error('没有可恢复的 Agent 原生会话 ID，终端已保留');
+        const entries = [structuredClone(entry), ...this.entries.filter(item => item.sessionId !== entry.sessionId)];
+        fs.mkdirSync(path.dirname(this.file), { recursive: true, mode: 0o700 });
+        const temporary = `${this.file}.${process.pid}.tmp`;
+        fs.writeFileSync(temporary, JSON.stringify({ version: 1, entries }), { mode: 0o600 });
+        fs.renameSync(temporary, this.file);
+        this.entries = entries;
+        return structuredClone(entry);
+    }
+}
+export function completedExecution(tasks, serviceId, sessionId) {
+    const matches = (member) => member?.serviceId === serviceId && member.sessionId === sessionId;
+    if (tasks.some(task => matches(task.coordinator) || task.workflow?.reviewers.some(matches)
+        || task.status === 'open' && (matches(task.attempts.find(a => a.id === task.activeAttemptId)?.assignee) || matches(task.scheduledAssignee)))) {
+        throw new Error('此会话仍承担协作工作，不能归档；请完成当前任务后再操作');
+    }
+    const completed = tasks.filter(task => task.status !== 'open' && task.workspace && task.workflow?.kind === 'step' && task.workflow.isolated
+        && matches(task.attempts.find(a => a.id === task.activeAttemptId)?.assignee));
+    if (!completed.length)
+        throw new Error('此会话没有已完成的独立执行任务，终端已保留');
+    return completed;
+}

package/dist/server/entry.js

@@ -32,6 +32,7 @@ import { fileURLToPath } from 'url';
 import { WebSocketServer } from 'ws';
 import terminalRoutes, { handleTerminalWebSocket, handleControlWebSocket, resolveStableFederationSessionId } from './routes/terminal.js';
 import androidRoutes, { handleAndroidWebSocket } from './routes/android.js';
+import computerRoutes, { handleComputerWebSocket, stopComputerBridges } from './routes/computer.js';
 import { exitWithStartupFailure } from './utils/startupFailure.js';
 import { androidRecordings } from './android/recording.js';
 import { stopAllScrcpySessions } from './android/scrcpy.js';
@@ -349,6 +350,9 @@ export function createApp(options = {}) {
     app.use('/api/android', requireAuth({ bypass: isTrustedLocalCliRequest }));
     app.use('/api/android', csrfProtection.verifyMiddleware({ bypass: isTrustedLocalCliRequest }));
     app.use('/api/android', androidRoutes);
+    app.use('/api/computer', requireAuth({ bypass: isTrustedLocalCliRequest }));
+    app.use('/api/computer', csrfProtection.verifyMiddleware({ bypass: isTrustedLocalCliRequest }));
+    app.use('/api/computer', computerRoutes);
     if (fs.existsSync(bundledClientIndexPath)) {
         const clientPath = pinBundledRuntimeClientDist(bundledClientDistPath);
         const compression = createStaticCompressionMiddleware(clientPath);
@@ -500,8 +504,9 @@ export function startServer(options = {}) {
         target.close(); });
     server.once('close', () => relayRouter.close());
     server.once('close', () => { void stopAllScrcpySessions(); void androidRecordings.stopAll(); });
+    server.once('close', stopComputerBridges);
     const federation = createFederationRuntime(app, path.join(homedir(), '.termdock', 'federation'), {
-        terminal: handleTerminalWebSocket, control: handleControlWebSocket, android: handleAndroidWebSocket,
+        terminal: handleTerminalWebSocket, control: handleControlWebSocket, android: handleAndroidWebSocket, computer: handleComputerWebSocket,
     }, {
         resolveSessionId: resolveStableFederationSessionId,
         collaborationConnected: (subjectId, rpc) => {

package/dist/server/federation/runtime.js

@@ -252,8 +252,8 @@ export async function createFederationRuntime(app, directory, handlers, options
                 }
             }
             revokeTimer = setInterval(() => {
-                for (const { socket: logical, sessionId, android } of sockets.values()) {
-                    if (android) {
+                for (const { socket: logical, sessionId, android, computer } of sockets.values()) {
+                    if (android || computer) {
                         if (!full(subjectId))
                             logical.close(4003, 'Authorization revoked');
                         continue;
@@ -569,18 +569,20 @@ export async function createFederationRuntime(app, directory, handlers, options
                         const url = new URL(packet.path, 'http://inner');
                         const match = /^\/api\/terminal\/([^/%]+)\/ws$/.exec(url.pathname);
                         const androidMatch = /^\/api\/android\/([^/%]+)\/ws$/.exec(url.pathname);
+                        const computer = url.pathname === '/api/computer/ws';
                         if (match)
                             check('session.view', match[1]);
                         else if (url.pathname === '/api/control/ws')
                             check('service.view');
-                        else if (androidMatch) {
+                        else if (androidMatch || computer) {
                             if (!full(subjectId))
                                 throw new Error('API_NOT_ALLOWED');
                         }
                         else
                             throw new Error('API_NOT_ALLOWED');
-                        const logical = new LogicalSocket(channel, packet.id, () => androidMatch ? full(subjectId) : allowed(subjectId, match ? 'session.view' : 'service.view', match?.[1]));
-                        sockets.set(packet.id, { socket: logical, sessionId: match?.[1], android: Boolean(androidMatch) });
+                        const logical = new LogicalSocket(channel, packet.id, () => (androidMatch || computer) ? full(subjectId) : allowed(subjectId, match ? 'session.view' : 'service.view', match?.[1]));
+                        sockets.set(packet.id, { socket: logical, sessionId: match?.[1], android: Boolean(androidMatch), computer,
+                            computerProtocol: computer ? url.searchParams.get('protocol') ?? 'vnc' : undefined });
                         logical.once('close', () => sockets.delete(packet.id));
                         send({ type: 'ws-ready', id: packet.id });
                         if (match)
@@ -598,6 +600,15 @@ export async function createFederationRuntime(app, directory, handlers, options
                                 maxFps: Number(url.searchParams.get('max_fps')) || undefined,
                             });
                         }
+                        else if (computer) {
+                            if (!handlers.computer) {
+                                logical.close(4403, 'API_NOT_ALLOWED');
+                                continue;
+                            }
+                            handlers.computer(logical, url.searchParams.get('host') ?? '', {
+                                protocol: url.searchParams.get('protocol') ?? undefined, port: url.searchParams.get('port') ?? undefined,
+                            });
+                        }
                         else
                             handlers.control(logical, randomUUID());
                     }
@@ -606,7 +617,14 @@ export async function createFederationRuntime(app, directory, handlers, options
                         if (!item || typeof packet.data !== 'string')
                             throw new Error('INVALID_STREAM');
                         const data = JSON.parse(packet.data);
-                        if (item.android) {
+                        if (item.computer) {
+                            if (!full(subjectId))
+                                throw new Error('AUTHORIZATION_DENIED');
+                            const types = item.computerProtocol === 'rdp' ? ['start', 'instruction', 'ack'] : ['data', 'ack'];
+                            if (!types.includes(data?.type))
+                                throw new Error('ACTION_NOT_ALLOWED');
+                        }
+                        else if (item.android) {
                             if (!full(subjectId))
                                 throw new Error('AUTHORIZATION_DENIED');
                             if (!['control', 'ack', 'ping', 'bitrate'].includes(data?.type))