termdock 1.4.320 → 1.4.322

package/dist/server/agent/collaborationPeerTransport.js

@@ -355,7 +355,8 @@ export class CollaborationPeerTransport {
                 return [];
             const facts = terminalMessage(message);
             const known = Array.isArray(packet.known) ? packet.known.find((item) => item?.id === message.id) : undefined;
-            if (known && known.status === facts.status && known.deliveredAt === facts.deliveredAt && known.shellConfirmed === message.shellConfirmed && (known.hasSnapshot || !message.snapshot))
+            if (known && known.status === facts.status && known.deliveredAt === facts.deliveredAt && known.shellConfirmed === message.shellConfirmed && (known.hasSnapshot || !message.snapshot)
+                && known.last_error === (store.diagnostic(message.id)?.last_error ?? null))
                 return [];
             const receipt = store.receipt(message.id);
             return [{ id: message.id, status: facts.status, deliveredAt: facts.deliveredAt,
@@ -447,7 +448,7 @@ export class CollaborationPeerTransport {
                 for (const message of payloads) {
                     const result = await client.request({ type: 'collaboration-exchange', groupId: b.groupId,
                         context: mapContext(store.context(b.groupId), id => id.startsWith('remote:') ? id : remoteSession(b.localOrigin, id)),
-                        ids: batch.map(m => m.id), known: batch.map(m => ({ id: m.id, status: m.status, deliveredAt: m.deliveredAt, hasSnapshot: !!m.snapshot, shellConfirmed: m.shellConfirmed })), ...(message ? { message } : {}) });
+                        ids: batch.map(m => m.id), known: batch.map(m => ({ id: m.id, status: m.status, deliveredAt: m.deliveredAt, hasSnapshot: !!m.snapshot, shellConfirmed: m.shellConfirmed, last_error: store.diagnostic(m.id)?.last_error ?? null })), ...(message ? { message } : {}) });
                     if (Array.isArray(result.activity))
                         for (const item of result.activity.slice(0, 500)) {
                             if (!item || typeof item.sessionId !== 'string' || item.sessionId.startsWith('remote:'))

package/dist/server/agent/collaborationRoutes.js

@@ -10,7 +10,7 @@ import { COLLAB_LIMITS, CollaborationError, MIN_ID_PREFIX_LENGTH, ambiguousIdMes
 export function cleanMemberName(value) {
     return value.replace(/[\u0000-\u001f\u007f]/g, ' ').replace(/\s+/g, ' ').trim().slice(0, 80);
 }
-export function collaborationRoutes({ store, resolveSession, deliver, rebind, resolveNames, renameSession }) {
+export function collaborationRoutes({ store, resolveSession, deliver, rebind, diagnoseRoute, resolveNames, renameSession }) {
     const router = Router();
     const run = (handler) => async (req, res) => {
         try {
@@ -96,6 +96,16 @@ export function collaborationRoutes({ store, resolveSession, deliver, rebind, re
         }
         res.json({ ok: true, route: await rebind(sessionId, pane ?? null) });
     }));
+    router.get('/route/:id', run(async (req, res, sessionId) => {
+        const id = String(req.params.id);
+        if (id !== sessionId && !store.groupsForSession(sessionId).some(group => group.sessionIds.includes(id)))
+            throw new CollaborationError('NOT_A_GROUP_MEMBER', 'Route diagnostics require a shared group', 403);
+        if (id.startsWith('remote:'))
+            throw new CollaborationError('REMOTE_ROUTE_DIAGNOSTICS_UNSUPPORTED', 'Query the owning service for the current runtime evidence', 409);
+        if (!diagnoseRoute)
+            throw new CollaborationError('ROUTE_DIAGNOSTICS_UNAVAILABLE', 'The running service does not support route diagnostics (minimum 1.4.321)', 409);
+        res.json({ ok: true, route: await diagnoseRoute(id) });
+    }));
     /** Accepts the short id a terminal shows as well as the full one; an
      *  ambiguous prefix is refused rather than guessed, so a reply can never
      *  land on the wrong thread. */
@@ -152,6 +162,9 @@ export function collaborationRoutes({ store, resolveSession, deliver, rebind, re
     };
     router.get('/capabilities', run((_req, res) => {
         res.json({ protocol_version: 2, server_version: getTermdockVersion(), limits: COLLAB_LIMITS,
+            route_diagnostics: !!diagnoseRoute, route_identity_recovery: !!diagnoseRoute, route_identity_recovery_min_version: '1.4.321',
+            agent_launch_generation_consistency: true, agent_launch_generation_consistency_min_version: '1.4.322',
+            terminal_input_check_diagnostics: true,
             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,

package/dist/server/agent/collaborationRouting.js

@@ -17,6 +17,11 @@ export class CollaborationRoutingStore {
                         || !/^%\d+$/.test(binding.pane.paneId) || !/^\$\d+$/.test(binding.pane.sessionId) || typeof binding.pane.agentSlug !== 'string'))) {
                     throw new Error('Invalid collaboration binding');
                 }
+                if (binding.routeRevision !== undefined && (typeof binding.routeRevision !== 'string' || !/^[a-zA-Z0-9-]{1,80}$/.test(binding.routeRevision)))
+                    throw new Error('Invalid route revision');
+                if (binding.lastRecovery !== undefined && (!binding.lastRecovery || !['native-identity', 'owner-confirmed'].includes(binding.lastRecovery.kind)
+                    || !Number.isSafeInteger(binding.lastRecovery.at)))
+                    throw new Error('Invalid route recovery record');
                 this.bindings.set(binding.sessionId, binding);
             }
         }
@@ -38,6 +43,10 @@ export class CollaborationRoutingStore {
     ownerOfBackend(id) {
         return [...this.bindings.values()].find((binding) => binding.backendSessionId === id)?.sessionId ?? null;
     }
+    hasOtherPaneOwner(id, pane) {
+        return [...this.bindings.values()].some(binding => binding.sessionId !== id && binding.pane
+            && binding.pane.serverPid === pane.serverPid && binding.pane.sessionId === pane.sessionId && binding.pane.paneId === pane.paneId);
+    }
     bind(binding) {
         this.assertReadable();
         const owner = binding.backendSessionId ? this.ownerOfBackend(binding.backendSessionId) : null;
@@ -65,6 +74,29 @@ export class CollaborationRoutingStore {
         this.bindings = next;
     }
 }
+export function assessCollaborationRouteIdentity(binding, panes, ownershipConfirmed, unconfirmedWrite) {
+    const selected = selectCollaborationPane(binding, panes);
+    const metadata = (pane) => ({ serverPid: pane.serverPid, sessionId: pane.sessionId,
+        paneId: pane.paneId, panePid: pane.panePid, agentSlug: pane.agentSlug, nativeSessionId: pane.nativeSessionId });
+    const diagnostics = { expected: binding.pane ? { ...binding.pane } : null,
+        observed: panes.slice(0, 20).map(pane => ({ ...metadata(pane), nativeIdentitySource: pane.nativeIdentitySource ?? null, nativeIdentityFailure: pane.nativeIdentityFailure ?? null, nativeIdentityVerified: pane.nativeIdentityVerified === true })),
+        truncated: panes.length > 20, recovery: 'unchanged', reason: null,
+        rebind_command: `td collab --session ${binding.sessionId} rebind${panes.length === 1 ? ` --pane ${panes[0].paneId}` : ''}` };
+    if (selected.state !== 'identity-mismatch')
+        return { ...selected, diagnostics };
+    const nativeId = binding.pane?.nativeSessionId ?? binding.nativeSessionId;
+    const slug = binding.pane?.agentSlug || binding.agentSlug;
+    const matching = panes.filter(pane => !pane.isShell && pane.agentSlug === slug && pane.nativeSessionId === nativeId
+        && !pane.nativeIdentityFailure && pane.nativeIdentityVerified === true);
+    diagnostics.recovery = 'confirmation-required';
+    diagnostics.reason = unconfirmedWrite ? 'DELIVERY_OUTCOME_UNCONFIRMED' : !ownershipConfirmed ? 'ROUTE_OWNERSHIP_UNCONFIRMED'
+        : !nativeId || !slug ? 'NATIVE_IDENTITY_UNCONFIRMED' : matching.length > 1 ? 'MULTIPLE_NATIVE_IDENTITY_MATCHES'
+            : matching.length !== 1 ? 'NATIVE_IDENTITY_UNCONFIRMED' : null;
+    if (diagnostics.reason)
+        return { ...selected, diagnostics };
+    diagnostics.recovery = 'automatic';
+    return { state: 'ready', pane: matching[0], diagnostics };
+}
 // Once pinned, changing the active pane cannot change the recipient. A reused
 // tmux name/pane after a server restart must not inherit an old peer's inbox.
 export function selectCollaborationPane(binding, panes) {

package/dist/server/agent/collaborationStore.js

@@ -584,6 +584,10 @@ export class CollaborationStore {
         this.expire();
         return [...new Set(this.document.messages.filter((message) => message.status === 'pending').map((message) => message.toSessionId))];
     }
+    hasUnconfirmedDelivery(sessionId) {
+        return this.document.messages.some(message => message.toSessionId === sessionId && message.status === 'pending'
+            && (this.document.transport?.[message.id]?.attempt_count ?? 0) > 0);
+    }
     confirmShell(messageId) {
         const message = this.getMessage(messageId);
         if (!message || message.status !== 'pending')
@@ -773,6 +777,25 @@ export class CollaborationStore {
         (this.document.transport ??= {})[id] = diagnostic;
         this.persist();
     }
+    /** A route blocks the whole recipient queue, not just its first message. */
+    recordRecipientTransport(sessionId, patch) {
+        let changed = false;
+        for (const message of this.document.messages) {
+            if (message.toSessionId !== sessionId || message.status !== 'pending')
+                continue;
+            const previous = this.document.transport?.[message.id];
+            if ((previous?.checked_at ?? 0) > patch.checked_at)
+                continue;
+            const next = { relay_online: null, peer_reachable: null, next_retry_at: null, last_error: null,
+                ...previous, ...patch, attempt_count: previous?.attempt_count ?? 0 };
+            if (JSON.stringify(previous) === JSON.stringify(next))
+                continue;
+            (this.document.transport ??= {})[message.id] = next;
+            changed = true;
+        }
+        if (changed)
+            this.persist();
+    }
     receipt(id, raw = false) {
         const message = this.getMessage(id);
         if (!message)
@@ -788,7 +811,10 @@ export class CollaborationStore {
             failure_reason: message.failureReason ?? null, delivery_semantics: message.status === 'stored' ? 'durable_storage' : facts.deliverySource ?? (facts.deliveredAt === null ? 'not_delivered' : 'legacy_or_unspecified'),
             snapshot: message.snapshot ? (raw ? message.snapshot : plainCollaborationSnapshot(message.snapshot)) : null,
             delivery: { status: facts.status,
-                stage: message.status === 'stored' ? 'stored' : facts.deliveredAt !== null ? 'terminal_written' : diagnostic?.remote_received_at ? 'remote_received' : 'queued',
+                stage: message.status === 'stored' ? 'stored' : facts.deliveredAt !== null ? 'terminal_written' : diagnostic?.route_state === 'identity-mismatch' || diagnostic?.last_error === 'TMUX_PANE_CHANGED' ? 'blocked' : diagnostic?.remote_received_at ? 'remote_received' : 'queued',
+                ...(!diagnostic?.route_diagnostics && diagnostic?.last_error === 'TMUX_PANE_CHANGED' ? { requires_confirmation: true } : {}),
+                ...(diagnostic?.route_diagnostics ? { route: diagnostic.route_diagnostics, route_state: diagnostic.route_state,
+                    requires_confirmation: diagnostic.route_diagnostics.recovery === 'confirmation-required' } : {}),
                 remote_received_at: diagnostic?.remote_received_at ?? null, delivered_at: facts.deliveredAt, error: message.failureReason ?? diagnostic?.last_error ?? null },
             reply: { status: replies.length ? 'received' : 'pending', ack_at: replies.find(reply => reply.responseKind === 'ack')?.createdAt ?? null, reply_ids: replies.map(reply => reply.id) },
             idempotency_key: message.idempotencyKey ?? null,

package/dist/server/agent/collaborationTaskCli.js

@@ -15,7 +15,7 @@ export async function executeTaskCommand(command, request, io) {
         plan: [...bodyOptions, 'attempt', 'evidence'], review: [...bodyOptions, 'artifact', 'evidence', 'verdict'], comment: bodyOptions,
         'request-review': [...bodyOptions, 'artifact', 'assignee', 'revision'],
         revise: [...bodyOptions, 'revision'], close: [...bodyOptions, 'revision'], reopen: [...bodyOptions, 'revision'],
-        coordinate: [...bodyOptions, 'revision'], pause: [...bodyOptions, 'revision'], resume: [...bodyOptions, 'revision'], retry: [...bodyOptions, 'revision'],
+        coordinate: [...bodyOptions, 'revision', 'summary'], pause: [...bodyOptions, 'revision'], resume: [...bodyOptions, 'revision'], retry: [...bodyOptions, 'revision'],
     };
     for (const flag of Object.keys(o))
         if (![...allowed[operation], ...(o.principal ? originOptions : []), 'principal', 'session', 'json', 'jsonl', 'text', 'help'].includes(flag))

package/dist/server/agent/collaborationTaskGuidance.js

@@ -0,0 +1,2 @@
+/** Shared across first dispatch and subsequent coordination wakes. */
+export const GOAL_EXPERIENCE_GUIDE = "用户可理解的拆分与更新：一个用户目标保留一张主卡片，所有执行工作都挂在这个目标下；跟进与返工沿用原目标，不用新的顶层目标表达同一件事。子任务按可验收成果划分，一项有明确产物、负责人、完成标准和必要依赖；标题用简短动词加成果名称，不用角色名、过程日志、ID或‘好的/按计划’。简单问题只安排一个必要执行任务；复杂任务仅在产物或负责人可独立验收时拆分，不为采集、复述、重复汇总制造多份卡片。首次拆分后、范围或依赖变化、明确里程碑或受阻时，用 task coordinate --revision <最新版本> --summary '已完成什么；当前推进什么；下一步或需要用户什么' --content '工作划分、各项产物、依赖顺序和依据' 更新当前目标。摘要面向用户，简短说明变化和下一步，不堆哈希、路径、版本号和验证日志；完整证据保留正文。执行成员用 report --attempt <当前尝试> --status working|blocked|failed --summary '当前明确进展或缺少的条件'；没有新事实不要重复发报告，不报告百分比、预估剩余时间或无法观测的内部活动。只有存在必要的人类决定时用 task ask，普通安排说明不要求用户确认方案。";

package/dist/server/agent/collaborationTaskStore.js

@@ -1,3 +1,4 @@
+import { GOAL_EXPERIENCE_GUIDE } from './collaborationTaskGuidance.js';
 import { randomBytes, createHash } from 'node:crypto';
 import { readFileSync, writeFileSync, mkdirSync, renameSync } from 'node:fs';
 import { dirname } from 'node:path';
@@ -186,15 +187,17 @@ export class CollaborationTaskStore {
             const current = task.attempts.find(a => a.id === task.activeAttemptId);
             const result = task.artifacts.filter(a => a.kind === 'result' && a.attemptId === task.activeAttemptId).at(-1);
             const plan = task.artifacts.filter(a => a.kind === 'plan' && a.attemptId === task.activeAttemptId).at(-1);
-            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 reportSummary = (current?.report?.summary || 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 coordination = task.events.filter(e => e.kind === 'coordinate' && e.attemptId === task.activeAttemptId).at(-1);
             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, ...(task.purpose === 'automation' ? { execution: taskExecution(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: task.acceptance.slice(0, 512),
                 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 }] : [],
+                attempts: current ? [{ ...current, report: current.report ? { ...current.report, summary: reportSummary, summarySource: current.report.summary?.trim() ? 'explicit' : 'excerpt', 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 })),
                 decisions: task.decisions.filter(d => d.status === 'pending').map(d => ({ ...d, question: d.question.slice(0, 512), options: [] })),
-                events: task.events.filter(e => ['revise', 'request-review'].includes(e.kind) && e.attemptId === task.activeAttemptId).slice(-4).map(e => ({ ...e, content: ['user', 'integration'].includes(e.source ?? '') && e.kind === 'revise' ? e.content.slice(0, 512) : '' })) };
+                events: [...task.events.filter(e => ['revise', 'request-review'].includes(e.kind) && e.attemptId === task.activeAttemptId).slice(-4).map(e => ({ ...e, content: ['user', 'integration'].includes(e.source ?? '') && e.kind === 'revise' ? e.content.slice(0, 512) : '' })),
+                    ...(coordination ? [{ ...coordination, content: (coordination.summary || coordination.content).slice(0, 512), summary: coordination.summary?.slice(0, 512), evidence: undefined }] : [])].sort((a, b) => a.sequence - b.sequence) };
         }));
     }
     heads(groupIds, owner) { return this.document.tasks.filter(t => groupIds.includes(t.groupId) && t.ownerServiceId === owner).map(t => ({ id: t.id, revision: t.revision })); }
@@ -227,10 +230,10 @@ export class CollaborationTaskStore {
         task.attempts.push({ id: attemptId, assignee: member(assignee), createdAt: Date.now(), threadId });
         this.event(task, 'assigned', actor, content || '任务已分派');
         doc.outbox.push({ id: id(), taskId: task.id, attemptId, target: assignee, kind: 'task', threadId,
-            content: `本次执行身份：${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。只按用户授权运行测试。' : ''}` });
+            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 正文中。明确里程碑、交付范围变化或遇到阻塞时，可用 report --status working|blocked|failed --summary '用户能理解的当前进展与下一步' --content '原始说明与证据' 更新，不以终端有输出代替报告，不重复无变化的进展。如果同一尝试已经交付或任务已归档，不要重复实施。${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} 创建对应执行成员，再把子任务分派给它。已有成员及其代码执行会话保留创建时的启动方案，不因默认方案变更而更换模型。`;
+        return `${this.baseGoalInstructions(task)}\n${GOAL_EXPERIENCE_GUIDE}\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 '直接回答用户的简短结果和限制'；只读目标直接汇总已核对结果，不创建集成或重复汇总任务。正文保留证据、评审结论和限制，仅代码目标补充目录、分支和提交，等待用户最终验收。任何异常都要留下明确说明，不伪造完成或进度。`;
@@ -354,8 +357,8 @@ export class CollaborationTaskStore {
             taskPurpose(input.purpose);
         const content = text(input.content, '内容');
         const summary = text(input.summary, '结果摘要', 2400);
-        if (summary && (input.kind !== 'report' || input.status !== 'complete'))
-            throw new CollaborationError('INVALID_SUMMARY', '摘要只能随完成结果提交');
+        if (summary && input.kind !== 'coordinate' && (input.kind !== 'report' || !['working', 'blocked', 'failed', 'complete'].includes(input.status ?? '')))
+            throw new CollaborationError('INVALID_SUMMARY', '摘要只能用于进展、阻塞、失败、结果或协调说明');
         if (input.verdict !== undefined && !['pass', 'changes', 'blocked'].includes(input.verdict))
             throw new CollaborationError('INVALID_VERDICT', '评审结论无效');
         if (input.evidence !== undefined && Buffer.byteLength(JSON.stringify(input.evidence)) > 16_384)
@@ -470,10 +473,12 @@ export class CollaborationTaskStore {
                     if (plan && task.approvedPlanArtifactId !== plan.id)
                         throw new CollaborationError('PLAN_PENDING', '方案尚未由用户确认，请先等待决定', 409);
                 }
-                attempt.report = { status: input.status, content, evidence: input.evidence, createdAt: Date.now() };
+                attempt.report = { status: input.status, content, ...(summary ? { summary } : {}), evidence: input.evidence, createdAt: Date.now() };
                 const event = this.event(task, 'report', actor, content, attempt.id);
                 event.reportStatus = input.status;
                 event.evidence = input.evidence;
+                if (summary)
+                    event.summary = summary;
                 if (input.status === 'complete' && attempt.id === task.activeAttemptId && task.status === 'accepted') {
                     task.status = 'open';
                     delete task.acceptedArtifactId;
@@ -631,7 +636,9 @@ export class CollaborationTaskStore {
             else if (input.kind === 'coordinate') {
                 if (task.workflow?.kind !== 'goal' || !sameMember(actor, task.coordinator) || !content)
                     throw new CollaborationError('COORDINATOR_REQUIRED', '请由目标协调者提交本次协调说明', 403);
-                this.event(task, 'coordinate', actor, content);
+                const event = this.event(task, 'coordinate', actor, content);
+                if (summary)
+                    event.summary = summary;
                 task.coordination = { notifiedSequence: task.events.at(-1).sequence, acknowledgedSequence: task.events.at(-1).sequence, notifiedAt: Date.now() };
                 delete task.automationIssue;
             }
@@ -807,7 +814,7 @@ export class CollaborationTaskStore {
                 else if (action === 'wake') {
                     const updates = task.events.filter(e => e.sequence > task.coordination.notifiedSequence && e.kind !== 'coordinate');
                     doc.outbox.push({ id: id(), taskId: task.id, attemptId: task.activeAttemptId, target: task.coordinator, kind: 'message', threadId: task.id,
-                        content: `当前协调身份：${task.coordinator.sessionId}；命令带 --session ${task.coordinator.sessionId}。\n目标「${task.title}」有新的明确事件，请继续协调：\n${updates.slice(-8).map(e => `${new Date(e.createdAt).toISOString()} ${e.content.slice(0, 1200)}`).join('\n')}\n用 td collab task get ${task.id} --json 读取完整上下文与子任务；安排必要下一步后 task coordinate ${task.id} --revision <最新版本> --content '协调说明'。自动评审和依赖已由服务接续，不要重复分派。\n当前流程指南：查询、检查、分析必须 --work-type read-only，复用 roster 现有执行成员；只有修改代码才用 code 和独立目录。只读报告由你直接汇总，不新增仅转述的汇总子任务。已评审且 HEAD 等于 base 的交付没有代码变化，不需要集成；有代码变化才安排必要集成。用户有新要求时继续本目标，交付新版本，不重做已有采样。最终汇总通过评审且无新要求时等待用户验收，不重复提交相同结果。` });
+                        content: `当前协调身份：${task.coordinator.sessionId}；命令带 --session ${task.coordinator.sessionId}。\n目标「${task.title}」有新的明确事件，请继续协调：\n${updates.slice(-8).map(e => `${new Date(e.createdAt).toISOString()} ${e.content.slice(0, 1200)}`).join('\n')}\n用 td collab task get ${task.id} --json 读取完整上下文与子任务；安排必要下一步后 task coordinate ${task.id} --revision <最新版本> --content '协调说明'。自动评审和依赖已由服务接续，不要重复分派。\n当前流程指南：查询、检查、分析必须 --work-type read-only，复用 roster 现有执行成员；只有修改代码才用 code 和独立目录。只读报告由你直接汇总，不新增仅转述的汇总子任务。已评审且 HEAD 等于 base 的交付没有代码变化，不需要集成；有代码变化才安排必要集成。用户有新要求时继续本目标，交付新版本，不重做已有采样。最终汇总通过评审且无新要求时等待用户验收，不重复提交相同结果。\n${GOAL_EXPERIENCE_GUIDE}` });
                     task.coordination.notifiedSequence = task.events.at(-1).sequence;
                     task.coordination.notifiedAt = Date.now();
                 }

package/dist/server/agent/collaborationTmuxDelivery.js

@@ -40,6 +40,7 @@ export function writeCollaborationTmuxPane(run, pane, prompt, stdin, assertCurre
     progress?.('queue_wait');
     return serializeTerminalInput(paneInputKey(pane), () => {
         progress?.('queue_acquired');
+        assertCurrent?.('queue_acquired');
         return writeTmuxPrompt(run, pane, prompt, stdin, assertCurrent, progress);
     });
 }
@@ -47,7 +48,7 @@ async function writeTmuxPrompt(run, pane, prompt,
 /** Body travels on stdin so tmux cannot parse its semicolons/backslashes. */
 stdin, assertCurrent, progress) {
     await assertSamePane(run, pane);
-    assertCurrent?.();
+    assertCurrent?.('before_paste');
     // A fixed pane target is independent of the current window, keyboard focus
     // and browser presence. Delivery goes through a named tmux buffer rather
     // than `send-keys -l`: while a pane is in copy-mode, literal bytes are
@@ -81,7 +82,7 @@ stdin, assertCurrent, progress) {
         progress?.('paste_written');
         await waitForPromptSubmit();
         await assertSamePane(run, pane);
-        assertCurrent?.();
+        assertCurrent?.('before_submit');
         progress?.('submit_attempted');
         await run([
             // The submit key rides outside the paste block: inside it, an editor

package/dist/server/agent/integrationCli.js

@@ -61,6 +61,12 @@ export const INTEGRATION_HELP = `td integration — local scoped integration adm
   diagnostics <TD-session-id> (read stored launch/restore diagnostics; administrator only)
     1.4.314 adds phase/timestamps, paste/submit write facts and target-change
     evidence; no argv/environment/credentials or application readiness claim.
+    1.4.322 adds guard_captured/runtime_resolving/runtime_resolved stages and
+    target_change.check_phase/guard_captured_at/checked_at, launch IDs and route revisions.
+    Check actual server agent_launch_generation_consistency=true (minimum 1.4.322),
+    terminal_input_check_diagnostics=true; upgrading only the CLI does not fix a running service.
+    TERMINAL_INPUT_TARGET_CHANGED still rejects an actually replaced target.
+    create never auto-retries; retry-cold remains a separate, explicitly authorized operation.
     Prior versions cannot reconstruct missing launch evidence retroactively.
   create --file <policy.json> --credential-file <private-output.json>
   update --file <policy.json> (same identity/group; preserves the credential)

package/dist/server/agent/integrationServer.js

@@ -246,6 +246,8 @@ export class IntegrationRuntime {
             session_startup_input_clear: true, session_startup_input_clear_min_version: '1.4.310',
             agent_launch_process_check: true, agent_launch_process_check_min_version: '1.4.312',
             terminal_input_runtime_fence: true, terminal_input_runtime_fence_min_version: '1.4.313',
+            agent_launch_generation_consistency: true, agent_launch_generation_consistency_min_version: '1.4.322',
+            terminal_input_check_diagnostics: true,
             session_launch_diagnostics: true, session_launch_diagnostics_min_version: '1.4.314',
             session_cold_retry: true, session_cold_retry_min_version: '1.4.314',
             session_rename: true, session_rename_min_version: '1.4.315',

package/dist/server/agent/promptDelivery.js

@@ -22,12 +22,12 @@ export function writeBracketedPrompt(target, prompt, assertCurrent, progress) {
     progress?.('queue_wait');
     return serializeTerminalInput(target, async () => {
         progress?.('queue_acquired');
-        assertCurrent?.();
+        assertCurrent?.('queue_acquired');
         progress?.('paste_attempted');
         target.write(buildBracketedPasteBytes(prompt));
         progress?.('paste_written');
         await waitForPromptSubmit();
-        assertCurrent?.();
+        assertCurrent?.('before_submit');
         progress?.('submit_attempted');
         target.write('\r');
         progress?.('submit_written');

package/dist/server/agent/sessionBindingRecovery.js

@@ -39,7 +39,7 @@ export function resolveCollaborationBackend(record, records, backends, routing)
         return null;
     if (records.some((other) => other.sessionId !== record.sessionId && other.backendSessionId === id))
         return null;
-    routing.bind({ sessionId: record.sessionId, backendSessionId: id, mode: backend.mode,
+    routing.bind({ ...binding, sessionId: record.sessionId, backendSessionId: id, mode: backend.mode,
         tmuxSessionName: backend.tmuxSessionName,
         agentSlug: binding?.agentSlug ?? backend.agent?.slug ?? record.agentResume?.slug ?? null,
         nativeSessionId: binding?.nativeSessionId ?? backend.agentSession?.sessionId ?? record.agentResume?.sessionId ?? null,

package/dist/server/agent/sessionLaunchState.js

@@ -0,0 +1,20 @@
+import { TerminalInputTargetChangedError } from './terminalInput.js';
+/** Display/identity metadata may have crossed an await with an old snapshot.
+ * Only the launch lifecycle can change these server-owned control fields. */
+export function mergeSessionLaunchState(candidate, current, change) {
+    if (!change)
+        return current ? { ...candidate,
+            agentLaunchGeneration: current.agentLaunchGeneration ?? null,
+            agentLaunchCheck: current.agentLaunchCheck ?? null,
+        } : candidate;
+    if (!current || (current.agentLaunchGeneration ?? null) !== change.expectedGeneration
+        || (current.agentLaunchCheck?.id ?? null) !== change.expectedCheckId) {
+        throw new TerminalInputTargetChangedError({
+            expected_backend_session_id: candidate.backendSessionId, current_backend_session_id: current?.backendSessionId ?? null,
+            expected_launch_id: change.expectedGeneration, current_launch_id: current?.agentLaunchGeneration ?? null,
+            backend_instance_matches: !!current && candidate.backendSessionId === current.backendSessionId,
+            check_phase: 'launch_state_commit', checked_at: Date.now(),
+        });
+    }
+    return { ...candidate, agentLaunchGeneration: change.generation, agentLaunchCheck: change.check };
+}

package/dist/server/agent/terminalInput.js

@@ -22,6 +22,23 @@ export class TerminalInputTargetChangedError extends Error {
         this.evidence = evidence;
     }
 }
+/** Capture once, including for a launch's own command. Never adopt a newer
+ * generation simply because the physical backend has stayed the same. */
+export function captureRuntimeInputGuard(current, expected = current()) {
+    const capturedAt = Date.now();
+    return (phase = 'guard_capture') => {
+        const actual = current();
+        const matches = actual.backendInstance === expected.backendInstance;
+        if (actual.backendSessionId !== expected.backendSessionId || !matches
+            || actual.launchId !== expected.launchId || actual.routeRevision !== expected.routeRevision) {
+            throw new TerminalInputTargetChangedError({ expected_backend_session_id: expected.backendSessionId,
+                current_backend_session_id: actual.backendSessionId, expected_launch_id: expected.launchId,
+                current_launch_id: actual.launchId, backend_instance_matches: matches, check_phase: phase,
+                guard_captured_at: capturedAt, checked_at: Date.now(), expected_route_revision: expected.routeRevision,
+                current_route_revision: actual.routeRevision });
+        }
+    };
+}
 /** Clearing a one-time launch check does not change the runtime generation. */
 export function captureTerminalInputGuard(current, expected = current()) {
     return () => {