termdock 1.4.306 → 1.4.307

package/dist/server/agent/collaborationTaskService.js

@@ -1,6 +1,7 @@
 import { CollaborationError } from './collaborationProtocol.js';
 import { captureTaskCommit } from './collaborationTaskWorkspace.js';
 import { taskBundleChunk } from './collaborationTaskBundles.js';
+import { taskExecution, taskPurpose, taskPurposeFilter } from './collaborationTaskPurpose.js';
 import { taskMemberKey } from './collaborationTaskTypes.js';
 /** One authority per task; replicas are records, never competing decision writers. */
 export class CollaborationTaskService {
@@ -56,12 +57,13 @@ export class CollaborationTaskService {
             const template = task.workflow?.reviewers.some(m => taskMemberKey(m) === taskMemberKey(member));
             return { member, sessionId, launchProfile: group.memberLaunchProfiles?.[sessionId], role: `${template ? '此目标的执行成员模板；' : ''}${group.roles?.[sessionId] ?? ''}` };
         });
-        return { ...task, children, roster, launchProfiles: summary ? undefined : group?.launchProfiles, defaultLaunchProfileId: summary ? undefined : group?.defaultLaunchProfileId, memberSessions, replica: task.ownerServiceId !== this.self, summaryOnly: summary, outbox: (summary ? [] : this.tasks.pending(task.id))
+        return { ...task, purpose: taskPurpose(task.purpose), ...(task.purpose === 'automation' ? { execution: task.execution ?? taskExecution(task) } : {}), children, roster, launchProfiles: summary ? undefined : group?.launchProfiles, defaultLaunchProfileId: summary ? undefined : group?.defaultLaunchProfileId, memberSessions, replica: task.ownerServiceId !== this.self, summaryOnly: summary, outbox: (summary ? [] : this.tasks.pending(task.id))
                 .map(({ id, attemptId, messageId, lastError }) => ({ id, attemptId, messageId, lastError })) };
     }
-    list(groupId, actor) {
+    list(groupId, actor, purpose = 'all') {
         this.group(groupId, actor);
-        return this.tasks.list([groupId], true).map(task => this.view(task, true));
+        const filter = taskPurposeFilter(purpose);
+        return this.tasks.list([groupId], true).filter(task => filter === 'all' || taskPurpose(task.purpose) === filter).map(task => this.view(task, true));
     }
     async get(taskId, actor) {
         const task = this.tasks.get(taskId);
@@ -71,8 +73,10 @@ export class CollaborationTaskService {
         return this.view(task);
     }
     async create(input, actor, origin) {
-        this.group(input.groupId, actor);
+        const group = this.group(input.groupId, actor);
         this.validateMembers(input.groupId, input);
+        if (input.purpose === 'automation' && group.federated)
+            throw new CollaborationError('BACKGROUND_TASK_LOCAL_ONLY', '首版后台自动化记录使用本机协作组', 409);
         const dependencies = [...(input.dependsOn ?? []), ...(input.parentTaskId ? [input.parentTaskId] : [])];
         const authority = dependencies.length ? this.tasks.get(dependencies[0])?.ownerServiceId : this.self;
         if (!authority)
@@ -97,8 +101,10 @@ export class CollaborationTaskService {
         const task = this.tasks.get(taskId);
         if (!task)
             throw new CollaborationError('TASK_NOT_FOUND', '任务不存在', 404);
-        this.group(task.groupId, actor);
+        const group = this.group(task.groupId, actor);
         this.validateMembers(task.groupId, input);
+        if (input.kind === 'configure' && input.purpose === 'automation' && group.federated)
+            throw new CollaborationError('BACKGROUND_TASK_LOCAL_ONLY', '首版后台自动化记录使用本机协作组', 409);
         if (origin && task.ownerServiceId !== this.self)
             throw new CollaborationError('INTEGRATION_LOCAL_ONLY', '首版集成任务须由本机服务保存', 409);
         if (task.ownerServiceId !== this.self) {
@@ -131,7 +137,8 @@ export class CollaborationTaskService {
                         commit: child.artifacts.find(a => a.id === child.acceptedArtifactId)?.evidence?.commit })) } };
         }
         const updated = this.tasks.apply(taskId, input, actor, origin);
-        void this.flush();
+        if (input.kind !== 'configure')
+            void this.flush();
         return this.view(updated);
     }
     heads(groupIds) { return this.tasks.heads(groupIds, this.self); }

package/dist/server/agent/collaborationTaskStore.js

@@ -2,6 +2,7 @@ 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 { taskExecution, taskPurpose } from './collaborationTaskPurpose.js';
 import { CollaborationError } from './collaborationProtocol.js';
 import { taskMemberKey } from './collaborationTaskTypes.js';
 const id = () => randomBytes(16).toString('hex');
