termdock 1.4.299 → 1.4.301

package/dist/server/agent/collaborationGroupRoutes.js

@@ -1,6 +1,7 @@
 import { Router } from 'express';
 import { CollaborationError } from './collaborationProtocol.js';
 import { COLLAB_NAME_FORBIDDEN } from './collaborationPrompt.js';
+import { validateLaunchProfiles } from './collaborationLaunchProfiles.js';
 /** The current service owns group membership, including retained offline members. */
 export function collaborationGroupRoutes(options) {
     const router = Router();
@@ -11,15 +12,15 @@ export function collaborationGroupRoutes(options) {
     router.post('/collaboration-groups', async (req, res) => {
         try {
             const body = req.body ?? {};
-            const { id, name, sessionIds, expectedUpdatedAt } = body;
+            const { id, name, sessionIds, expectedUpdatedAt, launchProfiles, defaultLaunchProfileId } = body;
             // Unknown fields used to be dropped silently while the save still
             // returned ok — a caller submitting `members` to rename someone got a
             // success and no rename. Reject them and route the common case (member
             // renames) to the command that actually does it.
-            const unknownKeys = Object.keys(body).filter((key) => !['id', 'name', 'sessionIds', 'expectedUpdatedAt'].includes(key));
+            const unknownKeys = Object.keys(body).filter((key) => !['id', 'name', 'sessionIds', 'expectedUpdatedAt', 'launchProfiles', 'defaultLaunchProfileId'].includes(key));
             if (unknownKeys.length) {
                 const hint = unknownKeys.includes('members') ? '；要改成员显示名请用 td collab rename <session-id> <新名字>' : '';
-                throw new CollaborationError('INVALID_GROUP', `含未知字段 ${unknownKeys.join('、')}（合法字段：name, sessionIds, id, expectedUpdatedAt）${hint}`, 400);
+                throw new CollaborationError('INVALID_GROUP', `含未知字段 ${unknownKeys.join('、')}（合法字段：name, sessionIds, id, expectedUpdatedAt, launchProfiles, defaultLaunchProfileId）${hint}`, 400);
             }
             if ((id !== undefined && (typeof id !== 'string' || !id))
                 || typeof name !== 'string' || !name.trim() || !Array.isArray(sessionIds)
@@ -36,15 +37,19 @@ export function collaborationGroupRoutes(options) {
                 throw new CollaborationError('GROUP_CHANGED', `协作组已被修改（当前 updatedAt=${existing?.updatedAt}）。请先确认最新成员列表，再以 expectedUpdatedAt=${existing?.updatedAt} 重新提交`, 409, { currentUpdatedAt: existing?.updatedAt });
             }
             const ids = [...new Set(sessionIds)];
+            const launch = launchProfiles !== undefined || defaultLaunchProfileId !== undefined ? {
+                launchProfiles: validateLaunchProfiles(launchProfiles ?? existing?.launchProfiles ?? [], defaultLaunchProfileId ?? null),
+                defaultLaunchProfileId: defaultLaunchProfileId ?? null,
+            } : {};
             if (options.save) {
-                res.json(await options.save(req, { id, name, sessionIds: ids, expectedUpdatedAt }));
+                res.json(await options.save(req, { id, name, sessionIds: ids, expectedUpdatedAt, ...launch }));
                 return;
             }
             const known = new Set([...options.sessions().map((session) => session.sessionId), ...(existing?.sessionIds ?? [])]);
             if (ids.some((value) => !known.has(value))) {
                 throw new CollaborationError('MEMBERS_CHANGED', '所选会话已变化，请刷新后重新选择；尚未保存任何修改', 409);
             }
-            res.json({ group: options.store.save({ id, name, sessionIds: ids }) });
+            res.json({ group: options.store.save({ id, name, sessionIds: ids, ...launch }) });
         }
         catch (error) {
             res.status(error instanceof CollaborationError ? error.httpStatus : 500)

package/dist/server/agent/collaborationLaunchProfiles.js

@@ -0,0 +1,43 @@
+import { CollaborationError } from './collaborationProtocol.js';
+/** User-authored shell commands; never interpolate coordinator-provided parameters. */
+export function validateLaunchProfiles(profiles, defaultId) {
+    const invalid = () => { throw new CollaborationError('INVALID_LAUNCH_PROFILE', '启动方案无效：请填写唯一标识、名称、Agent 和单行启动命令，并选择存在的默认方案', 400); };
+    if (!Array.isArray(profiles) || profiles.length > 20)
+        return invalid();
+    const ids = new Set();
+    for (const profile of profiles) {
+        if (!profile || typeof profile !== 'object' || Array.isArray(profile)
+            || Object.keys(profile).some(key => !['id', 'name', 'agentSlug', 'command', 'notes'].includes(key))
+            || typeof profile.id !== 'string' || !/^[a-zA-Z0-9_-]{1,64}$/.test(profile.id) || ids.has(profile.id)
+            || typeof profile.name !== 'string' || !profile.name.trim() || profile.name.length > 100
+            || typeof profile.agentSlug !== 'string' || !/^[a-zA-Z0-9_-]{1,64}$/.test(profile.agentSlug)
+            || typeof profile.command !== 'string' || !profile.command.trim() || profile.command.length > 4096
+            || typeof profile.notes !== 'string' || profile.notes.length > 2000
+            || /[\x00-\x1f\x7f]/.test(profile.command + profile.name)
+            || /[\x00-\x08\x0b-\x1f\x7f]/.test(profile.notes))
+            return invalid();
+        ids.add(profile.id);
+    }
+    if (defaultId !== undefined && defaultId !== null && (typeof defaultId !== 'string' || !ids.has(defaultId)))
+        return invalid();
+    return profiles.map(p => ({ id: p.id, name: p.name.trim(), agentSlug: p.agentSlug, command: p.command.trim(), notes: p.notes.trim() }));
+}
+export function resolveCollaborationLaunch(group, input) {
+    if (input.launchProfileId !== undefined && typeof input.launchProfileId !== 'string')
+        throw new CollaborationError('INVALID_LAUNCH_PROFILE', '启动方案标识必须是文本', 400);
+    const slug = typeof input.agentSlug === 'string' ? input.agentSlug.trim().toLowerCase() : '';
+    const explicit = typeof input.launchProfileId === 'string' && !!input.launchProfileId;
+    const profileId = explicit ? input.launchProfileId : input.launchProfileId === '' ? null : group.defaultLaunchProfileId;
+    const candidate = group.launchProfiles?.find(p => p.id === profileId);
+    if (explicit && !candidate)
+        throw new CollaborationError('LAUNCH_PROFILE_NOT_FOUND', '启动方案已被删除，请读取最新协作组配置', 409);
+    if (explicit && slug && candidate.agentSlug !== slug)
+        throw new CollaborationError('LAUNCH_PROFILE_AGENT_MISMATCH', '启动方案与所选 Agent 类型不一致', 400);
+    const profile = candidate && (!slug || candidate.agentSlug === slug) ? candidate : undefined;
+    if (profile)
+        validateLaunchProfiles([profile], profile.id);
+    return { agentSlug: profile?.agentSlug ?? slug, profile };
+}
+export function launchProfileKey(profile) {
+    return profile ? JSON.stringify([profile.id, profile.agentSlug, profile.command]) : '';
+}

package/dist/server/agent/collaborationRoutes.js

@@ -1,4 +1,5 @@
 import { terminalMessage } from './collaborationStore.js';
+import { getTermdockVersion } from '../utils/version.js';
 import { assertPeerRegistrationAuthority } from './collaborationPeerTransport.js';
 import { Router } from 'express';
 import { COLLAB_LIMITS, CollaborationError, MIN_ID_PREFIX_LENGTH, ambiguousIdMessage, extrasFromBody } from './collaborationProtocol.js';
@@ -150,10 +151,11 @@ export function collaborationRoutes({ store, resolveSession, deliver, rebind, re
         }
     };
     router.get('/capabilities', run((_req, res) => {
-        res.json({ protocol_version: 2, limits: COLLAB_LIMITS,
+        res.json({ protocol_version: 2, server_version: getTermdockVersion(), limits: COLLAB_LIMITS,
             task_workflow: { version: 2, command: 'td collab task', single_authority: true, explicit_reports: true,
                 managed_goals: true, automatic_review: true, dependency_dispatch: true, isolated_worktrees: true, encrypted_commit_transfer: true,
                 durable_questions: true, user_acceptance: true, versioned_artifacts: true, independent_reviews: true,
+                correlated_responses: true, accepted_comments: true,
                 task_reply: 'Replies to task-linked user messages are stored in the task; status=stored is not a terminal delivery receipt' },
             routing: { background_recovery: true, explicit_rebind: Boolean(rebind), fixed_tmux_pane: true },
             statuses: ['pending', 'delivered', 'failed', 'expired'], queued_status: 'pending',
@@ -211,7 +213,7 @@ export function collaborationRoutes({ store, resolveSession, deliver, rebind, re
                 const extras = extrasFromBody(req.body);
                 const status = extras.task?.status ?? (extras.responseKind === 'ack' ? 'ack' : extras.responseKind === 'result' ? 'complete' : extras.responseKind === 'progress' ? 'working' : null);
                 const task = await req.app.locals.collaborationTasks.apply(link.taskId, {
-                    kind: status ? 'report' : 'comment', status: status ?? undefined, attemptId: link.attemptId,
+                    kind: status ? 'report' : link.replyToEventId ? 'respond' : 'comment', replyToEventId: link.replyToEventId, status: status ?? undefined, attemptId: link.attemptId,
                     content: req.body.content, evidence: extras.task?.evidence, idempotencyKey: extras.idempotencyKey,
                 }, req.app.locals.collaborationService.taskMember(sessionId));
                 res.json({ ok: true, status: 'stored', task_recorded: true, task_id: task.id, task_revision: task.revision });
@@ -323,6 +325,8 @@ export function collaborationRoutes({ store, resolveSession, deliver, rebind, re
             id: group.id, name: group.name, sessionIds: group.sessionIds,
             members: group.sessionIds.map((sessionId) => ({ sessionId, name: names[sessionId] ?? null })),
             roles: group.roles ?? {},
+            launchProfiles: group.launchProfiles ?? [], defaultLaunchProfileId: group.defaultLaunchProfileId ?? null,
+            memberLaunchProfiles: group.memberLaunchProfiles ?? {},
         };
     };
     router.get('/rules', run((req, res, sessionId) => {

package/dist/server/agent/collaborationService.js

@@ -3,6 +3,7 @@ import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
 import { dirname } from 'node:path';
 import { CollaborationError } from './collaborationProtocol.js';
 import { COLLAB_NAME_FORBIDDEN } from './collaborationPrompt.js';
+import { validateLaunchProfiles } from './collaborationLaunchProfiles.js';
 import { remoteSession, validateCollaborationNode } from './collaborationPeerTransport.js';
 const hash = (value) => createHash('sha256').update(value).digest('hex');
 const address = (id) => { if (!id.startsWith('remote:'))
@@ -12,6 +13,7 @@ const local = (origin, id) => { const a = address(id); return a?.origin === orig
 const mapRoles = (value, map) => value && Object.fromEntries(Object.entries(value).map(([id, item]) => [map(id), item]));
 function mapGroup(group, map) {
     return { ...group, sessionIds: group.sessionIds.map(map), roles: mapRoles(group.roles, map), roleVersions: mapRoles(group.roleVersions, map),
+        memberLaunchProfiles: mapRoles(group.memberLaunchProfiles, map),
         instructions: group.instructions && { ...group.instructions, updatedBy: map(group.instructions.updatedBy) } };
 }
 /** Sole owner of peer discovery and group replication. UI and CLI call the same
@@ -460,10 +462,14 @@ export class CollaborationService {
             throw new CollaborationError('GROUP_CHANGED', `协作组已变化（当前 updatedAt=${existing.updatedAt}），请刷新后重试`, 409, { currentUpdatedAt: existing.updatedAt });
         if (typeof input.name !== 'string' || !input.name.trim() || COLLAB_NAME_FORBIDDEN.test(input.name) || !Array.isArray(input.sessionIds) || input.sessionIds.some(id => typeof id !== 'string'))
             throw new Error('INVALID_GROUP');
+        const launch = input.launchProfiles !== undefined || input.defaultLaunchProfileId !== undefined ? {
+            launchProfiles: validateLaunchProfiles(input.launchProfiles ?? existing?.launchProfiles ?? [], input.defaultLaunchProfileId ?? null),
+            defaultLaunchProfileId: input.defaultLaunchProfileId ?? null,
+        } : {};
         if (!input.sessionIds.some(id => address(id)) && !existing?.federated) {
             if (input.sessionIds.some(id => !this.options.sessions().some(s => s.sessionId === id) && !existing?.sessionIds.includes(id)))
                 throw new Error('GROUP_MEMBER_UNAVAILABLE');
-            return { group: this.options.store.save(input) };
+            return { group: this.options.store.save({ ...input, ...launch }) };
         }
         if (input.sessionIds.length < 2)
             throw new CollaborationError('INVALID_GROUP', '跨服务组仍需两个成员；修改未保存', 400);
@@ -477,7 +483,7 @@ export class CollaborationService {
         const available = new Set([...this.options.sessions(), ...this.directory().sessions.filter(s => s.serviceConnected)].map(s => s.sessionId));
         if (!Array.isArray(input.sessionIds) || input.sessionIds.some(id => !available.has(id) && !existing?.sessionIds.includes(id)))
             throw new Error('GROUP_MEMBER_UNAVAILABLE');
-        const group = { ...existing, id: existing?.federated ? existing.id : `cross-${randomBytes(16).toString('hex')}`, name: input.name,
+        const group = { ...existing, ...launch, id: existing?.federated ? existing.id : `cross-${randomBytes(16).toString('hex')}`, name: input.name,
             sessionIds: [...new Set(input.sessionIds)], createdAt: existing?.createdAt ?? Date.now(), updatedAt: Math.max(Date.now(), (existing?.updatedAt ?? 0) + 1), federated: true };
         const canonical = mapGroup(group, id => address(id) ? id : remoteSession(this.node().origin, id));
         if (canonical.sessionIds.some(id => !this.nodes().some(node => node.origin === address(id)?.origin)))

package/dist/server/agent/collaborationStore.js

@@ -1,4 +1,5 @@
 import { plainCollaborationSnapshot } from './collaborationText.js';
+import { validateLaunchProfiles } from './collaborationLaunchProfiles.js';
 import fs from 'node:fs';
 import path from 'node:path';
 import crypto from 'node:crypto';
@@ -43,6 +44,9 @@ export class CollaborationStore {
     filePath;
     drawId;
     onMessageQueued;
+    changeListeners = new Set();
+    subscribe(listener) { this.changeListeners.add(listener); return () => { this.changeListeners.delete(listener); }; }
+    snapshotMessages() { return structuredClone(this.document.messages); }
     peerActivity = new Map();
     recordPeerActivity(sessionId, outputAt, observedAt) {
         if (this.peerActivity.size >= 2000 && !this.peerActivity.has(sessionId))
@@ -122,9 +126,14 @@ export class CollaborationStore {
         const existing = input.id ? this.document.groups.find((group) => group.id === input.id) : null;
         if (input.id && (!existing || existing.deleted))
             throw new CollaborationError('GROUP_NOT_FOUND', '协作组已删除，请刷新列表', 404);
+        const launchProfiles = input.launchProfiles === undefined ? existing?.launchProfiles : validateLaunchProfiles(input.launchProfiles, input.defaultLaunchProfileId ?? null);
+        const defaultLaunchProfileId = input.defaultLaunchProfileId !== undefined ? input.defaultLaunchProfileId : input.launchProfiles !== undefined ? null : existing?.defaultLaunchProfileId;
+        if (launchProfiles || defaultLaunchProfileId)
+            validateLaunchProfiles(launchProfiles ?? [], defaultLaunchProfileId);
         const sessionIds = Array.from(new Set(input.sessionIds.map((id) => id.trim()).filter(Boolean)));
         const group = pruneRoles({
             ...existing,
+            launchProfiles, defaultLaunchProfileId,
             ...(existing?.remoteSessions ? { remoteSessions: existing.remoteSessions.filter((session) => sessionIds.includes(session.sessionId)) } : {}),
             id: existing?.id ?? newCollaborationId(this.takenIds(), this.drawId),
             name: input.name.trim(),
@@ -138,6 +147,15 @@ export class CollaborationStore {
         this.persist();
         return group;
     }
+    setMemberLaunchProfile(groupId, sessionId, profile) {
+        const group = this.getGroup(groupId);
+        if (!group || group.deleted || !group.sessionIds.includes(sessionId))
+            throw new CollaborationError('NOT_A_MEMBER', '会话不在协作组内', 409);
+        const [snapshot] = validateLaunchProfiles([profile], profile.id);
+        this.document.groups = this.document.groups.map(g => g.id === groupId ? { ...g,
+            memberLaunchProfiles: { ...g.memberLaunchProfiles, [sessionId]: snapshot }, updatedAt: Math.max(Date.now(), g.updatedAt + 1) } : g);
+        this.persist();
+    }
     /** Set or clear a member's role (定位). The target may be any group member —
      * oneself, a peer, or a federated remote session; peers can set each other's
      * roles. Roles ride the group document into federation and are dropped
@@ -199,7 +217,9 @@ export class CollaborationStore {
                             ...(group.remoteSessions ? { remoteSessions: group.remoteSessions.filter((session) => sourceIds.includes(session.sessionId)) } : {}),
                             updatedAt: Math.max(now, group.updatedAt + 1) }, sourceIds)];
                 }
-                return group.id === target.id ? [{ ...group, sessionIds: [...new Set([...group.sessionIds, input.sessionId])], updatedAt: Math.max(now, group.updatedAt + 1) }] : [group];
+                return group.id === target.id ? [{ ...group, sessionIds: [...new Set([...group.sessionIds, input.sessionId])],
+                        ...(source.memberLaunchProfiles?.[input.sessionId] ? { memberLaunchProfiles: { ...group.memberLaunchProfiles, [input.sessionId]: source.memberLaunchProfiles[input.sessionId] } } : {}),
+                        updatedAt: Math.max(now, group.updatedAt + 1) }] : [group];
             }),
             messages: this.document.messages,
         };
@@ -727,6 +747,12 @@ export class CollaborationStore {
             fs.writeFileSync(temporaryPath, serialized, { mode: 0o600 });
             fs.renameSync(temporaryPath, this.filePath);
             this.persistedDocument = serialized;
+            for (const listener of this.changeListeners) {
+                try {
+                    listener();
+                }
+                catch { /* Journal retries from durable source records. */ }
+            }
         }
         catch (error) {
             this.document = JSON.parse(this.persistedDocument);
@@ -739,6 +765,11 @@ function stableJson(value) {
         ? Object.fromEntries(Object.entries(entry).sort(([a], [b]) => a.localeCompare(b))) : entry);
 }
 function validateFederatedGroup(group) {
+    if (group.launchProfiles !== undefined || group.defaultLaunchProfileId !== undefined)
+        validateLaunchProfiles(group.launchProfiles ?? [], group.defaultLaunchProfileId);
+    if (group.memberLaunchProfiles)
+        for (const profile of Object.values(group.memberLaunchProfiles))
+            validateLaunchProfiles([profile], profile.id);
     if (!group.federated || typeof group.id !== 'string' || !group.id.startsWith('cross-') || typeof group.name !== 'string' || !group.name.trim()
         || !Number.isFinite(group.updatedAt) || !Number.isFinite(group.createdAt)
         || !Array.isArray(group.sessionIds) || group.sessionIds.some((id) => typeof id !== 'string')

package/dist/server/agent/collaborationTaskCli.js

@@ -3,8 +3,12 @@ import { randomUUID } from 'node:crypto';
 export async function executeTaskCommand(command, request, io) {
     const o = command.options, operation = command.operation;
     const bodyOptions = ['content', 'file', 'stdin', 'idempotency-key'];
+    const originOptions = ['source', 'external-actor', 'external-message-id', 'metadata'];
+    if (originOptions.some(key => o[key]) && !o.principal)
+        throw new Error('External source metadata requires --principal');
     const allowed = {
         list: ['group'], get: [], create: [...bodyOptions, 'group', 'title', 'constraints', 'acceptance', 'assignee', 'coordinator', 'parent', 'depends-on', 'managed', 'reviewers', 'shared-directory', 'integration', 'work-type'],
+        answer: [...bodyOptions, 'decision'], respond: [...bodyOptions, 'attempt', 'to-event', 'evidence'],
         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'],
@@ -12,7 +16,7 @@ export async function executeTaskCommand(command, request, io) {
         coordinate: [...bodyOptions, 'revision'], pause: [...bodyOptions, 'revision'], resume: [...bodyOptions, 'revision'], retry: [...bodyOptions, 'revision'],
     };
     for (const flag of Object.keys(o))
-        if (![...allowed[operation], 'session', 'json', 'jsonl', 'text', 'help'].includes(flag))
+        if (![...allowed[operation], ...(o.principal ? originOptions : []), 'principal', 'session', 'json', 'jsonl', 'text', 'help'].includes(flag))
             throw new Error(`--${flag} is not supported by task ${operation}`);
     if (operation === 'list')
         return request('GET', `/tasks${o.group ? `?group=${encodeURIComponent(String(o.group))}` : ''}`);
@@ -32,8 +36,12 @@ export async function executeTaskCommand(command, request, io) {
         throw new Error('Read task get first, then supply --revision to avoid overwriting another decision');
     if (['assign', 'request-review'].includes(operation) && !o.assignee)
         throw new Error('This task operation requires --assignee');
-    if (['report', 'ask', 'plan'].includes(operation) && !o.attempt)
+    if (['report', 'respond', 'ask', 'plan'].includes(operation) && !o.attempt)
         throw new Error('Use --attempt from the dispatch message; never guess the current attempt');
+    if (operation === 'respond' && !o['to-event'])
+        throw new Error('respond requires --to-event <comment-event-id>');
+    if (operation === 'answer' && !o.decision)
+        throw new Error('answer requires --decision <question-id>');
     if (operation === 'create') {
         if (!o.title || !o.group)
             throw new Error('task create requires --title and --group');
@@ -47,7 +55,7 @@ export async function executeTaskCommand(command, request, io) {
     if (options !== undefined && (!Array.isArray(options) || options.some(v => typeof v !== 'string')))
         throw new Error('--options must be a JSON array of strings');
     return request('POST', `/tasks/${encodeURIComponent(command.target)}`, { input: {
-            kind: operation === 'plan' ? 'submit-plan' : operation, idempotencyKey, expectedRevision, content,
+            replyToEventId: o['to-event'], decisionId: o.decision, 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, summary: o.summary,
         } });

package/dist/server/agent/collaborationTaskService.js

@@ -54,9 +54,9 @@ export class CollaborationTaskService {
         const roster = summary ? undefined : group?.sessionIds.map(sessionId => {
             const member = this.peers.taskMember(sessionId);
             const template = task.workflow?.reviewers.some(m => taskMemberKey(m) === taskMemberKey(member));
-            return { member, sessionId, role: `${template ? '此目标的执行成员模板；' : ''}${group.roles?.[sessionId] ?? ''}` };
+            return { member, sessionId, launchProfile: group.memberLaunchProfiles?.[sessionId], role: `${template ? '此目标的执行成员模板；' : ''}${group.roles?.[sessionId] ?? ''}` };
         });
-        return { ...task, children, roster, memberSessions, replica: task.ownerServiceId !== this.self, summaryOnly: summary, outbox: (summary ? [] : this.tasks.pending(task.id))
+        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))
                 .map(({ id, attemptId, messageId, lastError }) => ({ id, attemptId, messageId, lastError })) };
     }
     list(groupId, actor) {
@@ -70,7 +70,7 @@ export class CollaborationTaskService {
         this.group(task.groupId, actor);
         return this.view(task);
     }
-    async create(input, actor) {
+    async create(input, actor, origin) {
         this.group(input.groupId, actor);
         this.validateMembers(input.groupId, input);
         const dependencies = [...(input.dependsOn ?? []), ...(input.parentTaskId ? [input.parentTaskId] : [])];
@@ -81,22 +81,26 @@ export class CollaborationTaskService {
             if (this.tasks.get(dependency)?.ownerServiceId !== authority)
                 throw new CollaborationError('DEPENDENCY_AUTHORITY_REQUIRED', '依赖与父任务需在同一来源服务创建', 409);
         }
+        if (origin && authority !== this.self)
+            throw new CollaborationError('INTEGRATION_LOCAL_ONLY', '首版集成任务须由本机服务保存', 409);
         if (authority !== this.self) {
             const result = await this.peers.requestTasks(authority, { op: 'create', input, actorSessionId: actor?.sessionId ?? null });
             const task = result.task;
             this.tasks.merge(task, authority);
             return this.view(task);
         }
-        const task = this.tasks.create(this.self, input, actor);
+        const task = this.tasks.create(this.self, input, actor, origin);
         void this.flush();
         return this.view(task);
     }
-    async apply(taskId, input, actor) {
+    async apply(taskId, input, actor, origin) {
         const task = this.tasks.get(taskId);
         if (!task)
             throw new CollaborationError('TASK_NOT_FOUND', '任务不存在', 404);
         this.group(task.groupId, actor);
         this.validateMembers(task.groupId, input);
+        if (origin && task.ownerServiceId !== this.self)
+            throw new CollaborationError('INTEGRATION_LOCAL_ONLY', '首版集成任务须由本机服务保存', 409);
         if (task.ownerServiceId !== this.self) {
             const result = await this.peers.requestTasks(task.ownerServiceId, { op: 'apply', taskId, input, actorSessionId: actor?.sessionId ?? null });
             this.tasks.merge(result.task, task.ownerServiceId);
@@ -126,7 +130,7 @@ export class CollaborationTaskService {
                         artifactId: child.acceptedArtifactId, integration: child.workflow?.integration === true,
                         commit: child.artifacts.find(a => a.id === child.acceptedArtifactId)?.evidence?.commit })) } };
         }
-        const updated = this.tasks.apply(taskId, input, actor);
+        const updated = this.tasks.apply(taskId, input, actor, origin);
         void this.flush();
         return this.view(updated);
     }
@@ -196,7 +200,7 @@ export class CollaborationTaskService {
             const queued = this.messages.send({ groupId: group.id, fromSessionId: null, toSessionIds: [recipient.sessionId],
                 kind: packet.kind === 'task' ? 'task' : 'message', content: String(packet.content ?? ''), threadId: attempt?.threadId ?? task.id,
                 idempotencyKey: `task:${peer.serviceId}:${String(packet.outboxId)}`,
-                metadata: { taskOutboxId: packet.outboxId, termdockTask: { taskId: task.id, attemptId: attempt?.id ?? null, ownerServiceId: peer.serviceId } } });
+                metadata: { taskOutboxId: packet.outboxId, termdockTask: { taskId: task.id, attemptId: attempt?.id ?? null, ownerServiceId: peer.serviceId, replyToEventId: task.events.find(e => e.deliveryId === packet.outboxId && e.attemptId === attempt?.id && e.kind === 'comment')?.id } } });
             this.deliver(recipient.sessionId);
             return { receipt: this.receipt(queued[0].id) };
         }
@@ -313,14 +317,16 @@ export class CollaborationTaskService {
                 if (!task?.workflow)
                     return true;
                 const root = task.workflow.rootTaskId ? this.tasks.get(task.workflow.rootTaskId) : task;
-                return !task.workflow.paused && !root?.workflow?.paused && root?.status === 'open';
+                const consultation = outbox.replyToEventId && task.events.some(e => e.id === outbox.replyToEventId && e.kind === 'comment');
+                return consultation || !task.workflow.paused && !root?.workflow?.paused && root?.status === 'open';
             }).slice(0, 16);
             for (const outbox of ready) {
                 try {
                     const task = this.tasks.get(outbox.taskId);
                     this.group(task.groupId, outbox.target);
                     const root = task.workflow?.rootTaskId ? this.tasks.get(task.workflow.rootTaskId) : task;
-                    if (task.workflow && (task.workflow.paused || root?.workflow?.paused || root?.status !== 'open'))
+                    const consultation = outbox.replyToEventId && task.events.some(e => e.id === outbox.replyToEventId && e.kind === 'comment');
+                    if (task.workflow && !consultation && (task.workflow.paused || root?.workflow?.paused || root?.status !== 'open'))
                         continue;
                     if (outbox.target.serviceId === this.self) {
                         if (outbox.messageId && this.messages.getMessage(outbox.messageId)) {
@@ -330,7 +336,7 @@ export class CollaborationTaskService {
                         }
                         const queued = this.messages.send({ groupId: task.groupId, fromSessionId: null, toSessionIds: [outbox.target.sessionId],
                             kind: outbox.kind, content: outbox.content, threadId: outbox.threadId, idempotencyKey: `task:${this.self}:${outbox.id}`,
-                            metadata: { termdockTask: { taskId: task.id, attemptId: outbox.attemptId, ownerServiceId: this.self } } });
+                            metadata: { termdockTask: { taskId: task.id, attemptId: outbox.attemptId, ownerServiceId: this.self, replyToEventId: outbox.replyToEventId } } });
                         this.deliver(outbox.target.sessionId);
                         this.tasks.delivered(outbox.id, this.receipt(queued[0].id));
                     }