termdock 1.4.327 → 1.4.329

package/dist/server/agent/integrationSessions.js

@@ -61,6 +61,7 @@ export class IntegrationSessions {
     lifecycle = new SessionLifecycleCoordinator();
     mutations = new Map();
     coldRetries = new Set();
+    reconcilingBindings = new Set();
     closingOperations = new Set();
     timers = new Set();
     stopObservation;
@@ -302,7 +303,13 @@ export class IntegrationSessions {
         return record;
     }
     async restore(principal, id, key) {
-        return this.mutate(principal, key, ['restore', id], () => this.lifecycle.run(id, () => this.restoreOnce(principal, id, key)));
+        return this.mutate(principal, key, ['restore', id], async () => {
+            // A get can reconcile a proven tmux-recovery binding before restore takes
+            // the per-session lifecycle lock. restoreOnce then sees the exact live
+            // native owner and remains a no-op instead of launching a second Agent.
+            await this.get(principal, id);
+            return this.lifecycle.run(id, () => this.restoreOnce(principal, id, key));
+        });
     }
     async retryCold(principal, id, generation, key) {
         return this.mutate(principal, key, ['retry-cold', id, generation], () => this.lifecycle.run(id, async () => {
@@ -690,7 +697,7 @@ export class IntegrationSessions {
             return record;
         }));
     }
-    async refresh(id) {
+    async refresh(id, allowBindingReconciliation = true) {
         const record = structuredClone(this.doc.sessions.find(s => s.session_id === id));
         if (!record)
             return;
@@ -781,8 +788,19 @@ export class IntegrationSessions {
             const current = this.doc.sessions.find(s => s.session_id === id);
             if (JSON.stringify(current) !== JSON.stringify(record))
                 return;
+            if (this.lifecycle.active(id) || this.pending.has(id))
+                return;
             const code = error.code;
             const errorCode = typeof code === 'string' ? code : 'SESSION_OBSERVATION_FAILED';
+            if (allowBindingReconciliation && errorCode === 'SESSION_IDENTITY_MISMATCH' && this.adapter.reconcileRecoveryBinding
+                && ['ready', 'failed'].includes(record.state) && (record.runtime_present === true || record.state === 'failed')
+                && (!record.error_code || record.error_code === 'SESSION_IDENTITY_MISMATCH')
+                && record.agent_native_session_id && record.terminal_binding && !record.operation_uncertain
+                && !record.close_intent && !record.rename_pending && !record.cold_retry_pending
+                && !this.pending.has(id) && !this.lifecycle.active(id)) {
+                if (await this.reconcileRecoveredBinding(record))
+                    return;
+            }
             if (record.state !== 'failed' || record.error_code !== errorCode)
                 this.saveRecord({ ...record, state: 'failed', error_code: errorCode,
                     launch_diagnostics: record.launch_diagnostics ? launchFailure(record.launch_diagnostics, error, errorCode) : undefined, updated_at: Date.now() });
@@ -871,11 +889,66 @@ export class IntegrationSessions {
             this.saveRecord(next);
         }
     }
+    async reconcileRecoveredBinding(expected) {
+        const id = expected.session_id;
+        const reconcile = this.adapter.reconcileRecoveryBinding;
+        if (!reconcile || this.lifecycle.active(id) || this.pending.has(id))
+            return false;
+        let committed = false;
+        try {
+            await this.lifecycle.run(id, async () => {
+                const current = this.doc.sessions.find(record => record.session_id === id);
+                if (!current || JSON.stringify(current) !== JSON.stringify(expected) || this.pending.has(id)
+                    || !['ready', 'failed'].includes(current.state) || !(current.runtime_present === true || current.state === 'failed')
+                    || (current.error_code && current.error_code !== 'SESSION_IDENTITY_MISMATCH')
+                    || current.operation_uncertain || current.close_intent || current.rename_pending || current.cold_retry_pending
+                    || !current.agent_native_session_id || !current.terminal_binding)
+                    return;
+                this.reconcilingBindings.add(id);
+                let reconciled;
+                try {
+                    reconciled = await reconcile.call(this.adapter, current);
+                }
+                catch {
+                    return;
+                }
+                if (!reconciled || JSON.stringify(reconciled.binding) === JSON.stringify(current.terminal_binding))
+                    return;
+                const latest = this.doc.sessions.find(record => record.session_id === id);
+                if (!latest || JSON.stringify(latest) !== JSON.stringify(current))
+                    return;
+                const now = Date.now();
+                const next = { ...current, terminal_binding: structuredClone(reconciled.binding), state: 'ready',
+                    runtime_present: true, error_code: null, operation_uncertain: false, generation: (current.generation ?? 1) + 1,
+                    operation_id: randomUUID(), updated_at: now,
+                    binding_reconciliation: { at: now, recovery_operation_id: reconciled.recoveryOperationId,
+                        previous_binding: structuredClone(current.terminal_binding) },
+                    startup_input: startupInput(current, now) };
+                this.saveRecord(next);
+                committed = true;
+            });
+        }
+        catch {
+            return false;
+        }
+        finally {
+            this.reconcilingBindings.delete(id);
+        }
+        if (committed) {
+            try {
+                this.adapter.recoveryBindingReconciled?.(id);
+            }
+            catch { /* The worker also retries on its normal tick. */ }
+        }
+        return committed;
+    }
     /** Only gates configured launches. Native UUID and Agent turn state are not input prerequisites. */
     async deliveryReadiness(id) {
         const existing = this.doc.sessions.find(record => record.session_id === id);
         if (!existing)
             return null;
+        if (this.reconcilingBindings.has(id))
+            return { allowed: false, reason: 'SESSION_BINDING_RECONCILIATION_PENDING' };
         if (this.closingOperations.has(id))
             return { allowed: false, reason: 'SESSION_OPERATION_IN_PROGRESS' };
         if (existing.state === 'closed')
@@ -886,7 +959,10 @@ export class IntegrationSessions {
             return { allowed: false, reason: existing.state === 'released' ? 'SESSION_RELEASED' : 'SESSION_OPERATION_IN_PROGRESS' };
         if (!existing.startup_input)
             return null;
-        await this.refresh(id);
+        // This callback can run inside the delivery worker's own queue. Binding
+        // reconciliation must enter that queue from get/observation, never wait on
+        // the worker from within itself.
+        await this.refresh(id, false);
         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 };

package/dist/server/entry.js

@@ -116,6 +116,10 @@ function shouldWriteClientLog(level, message) {
         clientLogSuppressedCount += 1;
         return false;
     }
+    // Motion trace records share a label but contain different ordered samples.
+    // Preserve every chunk while retaining the global rate limit above.
+    if (message === 'COMPUTER_MOTION_TRACE')
+        return true;
     const key = `${String(level ?? 'info')}\u0000${String(message ?? '')}`;
     const last = clientLogRecent.get(key);
     if (last && now - last < CLIENT_LOG_DEDUP_WINDOW_MS) {

package/dist/server/routes/rdp.js

@@ -119,7 +119,7 @@ export function handleRdpWebSocket(socket, host, port) {
                     width: String(Math.max(640, Math.min(2560, Number(message.width) || 1280))),
                     height: String(Math.max(480, Math.min(1600, Number(message.height) || 800))),
                     'color-depth': '32', 'disable-audio': 'true', 'enable-drive': 'false',
-                    'disable-copy': 'true', 'server-layout': 'en-us-qwerty', 'resize-method': 'display-update',
+                    'disable-copy': 'false', 'disable-paste': 'false', 'server-layout': 'en-us-qwerty', 'resize-method': 'display-update',
                 };
                 void resolveComputerHost(host).then(async (address) => {
                     if (closed)

package/dist/server/routes/terminal.js

@@ -20,6 +20,7 @@ import { TerminalPasteBuffer } from '../utils/terminalPasteBuffer.js';
 import { SharedSessionSampler, SharedSnapshotCache } from '../utils/sharedSampling.js';
 import { batchTmuxOptions, TmuxMetadataWriter } from '../utils/tmuxMetadataWriter.js';
 import { redrawTmuxClient } from '../utils/tmuxClientRedraw.js';
+import { claimTmuxSize } from '../utils/tmuxSizeOwnership.js';
 import { TmuxInitialScreen } from '../utils/tmuxInitialScreen.js';
 import { TerminalOutputDelivery, resolveTerminalReplayCursor } from '../utils/terminalOutputDelivery.js';
 import express from 'express';
@@ -73,6 +74,7 @@ import { NativeSessionSearch } from '../agent/nativeSessionSearch.js';
 import { CollaborationError } from '../agent/collaborationProtocol.js';
 import { resolveCollaborationBackend, resolveCollaborationSessionId } from '../agent/sessionBindingRecovery.js';
 import { CollaborationRoutingStore, selectCollaborationPane, selectDrivePane, assessCollaborationRouteIdentity } from '../agent/collaborationRouting.js';
+import { selectRecoveredIntegrationBinding } from '../agent/integrationRecoveryBinding.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';
@@ -170,6 +172,7 @@ const TERMDOCK_FRONTEND_SESSION_ID_OPTION = '@termdock-frontend-session-id';
 const wsClients = new Map();
 const outputDeliveries = new WeakMap();
 const independentTmuxClients = new WeakSet();
+const tmuxAttachments = new WeakMap();
 const independentTmuxReplays = new WeakMap();
 const TERMINAL_STREAM_EPOCH = crypto.randomUUID();
 // Sessions where copy-mode -e just auto-exited at the bottom.
@@ -2072,6 +2075,28 @@ function integrationTerminalRecord(record) {
         integrationError('SESSION_IDENTITY_MISMATCH', 'Owned TD terminal binding changed', 409);
     return terminal;
 }
+async function integrationRecoveryOwnership(record) {
+    const root = `${TERMDOCK_DIR}/integration-state`;
+    const directories = await fs.promises.readdir(root, { withFileTypes: true }).catch(() => []);
+    const descriptorOwners = [];
+    const principalOwners = [];
+    for (const directory of directories) {
+        if (!directory.isDirectory())
+            continue;
+        const directoryPath = path.join(root, directory.name);
+        const sessions = await readJsonFileIfExists(path.join(directoryPath, 'integration-sessions.json'));
+        for (const session of sessions?.sessions ?? [])
+            if (session.session_id === record.session_id) {
+                descriptorOwners.push({ sessionId: String(session.session_id), groupId: String(session.group_id ?? ''), principalId: String(session.principal_id ?? '') });
+            }
+        const integrations = await readJsonFileIfExists(path.join(directoryPath, 'integrations.json'));
+        for (const principal of integrations?.principals ?? [])
+            if (principal.id === record.principal_id) {
+                principalOwners.push({ principalId: String(principal.id), groupId: String(principal.groupId ?? ''), revoked: principal.revoked === true });
+            }
+    }
+    return { descriptorOwners, principalOwners };
+}
 async function integrationTmuxPresent(record) {
     try {
         await runTmux(['has-session', '-t', `=wt-integration-${record.session_id}`]);
@@ -2299,6 +2324,73 @@ export const integrationSessionAdapter = {
             collaborationRouting.bind({ ...route, nativeSessionId: nativeId, pane: { ...route.pane, nativeSessionId: nativeId } });
         return { exists: true, running: Boolean(pane.agentSlug), shell: await integrationPaneIsIdleShell(pane), agentSlug: pane.agentSlug || null, nativeId };
     },
+    async reconcileRecoveryBinding(record) {
+        if (process.platform !== 'linux' || !record.agent_native_session_id || !record.terminal_binding)
+            return null;
+        const expectedNativeSessionId = record.agent_native_session_id;
+        let reconciled = null;
+        const collect = async () => {
+            const sessionName = `wt-integration-${record.session_id}`;
+            const recoveryAfter = Math.max(record.created_at, record.binding_reconciliation?.at ?? 0);
+            const matchingRecovery = tmuxRecoveryOperations.all().reverse().find(operation => operation.items.some(item => item.sessionId === record.session_id && item.state === 'succeeded'
+                && Number.isSafeInteger(item.completedAt) && item.completedAt > recoveryAfter));
+            const owners = await integrationRecoveryOwnership(record);
+            const groupOwners = collaborationStore.list().filter(group => !group.deleted && group.sessionIds.includes(record.session_id)).map(group => group.id);
+            const globalOwners = globalSessionState.sessions.filter(session => session.sessionId === record.session_id || session.tmuxSessionName === sessionName);
+            const terminal = globalSessionState.sessions.find(session => session.sessionId === record.session_id);
+            const backendMatches = [...terminalSessions].filter(([, backend]) => backend.mode === 'tmux' && backend.tmuxSessionName === sessionName);
+            const backendOwnershipVerified = !!terminal && terminal.mode === 'tmux' && terminal.tmuxSessionName === sessionName
+                && terminal.agentResume?.slug === record.agent_slug && terminal.agentResume.sessionId === expectedNativeSessionId
+                && backendMatches.length === 1 && !globalSessionState.sessions.some(other => other.sessionId !== record.session_id
+                && (other.tmuxSessionName === sessionName || other.backendSessionId === backendMatches[0]?.[0]))
+                && [null, record.session_id].includes(collaborationRouting.ownerOfBackend(backendMatches[0]?.[0] ?? ''));
+            let panes = [];
+            if (backendOwnershipVerified && backendMatches.length === 1) {
+                await runTmux(['has-session', '-t', `=${sessionName}`]);
+                const layout = await getTmuxLayout(sessionName);
+                if (layout.sessionName === sessionName && layout.windows.flatMap(window => window.panes).length === 1) {
+                    const [backendSessionId] = backendMatches[0];
+                    const unpinned = { sessionId: record.session_id, backendSessionId, mode: 'tmux',
+                        tmuxSessionName: sessionName, agentSlug: record.agent_slug, nativeSessionId: expectedNativeSessionId, pane: null };
+                    const inspected = await inspectCollaborationTmux(unpinned, null, false, true, true, true);
+                    panes = (inspected.candidates ?? []).map(pane => ({ tmuxSessionName: sessionName,
+                        agentSlug: pane.agentSlug, nativeSessionId: pane.nativeSessionId,
+                        nativeIdentitySource: pane.nativeIdentitySource ?? null, nativeIdentityVerified: pane.nativeIdentityVerified === true,
+                        binding: { serverPid: pane.serverPid, sessionId: pane.sessionId, paneId: pane.paneId, panePid: pane.panePid,
+                            agentSlug: pane.agentSlug, nativeSessionId: pane.nativeSessionId } }));
+                }
+            }
+            const selected = selectRecoveredIntegrationBinding({ sessionId: record.session_id, groupId: record.group_id, principalId: record.principal_id,
+                agentSlug: record.agent_slug, nativeSessionId: expectedNativeSessionId, tmuxSessionName: sessionName,
+                descriptorOwners: owners.descriptorOwners, principalOwners: owners.principalOwners, groupOwners,
+                terminalOwners: globalOwners.map(session => session.sessionId), backendOwnershipVerified,
+                recoveryOperationId: matchingRecovery?.id ?? null, panes });
+            return selected && backendMatches.length === 1 ? { ...selected, backendSessionId: backendMatches[0][0] } : null;
+        };
+        await collaborationDeliveryWorker.reconfigure(record.session_id, async () => {
+            if (routeHasUnconfirmedWrite(record.session_id))
+                throw Object.assign(new Error('A previous terminal write has an uncertain outcome'), { code: 'ROUTE_DELIVERY_OUTCOME_UNCONFIRMED' });
+            const first = await collect();
+            if (!first)
+                throw Object.assign(new Error('Recovery binding evidence is incomplete, ambiguous, or does not match the exact native identity'), { code: 'SESSION_RECOVERY_BINDING_UNCONFIRMED' });
+            const second = await collect();
+            if (!second || first.recoveryOperationId !== second.recoveryOperationId || first.backendSessionId !== second.backendSessionId
+                || JSON.stringify(first.binding) !== JSON.stringify(second.binding)) {
+                throw Object.assign(new Error('Integration runtime changed while recovery binding was being verified'), { code: 'SESSION_RECOVERY_BINDING_CHANGED' });
+            }
+            if (routeHasUnconfirmedWrite(record.session_id) || collaborationRouting.hasOtherPaneOwner(record.session_id, second.binding)) {
+                throw Object.assign(new Error('A previous write or another route owner prevents automatic binding reconciliation'), { code: 'ROUTE_DELIVERY_OUTCOME_UNCONFIRMED' });
+            }
+            const previous = collaborationRouting.get(record.session_id);
+            collaborationRouting.bind({ sessionId: record.session_id, backendSessionId: second.backendSessionId,
+                mode: 'tmux', tmuxSessionName: `wt-integration-${record.session_id}`, agentSlug: record.agent_slug,
+                nativeSessionId: record.agent_native_session_id, pane: second.binding, routeRevision: crypto.randomUUID(),
+                lastRecovery: { kind: 'native-identity', at: Date.now(), previousPane: previous?.pane ?? record.terminal_binding ?? null } });
+            reconciled = { binding: second.binding, recoveryOperationId: second.recoveryOperationId };
+        });
+        return reconciled;
+    },
+    recoveryBindingReconciled(sessionId) { collaborationDeliveryWorker.wake(sessionId); },
     async create(record, prepared, progress) {
         await listDetectedAgentLaunchers();
         if (!agentBySlug(record.agent_slug))
@@ -5279,7 +5371,7 @@ function cleanupSession(sessionId, options) {
         }
     }
 }
-function broadcastToWs(sessionId, data, excludeClientId, output, eventType) {
+function broadcastToWs(sessionId, data, excludeClientId, output) {
     const clients = wsClients.get(sessionId);
     const session = terminalSessions.get(sessionId);
     if (!clients)
@@ -5287,7 +5379,7 @@ function broadcastToWs(sessionId, data, excludeClientId, output, eventType) {
     for (const [clientId, ws] of clients.entries()) {
         if (excludeClientId && clientId === excludeClientId)
             continue;
-        if (independentTmuxClients.has(ws) && (output || eventType === 'pty-size'))
+        if (independentTmuxClients.has(ws) && output)
             continue;
         try {
             if (ws.readyState !== ws.OPEN)
@@ -5311,7 +5403,7 @@ function broadcastToWs(sessionId, data, excludeClientId, output, eventType) {
 }
 function broadcastJsonWs(sessionId, payload, excludeClientId) {
     const output = payload?.type === 'data' ? payload : undefined;
-    broadcastToWs(sessionId, JSON.stringify(payload), excludeClientId, output, payload?.type);
+    broadcastToWs(sessionId, JSON.stringify(payload), excludeClientId, output);
 }
 // 统一的 pty resize 入口：调用 ptyProcess.resize 改变 pty size 之后，把
 // 真实尺寸广播给除发起方之外的所有 ws client。多端场景下，B 端把 pty
@@ -8922,6 +9014,7 @@ export function handleTerminalWebSocket(ws, sessionId, clientId, options = {}, i
     let clientCols = session.cols;
     let clientRows = session.rows;
     let initialAttachmentResize = true;
+    let tmuxSizeOwnershipSupported = false;
     let initialScreen = null;
     if (initialDimensions && options.independentTmux) {
         clientCols = initialDimensions.cols;
@@ -8935,6 +9028,7 @@ export function handleTerminalWebSocket(ws, sessionId, clientId, options = {}, i
         const provider = await getPtyProvider();
         const tmuxBinary = getTmuxBinary();
         const supportsFeatures = await supportsTmuxClientFeatures(tmuxBinary);
+        tmuxSizeOwnershipSupported = supportsFeatures;
         // The metadata observer must not choose the pane size while a browser
         // owns an attached client. Resolve by exact PID, never another client.
         const raw = await runTmux(['list-clients', '-t', session.tmuxSessionName, '-F', '#{client_pid} #{client_tty}']);
@@ -8961,6 +9055,8 @@ export function handleTerminalWebSocket(ws, sessionId, clientId, options = {}, i
             delivery.enqueue({ type: 'data', data: liveData });
     }, () => { if (ws.readyState === ws.OPEN)
         ws.close(1012, 'Tmux display client detached'); }) : null;
+    if (attachment)
+        tmuxAttachments.set(ws, attachment);
     // Register client
     let clients = wsClients.get(sessionId);
     if (!clients) {
@@ -9198,27 +9294,41 @@ export function handleTerminalWebSocket(ws, sessionId, clientId, options = {}, i
                     const rows = Number(msg.rows);
                     if (Number.isFinite(cols) && Number.isFinite(rows) && cols > 0 && rows > 0) {
                         if (attachment) {
-                            const cleanCols = Math.floor(cols), cleanRows = Math.floor(rows);
-                            const sameSize = clientCols === cleanCols && clientRows === cleanRows;
-                            const ok = sameSize ? attachment.attached : attachment.resize(cleanCols, cleanRows);
-                            if (ok) {
-                                // The first resize confirms the grid supplied at attachment.
-                                // Its PTY is already drawing that grid; forcing refresh-client
-                                // here repeats the initial clear/full redraw. Later same-size
-                                // requests remain explicit display recovery requests.
-                                const needsRedraw = sameSize && !initialAttachmentResize;
-                                initialAttachmentResize = false;
-                                clientCols = cleanCols;
-                                clientRows = cleanRows;
-                                session.lastActivity = Date.now();
-                                if (needsRedraw)
-                                    await redrawTmuxClient(runTmux, session.tmuxSessionName, attachment.pid);
-                            }
-                            if (ws.readyState === ws.OPEN)
-                                ws.send(JSON.stringify({
-                                    type: 'resize-ack', seq: typeof msg.seq === 'number' ? msg.seq : undefined,
-                                    ok, cols: clientCols, rows: clientRows, screenSyncPending: false,
-                                }));
+                            await enqueueTmuxIo(session, async () => {
+                                const cleanCols = Math.floor(cols), cleanRows = Math.floor(rows);
+                                const displayPids = new Set();
+                                for (const client of wsClients.get(sessionId)?.values() ?? []) {
+                                    const pid = tmuxAttachments.get(client)?.pid;
+                                    if (pid !== undefined)
+                                        displayPids.add(pid);
+                                }
+                                if (tmuxSizeOwnershipSupported) {
+                                    await claimTmuxSize(runTmux, session.tmuxSessionName, attachment.pid, displayPids);
+                                }
+                                const sameSize = clientCols === cleanCols && clientRows === cleanRows;
+                                const ok = sameSize ? attachment.attached : attachment.resize(cleanCols, cleanRows);
+                                if (ok) {
+                                    // The first resize confirms the grid supplied at attachment.
+                                    // Its PTY is already drawing that grid; forcing refresh-client
+                                    // here repeats the initial clear/full redraw. Later same-size
+                                    // requests remain explicit display recovery requests.
+                                    const needsRedraw = sameSize && !initialAttachmentResize;
+                                    initialAttachmentResize = false;
+                                    clientCols = cleanCols;
+                                    clientRows = cleanRows;
+                                    session.lastActivity = Date.now();
+                                    broadcastJsonWs(sessionId, {
+                                        type: 'pty-size', cols: clientCols, rows: clientRows, source: `ws-resize:${clientId}`,
+                                    }, clientId);
+                                    if (needsRedraw)
+                                        await redrawTmuxClient(runTmux, session.tmuxSessionName, attachment.pid);
+                                }
+                                if (ws.readyState === ws.OPEN)
+                                    ws.send(JSON.stringify({
+                                        type: 'resize-ack', seq: typeof msg.seq === 'number' ? msg.seq : undefined,
+                                        ok, cols: clientCols, rows: clientRows, screenSyncPending: false,
+                                    }));
+                            });
                             break;
                         }
                         const sameSize = session.cols === Math.floor(cols) && session.rows === Math.floor(rows);

package/dist/server/utils/tmuxClientCapabilities.js

@@ -20,6 +20,6 @@ export function buildTmuxAttachArgs(sessionName, supportsFeatures) {
         // non-ASCII cells before the encrypted output ever reaches the renderer.
         '-u',
         ...(supportsFeatures ? ['-T', 'RGB,sync'] : []),
-        'attach-session', '-t', sessionName,
+        'attach-session', ...(supportsFeatures ? ['-f', 'ignore-size'] : []), '-t', sessionName,
     ];
 }

package/dist/server/utils/tmuxSizeOwnership.js

@@ -0,0 +1,18 @@
+/** Only an explicitly selected display may influence tmux's window size.
+ * Terminal replies and focus events also count as activity for window-size
+ * latest, so leaving every display eligible makes idle viewers fight.
+ */
+export async function claimTmuxSize(run, session, pid, displayPids) {
+    if (pid === undefined)
+        return;
+    const clients = (await run(['list-clients', '-t', session, '-F', '#{client_pid} #{client_tty}']))
+        .trim().split('\n').map(line => line.trim().split(/\s+/));
+    const target = clients.find(([value]) => value === String(pid));
+    if (!target?.[1])
+        return;
+    const commands = clients
+        .filter(([value, tty]) => tty && value !== String(pid) && displayPids.has(Number(value)))
+        .map(([, tty]) => ['refresh-client', '-t', tty, '-f', 'ignore-size']);
+    commands.push(['refresh-client', '-t', target[1], '-f', '!ignore-size']);
+    await run(commands.flatMap((command, index) => index ? [';', ...command] : command));
+}

package/docs/integrations.md

@@ -1327,3 +1327,30 @@ TD/native session、运行承载、消息/reply、consumer 游标或历史；不
 `GROUP_ARCHIVE_STATE_UNCONFIRMED`，不会猜测或重建。只允许本机非 federated、未删除
 组；删除组、跨服务组和不确定的目标分别返回 `GROUP_NOT_FOUND`、`GROUP_NOT_LOCAL`、
 `GROUP_ARCHIVE_TARGET_UNAVAILABLE`。归档不延长消息历史保留期。
+
+## 1.4.328：IntegrationSession 对账 tmux recovery 的新承载
+
+最低 CLI / 实际服务 **1.4.328**，能力回读字段为
+`session_recovery_binding_reconcile=true` 与
+`session_recovery_binding_reconcile_min_version=1.4.328`。该自动对账目前只在 Linux
+提供；其它平台返回 capability=false，因为没有同等的当前 writer-lock 身份证明。
+
+所属 principal 调用现有 `session get` 时，如果 IntegrationSession 因
+`SESSION_IDENTITY_MISMATCH` 指向旧 pane，而 TD 持久恢复 operation 已成功恢复该逻辑
+session，服务会尝试受限对账。它要求当前唯一受管终端名严格为
+`wt-integration-<session_id>`，IntegrationSession 与有效 principal/group 的持久归属唯一，
+当前组和全局终端记录唯一，只有一个 tmux pane/backend，且该前台 Agent 的当前 Linux
+flock-owner 身份独立核验出原 agent slug 与原生 UUID。目标元组会连续采样确认未变，
+并在现有投递 worker 屏障内更新绑定。
+
+成功后保留逻辑 `session_id`、group、principal、原生 UUID、消息与历史，只更新
+`terminal_binding`、状态和 `generation`，并在 `binding_reconciliation` 记录旧绑定及
+对应 `recovery_operation_id`。不会启动或恢复第二个 Agent，也不创建 task、发送正文或
+重放已写入的消息。此前写入结果不明时不会自动改绑；已写入的消息保持原 receipt，
+尚未写入的 pending 消息由原 worker 继续处理。
+
+任一 owner 缺失/重复、tmux 名或 pane 不唯一、native UUID 不同、writer-lock 不可核验、
+没有该 session 成功的恢复 operation，或绑定在双重采样间再次变化时，服务保持
+fail-closed，旧绑定与原消息保留，`session get` 仍报告身份错误；不会按 tmux 名称、PID
+缓存、cwd、argv 中的 resume 参数或显示名猜测认领。此 capability 不新增权限；仅通过
+`session.read` 认证的所属 principal 可触发其自身记录的对账。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "termdock",
-  "version": "1.4.327",
+  "version": "1.4.329",
   "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.327",
+  "version": "1.4.329",
   "runtimeProtocolVersion": 1,
   "minimumDesktopVersion": "1.4.46",
   "nodeMajor": 22,
   "dependencyHash": "sha256-oaGYi/P5ob8sd6VnNBOwshKozjhdV+hYiCmLAsn5x00=",
-  "serverBundleHash": "sha256-8rbCJEWANeXtZp/cvJ7UT9tGunnkMMxL7mcvARckvLQ=",
-  "clientBundleHash": "sha256-c+kY8sLmG3zeMRdXsCgqDWaIqC7vboMYVHsXMgZcbHU=",
+  "serverBundleHash": "sha256-R3DBIQv0z+SBN+LCWHRsFbWHqQ92u8mBkCkfn1MJdok=",
+  "clientBundleHash": "sha256-GLTHYP07SNJ24my1kl9LAFyEV1xLXDYzMzPHumxvQSo=",
   "entrypoint": "dist/server/cli.js",
   "clientEntrypoint": "dist/client/index.html"
 }

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

@@ -1,2 +0,0 @@
-import{bA as r}from"./app-D2yRvfNE.js";import{b as m}from"./dnd-BCFAPC0L.js";import{b as n}from"./RightSidebar-TFRZlsFX.js";import"./react-XDCjal2T.js";import"./terminal-C7X98Amf.js";import"./App-C0c83Pxp.js";import"./gestureArbiter-miROLzXb.js";import"./triangle-alert-DqUvQ_x8.js";import"./referenceLongPress-DqibFmuj.js";import"./DiffReview-BA7zArOA.js";import"./sparkles-CgDDXr95.js";import"./DiffViewer-B0YoRCEi.js";import"./ChangeWalkthroughPanel-Bt4fjEoD.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};