@@ -50,6 +51,9 @@ function validateSnapshot(task) {
     text(task.spec, '任务内容', 32_000, true);
     text(task.constraints, '约束');
     text(task.acceptance, '完成标准');
+    taskPurpose(task.purpose);
+    if (task.purpose === 'automation' && (task.workflow || task.parentTaskId || task.dependsOn.length || task.coordinator))
+        invalid();
     member({ serviceId: task.ownerServiceId, sessionId: 'validation' });
     if (task.coordinator !== null)
         member(task.coordinator);
@@ -83,6 +87,8 @@ function validateSnapshot(task) {
             invalid();
         if (event.deliveryId !== undefined && !validId(event.deliveryId))
             invalid();
+        if (event.purpose !== undefined)
+            taskPurpose(event.purpose);
         if (event.source !== undefined && !['system', 'user', 'integration'].includes(event.source))
             invalid();
         if (event.actor !== null)
@@ -183,7 +189,7 @@ export class CollaborationTaskStore {
             const reportSummary = current?.report?.content.split(/\n\s*\n/).map(paragraph => paragraph.split('\n').filter(line => !/^#{1,6}\s/.test(line)).join('\n').trim()).find(Boolean)?.slice(0, 512);
             const automationIssueSource = task.automationIssue ? current?.report && ['blocked', 'failed'].includes(current.report.status)
                 && task.automationIssue === current.report.content.slice(0, 1000) ? 'member-report' : 'system' : undefined;
-            return { ...task, automationIssueSource, spec: task.spec.slice(0, 512), constraints: '', acceptance: '',
+            return { ...task, ...(task.purpose === 'automation' ? { execution: taskExecution(task) } : {}), automationIssueSource, 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, summary: reportSummary, 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: '', summary: (a.summary || (a.kind === 'result' && collaborationResultPresentation(a.content).condensed ? collaborationResultPresentation(a.content).summary : undefined))?.slice(0, 800), evidence: undefined })),
@@ -221,7 +227,7 @@ 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: `本次执行身份：${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。只按用户授权运行测试。' : ''}` });
+            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.purpose === 'automation' ? '\n这是独立后台自动化执行记录：complete 是你明确提交的执行结果，无需等待用户 accepted。机械校验和外部发布由接入系统处理；纯咨询用 respond 关联原 comment，不重复提交 complete。必要问题用 ask 保留原文，由接入系统联系用户并回答。' : ''}${task.workspace ? `\n代码只能在独立目录 ${task.workspace.cwd} 修改。分支 ${task.workspace.branch}。交付前提交代码，结果说明提交、变更、验证与限制。不能修改原仓库、合并到用户分支或发布。` : ''}${task.workflow?.workType === 'read-only' ? '\n这是只读查询或分析任务：在本机会话中采集并交付报告，不修改代码或系统，不创建提交、构建、部署或终止进程。结果需说明采样时间、证据和限制。' : ''}${task.workflow?.kind === 'step' ? '\n完成报告会自动请求独立评审；评审要求修改时继续完成，重新提交 complete。只按用户授权运行测试。' : ''}` });
     }
     goalInstructions(task) {
         return `${this.baseGoalInstructions(task)}\n启动 Agent 前，读取 task get 返回的 launchProfiles、defaultLaunchProfileId 和 roster.launchProfile。根据用户填写的 notes 判断适用任务；这些是选用建议，不是能力或性能保证。需要另一种模型或参数时，用 td collab spawn ${task.groupId} <agentSlug> --launch-profile <方案id> --cwd <项目目录> --session ${task.coordinator?.sessionId} 创建对应执行成员，再把子任务分派给它。已有成员及其代码执行会话保留创建时的启动方案，不因默认方案变更而更换模型。`;
@@ -248,6 +254,9 @@ export class CollaborationTaskStore {
             content: `你被指定为任务「${task.title}」的协调者。\n目标：${task.spec}\n约束：${task.constraints || '未补充'}\n验收标准：${task.acceptance || '由用户决定'}\n任务 ID：${task.id}\n用 td collab task get ${task.id} --text 查看原始记录；用 task list --group ${task.groupId} 查看工作组。需要拆分时用 task create --group ${task.groupId} --parent ${task.id} --title '子任务标题' --content '任务内容'。分派前查询 revision，再用 task assign --revision；把必要的人类决策交给 task ask，不推断成员忙闲，不停止其他成员终端。` });
     }
     create(owner, input, actor, origin) {
+        const purpose = taskPurpose(input.purpose);
+        if (purpose === 'automation' && (input.managed || input.parentTaskId || input.dependsOn?.length || input.coordinator || input.reviewers?.length || input.integration))
+            throw new CollaborationError('AUTOMATION_STANDALONE_REQUIRED', '后台自动化记录不加入人工目标、依赖或评审流程');
         const title = text(input.title, '标题', 640, true), spec = text(input.spec, '任务内容', 32_000, true);
         const constraints = text(input.constraints, '约束'), acceptance = text(input.acceptance, '完成标准');
         if (input.dependsOn !== undefined && (!Array.isArray(input.dependsOn) || input.dependsOn.length > 32 || input.dependsOn.some(v => typeof v !== 'string')))
@@ -276,6 +285,8 @@ export class CollaborationTaskStore {
             for (const dependency of [...dependsOn, ...(input.parentTaskId ? [input.parentTaskId] : [])]) {
                 if (!doc.tasks.some(t => t.id === dependency && t.groupId === input.groupId))
                     throw new CollaborationError('TASK_DEPENDENCY_NOT_FOUND', '父任务或依赖任务不在当前协作组', 404);
+                if (doc.tasks.find(t => t.id === dependency)?.purpose === 'automation')
+                    throw new CollaborationError('AUTOMATION_STANDALONE_REQUIRED', '后台自动化记录不能作为人工任务父级或验收依赖');
             }
             const now = Date.now();
             const parent = doc.tasks.find(t => t.id === input.parentTaskId);
@@ -307,11 +318,11 @@ export class CollaborationTaskStore {
                 if (!required.length || required.some(t => !dependsOn.includes(t.id)))
                     throw new CollaborationError('INTEGRATION_DEPENDENCIES_REQUIRED', '集成任务必须依赖目标下全部实施子任务');
             }
-            const task = { id: id(), ownerServiceId: owner, groupId: input.groupId, title, spec, constraints, acceptance,
+            const task = { id: id(), ownerServiceId: owner, groupId: input.groupId, title, spec, constraints, acceptance, purpose,
                 coordinator: parent?.workflow ? parent.coordinator : input.coordinator !== undefined ? input.coordinator : input.parentTaskId ? doc.tasks.find(t => t.id === input.parentTaskId)?.coordinator ?? actor : null,
                 parentTaskId: input.parentTaskId ?? null, dependsOn, createdAt: now, updatedAt: now, revision: 1,
                 ...(origin ? { origin: structuredClone(origin) } : {}), status: 'open', activeAttemptId: null, attempts: [], decisions: [], artifacts: [], events: [], deliveries: [], ...(workflow ? { workflow } : {}) };
-            this.event(task, 'created', actor, spec);
+            this.event(task, 'created', actor, spec).purpose = purpose;
             if (parent?.constraints)
                 task.constraints = text([parent.constraints, constraints].filter(Boolean).join('\n'), '继承约束');
             if (workflow?.kind === 'goal') {
@@ -335,6 +346,12 @@ export class CollaborationTaskStore {
         }, origin);
     }
     apply(taskId, input, actor, origin) {
+        if (input.purpose !== undefined && input.kind !== 'configure')
+            throw new CollaborationError('INVALID_TASK_PURPOSE', 'purpose can only be changed through configure');
+        if (input.kind === 'configure' && input.purpose === undefined)
+            throw new CollaborationError('INVALID_TASK_PURPOSE', 'configure requires purpose');
+        if (input.kind === 'configure')
+            taskPurpose(input.purpose);
         const content = text(input.content, '内容');
         const summary = text(input.summary, '结果摘要', 2400);
         if (summary && (input.kind !== 'report' || input.status !== 'complete'))
@@ -353,6 +370,8 @@ export class CollaborationTaskStore {
             if (origin && ['accept', 'approve-plan', 'report', 'ask', 'submit-plan', 'review', 'respond'].includes(input.kind))
                 throw new CollaborationError('INTEGRATION_OPERATION_DENIED', '此操作需要用户或原执行成员身份', 403);
             const coordination = actor === null || sameMember(actor, task.coordinator);
+            if (input.kind === 'configure' && actor !== null)
+                throw new CollaborationError('USER_DECISION_REQUIRED', '用途配置需要用户管理身份或授权的集成身份', 403);
             if (['assign', 'coordinator', 'close', 'reopen', 'revise', 'request-review', 'coordinate', 'pause', 'resume', 'retry'].includes(input.kind) && !coordination)
                 throw new CollaborationError('TASK_PERMISSION_DENIED', '此操作需要用户或当前协调者', 403);
             if (['answer', 'accept', 'approve-plan'].includes(input.kind) && actor !== null)
@@ -360,7 +379,7 @@ export class CollaborationTaskStore {
             if (!['report', 'ask', 'submit-plan', 'review', 'comment', 'respond', 'answer'].includes(input.kind) && input.expectedRevision !== task.revision)
                 throw new CollaborationError('TASK_CHANGED', '任务已更新，请查看最新记录后重试', 409);
             const userFollowup = actor === null && input.kind === 'revise' && !!content;
-            if (task.status !== 'open' && !['reopen', 'report'].includes(input.kind) && !(task.status === 'accepted' && (userFollowup || ['comment', 'respond'].includes(input.kind))))
+            if (task.status !== 'open' && !['configure', 'reopen', 'report'].includes(input.kind) && !(task.status === 'accepted' && (userFollowup || ['comment', 'respond'].includes(input.kind))))
                 throw new CollaborationError('TASK_ARCHIVED', '任务已归档；需要继续时请重新打开', 409);
             if (task.workflow && task.status !== 'open' && input.kind !== 'reopen' && !(task.status === 'accepted' && (userFollowup || ['comment', 'respond'].includes(input.kind))))
                 throw new CollaborationError('TASK_ARCHIVED', '自动协作的已完成版本不能追加执行报告，请先重新打开', 409);
@@ -390,7 +409,15 @@ export class CollaborationTaskStore {
                 throw new CollaborationError('ATTEMPT_SUPERSEDED', '这轮分派已被替换，不能再请求用户决定', 409);
             if (task.workflow && ['report', 'ask', 'submit-plan'].includes(input.kind) && attempt?.id !== task.activeAttemptId)
                 throw new CollaborationError('ATTEMPT_SUPERSEDED', '自动协作只能推进当前分派', 409);
-            if (input.kind === 'assign') {
+            if (input.kind === 'configure') {
+                const purpose = taskPurpose(input.purpose);
+                if (purpose === 'automation' && (task.workflow || task.parentTaskId || task.dependsOn.length || task.coordinator
+                    || doc.tasks.some(t => t.parentTaskId === task.id || t.workflow?.rootTaskId === task.id || t.dependsOn.includes(task.id))))
+                    throw new CollaborationError('AUTOMATION_STANDALONE_REQUIRED', '只能把独立记录改为后台自动化用途');
+                task.purpose = purpose;
+                this.event(task, 'configured', actor, content || `任务用途已配置为 ${purpose}`).purpose = purpose;
+            }
+            else if (input.kind === 'assign') {
                 if (task.workflow?.kind === 'goal' && !sameMember(input.assignee ?? null, task.coordinator))
                     throw new CollaborationError('GOAL_COORDINATOR_REQUIRED', '目标由协调者负责，请在子任务中分派实施');
                 if (task.dependsOn.some(dep => doc.tasks.find(t => t.id === dep)?.status !== 'accepted'))
@@ -407,6 +434,8 @@ export class CollaborationTaskStore {
                 this.notifyCoordinator(doc, task);
             }
             else if (input.kind === 'coordinator') {
+                if (task.purpose === 'automation' && input.coordinator)
+                    throw new CollaborationError('AUTOMATION_STANDALONE_REQUIRED', '后台自动化记录不加入人工协调流程');
                 if (task.workflow && !input.coordinator)
                     throw new CollaborationError('GOAL_COORDINATOR_REQUIRED', '自动协作需要协调者');
                 const previousCoordinator = task.coordinator;

package/dist/server/agent/integrationServer.js

@@ -6,7 +6,7 @@ import { homedir } from 'node:os';
 import { timingSafeEqual } from 'node:crypto';
 import { CollaborationError } from './collaborationProtocol.js';
 import { terminalMessage } from './collaborationStore.js';
-import { IntegrationStore, INTEGRATION_PROTOCOL, integrationError } from './integrationStore.js';
+import { IntegrationStore, INTEGRATION_PROTOCOL, INTEGRATION_OPERATIONS, integrationError } from './integrationStore.js';
 import { IntegrationSessions, publicIntegrationSession } from './integrationSessions.js';
 import { getTermdockVersion } from '../utils/version.js';
 export function integrationSocketPath(port) { return path.join(homedir(), '.termdock', `integration-${port}.sock`); }
@@ -73,7 +73,7 @@ export class IntegrationRuntime {
             integrationError('INVALID_INTEGRATION_POLICY', 'Policy identity must match the requested identity'); this.group(req.body?.groupId); this.store.update(req.body); return { ok: true, id: req.params.id }; }));
         app.post('/admin/principals/:id/revoke', run(req => { admin(req); this.store.revoke(req.params.id); return { ok: true }; }));
         app.get('/capabilities', run(req => { const p = principal(req); return { ...this.capabilities(), principal: { id: p.id, group_id: p.groupId, permissions: p.permissions, launch_profiles: p.launchProfiles.map(profile => ({ id: profile.id, agent_slug: profile.agentSlug, cwd_roots: profile.cwdRoots, startup_input_condition: !!profile.startupInput })) } }; }));
-        app.get('/tasks', run(req => { const p = principal(req); this.authorize(p, 'task.read', req.query.group); return { tasks: options.tasks.list(p.groupId, null) }; }));
+        app.get('/tasks', run(req => { const p = principal(req); this.authorize(p, 'task.read', req.query.group); return { tasks: options.tasks.list(p.groupId, null, req.query.purpose) }; }));
         app.get('/tasks/:id', run(async (req) => { const p = principal(req); this.taskPermission(p, req.params.id, 'task.read'); return { task: await options.tasks.get(req.params.id, null) }; }));
         app.post('/tasks', run(async (req) => {
             const p = principal(req), raw = req.body?.input ?? {};
@@ -81,7 +81,7 @@ export class IntegrationRuntime {
             if (raw.managed || raw.parentTaskId || raw.dependsOn?.length || raw.coordinatorSessionId || raw.reviewerSessionIds?.length || raw.integration)
                 integrationError('INTEGRATION_OPERATION_DENIED', 'Integration creates ordinary standalone tasks only', 403);
             const input = { idempotencyKey: raw.idempotencyKey, groupId: p.groupId, title: raw.title, spec: raw.spec,
-                constraints: raw.constraints, acceptance: raw.acceptance, assignee: raw.assigneeSessionId ? options.peers.taskMember(String(raw.assigneeSessionId)) : undefined };
+                purpose: raw.purpose, constraints: raw.constraints, acceptance: raw.acceptance, assignee: raw.assigneeSessionId ? options.peers.taskMember(String(raw.assigneeSessionId)) : undefined };
             if (input.assignee)
                 this.authorize(p, 'task.assign');
             const task = await options.tasks.create(input, null, this.origin(p, req.body?.origin));
@@ -90,13 +90,13 @@ export class IntegrationRuntime {
         }));
         app.post('/tasks/:id', run(async (req) => {
             const p = principal(req), raw = req.body?.input ?? {};
-            const permissions = { assign: 'task.assign', comment: 'task.comment', revise: 'task.revise', answer: 'task.answer' };
+            const permissions = { configure: 'task.configure', assign: 'task.assign', comment: 'task.comment', revise: 'task.revise', answer: 'task.answer' };
             const permission = permissions[raw.kind];
             if (!permission)
                 integrationError('INTEGRATION_OPERATION_DENIED', 'Operation requires a user or terminal member', 403);
             this.taskPermission(p, req.params.id, permission);
             const input = { kind: raw.kind, idempotencyKey: raw.idempotencyKey, content: raw.content,
-                expectedRevision: raw.expectedRevision, decisionId: raw.decisionId,
+                purpose: raw.purpose, expectedRevision: raw.expectedRevision, decisionId: raw.decisionId,
                 assignee: raw.assigneeSessionId ? options.peers.taskMember(String(raw.assigneeSessionId)) : undefined };
             const task = await options.tasks.apply(req.params.id, input, null, this.origin(p, req.body?.origin));
             this.sync();
@@ -148,7 +148,8 @@ export class IntegrationRuntime {
             integration_policy_update: true,
             session_restore_diagnostics: true,
             native_identity_linux_flock_owner: process.platform === 'linux',
-            permissions: ['task.read', 'task.create', 'task.assign', 'task.comment', 'task.revise', 'task.answer', 'events.read', 'session.create', 'session.read', 'session.restore'] };
+            background_task_records: true, task_purpose_configuration: true, explicit_execution_state: true,
+            permissions: INTEGRATION_OPERATIONS };
     }
     error(error) {
         return { type: 'error', ok: false, code: error instanceof CollaborationError ? error.code : 'INTEGRATION_INTERNAL_ERROR',

package/dist/server/agent/integrationStore.js

@@ -3,7 +3,7 @@ import path from 'node:path';
 import { createHash, randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
 import { CollaborationError } from './collaborationProtocol.js';
 export const INTEGRATION_PROTOCOL = 1;
-export const INTEGRATION_OPERATIONS = ['task.read', 'task.create', 'task.assign', 'task.comment', 'task.revise', 'task.answer', 'events.read', 'session.create', 'session.read', 'session.restore'];
+export const INTEGRATION_OPERATIONS = ['task.read', 'task.create', 'task.configure', 'task.assign', 'task.comment', 'task.revise', 'task.answer', 'events.read', 'session.create', 'session.read', 'session.restore'];
 export function integrationError(code, message, status = 400) { throw new CollaborationError(code, message, status); }
 export function atomicJson(file, value) {
     fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });

package/docs/integrations.md

@@ -7,7 +7,8 @@
 **实际运行服务至少 1.4.303**。没有 PTY 附着的已登记 tmux 的重复保护修复要求
 **实际运行服务至少 1.4.304**。管理员恢复诊断要求 **CLI / 实际服务均至少 1.4.305**；
 直接 exec 为 pane PID 的原生 argv 核验及可选 Linux 持锁身份要求 **实际服务至少 1.4.306**；
-建议 CLI 与服务同步安装 1.4.306（既有接入命令的 CLI 最低仍为 1.4.301，诊断 CLI 最低为 1.4.305）。
+后台执行记录与用途迁移要求 **CLI / 实际服务均至少 1.4.307**；
+建议 CLI 与服务同步安装 1.4.307（既有接入命令的 CLI 最低仍为 1.4.301，诊断 CLI 最低为 1.4.305）。
 现有 `--session`、消息投递、任务报告与自动协作入口继续兼容；旧的
 `task create --integration` 仍表示代码集成子任务，新身份使用 `--principal`。
 
@@ -140,12 +141,97 @@ td collab --principal report-bridge capabilities
 `principal.launch_profiles` 中目标 profile 的 `startup_input_condition=true`。
 这些布尔值由实际服务回读；服务能力支持不等于身份已配置条件。
 
+## 后台自动化执行记录（1.4.307）
+
+`td automation` 是已有定时投递入口：`list/create/show/run/pause/resume/delete`。
+它的 run `success` 只表示投递，记录不包含结果版本或关联咨询，最多保留 100 条；
+它不是本节的后台执行记录。外部定时器继续由接入方管理。
+
+后台工作复用可靠的 task/attempt/artifact/event 存储，显式使用
+`purpose=automation`。旧记录缺少 purpose 时按 `interactive` 处理，新建也默认 interactive。
+这是使用方式与记录契约，不是安全隔离或简单 CSS 隐藏：
+
+- automation 是本机协作组内的独立记录；不加入人工目标、父子任务、依赖验收、协调者或自动评审。
+- 继续通过原 session 投递、精确恢复，用原 attempt report、comment/respond 和持久事件关联。
+- `complete` 是执行成员的明确结果交付，无需逐期 accepted。它不等于业务机械校验通过或外部发布成功。
+  业务按 artifact_id 保存机械校验和外部 outbox；本版 `external_validation=false`。
+- 用户任务生命周期 `status=open|accepted|closed` 保持既有含义；后台是否执行交付，读下面的 `execution`，
+  不等待 `status=accepted`。不自动生成 accepted；principal 仍不能验收。已有用户验收历史保留。
+- 人工工作台列表 API 默认只列 interactive，看板与“需要你”同样排除 automation，
+  包括 complete、blocked、failed、预期测试超时和真实提问。业务负责在飞书分诊/提问，
+  可使用 task ask/answer 持久关联。异常、问题原文、投递状态和失败重试并未删除或改成成功。
+- Agent CLI 与 principal 的 task list 默认保留全部授权组记录；可用 `--purpose automation|interactive|all` 筛选。
+  task get 不受用途过滤，原始正文与历史仍可回读。用途不代替组权限。
+
+先核验实际服务 capabilities：
+`background_task_records=true`、`task_purpose_configuration=true`、`explicit_execution_state=true`。
+普通 collab 能力位在 `task_workflow` 内，principal 的在响应顶层。CLI 与实际服务均至少 1.4.307，协议仍是 1。
+CLI 对带 purpose 的操作和 configure 会先探测能力，缺失返回
+`BACKGROUND_TASK_RECORDS_UNSUPPORTED`，不会向旧服务提交变更或降级创建普通任务。
+
+新建后台执行记录（使用既有私有凭据文件注入）：
+
+```sh
+td collab --principal report-bridge task create --group <本机组ID> \
+  --purpose automation --title '本期报告' --content '完整执行要求' \
+  --assignee <原TD-session-id> --idempotency-key <本次创建键>
+td collab --principal report-bridge task list --purpose automation
+td collab --principal report-bridge task get <task-id>
+```
+
+automation 的完整与摘要响应均提供 `execution`：
+
+```json
+{
+  "status": "complete",
+  "attemptId": "原执行尝试ID",
+  "reportEventId": "原report事件ID",
+  "artifactId": "本版本结果ID",
+  "reportedAt": 1791636000000
+}
+```
+
+`execution.status` 为 `unassigned`、`awaiting_report` 或明确成员报告的
+`ack/working/blocked/complete/failed`。它只根据当前 attempt 的有序原始 report/revise 事件生成：
+尚未报告及最新 revise 之后等待新报告时，reportEventId/artifactId/reportedAt 为 null；
+只有当前明确 complete 的 artifactId 非 null。comment/respond 不改变 execution、结果或 attempt；
+revise 使旧一轮 execution 失效，再次 complete 产生新 artifact。历史 attempt 的报告不会覆盖当前执行事实。
+投递成功、终端快照、事件 ACK、其他会话忙闲均不能推导 execution 状态。
+`reportedAt` 是原 report 事件时间，execution 为回读投影，不写回或伪造原报告。
+
+已有普通任务原地迁移，不重跑：管理员先在原策略的 permissions 中**追加** `task.configure`，
+保留 id/groupId/其他权限/profile/启动条件，用 `td integration update --file <原策略.json>` 更新。
+该操作保留凭据；仍需核对 principal.permissions，不能把服务支持的 permissions 当实际授权。
+然后读取原记录的最新 revision：
+
+```sh
+td collab --principal report-bridge task get <原task-id>
+td collab --principal report-bridge task configure <原task-id> \
+  --purpose automation --revision <刚回读的revision> \
+  --idempotency-key <此记录的用途迁移键>
+```
+
+configure 在同一持久事务中更新 purpose、revision 并记录 `task.configured`（payload.event.purpose）。
+创建事件也保留创建时 purpose。新配置事件沿用既有持久推送/重连/ACK 契约。
+用途迁移保留原 task/group/attempt/session 关联、投递、artifact、原始事件和已验收/关闭历史，
+不建立新 attempt/session，不投递正文、不恢复终端、不自动 accepted。
+旧创建请求的同一幂等键仍绑定原请求体；不要把它改为带新 purpose 的 create，否则会正确报幂等冲突。
+迁移后保持原业务键与 TD ID，只有未来新记录才使用 purpose=automation 的新创建请求。
+测试记录也可配置为 automation，测试与正式业务组的分离仍由接入方完成，不自动替别人迁移任务。
+
+configure 需要本机管理员（既有受权任务 API）或授权组内持有 `task.configure` 的 principal；
+终端成员不能配置。拒绝无 grant、跨组、过期 revision；同一幂等请求返回原事件且不重复追加。
+`TASK_CHANGED` 时重新读取并核对，不盲覆写。用途非法返回 `INVALID_TASK_PURPOSE`；
+非独立记录返回 `AUTOMATION_STANDALONE_REQUIRED`，跨服务组返回 `BACKGROUND_TASK_LOCAL_ONLY`。
+已关闭的记录只迁移用途仍保持关闭，不由 configure 隐式恢复咨询或执行。
+
 ## 任务与权限
 
 | 操作 | 外部身份 | 会话成员 / 用户规则 |
 | --- | --- | --- |
 | list/get | `task.read`，只读授权组 | 保留现有组权限 |
-| create | `task.create`，普通独立任务 | 指定负责人另需 `task.assign`，必须在组内 |
+| create | `task.create`，独立任务或后台执行记录 | 指定负责人另需 `task.assign`，必须在组内 |
+| configure | `task.configure` | 显式配置用途，必须带 revision 与幂等键；会话成员不能配置 |
 | assign | `task.assign` | 必须带当前 revision；新建 attempt，不隐式恢复会话 |
 | comment | `task.comment` | open/accepted 可咨询，保留原结果、验收和 attempt |
 | revise | `task.revise` | 带 revision，重开并使旧结果失去验收资格，沿用当前 attempt |
@@ -208,6 +294,7 @@ task 事件 `event_id` 与任务内事件 ID 一致，`respond.reply_to_event_id
 | kind | payload |
 | --- | --- |
 | `task.created/assigned/scheduled/coordinator` | `{event}`：原事件、actor、content、attemptId、sequence、createdAt、origin 等 |
+| `task.configured` | `{event}`：`purpose=interactive|automation`，原配置操作者、时间及 source/origin；没有终端投递 |
 | `task.report` | `{event}`：另含明确 reportStatus（ack/working/blocked/complete/failed）、evidence；新 complete 含 artifactId |
 | `task.comment/respond/revise` | `{event}`：咨询含 target/deliveryId，答复含 replyToEventId |
 | `task.question/answer` | `{event}`；decision 的完整状态从 task get 回读 |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "termdock",
-  "version": "1.4.306",
+  "version": "1.4.307",
   "description": "A complete web-based terminal application with modern UI",
   "type": "module",
   "main": ".desktop-dist/main.js",

package/runtime-manifest.json

@@ -1,13 +1,13 @@
 {
   "schemaVersion": 1,
   "packageName": "termdock",
-  "version": "1.4.306",
+  "version": "1.4.307",
   "runtimeProtocolVersion": 1,
   "minimumDesktopVersion": "1.4.46",
   "nodeMajor": 22,
   "dependencyHash": "sha256-E9GDa4nrCXADRXdyPKufusZt6IcCr4m2mGdx5h34KMQ=",
-  "serverBundleHash": "sha256-X8EpOnbvlZo/rtZ5QLd5zVKFUOFeDkxeqJmY0hUBQnE=",
-  "clientBundleHash": "sha256-HOoNMOYhnph9XwUhSYE5W2CdI9Vb4g0c64ubW49LnXE=",
+  "serverBundleHash": "sha256-SmxpQ63ErP59HLeERjJ0euDs74G6un227eMPe9/sAEI=",
+  "clientBundleHash": "sha256-dfDbp6qzSoUEczQc0mFdVx2jNb+7Oabm+ZvcTpBThnw=",
   "entrypoint": "dist/server/cli.js",
   "clientEntrypoint": "dist/client/index.html"
 }

package/dist/client/assets/CollaborationTaskContent-B_mzpNuw.js

@@ -1,2 +0,0 @@
-import{bv as r}from"./app-D6vN8PW-.js";import{b as m}from"./dnd-BCFAPC0L.js";import{b as n}from"./RightSidebar-CcMSU1v8.js";import"./react-XDCjal2T.js";import"./terminal-C7X98Amf.js";import"./App-BziVLy1b.js";import"./gestureArbiter-CXYHfU__.js";import"./triangle-alert-DzV0gQXz.js";import"./referenceLongPress-Df8W2cyP.js";import"./DiffReview-DjG9vCpH.js";import"./sparkles-DOuEtn62.js";import"./DiffViewer-6n3tgsdc.js";import"./ChangeWalkthroughPanel-00oa0z6w.js";function v({content:o}){const e=m.useMemo(()=>n(o.split(`
-`),null,null),[o]);return r.jsx("div",{className:"min-w-0 space-y-3 break-words text-sm leading-6 text-foreground [&_h1]:text-lg [&_h2]:text-base [&_h3]:text-sm [&_pre]:max-w-full [&_table]:text-xs",children:e.map((t,i)=>r.jsx("div",{className:"min-w-0",children:typeof t.content=="function"?t.content(null):t.content},i))})}export{v as default};

package/dist/client/assets/channel-CBc8-n7y.js

@@ -1 +0,0 @@
-import{c as a,C as n}from"./mermaid.core-DM6Rlal9.js";const t=(r,o)=>a.lang.round(n.parse(r)[o]);export{t as c};

package/dist/client/assets/classDiagram-ZZMXUADV-CNFc2dOc.js

@@ -1 +0,0 @@
-import{s as a,a as s,c as t,C as e}from"./chunk-TICWLB2K-BKaW9Z9i.js";import{d as i}from"./mermaid.core-DM6Rlal9.js";import"./chunk-5VM5RSS4-Bi4Hc8yL.js";import"./chunk-XXDRQBXY-DcHZ_FHb.js";import"./chunk-POPQ4Y6H-BRzm6Uzi.js";import"./chunk-F27PBJKO-DvVWvQEk.js";import"./purify.es-4eNOHKSq.js";import"./app-D6vN8PW-.js";import"./react-XDCjal2T.js";import"./dnd-BCFAPC0L.js";import"./terminal-C7X98Amf.js";var g={parser:t,get db(){return new e},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{g as diagram};

package/dist/client/assets/classDiagram-v2-VYDZK3BY-CNFc2dOc.js

@@ -1 +0,0 @@
-import{s as a,a as s,c as t,C as e}from"./chunk-TICWLB2K-BKaW9Z9i.js";import{d as i}from"./mermaid.core-DM6Rlal9.js";import"./chunk-5VM5RSS4-Bi4Hc8yL.js";import"./chunk-XXDRQBXY-DcHZ_FHb.js";import"./chunk-POPQ4Y6H-BRzm6Uzi.js";import"./chunk-F27PBJKO-DvVWvQEk.js";import"./purify.es-4eNOHKSq.js";import"./app-D6vN8PW-.js";import"./react-XDCjal2T.js";import"./dnd-BCFAPC0L.js";import"./terminal-C7X98Amf.js";var g={parser:t,get db(){return new e},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{g as diagram};