termdock 1.4.300 → 1.4.302

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';
@@ -125,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(),
@@ -141,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
@@ -202,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,
         };
@@ -748,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/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) {

package/dist/server/agent/collaborationTaskStore.js

@@ -224,6 +224,9 @@ export class CollaborationTaskStore {
             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 `${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} 创建对应执行成员，再把子任务分派给它。已有成员及其代码执行会话保留创建时的启动方案，不因默认方案变更而更换模型。`;
+    }
+    baseGoalInstructions(task) {
         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) {
@@ -442,7 +445,7 @@ export class CollaborationTaskStore {
                 const event = this.event(task, 'report', actor, content, attempt.id);
                 event.reportStatus = input.status;
                 event.evidence = input.evidence;
-                if (input.status === 'complete' && task.status === 'accepted') {
+                if (input.status === 'complete' && attempt.id === task.activeAttemptId && task.status === 'accepted') {
                     task.status = 'open';
                     delete task.acceptedArtifactId;
                     delete task.completionMode;

package/dist/server/agent/collaborationTeam.js

@@ -6,10 +6,10 @@ export async function ensureTeam(options) {
     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 和目录，或在成员设置中移出后重新配置');
+        if (reserved && (reserved.role !== role || reserved.cwd !== options.cwd || (reserved.launchProfileKey ?? '') !== (options.launchProfileKey ?? ''))) {
+            throw new Error('本组已有自动配置的成员，请使用原 Agent、启动方案和目录，或在成员设置中移出后重新配置');
         }
-        const existing = reserved ?? members.find(member => !ids.includes(member.id) && member.agentSlug === options.agentSlug && member.cwd === options.cwd);
+        const existing = reserved ?? members.find(member => !ids.includes(member.id) && member.agentSlug === options.agentSlug && member.cwd === options.cwd && (member.launchProfileKey ?? '') === (options.launchProfileKey ?? ''));
         ids.push(existing?.id ?? await options.spawn(role));
     }
     return { coordinatorSessionId: ids[0], reviewerSessionIds: [ids[1]] };

package/dist/server/agent/integrationCli.js

@@ -9,6 +9,7 @@ import { getTermdockVersion } from '../utils/version.js';
 export const INTEGRATION_HELP = `td integration — local scoped integration administration
   groups | list
   create --file <policy.json> --credential-file <private-output.json>
+  update --file <policy.json> (same identity/group; preserves the credential)
   revoke <principal-id>
 Credentials are saved as a private file and never printed. Workers set
 TERMDOCK_INTEGRATION_CREDENTIAL_FILE, then use td collab --principal <id> …
@@ -70,10 +71,25 @@ export async function runIntegrationAdmin(argv, port, adminToken, write) {
             write(JSON.stringify(parsed(await request(socketPath, 'GET', action === 'groups' ? '/admin/groups' : '/admin/principals', undefined, headers(undefined, adminToken)))));
             return 0;
         }
+        if (action === 'update') {
+            if (!options['--file'] || Object.keys(options).length !== 1)
+                throw new Error('update requires only --file');
+            const policy = JSON.parse(fs.readFileSync(options['--file'], 'utf8'));
+            const capabilities = parsed(await request(socketPath, 'GET', '/admin/capabilities', undefined, headers(undefined, adminToken)));
+            if (capabilities.integration_policy_update !== true || policy.launchProfiles?.some((profile) => profile.startupInput !== undefined) && capabilities.startup_input_conditions !== true)
+                throw new CollaborationError('STARTUP_INPUT_CONDITION_UNSUPPORTED', 'Running service does not support this policy update', 409);
+            write(JSON.stringify(parsed(await request(socketPath, 'POST', `/admin/principals/${encodeURIComponent(policy.id)}/policy`, policy, headers(undefined, adminToken)))));
+            return 0;
+        }
         if (action === 'create') {
             if (!options['--file'] || !options['--credential-file'] || Object.keys(options).length !== 2)
                 throw new Error('create requires --file and --credential-file');
             const policy = JSON.parse(fs.readFileSync(options['--file'], 'utf8'));
+            if (policy.launchProfiles?.some((profile) => profile.startupInput !== undefined)) {
+                const capabilities = parsed(await request(socketPath, 'GET', '/admin/capabilities', undefined, headers(undefined, adminToken)));
+                if (capabilities.startup_input_conditions !== true)
+                    throw new CollaborationError('STARTUP_INPUT_CONDITION_UNSUPPORTED', 'Running service does not support startup input conditions', 409);
+            }
             const destination = path.resolve(options['--credential-file']);
             fs.mkdirSync(path.dirname(destination), { recursive: true, mode: 0o700 });
             fs.closeSync(fs.openSync(destination, 'wx', 0o600));

package/dist/server/agent/integrationServer.js

@@ -60,6 +60,7 @@ export class IntegrationRuntime {
                 integrationError('INTEGRATION_ADMIN_REQUIRED', 'Local administration credential is required', 401);
         };
         app.get('/admin/groups', run(req => { admin(req); return { groups: options.messages.list().filter(g => !g.federated).map(g => ({ id: g.id, name: g.name })) }; }));
+        app.get('/admin/capabilities', run(req => { admin(req); return this.capabilities(); }));
         app.get('/admin/principals', run(req => { admin(req); return { integrations: this.store.policies() }; }));
         app.post('/admin/principals', run(req => { admin(req); this.group(req.body?.groupId); const provisioned = this.store.provision(req.body); try {
             this.sync();
@@ -67,8 +68,10 @@ export class IntegrationRuntime {
         catch {
             this.scheduleRetry();
         } return { id: provisioned.principal.id, token: provisioned.token, protocol: INTEGRATION_PROTOCOL }; }));
+        app.post('/admin/principals/:id/policy', run(req => { admin(req); if (req.body?.id !== req.params.id)
+            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 })) } }; }));
+        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/: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) => {
@@ -140,6 +143,8 @@ export class IntegrationRuntime {
             integration_principal: true, group_scoped_permissions: true, durable_event_push: true,
             event_ack_semantics: 'durable_received', correlated_task_responses: true, accepted_task_comments: true,
             idempotent_session_create: true, exact_session_restore: true, external_validation: false,
+            startup_input_conditions: true,
+            integration_policy_update: true,
             permissions: ['task.read', 'task.create', 'task.assign', 'task.comment', 'task.revise', 'task.answer', 'events.read', 'session.create', 'session.read', 'session.restore'] };
     }
     error(error) {

package/dist/server/agent/integrationSessions.js

@@ -10,8 +10,12 @@ export function integrationLaunchCommand(record, restore) {
     const quote = (value) => "'" + value.replaceAll("'", "'\\''") + "'";
     return `cd -- ${quote(record.cwd)} && ${[record.profile.executable, ...args].map(quote).join(' ')}`;
 }
+function startupInput(record, now) {
+    const condition = record.startup_condition ?? record.profile.startupInput;
+    return condition ? { state: 'pending', deadline: now + (condition.timeoutMs ?? 120000), matched_since: null, observed_at: null } : undefined;
+}
 export function publicIntegrationSession(record) {
-    const { profile: _, deadline: _deadline, launch_submitted: _submitted, ...publicRecord } = record;
+    const { profile: _, deadline: _deadline, launch_submitted: _submitted, startup_condition: _condition, ...publicRecord } = record;
     return publicRecord;
 }
 export function permittedCwd(profile, cwd) {
@@ -48,6 +52,7 @@ export class IntegrationSessions {
     restoring = new Set();
     timers = new Set();
     stopObservation;
+    stopDeliveryGuard;
     observing = false;
     observeAgain = false;
     constructor(file, adapter, bindingTimeout = 120000) {
@@ -65,14 +70,21 @@ export class IntegrationSessions {
                 throw error;
         }
         for (const record of this.doc.sessions)
-            if (['starting', 'restoring', 'binding_pending'].includes(record.state))
+            if (['starting', 'restoring', 'binding_pending'].includes(record.state) || record.startup_input?.state === 'pending')
                 this.scheduleRefresh(record);
+        // A pre-restart partial match cannot prove continuity of the live screen.
+        for (const record of this.doc.sessions)
+            if (record.startup_input && record.startup_input.state !== 'observed')
+                record.startup_input.matched_since = null;
+        this.stopDeliveryGuard = adapter.registerDeliveryGuard?.(id => this.deliveryReadiness(id));
         this.stopObservation = adapter.subscribe(() => { void this.refreshAll().catch(() => { }); });
     }
     scheduleRefresh(record) {
-        const timer = setTimeout(() => { this.timers.delete(timer); void this.refresh(record.session_id).catch(() => { }); }, Math.max(1, record.deadline - Date.now() + 5));
-        timer.unref();
-        this.timers.add(timer);
+        for (const deadline of new Set([record.deadline, ...(record.startup_input ? [record.startup_input.deadline] : [])])) {
+            const timer = setTimeout(() => { this.timers.delete(timer); void this.refresh(record.session_id).catch(() => { }); }, Math.max(1, deadline - Date.now() + 5));
+            timer.unref();
+            this.timers.add(timer);
+        }
     }
     subscribe(listener) { this.listeners.add(listener); return () => { this.listeners.delete(listener); }; }
     snapshot() { return structuredClone(this.doc.sessions); }
@@ -128,6 +140,7 @@ export class IntegrationSessions {
             group_id: principal.groupId, principal_id: principal.id, agent_slug: profile.agentSlug, agent_native_session_id: null,
             state: 'starting', error_code: null, cwd, launch_profile: profile.id, profile: structuredClone(profile),
             created_at: now, updated_at: now, deadline: now + this.bindingTimeout, launch_submitted: false };
+        record.startup_input = startupInput(record, now);
         this.doc.requests[request.scoped] = { hash: request.hash, sessionId: record.session_id };
         try {
             this.saveRecord(record);
@@ -202,6 +215,9 @@ export class IntegrationSessions {
             record.operation_id = randomUUID();
             record.deadline = Date.now() + this.bindingTimeout;
             record.updated_at = Date.now();
+            if (!record.profile.startupInput && !record.startup_condition)
+                record.startup_condition = structuredClone(principal.launchProfiles.find(profile => profile.id === record.launch_profile)?.startupInput);
+            record.startup_input = startupInput(record, Date.now());
             this.doc.requests[request.scoped] = { hash: request.hash, sessionId: id };
             try {
                 this.saveRecord(record);
@@ -267,13 +283,45 @@ export class IntegrationSessions {
             next.state = 'failed';
             next.error_code = 'SESSION_BINDING_TIMEOUT';
         }
+        if (next.startup_input && next.startup_input.state !== 'observed') {
+            const condition = next.startup_condition ?? next.profile.startupInput;
+            let matched = false;
+            if (observed.running && observed.agentSlug === record.agent_slug && (!next.error_code || next.error_code === 'SESSION_BINDING_TIMEOUT') && this.adapter.capture) {
+                try {
+                    const fold = (text) => text.replace(/[^\S\r\n]+/g, ' ').trim();
+                    const viewport = fold(await this.adapter.capture(next));
+                    matched = condition.allOf.every(term => viewport.includes(fold(term))) && !(condition.noneOf ?? []).some(term => viewport.includes(fold(term)));
+                }
+                catch { /* Missing capture never opens the delivery guard. */ }
+            }
+            const input = { ...next.startup_input };
+            input.matched_since = matched ? input.matched_since ?? Date.now() : null;
+            if (matched && Date.now() - input.matched_since >= (condition.stableMs ?? 1000)) {
+                input.state = 'observed';
+                input.observed_at = Date.now();
+            }
+            else
+                input.state = Date.now() >= input.deadline ? 'timed_out' : 'pending';
+            next.startup_input = input;
+        }
         if (JSON.stringify(this.doc.sessions.find(s => s.session_id === id)) !== JSON.stringify(record))
             return;
-        if (next.state !== record.state || next.error_code !== record.error_code || next.agent_native_session_id !== record.agent_native_session_id) {
+        if (JSON.stringify(next) !== JSON.stringify(record)) {
             next.updated_at = Date.now();
             this.saveRecord(next);
         }
     }
+    /** Only gates configured launches. Native UUID and Agent turn state are not input prerequisites. */
+    async deliveryReadiness(id) {
+        if (!this.doc.sessions.find(record => record.session_id === id)?.startup_input)
+            return null;
+        await this.refresh(id);
+        const record = this.doc.sessions.find(record => record.session_id === id);
+        if (record.error_code && record.error_code !== 'SESSION_BINDING_TIMEOUT')
+            return { allowed: false, reason: record.error_code };
+        return record.startup_input.state === 'observed' ? { allowed: true, reason: null }
+            : { allowed: false, reason: record.startup_input.state === 'timed_out' ? 'SESSION_STARTUP_INPUT_TIMEOUT' : 'SESSION_STARTUP_INPUT_PENDING' };
+    }
     async refreshAll() {
         if (this.observing) {
             this.observeAgain = true;
@@ -291,6 +339,6 @@ export class IntegrationSessions {
             this.observing = false;
         }
     }
-    close() { this.stopObservation(); for (const timer of this.timers)
+    close() { this.stopObservation(); this.stopDeliveryGuard?.(); for (const timer of this.timers)
         clearTimeout(timer); }
 }

package/dist/server/agent/integrationStore.js

@@ -54,6 +54,16 @@ export function validatePolicy(value) {
             integrationError('INVALID_INTEGRATION_POLICY', 'resumeArgv requires one {sessionId} and one {launchArgs}; --last is forbidden');
         if (!Array.isArray(profile.cwdRoots) || !profile.cwdRoots.length || profile.cwdRoots.some(root => typeof root !== 'string' || !path.isAbsolute(root) || /[\x00-\x1f\x7f]/.test(root)))
             integrationError('INVALID_INTEGRATION_POLICY', 'cwdRoots must be absolute paths');
+        if (profile.startupInput !== undefined) {
+            const condition = profile.startupInput;
+            const validTerms = (terms) => Array.isArray(terms) && terms.length <= 16
+                && terms.every(term => typeof term === 'string' && !!term.trim() && term.length <= 256 && !/[\x00-\x1f\x7f]/.test(term));
+            if (!condition || !validTerms(condition.allOf) || !condition.allOf.length || condition.noneOf !== undefined && !validTerms(condition.noneOf)
+                || condition.stableMs !== undefined && (!Number.isInteger(condition.stableMs) || condition.stableMs < 500 || condition.stableMs > 5000)
+                || condition.timeoutMs !== undefined && (!Number.isInteger(condition.timeoutMs) || condition.timeoutMs < 1000 || condition.timeoutMs > 120000)) {
+                integrationError('INVALID_INTEGRATION_POLICY', 'Invalid startupInput literal conditions or timing bounds');
+            }
+        }
     }
     // Policies contain launcher configuration, never authentication material.
     return structuredClone({ id: value.id, groupId: value.groupId, permissions: value.permissions, launchProfiles: value.launchProfiles });
@@ -101,6 +111,19 @@ export class IntegrationStore {
         this.write(next);
         return { principal: checked, token };
     }
+    update(policy) {
+        const checked = validatePolicy(policy), next = structuredClone(this.doc);
+        const index = next.principals.findIndex(principal => principal.id === checked.id);
+        if (index < 0)
+            integrationError('INTEGRATION_NOT_FOUND', 'Integration does not exist', 404);
+        const existing = next.principals[index];
+        if (existing.revoked)
+            integrationError('INTEGRATION_REVOKED', 'Revoked identities cannot be reactivated', 403);
+        if (existing.groupId !== checked.groupId)
+            integrationError('INTEGRATION_GROUP_IMMUTABLE', 'An existing identity cannot change its group', 409);
+        next.principals[index] = { ...checked, tokenHash: existing.tokenHash, revoked: false };
+        this.write(next);
+    }
     revoke(id) {
         const next = structuredClone(this.doc), principal = next.principals.find(p => p.id === id);
         if (!principal)

package/dist/server/agent/registry.js

@@ -220,7 +220,7 @@ function replayFlags(agent, argv) {
  * the only durable source available for a future recovery.
  */
 export function inferResumeSessionId(agent, argv) {
-    const safeId = (value) => value && /^[A-Za-z0-9._-]+$/.test(value) ? value : null;
+    const safeId = (value) => value && !value.startsWith('-') && /^[A-Za-z0-9._-]+$/.test(value) ? value : null;
     let named = -1;
     for (let index = 0; index < argv.length; index += 1) {
         if (tokenNamesAgent(argv[index], agent)) {
@@ -231,6 +231,36 @@ export function inferResumeSessionId(agent, argv) {
     if (named < 0)
         return null;
     const tail = argv.slice(named + 1);
+    if (agent.isPlugin) {
+        const template = getPluginResumeConfig(agent.slug)?.command.trim().split(/\s+/);
+        if (!template || !tokenNamesAgent(template[0], agent))
+            return null;
+        const pattern = template.slice(1);
+        if (pattern.join(' ').split('{sessionId}').length !== 2)
+            return null;
+        const matches = new Set();
+        // A positional resume command must start the argument tail. Flag-based
+        // templates may follow other launch flags, as for built-in --resume.
+        const starts = pattern[0]?.startsWith('-') ? tail.map((_, index) => index) : [0];
+        for (const start of starts) {
+            let id = null;
+            const matched = pattern.every((token, index) => {
+                const value = tail[start + index];
+                if (value === undefined)
+                    return false;
+                if (!token.includes('{sessionId}'))
+                    return token === value;
+                const [prefix, suffix] = token.split('{sessionId}');
+                if (!value.startsWith(prefix) || !value.endsWith(suffix))
+                    return false;
+                id = safeId(value.slice(prefix.length, suffix ? -suffix.length : undefined));
+                return !!id;
+            });
+            if (matched && id)
+                matches.add(id);
+        }
+        return matches.size === 1 ? [...matches][0] : null;
+    }
     if (agent.slug === 'codex') {
         const resume = tail.indexOf('resume');
         return resume >= 0 ? safeId(tail[resume + 1]) : null;

package/dist/server/routes/terminal.js

@@ -54,6 +54,7 @@ import { CollaborationStore } from '../agent/collaborationStore.js';
 import { COLLAB_NAME_FORBIDDEN, formatCollaborationDelivery } from '../agent/collaborationPrompt.js';
 import { ambiguousIdMessage } from '../agent/collaborationProtocol.js';
 import { buildCollaborationSpawnCommand, resolveCollaborationSpawnMode } from '../agent/collaborationSpawn.js';
+import { resolveCollaborationLaunch, launchProfileKey } from '../agent/collaborationLaunchProfiles.js';
 import { SessionSearchStore } from '../agent/sessionSearchStore.js';
 import { NativeSessionSearch } from '../agent/nativeSessionSearch.js';
 import { CollaborationError } from '../agent/collaborationProtocol.js';
@@ -439,6 +440,7 @@ async function flushClientStateBroadcast() {
     }
 }
 const integrationSessionObservers = new Set();
+let integrationDeliveryGuard;
 function notifyIntegrationSessions() { for (const listener of integrationSessionObservers) {
     try {
         listener();
@@ -1594,7 +1596,9 @@ async function inspectCollaborationTmux(binding, requestedPane, allowPlainPane =
     if (!Number.isInteger(serverPid) || serverPid <= 0)
         throw new Error('TMUX_SERVER_IDENTITY_UNAVAILABLE');
     const panes = await Promise.all(layout.windows.flatMap((window) => window.panes).map(async (pane) => {
-        const program = await resolveTmuxPaneProgram(pane);
+        // Native identity needs the foreground argv even for a named binary;
+        // pane_current_command alone cannot prove an exact resumed conversation.
+        const program = await resolveTmuxPaneProgram(pane, true);
         const agent = detectAgentFromCommand(program?.rawArgs ?? program?.command ?? '', agentCustomCommands());
         const nativeSessionId = agent && program?.rawArgs ? inferResumeSessionId(agent, splitCommandToArgv(program.rawArgs)) : null;
         return { serverPid, sessionId: layout.sessionId, paneId: pane.id, panePid: pane.pid,
@@ -1658,6 +1662,11 @@ async function resolveCollaborationRoute(frontendSessionId) {
     let record = globalSessionState.sessions.find((candidate) => candidate.sessionId === frontendSessionId);
     if (!record)
         return { state: 'offline', reason: 'SESSION_REMOVED' };
+    if (record.tmuxSessionName?.startsWith('wt-integration-') && !integrationDeliveryGuard)
+        return { state: 'unavailable', reason: 'INTEGRATION_RUNTIME_UNAVAILABLE' };
+    const startup = await integrationDeliveryGuard?.(frontendSessionId);
+    if (startup && !startup.allowed)
+        return { state: 'recovering', reason: startup.reason ?? 'SESSION_STARTUP_INPUT_PENDING' };
     let backend = resolveOrchestrationBackend(record);
     let binding = collaborationRouting.get(frontendSessionId) ?? {
         sessionId: record.sessionId, backendSessionId: null, mode: record.mode, tmuxSessionName: record.tmuxSessionName,
@@ -1745,7 +1754,7 @@ function deliverCollaborationInboxWhenAgentReady(frontendSessionId) {
     collaborationDeliveryWorker.wake(frontendSessionId);
 }
 async function spawnCollaborationAgentSession(req, group, sourceSessionId, input, bootstrapRole) {
-    const agentSlug = typeof input.agentSlug === 'string' ? input.agentSlug.trim().toLowerCase() : '';
+    const { agentSlug, profile } = resolveCollaborationLaunch(group, input);
     const launchers = await listDetectedAgentLaunchers();
     const launcher = launchers.find((candidate) => candidate.slug === agentSlug);
     if (!launcher)
@@ -1767,7 +1776,7 @@ async function spawnCollaborationAgentSession(req, group, sourceSessionId, input
     }
     const requestedCwd = typeof input.cwd === 'string' ? input.cwd.trim() : '';
     const opened = await openInventorySession(req, {
-        name: requestedName || `${launcher.displayName} · ${group.name}`,
+        name: requestedName || `${profile?.name ?? launcher.displayName} · ${group.name}`,
         customName: true,
         mode,
         cwd: requestedCwd || fallbackRecord?.cwd || undefined,
@@ -1796,7 +1805,9 @@ async function spawnCollaborationAgentSession(req, group, sourceSessionId, input
     });
     if (bootstrapRole)
         collaborationStore.setRole({ groupId: group.id, sessionId: frontendSessionId, role: bootstrapRole });
-    writeTerminalInput(backend, `${buildCollaborationSpawnCommand({ slug: launcher.slug, command: launcher.command })}\r`);
+    if (profile)
+        collaborationStore.setMemberLaunchProfile(group.id, frontendSessionId, profile);
+    writeTerminalInput(backend, `${buildCollaborationSpawnCommand({ slug: launcher.slug, command: profile?.command ?? launcher.command })}\r`);
     const requestedTask = typeof input.task === 'string' ? input.task.trim().slice(0, 20_000) : '';
     collaborationStore.send({
         groupId: updatedGroup.id,
@@ -1808,7 +1819,7 @@ async function spawnCollaborationAgentSession(req, group, sourceSessionId, input
     setTimeout(() => {
         deliverCollaborationInboxWhenAgentReady(frontendSessionId);
     }, 300).unref?.();
-    return { group: updatedGroup, session: orchestrationSessionSnapshot(globalSessionState.sessions.find((candidate) => candidate.sessionId === frontendSessionId)) };
+    return { group: collaborationStore.getGroup(group.id), session: orchestrationSessionSnapshot(globalSessionState.sessions.find((candidate) => candidate.sessionId === frontendSessionId)) };
 }
 /** Restricted session adapter: only preconfigured argv and the exact owned
  * terminal can be launched; no remote drive or arbitrary shell commands. */
@@ -1836,6 +1847,16 @@ function integrationTerminalRecord(record) {
 }
 export const integrationSessionAdapter = {
     subscribe(listener) { integrationSessionObservers.add(listener); return () => { integrationSessionObservers.delete(listener); }; },
+    registerDeliveryGuard(guard) { integrationDeliveryGuard = guard; return () => { if (integrationDeliveryGuard === guard)
+        integrationDeliveryGuard = undefined; }; },
+    async capture(record) {
+        const observed = await integrationSessionAdapter.inspect(record);
+        if (!observed.exists || !observed.running || observed.agentSlug !== record.agent_slug || !record.terminal_binding
+            || record.agent_native_session_id && observed.nativeId && record.agent_native_session_id !== observed.nativeId) {
+            integrationError('SESSION_IDENTITY_MISMATCH', 'Startup input observation requires the original Agent pane', 409);
+        }
+        return captureTmuxPaneText(runTmux, record.terminal_binding);
+    },
     async inspect(record) {
         const terminal = integrationTerminalRecord(record);
         if (!terminal)
@@ -1959,10 +1980,16 @@ export function prepareCollaborationTaskWorker(task, template, dependencies, ser
         if (!source || template.serviceId !== service.descriptor().serviceId)
             throw new Error('执行成员当前不可用，请协调者重新分派');
         const snapshot = orchestrationSessionSnapshot(source);
+        const inheritedProfile = collaborationStore.getGroup(task.groupId)?.memberLaunchProfiles?.[template.sessionId];
         const slug = snapshot.agent?.slug ?? source.agentResume?.slug;
         const launcher = (await listDetectedAgentLaunchers()).find(a => a.slug === slug);
         if (!launcher || !source.cwd)
             throw new Error('独立代码任务需要有项目目录的 Agent 成员，请选择可用成员');
+        if (inheritedProfile) {
+            if (inheritedProfile.agentSlug !== launcher.slug)
+                throw new Error('执行成员的启动方案与当前 Agent 不一致，请重新分派');
+            resolveCollaborationLaunch({ launchProfiles: [inheritedProfile] }, { launchProfileId: inheritedProfile.id, agentSlug: launcher.slug });
+        }
         const workspace = await prepareTaskWorkspace(task, source.cwd, dependencies, (dependency, repository) => importTaskDependency(task, dependency, repository, service, readDependency));
         await pathValidator.allowSessionCwd(workspace.cwd);
         const existing = globalSessionState.sessions.find(s => s.cwd === workspace.cwd);
@@ -1988,7 +2015,7 @@ export function prepareCollaborationTaskWorker(task, template, dependencies, ser
             const temporary = `${launchFile}.${process.pid}.tmp`;
             await fs.promises.writeFile(temporary, JSON.stringify({ sessionId: record.sessionId, backendId: opened.terminalSession.sessionId }), { mode: 0o600 });
             await fs.promises.rename(temporary, launchFile);
-            writeTerminalInput(backend, `${buildCollaborationSpawnCommand({ slug: launcher.slug, command: launcher.command })}\r`);
+            writeTerminalInput(backend, `${buildCollaborationSpawnCommand({ slug: launcher.slug, command: inheritedProfile?.command ?? launcher.command })}\r`);
         }
         const group = collaborationStore.getGroup(task.groupId);
         if (!group || group.deleted)
@@ -1996,6 +2023,8 @@ export function prepareCollaborationTaskWorker(task, template, dependencies, ser
         if (!group.sessionIds.includes(record.sessionId))
             await service.save({ id: group.id, name: group.name,
                 sessionIds: [...group.sessionIds, record.sessionId], expectedUpdatedAt: group.updatedAt });
+        if (inheritedProfile)
+            collaborationStore.setMemberLaunchProfile(group.id, record.sessionId, inheritedProfile);
         return { sessionId: record.sessionId, workspace };
     })().finally(() => preparingTaskWorkers.delete(key));
     preparingTaskWorkers.set(key, operation);
@@ -3817,14 +3846,14 @@ async function getProcessSnapshot() {
     });
     return processSnapshotPromise;
 }
-async function resolveTmuxPaneProgram(pane) {
+async function resolveTmuxPaneProgram(pane, requireArgs = false) {
     // If pane command is a known shell, try to find a child foreground process
     const command = normalizeProgramName(pane.command);
     const commandKey = command?.toLowerCase() ?? null;
     const isShell = commandKey ? shellNamesBackend.has(commandKey) : false;
     // If pane command is NOT a shell but also too generic (e.g. "node"), also try
     const isGeneric = commandKey ? genericProgramNames.has(commandKey) : false;
-    if (!isShell && !isGeneric) {
+    if (!isShell && !isGeneric && !requireArgs) {
         // Non-shell, non-generic command — pane_current_command is good enough
         return { command, source: 'tmux-pane', rawArgs: null };
     }
@@ -5956,26 +5985,28 @@ router.post('/operations/collaboration-groups/:groupId/team', async (req, res) =
             return res.status(404).json({ error: '协作组不存在' });
         if (group.federated)
             throw new Error('跨服务组请先从成员设置添加 Agent');
-        const agentSlug = typeof req.body?.agentSlug === 'string' ? req.body.agentSlug : '';
+        const { agentSlug, profile } = resolveCollaborationLaunch(group, req.body ?? {});
         if (!(await listDetectedAgentLaunchers()).some(agent => agent.slug === agentSlug))
             throw new Error('所选 Agent 当前不可用');
         if (typeof req.body?.cwd !== 'string' || !req.body.cwd.trim())
             throw new Error('请选择工作目录');
         const cwd = await resolveWorkingDirectory(req, req.body.cwd);
         const previous = preparingTeams.get(group.id) ?? Promise.resolve();
-        const operation = previous.catch(() => { }).then(() => ensureTeam({ agentSlug, cwd,
+        const operation = previous.catch(() => { }).then(() => ensureTeam({ agentSlug, cwd, launchProfileKey: launchProfileKey(profile),
             members: () => {
                 const current = collaborationStore.getGroup(group.id);
                 if (!current || current.deleted)
                     throw new Error('协作组已删除');
+                if (profile && launchProfileKey(current.launchProfiles?.find(p => p.id === profile.id)) !== launchProfileKey(profile))
+                    throw new Error('启动方案已变更，请重新开始协作');
                 return globalSessionState.sessions.filter(record => current.sessionIds.includes(record.sessionId))
-                    .map(record => ({ id: record.sessionId, cwd: record.cwd, role: current.roles?.[record.sessionId], agentSlug: orchestrationSessionSnapshot(record).agent?.slug }));
+                    .map(record => ({ id: record.sessionId, cwd: record.cwd, role: current.roles?.[record.sessionId], agentSlug: orchestrationSessionSnapshot(record).agent?.slug, launchProfileKey: launchProfileKey(current.memberLaunchProfiles?.[record.sessionId]) }));
             },
             spawn: async (role) => {
                 const current = collaborationStore.getGroup(group.id);
                 if (!current || current.deleted)
                     throw new Error('协作组已删除');
-                const result = await spawnCollaborationAgentSession(req, current, null, { agentSlug, cwd, mode: 'tmux', name: role.startsWith('自动协调者') ? `协调 ${group.name}` : `执行与评审 ${group.name}` }, role);
+                const result = await spawnCollaborationAgentSession(req, current, null, { agentSlug, launchProfileId: profile?.id ?? '', cwd, mode: 'tmux', name: role.startsWith('自动协调者') ? `协调 ${group.name}` : `执行与评审 ${group.name}` }, role);
                 return result.session.sessionId;
             },
         }));