termdock 1.4.319 → 1.4.321

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,7 @@ 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',
             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/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/routes/terminal.js

@@ -66,7 +66,7 @@ import { SessionSearchStore } from '../agent/sessionSearchStore.js';
 import { NativeSessionSearch } from '../agent/nativeSessionSearch.js';
 import { CollaborationError } from '../agent/collaborationProtocol.js';
 import { resolveCollaborationBackend, resolveCollaborationSessionId } from '../agent/sessionBindingRecovery.js';
-import { CollaborationRoutingStore, selectCollaborationPane, selectDrivePane } from '../agent/collaborationRouting.js';
+import { CollaborationRoutingStore, selectCollaborationPane, selectDrivePane, assessCollaborationRouteIdentity } from '../agent/collaborationRouting.js';
 import { CollaborationDeliveryWorker } from '../agent/collaborationDeliveryWorker.js';
 import { approveCollaborationDialog, captureTmuxPaneHistory, captureTmuxPaneText, sendTmuxPaneKey, writeCollaborationTmuxPane } from '../agent/collaborationTmuxDelivery.js';
 import { listAllHookAgents, refreshStaleHooksAtLaunch, installHooksForSlug, uninstallHooksForSlug, } from '../agent/installers.js';
@@ -678,6 +678,9 @@ process.on('SIGINT', () => { void shutdownWithRecordings(); });
 // 服务启动时从磁盘加载（带去重，防止历史累积的重复条目复活）
 void (async () => {
     await Promise.all([loadGlobalSessionStateFromDisk(), loadTmuxRecoveryStateFromDisk()]);
+    // Delivery needs the loaded inventory, not optional PTY adoption/metadata backfill.
+    // Those steps must not leave durable messages without a background scheduler.
+    collaborationDeliveryWorker.start();
     await watchGlobalSessionStateFile();
     // pty-host adoption runs after the state load (its record upserts must not
     // be clobbered) and before pruning (surviving shell records' backends are
@@ -687,7 +690,6 @@ void (async () => {
     });
     pruneOrphanSessions();
     await backfillPersistedTmuxMetadata();
-    collaborationDeliveryWorker.start();
 })();
 caffeinateManager.startNetworkMonitor();
 // 清理磁盘恢复后后端已不存在的 session 引用。
@@ -1483,13 +1485,15 @@ function terminalInputGuard(record) {
     const frontendSessionId = record.sessionId;
     const backendSessionId = record.backendSessionId;
     const launchId = record.agentLaunchGeneration ?? null;
+    const routeRevision = collaborationRouting.get(frontendSessionId)?.routeRevision ?? null;
     const backend = backendSessionId ? terminalSessions.get(backendSessionId) : undefined;
     return () => {
         const latest = globalSessionState.sessions.find(candidate => candidate.sessionId === frontendSessionId);
         if (!latest)
             throw new Error('SESSION_REMOVED');
         const instanceMatches = !backendSessionId || terminalSessions.get(backendSessionId) === backend;
-        if ((latest.agentLaunchGeneration ?? null) !== launchId || latest.backendSessionId !== backendSessionId || !instanceMatches) {
+        if ((collaborationRouting.get(frontendSessionId)?.routeRevision ?? null) !== routeRevision
+            || (latest.agentLaunchGeneration ?? null) !== launchId || latest.backendSessionId !== backendSessionId || !instanceMatches) {
             throw new TerminalInputTargetChangedError({ expected_backend_session_id: backendSessionId, current_backend_session_id: latest.backendSessionId,
                 expected_launch_id: launchId, current_launch_id: latest.agentLaunchGeneration ?? null, backend_instance_matches: instanceMatches });
         }
@@ -1612,6 +1616,7 @@ export function resolveStableFederationSessionId(id) {
 }
 function collaborationRemoteSessions() {
     return Array.from(new Map(collaborationStore.list().flatMap((group) => group.remoteSessions ?? [])
+        .filter(session => session.sessionId.startsWith('remote:'))
         .map((session) => {
         const facts = collaborationStore.sessionFacts(session.sessionId, false);
         const { currentTask: _currentTask, ...terminalSession } = session;
@@ -1622,8 +1627,7 @@ function collaborationRemoteSessions() {
     })).values());
 }
 function tryDeliverCollaborationInbox(frontendSessionId) {
-    const remote = collaborationRemoteSessions().find((session) => session.sessionId === frontendSessionId);
-    if (remote) {
+    if (frontendSessionId.startsWith('remote:')) {
         return { delivered: [], pending: collaborationStore.pendingCount(frontendSessionId), waitable: true,
             reason: '跨服务消息已入队，服务后台正在投递；使用 message get 查看送达回执或注册、重试原因。' };
     }
@@ -1669,7 +1673,7 @@ function formatLocalCollaborationMessages(frontendSessionId, messages) {
  *  agent-keyed selector can never reach it. Delivery still needs an agent (the
  *  confirm gate and prompt formatting assume a TUI); driving a terminal —
  *  run/capture — is a shell operation and works on any pane. */
-async function inspectCollaborationTmux(binding, requestedPane, allowPlainPane = false, nativeProcessIdentity = false, freshProcess = false) {
+async function inspectCollaborationTmux(binding, requestedPane, allowPlainPane = false, nativeProcessIdentity = false, freshProcess = false, describeNativeFailure = false) {
     if (!binding.tmuxSessionName)
         return { state: 'offline', reason: 'TMUX_BINDING_MISSING' };
     const name = `=${binding.tmuxSessionName}`;
@@ -1696,14 +1700,16 @@ async function inspectCollaborationTmux(binding, requestedPane, allowPlainPane =
         const program = await resolveTmuxPaneProgram(pane, true, nativeProcessIdentity || freshProcess);
         const agent = detectAgentFromCommand(program?.rawArgs ?? program?.command ?? '', agentCustomCommands());
         const identity = nativeProcessIdentity ? await observeProgramNativeIdentity(agent, program)
-            : { nativeId: agent && program?.rawArgs ? inferResumeSessionId(agent, splitCommandToArgv(program.rawArgs)) : null, failure: null };
-        if (identity.failure)
+            : { nativeId: agent && program?.rawArgs ? inferResumeSessionId(agent, splitCommandToArgv(program.rawArgs)) : null, failure: null, source: null };
+        if (identity.failure && !describeNativeFailure)
             integrationError(identity.failure === 'NATIVE_SESSION_IDENTITY_CONFLICT'
                 ? 'NATIVE_SESSION_ID_MISMATCH' : 'NATIVE_SESSION_OWNER_UNCONFIRMED', 'Current process native identity evidence conflicts or cannot be uniquely verified', 409);
         const nativeSessionId = identity.nativeId;
         return { serverPid, sessionId: layout.sessionId, paneId: pane.id, panePid: pane.pid,
             agentSlug: agent?.slug ?? '', nativeSessionId, cwd: pane.currentPath,
-            isShell: shellNamesBackend.has(normalizeProgramName(program?.command ?? '')?.toLowerCase() ?? '') };
+            isShell: shellNamesBackend.has(normalizeProgramName(program?.command ?? '')?.toLowerCase() ?? ''),
+            ...(nativeProcessIdentity ? { nativeIdentitySource: identity.source, nativeIdentityFailure: identity.failure,
+                nativeIdentityVerified: identity.source === 'linux-flock-owner' && !identity.failure } : {}) };
     }));
     const candidates = requestedPane ? panes.filter((pane) => pane.paneId === requestedPane) : panes;
     if (allowPlainPane && !binding.pane) {
@@ -1711,24 +1717,56 @@ async function inspectCollaborationTmux(binding, requestedPane, allowPlainPane =
         // pane so a plain shell member is drivable (run/capture are shell ops).
         return selectDrivePane(binding, candidates, layout.activePaneId);
     }
-    return selectCollaborationPane(binding, candidates);
+    return { ...selectCollaborationPane(binding, candidates), candidates };
+}
+function routeOwnershipConfirmed(frontendSessionId, binding, panes) {
+    const record = globalSessionState.sessions.find(candidate => candidate.sessionId === frontendSessionId);
+    return !!record && record.mode === 'tmux' && record.tmuxSessionName === binding.tmuxSessionName
+        && !globalSessionState.sessions.some(other => other.sessionId !== frontendSessionId && (other.tmuxSessionName === binding.tmuxSessionName
+            || !!binding.backendSessionId && other.backendSessionId === binding.backendSessionId))
+        && (!binding.backendSessionId || [null, frontendSessionId].includes(collaborationRouting.ownerOfBackend(binding.backendSessionId)))
+        && panes.every(pane => !collaborationRouting.hasOtherPaneOwner(frontendSessionId, pane));
+}
+function routeHasUnconfirmedWrite(frontendSessionId) {
+    return collaborationStore.hasUnconfirmedDelivery(frontendSessionId);
+}
+async function describeCollaborationRoute(frontendSessionId) {
+    const record = globalSessionState.sessions.find(candidate => candidate.sessionId === frontendSessionId);
+    if (!record)
+        throw new Error('SESSION_REMOVED');
+    const binding = collaborationRouting.get(frontendSessionId);
+    if (!binding || binding.mode !== 'tmux')
+        return { session_id: frontendSessionId, binding,
+            worker: collaborationDeliveryWorker.diagnostics(frontendSessionId), identity: null };
+    const inspected = await inspectCollaborationTmux(binding, null, false, true, true, true);
+    const assessment = assessCollaborationRouteIdentity(binding, inspected.candidates ?? [], routeOwnershipConfirmed(frontendSessionId, binding, inspected.candidates ?? []), routeHasUnconfirmedWrite(frontendSessionId));
+    return { session_id: frontendSessionId, binding, worker: collaborationDeliveryWorker.diagnostics(frontendSessionId),
+        observed_at: Date.now(), state: inspected.state, error: inspected.reason ?? null, identity: assessment.diagnostics,
+        integration_managed: record.tmuxSessionName?.startsWith('wt-integration-') ?? false };
 }
 async function rebindCollaborationRoute(frontendSessionId, paneId) {
     await collaborationDeliveryWorker.reconfigure(frontendSessionId, async () => {
         const record = globalSessionState.sessions.find((candidate) => candidate.sessionId === frontendSessionId);
         if (!record)
             throw new Error('SESSION_REMOVED');
+        if (record.tmuxSessionName?.startsWith('wt-integration-'))
+            throw new Error('INTEGRATION_SESSION_RESTORE_REQUIRED: use the owning principal session restore lifecycle');
         const previous = collaborationRouting.get(frontendSessionId);
+        if (routeHasUnconfirmedWrite(frontendSessionId))
+            throw new Error('ROUTE_DELIVERY_OUTCOME_UNCONFIRMED: inspect prior write outcome before rebinding; the body is not replayed');
         const binding = {
             sessionId: frontendSessionId, backendSessionId: previous?.backendSessionId ?? record.backendSessionId,
             mode: record.mode, tmuxSessionName: record.tmuxSessionName ?? previous?.tmuxSessionName ?? null,
             agentSlug: null, nativeSessionId: null, pane: null,
+            routeRevision: crypto.randomUUID(), lastRecovery: { kind: 'owner-confirmed', at: Date.now(), previousPane: previous?.pane ?? null },
         };
         if (binding.mode === 'tmux') {
             const inspected = await inspectCollaborationTmux(binding, paneId);
             if (inspected.state !== 'ready' || !inspected.pane)
                 throw new Error(inspected.reason ?? 'AGENT_NOT_RUNNING');
             const pane = inspected.pane;
+            if (!routeOwnershipConfirmed(frontendSessionId, binding, [pane]))
+                throw new Error('ROUTE_OWNERSHIP_UNCONFIRMED');
             binding.pane = { serverPid: pane.serverPid, sessionId: pane.sessionId, paneId: pane.paneId, panePid: pane.panePid,
                 agentSlug: pane.agentSlug, nativeSessionId: pane.nativeSessionId };
             binding.agentSlug = pane.agentSlug;
@@ -1759,6 +1797,7 @@ async function rebindCollaborationRoute(frontendSessionId, paneId) {
  * snapshot of the recipient after the write, and the sender judges from that.
  */
 async function resolveCollaborationRoute(frontendSessionId) {
+    let recoveredNativeIdentity = false;
     let record = globalSessionState.sessions.find((candidate) => candidate.sessionId === frontendSessionId);
     if (!record)
         return { state: 'offline', reason: 'SESSION_REMOVED' };
@@ -1774,7 +1813,26 @@ async function resolveCollaborationRoute(frontendSessionId) {
         agentSlug: record.agentResume?.slug ?? null, nativeSessionId: record.agentResume?.sessionId ?? null, pane: null,
     };
     if (binding.mode === 'tmux') {
-        const inspected = await inspectCollaborationTmux(binding, undefined, false, Boolean(record.agentLaunchCheck?.nativeSessionId), Boolean(record.agentLaunchCheck));
+        let inspected = await inspectCollaborationTmux(binding, undefined, false, Boolean(record.agentLaunchCheck?.nativeSessionId), Boolean(record.agentLaunchCheck));
+        if (inspected.state === 'identity-mismatch' && !record.tmuxSessionName?.startsWith('wt-integration-')) {
+            const observed = await inspectCollaborationTmux(binding, null, false, true, true, true);
+            const assessment = assessCollaborationRouteIdentity(binding, observed.candidates ?? [], routeOwnershipConfirmed(frontendSessionId, binding, observed.candidates ?? []), routeHasUnconfirmedWrite(frontendSessionId));
+            if (assessment.diagnostics.recovery !== 'automatic' || !assessment.pane)
+                return { state: 'identity-mismatch', reason: 'TMUX_PANE_CHANGED', diagnostics: assessment.diagnostics };
+            const previous = collaborationRouting.get(frontendSessionId);
+            if (JSON.stringify(previous) !== JSON.stringify(binding))
+                return { state: 'recovering', reason: 'ROUTE_CHANGED_DURING_RECOVERY' };
+            const verify = await inspectCollaborationTmux(binding, null, false, true, true, true);
+            const confirmed = assessCollaborationRouteIdentity(binding, verify.candidates ?? [], routeOwnershipConfirmed(frontendSessionId, binding, verify.candidates ?? []), routeHasUnconfirmedWrite(frontendSessionId));
+            if (confirmed.diagnostics.recovery !== 'automatic' || !confirmed.pane || JSON.stringify(confirmed.pane) !== JSON.stringify(assessment.pane)) {
+                return { state: 'identity-mismatch', reason: 'ROUTE_CHANGED_DURING_RECOVERY', diagnostics: confirmed.diagnostics };
+            }
+            binding = { ...binding, pane: confirmed.pane, routeRevision: crypto.randomUUID(),
+                lastRecovery: { kind: 'native-identity', at: Date.now(), previousPane: binding.pane } };
+            collaborationRouting.bind(binding);
+            inspected = { state: 'ready', pane: confirmed.pane };
+            recoveredNativeIdentity = true;
+        }
         assertGeneration();
         if (inspected.state !== 'ready' || !inspected.pane)
             return inspected;
@@ -1816,6 +1874,14 @@ async function resolveCollaborationRoute(frontendSessionId) {
         return { state: 'ready', isShell: pane.isShell, capture: async () => captureTmuxPaneText(runTmux, pinned), write: async (messages) => {
                 if (!globalSessionState.sessions.some((candidate) => candidate.sessionId === frontendSessionId))
                     throw new Error('SESSION_REMOVED');
+                if (recoveredNativeIdentity) {
+                    const current = await inspectCollaborationTmux(binding, null, false, true, true, true);
+                    const proof = current.candidates?.find(candidate => candidate.serverPid === pinned.serverPid && candidate.sessionId === pinned.sessionId
+                        && candidate.paneId === pinned.paneId && candidate.panePid === pinned.panePid);
+                    if (!proof?.nativeIdentityVerified || proof.nativeIdentityFailure || proof.nativeSessionId !== pinned.nativeSessionId
+                        || proof.agentSlug !== pinned.agentSlug || !routeOwnershipConfirmed(frontendSessionId, binding, [proof]))
+                        throw new Error('ROUTE_NATIVE_IDENTITY_CHANGED_BEFORE_WRITE');
+                }
                 await writeCollaborationTmuxPane(runTmux, pinned, formatLocalCollaborationMessages(frontendSessionId, messages), runTmuxStdin, () => { assertGeneration(); assertCurrent(); });
                 backend.lastActivity = Date.now();
             } };
@@ -6474,7 +6540,8 @@ router.get('/operations/collaboration-groups/:groupId/messages', (req, res) => {
         return ambiguousGroupResponse(res, ambiguous);
     if (!group)
         return res.status(404).json({ error: '协作组不存在' });
-    res.json({ messages: collaborationStore.listMessages(group.id, Number(req.query.limit) || 200) });
+    res.json({ messages: collaborationStore.listMessages(group.id, Number(req.query.limit) || 200)
+            .map(message => ({ ...message, delivery: collaborationStore.receipt(message.id).delivery })) });
 });
 router.post('/operations/collaboration-groups/:groupId/messages', (req, res) => {
     try {
@@ -6789,7 +6856,7 @@ router.post('/operations/orchestration/drive', async (req, res) => {
     }
 });
 router.use('/operations/orchestration', collaborationRoutes({ store: collaborationStore, resolveSession: resolveFrontendSessionId,
-    deliver: tryDeliverCollaborationInbox, rebind: rebindCollaborationRoute,
+    deliver: tryDeliverCollaborationInbox, rebind: rebindCollaborationRoute, diagnoseRoute: describeCollaborationRoute,
     resolveNames: (ids) => {
         const names = new Map([...collaborationRemoteSessions(),
             ...globalSessionState.sessions.map(orchestrationSessionSnapshot)].map((session) => [session.sessionId, session.name]));

package/dist/server/utils/settings.js

@@ -772,7 +772,7 @@ export function normalizeCollaborationPanels(value, depth = 0) {
 }
 export function normalizeRightSidebarTabs(value) {
     const raw = value && typeof value === 'object' ? value : {};
-    return { architecture: raw.architecture !== false, computer: raw.computer !== false };
+    return { architecture: raw.architecture === true, computer: raw.computer === true };
 }
 export function getRightSidebarTabsSetting() { return loadSettings().rightSidebarTabs; }
 export function setRightSidebarTabsSetting(patch) {

package/docs/integrations.md

@@ -1169,3 +1169,76 @@ TD/native session ID、消息/reply、事件/consumer 历史。没有 Agent 启
 并发不同键竞争/同键重放、删除/跨服务、管理员 Unix 路由/CLI 权限及 JSON、网页列表
 回读和旧网页表单版本冲突。DevBox 业务组及真实 macOS/iOS 显示尚待接入方实机验收，
 不以源码/模拟回归代替其运行现场。
+
+## 1.4.321：普通协作会话的承载变化、阻断诊断与恢复
+
+最低 CLI/实际服务均为 **1.4.321**；普通协作协议仍为 2，integration protocol 仍为 1。
+当前 CLI 版本不能替代实际服务版本；普通成员使用
+`td collab --session <自身ID> capabilities --json` 回读 `server_version`、
+`route_diagnostics=true`、`route_identity_recovery=true`、
+`route_identity_recovery_min_version=1.4.321`。
+
+```sh
+td collab --session <自身ID> route get <精确本地目标ID> --json
+td collab --session <自身ID> message get <原消息ID> --receipt-only --json
+# 只有目标拥有者在自己的真实终端确认“当前承载就是目标”后执行：
+td collab --session <目标自身ID> rebind --pane <当前pane-ID> --json
+```
+
+`route get` 为只读 `GET /operations/orchestration/route/:id`，只允许自身或共享组的本地
+成员；不解析前缀/名称，不替远端拥有者查询其当前进程。旧服务缺能力时 CLI 明确拒绝。
+返回 `route.session_id/binding/worker/observed_at/state/error/identity`：worker 包括
+`started/tick_in_progress/recipient_in_progress/last_tick_at/route/pending_count`；identity
+包括原 `expected`、当前 `observed`（最多 20 项、`truncated`）、`recovery/reason` 和
+拥有者正式 `rebind_command`。只导出承载标识、Agent 类型及原生身份证据元数据，
+没有终端正文、argv、环境或凭据。证据未知即未知，不使用旧缓存 UUID 替代当前身份。
+只读查询不启动/恢复 Agent、改绑或补键，不把进程/身份正确称为输入已就绪。
+
+已绑定的 tmux server/session/pane/PID 变化时，原物理身份保护仍拒绝直接写入。
+消息维持 `status=pending`，诊断会给 `delivery.stage=blocked`、`error=TMUX_PANE_CHANGED`、
+`route_state`、`requires_confirmation` 及 `route` 差异/建议；`attempt_count=0` 表示尚未
+尝试写入，不等于失败后可重发。现有 `message.delivery` 主动事件携带该 receipt；
+网页协作记录也展示绑定变化和投递暂停，保留原正文。跨服务交换在状态不变但错误变化
+时仍同步错误，不因 pending 状态相同而隐去新的阻断。运行服务未采集过的历史差异
+不能由新版本凭空补出；`worker.started` 等字段用于确认当前调度事实。
+
+本地/远端目标依据稳定 `remote:` 地址区分，组是否 federated 不影响组内本地消息进入
+本地 worker。后台 worker 在会话登记加载完成后启动，不等待额外 PTY adoption 或
+tmux 元数据 backfill；订阅消息存储变化并保留定时重试。缺绑定/进程/权限时仍保留原
+消息，诊断拒绝原因，不依赖网页维持投递。此加固不能替代旧现场的运行证据，也不能
+从过去缺少 transport 条目推断唯一内部根因。
+
+承载变化后的**自动**更新仅用于普通 tmux 会话，并同时要求：原生 ID/Agent 类型已知，
+当前可信 provider 独立核验同一原生 ID、同一 Agent，唯一匹配且原逻辑记录/后端/pane
+归属无冲突，没有原待投递消息的未确认写入尝试。对账前再次核验当前候选和登记，
+首次继续写入前再次核验当前原生身份。只改绑定，不启动/恢复/切换原生 Agent。
+当前独立证据 provider 是已配置的 Linux flock-owner 核验；核心不按 Agent 名称或
+TUI 展示字符串分支。argv 的 resume ID 只能作为启动意图元数据，单独不满足自动更新。
+因此没有可靠 provider 的 Mac 冷启动 Codex 等场景需要明确拥有者确认，不能宣称跨
+平台自动身份恢复已通过。独立证据的能力/适用平台由 provider 决定。
+
+原生身份缺失/不同、多匹配、归属不明或此前写入结果不明时，保留原消息并显示
+`confirmation-required` 及对应原因（`NATIVE_IDENTITY_UNCONFIRMED`、
+`MULTIPLE_NATIVE_IDENTITY_MATCHES`、`ROUTE_OWNERSHIP_UNCONFIRMED`、
+`DELIVERY_OUTCOME_UNCONFIRMED`）。拥有者确认当前承载后可用现有 rebind 明确接受当前
+Agent/原生身份；这不是承诺精确恢复旧原生历史，也不要求猜 UUID 或编辑私有记录。
+无运行 tmux 的情况须先通过原会话恢复入口恢复承载，不能靠 rebind 新建。
+
+重新绑定与投递按该逻辑成员的 worker 屏障串行，持久保存 `routeRevision` 和
+`lastRecovery={kind,at,previousPane}`，后者只记录最近一次自动/显式绑定恢复。
+绑定以 routing 文件原子替换提交；失败不采用新绑定。输入队列同时核验 routeRevision，
+旧队列不能在新绑定上继续粘贴/提交。待处理消息已经记录尝试（`attempt_count>0`）而结果
+未确认时，显式 rebind 返回 `ROUTE_DELIVERY_OUTCOME_UNCONFIRMED`，先对账，不能借修复
+重发正文。记录不承诺永久审计或跨掉电的恰好一次输入；原终端传输的写入语义/保留
+边界不变。
+
+`IntegrationSession` 不通过普通 rebind 绕过其代次/精确 UUID/配置与所有者保护，须继续
+用受限 principal 的 `session get/restore`；普通 rebind 对此返回
+`INTEGRATION_SESSION_RESTORE_REQUIRED`。当前修复不改变业务任务、principal、组、
+message/thread/幂等键或历史，不自动补 Enter、不用屏幕文字识别消费；delivered 仍只
+表示终端写入，完成须明确回复。
+
+回归覆盖同组本地消息处于 federated 组、存储变化唤醒/后台阻断、修复后原消息单次
+投递、不同/缺失/弱原生证据、多匹配/归属/未知旧写入拒绝、绑定持久化和失败、
+只读路由权限/CLI、网页暂停提示及加密传输边界。Mac 实际现场的当前原生身份尚未独立确认，原消息尚待拥有者确认及接入方实际服务
+升级/回读后继续投递；不以维护机回归冒充该现场已恢复。

package/package.json

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

package/runtime-manifest.json

@@ -1,13 +1,13 @@
 {
   "schemaVersion": 1,
   "packageName": "termdock",
-  "version": "1.4.319",
+  "version": "1.4.321",
   "runtimeProtocolVersion": 1,
   "minimumDesktopVersion": "1.4.46",
   "nodeMajor": 22,
   "dependencyHash": "sha256-oaGYi/P5ob8sd6VnNBOwshKozjhdV+hYiCmLAsn5x00=",
-  "serverBundleHash": "sha256-aIgdB+VZkOBFzs7DT4Slt/9Rm5pdM1mMkJXe3/FZxPM=",
-  "clientBundleHash": "sha256-WCUoxmf/ziVtU3GXXqX1A7M84gFLPv/RWWFcBBVtcfQ=",
+  "serverBundleHash": "sha256-o36V1OU5HWHaYRXX3y2vcIKrppx0O4wtdbCRN90DifI=",
+  "clientBundleHash": "sha256-rMB/XxqqSbnbT1KeX2KqTnR82mLyuW/NFSb1X7Y6BRE=",
   "entrypoint": "dist/server/cli.js",
   "clientEntrypoint": "dist/client/index.html"
 }

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

@@ -1,2 +0,0 @@
-import{by as r}from"./app-CI3Oh-41.js";import{b as m}from"./dnd-BCFAPC0L.js";import{b as n}from"./RightSidebar-CXykcIPb.js";import"./react-XDCjal2T.js";import"./terminal-C7X98Amf.js";import"./App-9yy2aYiT.js";import"./gestureArbiter-D6uN_O0i.js";import"./triangle-alert-B5d_l343.js";import"./referenceLongPress-C91ZK5h8.js";import"./DiffReview-C1TyvrA9.js";import"./sparkles-BhmNaa1u.js";import"./DiffViewer-ByAlz2NG.js";import"./ChangeWalkthroughPanel-B0JYVVwB.js";function g({content:o}){const e=m.useMemo(()=>n(o.split(`
-`),null,null),[o]);return r.jsx("div",{className:"min-w-0 space-y-3 break-words text-sm leading-6 text-foreground [&_h1]:text-lg [&_h2]:text-base [&_h3]:text-sm [&_pre]:max-w-full [&_table]:text-xs",children:e.map((t,i)=>r.jsx("div",{className:"min-w-0",children:typeof t.content=="function"?t.content(null):t.content},i))})}export{g as default};