@livedesk/hub 0.1.49 → 0.1.51

package/src/remote-hub.js

@@ -3,18 +3,18 @@ import os from 'os';
 import crypto from 'crypto';
 import { createHubRelayControl } from './transport/relay-hub-control.js';
 import { parseExactLiveStreamMonitorIndex } from './live-stream-monitor-contract.js';
-import {
-    BoundedSegmentedBuffer,
-    createBoundedAgentBinaryIngressLane
-} from './transport/agent-binary-ingress.js';
-import {
-    REMOTE_CLIPBOARD_FILE_ACTIONS,
-    REMOTE_CLIPBOARD_LIMITS,
-    REMOTE_CLIPBOARD_PROTOCOL,
-    normalizeRemoteClipboardCommandResult,
-    normalizeRemoteClipboardManifest,
-    remoteClipboardContentNeedsFileTransfer
-} from './remote-clipboard-contract.mjs';
+import {
+    BoundedSegmentedBuffer,
+    createBoundedAgentBinaryIngressLane
+} from './transport/agent-binary-ingress.js';
+import {
+    REMOTE_CLIPBOARD_FILE_ACTIONS,
+    REMOTE_CLIPBOARD_LIMITS,
+    REMOTE_CLIPBOARD_PROTOCOL,
+    normalizeRemoteClipboardCommandResult,
+    normalizeRemoteClipboardManifest,
+    remoteClipboardContentNeedsFileTransfer
+} from './remote-clipboard-contract.mjs';
 
 const DEFAULT_REMOTE_HUB_PORT = 5197;
 const DEFAULT_REMOTE_HUB_HOST = '0.0.0.0';
@@ -236,13 +236,13 @@ const REMOTE_FRAME_MODE_ALIASES = new Map([
 ]);
 const MAX_SYNTHETIC_DEVICES = 1000;
 const DEFAULT_HOST_TARGET_LEASE_MS = 30000;
-const DEFAULT_PUBLIC_IP_REFRESH_MS = 5 * 60 * 1000;
-const DEFAULT_PUBLIC_IP_TIMEOUT_MS = 1800;
-const DEFAULT_DEVICE_CONNECTION_STALE_MS = 20000;
-const DEFAULT_DEVICE_CONNECTION_SWEEP_MS = 5000;
-const DUPLICATE_DEVICE_LOG_THROTTLE_MS = 60000;
-const DUPLICATE_DEVICE_RETRY_AFTER_MS = 30000;
-const AGENT_BINARY_INGRESS_QUEUE_PACKETS = 16;
+const DEFAULT_PUBLIC_IP_REFRESH_MS = 5 * 60 * 1000;
+const DEFAULT_PUBLIC_IP_TIMEOUT_MS = 1800;
+const DEFAULT_DEVICE_CONNECTION_STALE_MS = 20000;
+const DEFAULT_DEVICE_CONNECTION_SWEEP_MS = 5000;
+const DUPLICATE_DEVICE_LOG_THROTTLE_MS = 60000;
+const DUPLICATE_DEVICE_RETRY_AFTER_MS = 30000;
+const AGENT_BINARY_INGRESS_QUEUE_PACKETS = 16;
 const AGENT_BINARY_INGRESS_QUEUE_MAX_BYTES = 12 * 1024 * 1024;
 const AGENT_BINARY_INGRESS_QUEUE_MAX_AGE_MS = 120;
 const MODE5_AGENT_BINARY_INGRESS_QUEUE_PACKETS = 2;
@@ -1089,7 +1089,7 @@ async function fetchTextWithTimeout(url, timeoutMs) {
             signal: controller.signal,
             headers: {
                 accept: 'application/json,text/plain;q=0.9,*/*;q=0.1',
-                'user-agent': 'LiveDesk-Hub/0.1'
+                'user-agent': 'VuvoDesk-Hub/0.1'
             }
         });
         if (!response.ok) {
@@ -1244,11 +1244,11 @@ const SUPPORTED_AGENT_OPERATIONS = new Set([
     'application.close',
     'file.read',
     'file.write',
-    'file.delete',
-    'file.list',
-    'file.search',
-    'directory.create',
-    'command.run',
+    'file.delete',
+    'file.list',
+    'file.search',
+    'directory.create',
+    'command.run',
     'script.run',
     'software.install',
     'network.status',
@@ -1280,7 +1280,7 @@ function readRawRemoteInputMonitorIndex(input) {
     return undefined;
 }
 
-function normalizeRemoteInputEvent(value = {}) {
+function normalizeRemoteInputEvent(value = {}) {
     const input = value && typeof value === 'object' ? value : {};
     const type = safeString(input.type || input.Type, 48);
     const normalizedX = Number(input.normalizedX ?? input.NormalizedX);
@@ -1301,14 +1301,14 @@ function normalizeRemoteInputEvent(value = {}) {
             .filter(Boolean))]
             .slice(0, 64)
         : null;
-    const key = normalizeRemoteKeyboardKey(input.key ?? input.Key);
-    const clipboardOperationId = safeString(
-        input.clipboardOperationId || input.operationId || input.ClipboardOperationId || input.OperationId,
-        128);
-    const clipboardDirection = safeString(
-        input.clipboardDirection || input.ClipboardDirection,
-        16).toLowerCase();
-    const clipboardManifest = input.clipboardManifest || input.manifest || input.ClipboardManifest || input.Manifest;
+    const key = normalizeRemoteKeyboardKey(input.key ?? input.Key);
+    const clipboardOperationId = safeString(
+        input.clipboardOperationId || input.operationId || input.ClipboardOperationId || input.OperationId,
+        128);
+    const clipboardDirection = safeString(
+        input.clipboardDirection || input.ClipboardDirection,
+        16).toLowerCase();
+    const clipboardManifest = input.clipboardManifest || input.manifest || input.ClipboardManifest || input.Manifest;
     let code = safeString(input.code ?? input.Code, 80);
     if ((!code || code === 'Unidentified') && (key === ' ' || key === 'Spacebar' || keyCode === 32)) {
         code = 'Space';
@@ -1333,13 +1333,13 @@ function normalizeRemoteInputEvent(value = {}) {
         shiftKey: input.shiftKey === true || input.ShiftKey === true,
         ctrlKey: input.ctrlKey === true || input.ControlKey === true || input.CtrlKey === true,
         altKey: input.altKey === true || input.AltKey === true,
-        metaKey: input.metaKey === true || input.MetaKey === true || input.commandKey === true || input.CommandKey === true,
-        clipboardOperationId,
-        operationId: clipboardOperationId,
-        clipboardDirection,
-        manifest: clipboardManifest && typeof clipboardManifest === 'object' && !Array.isArray(clipboardManifest)
-            ? clipboardManifest
-            : null,
+        metaKey: input.metaKey === true || input.MetaKey === true || input.commandKey === true || input.CommandKey === true,
+        clipboardOperationId,
+        operationId: clipboardOperationId,
+        clipboardDirection,
+        manifest: clipboardManifest && typeof clipboardManifest === 'object' && !Array.isArray(clipboardManifest)
+            ? clipboardManifest
+            : null,
         controlLeaseId: safeString(input.controlLeaseId || input.ControlLeaseId, 128),
         controlSessionId: safeString(input.controlSessionId || input.sessionId || input.ControlSessionId || input.SessionId, 160),
         controlCommandId: safeString(input.controlCommandId || input.commandId || input.ControlCommandId || input.CommandId, 128),
@@ -2331,29 +2331,29 @@ export function createRemoteHub(options = {}) {
 
     const enabled = isEnabledValue(env.LIVEDESK_REMOTE_HUB ?? env.MINDEXEC_REMOTE_HUB ?? env.REMOTE_HUB_ENABLED, true)
         && !isDisabledValue(env.REMOTE_HUB_DISABLED);
-    const host = safeString(env.REMOTE_HUB_HOST || DEFAULT_REMOTE_HUB_HOST, 128);
-    const requestedPort = normalizePort(env.REMOTE_HUB_PORT || DEFAULT_REMOTE_HUB_PORT);
-    const heartbeatMs = clampNumber(env.REMOTE_HUB_HEARTBEAT_MS, 1000, 60000, DEFAULT_HEARTBEAT_MS);
-    const defaultDeviceConnectionStaleMs = Math.max(
-        DEFAULT_DEVICE_CONNECTION_STALE_MS,
-        heartbeatMs * 4);
-    const deviceConnectionStaleMs = Number.isFinite(Number(options.deviceConnectionStaleMs))
-        ? clampNumber(options.deviceConnectionStaleMs, 100, 10 * 60 * 1000, defaultDeviceConnectionStaleMs)
-        : clampNumber(
-            env.REMOTE_HUB_DEVICE_CONNECTION_STALE_MS,
-            defaultDeviceConnectionStaleMs,
-            10 * 60 * 1000,
-            defaultDeviceConnectionStaleMs);
-    const deviceConnectionSweepMs = Number.isFinite(Number(options.deviceConnectionSweepMs))
-        ? clampNumber(options.deviceConnectionSweepMs, 25, 60000, DEFAULT_DEVICE_CONNECTION_SWEEP_MS)
-        : clampNumber(
-            env.REMOTE_HUB_DEVICE_CONNECTION_SWEEP_MS,
-            1000,
-            60000,
-            Math.min(DEFAULT_DEVICE_CONNECTION_SWEEP_MS, heartbeatMs));
-    const taskTimeoutMs = clampNumber(
-        options.taskTimeoutMs ?? env.REMOTE_HUB_TASK_TIMEOUT_MS,
-        50,
+    const host = safeString(env.REMOTE_HUB_HOST || DEFAULT_REMOTE_HUB_HOST, 128);
+    const requestedPort = normalizePort(env.REMOTE_HUB_PORT || DEFAULT_REMOTE_HUB_PORT);
+    const heartbeatMs = clampNumber(env.REMOTE_HUB_HEARTBEAT_MS, 1000, 60000, DEFAULT_HEARTBEAT_MS);
+    const defaultDeviceConnectionStaleMs = Math.max(
+        DEFAULT_DEVICE_CONNECTION_STALE_MS,
+        heartbeatMs * 4);
+    const deviceConnectionStaleMs = Number.isFinite(Number(options.deviceConnectionStaleMs))
+        ? clampNumber(options.deviceConnectionStaleMs, 100, 10 * 60 * 1000, defaultDeviceConnectionStaleMs)
+        : clampNumber(
+            env.REMOTE_HUB_DEVICE_CONNECTION_STALE_MS,
+            defaultDeviceConnectionStaleMs,
+            10 * 60 * 1000,
+            defaultDeviceConnectionStaleMs);
+    const deviceConnectionSweepMs = Number.isFinite(Number(options.deviceConnectionSweepMs))
+        ? clampNumber(options.deviceConnectionSweepMs, 25, 60000, DEFAULT_DEVICE_CONNECTION_SWEEP_MS)
+        : clampNumber(
+            env.REMOTE_HUB_DEVICE_CONNECTION_SWEEP_MS,
+            1000,
+            60000,
+            Math.min(DEFAULT_DEVICE_CONNECTION_SWEEP_MS, heartbeatMs));
+    const taskTimeoutMs = clampNumber(
+        options.taskTimeoutMs ?? env.REMOTE_HUB_TASK_TIMEOUT_MS,
+        50,
         30 * 60 * 1000,
         DEFAULT_AGENT_TASK_TIMEOUT_MS);
     const inputAckTimeoutMs = clampNumber(
@@ -2416,18 +2416,18 @@ export function createRemoteHub(options = {}) {
     const audioSockets = new Map();
     const fileSockets = new Map();
     const allSockets = new Set();
-    const agentBinaryIngressStates = new Set();
-    const pendingCommandResultWaiters = new Map();
-    const clipboardOperations = new Map();
+    const agentBinaryIngressStates = new Set();
+    const pendingCommandResultWaiters = new Map();
+    const clipboardOperations = new Map();
     const transportDiagnostics = new Map();
     const transportDiagnosticStartingDevices = new Set();
-    const duplicateDeviceLogAt = new Map();
-    let server = null;
-    let started = false;
-    let deviceConnectionSweepTimer = null;
-    let boundPort = requestedPort;
-    let lastError = '';
-    let hostTarget = null;
+    const duplicateDeviceLogAt = new Map();
+    let server = null;
+    let started = false;
+    let deviceConnectionSweepTimer = null;
+    let boundPort = requestedPort;
+    let lastError = '';
+    let hostTarget = null;
     let publicIPv4Cache = {
         address: safeString(env.LIVEDESK_REMOTE_PUBLIC_IPV4 || env.LIVEDESK_PUBLIC_IPV4 || env.REMOTE_HUB_PUBLIC_IPV4, 64),
         updatedAt: 0,
@@ -2748,14 +2748,14 @@ export function createRemoteHub(options = {}) {
             protocol: 'tcp-jsonl',
             protocolVersion: REMOTE_PROTOCOL_VERSION,
             agentProtocol: REMOTE_AGENT_PROTOCOL,
-            frameProtocol: buildRemoteFrameProtocolDescriptor(),
-            frameModes: getSupportedRemoteFrameModeProfiles(),
-            heartbeatMs,
-            deviceConnectionStaleMs,
-            deviceConnectionSweepMs,
-            taskTimeoutMs,
-            managerPackage,
-            managerVersion,
+            frameProtocol: buildRemoteFrameProtocolDescriptor(),
+            frameModes: getSupportedRemoteFrameModeProfiles(),
+            heartbeatMs,
+            deviceConnectionStaleMs,
+            deviceConnectionSweepMs,
+            taskTimeoutMs,
+            managerPackage,
+            managerVersion,
             hostInstanceId,
             agentPackage: '@livedesk/client',
             agentEndpoint: routeInfo.endpoint,
@@ -3018,7 +3018,7 @@ export function createRemoteHub(options = {}) {
         return true;
     }
 
-    function failPendingCommandResultWaiters(device, error = 'device-disconnected') {
+    function failPendingCommandResultWaiters(device, error = 'device-disconnected') {
         if (!device?.deviceId) {
             return;
         }
@@ -3035,31 +3035,31 @@ export function createRemoteHub(options = {}) {
                 result: null,
                 error: safeString(error, 500) || 'command-result-unavailable'
             });
-        }
-    }
-
-    function failPendingFileCommandResultWaiters(device, error = 'file-channel-disconnected') {
-        if (!device?.deviceId) {
-            return;
-        }
-        for (const [waiterKey, waiter] of pendingCommandResultWaiters) {
-            if (waiter.deviceId !== device.deviceId
-                || waiter.sessionId !== device.sessionId
-                || waiter.channel !== 'file') {
-                continue;
-            }
-            pendingCommandResultWaiters.delete(waiterKey);
-            clearPendingCommandResultWaiterDeadline(waiter);
-            waiter.resolve({
-                ok: false,
-                commandId: waiter.commandId,
-                result: null,
-                error: safeString(error, 500) || 'file-channel-disconnected'
-            });
-        }
-    }
-
-    function failPendingCommandResultWaiter(device, commandId, error = 'command-not-sent') {
+        }
+    }
+
+    function failPendingFileCommandResultWaiters(device, error = 'file-channel-disconnected') {
+        if (!device?.deviceId) {
+            return;
+        }
+        for (const [waiterKey, waiter] of pendingCommandResultWaiters) {
+            if (waiter.deviceId !== device.deviceId
+                || waiter.sessionId !== device.sessionId
+                || waiter.channel !== 'file') {
+                continue;
+            }
+            pendingCommandResultWaiters.delete(waiterKey);
+            clearPendingCommandResultWaiterDeadline(waiter);
+            waiter.resolve({
+                ok: false,
+                commandId: waiter.commandId,
+                result: null,
+                error: safeString(error, 500) || 'file-channel-disconnected'
+            });
+        }
+    }
+
+    function failPendingCommandResultWaiter(device, commandId, error = 'command-not-sent') {
         const normalizedCommandId = safeString(commandId, 128);
         const waiterKey = buildPendingCommandResultWaiterKey(
             device?.deviceId,
@@ -3080,7 +3080,7 @@ export function createRemoteHub(options = {}) {
         return true;
     }
 
-    function waitForCommandResult(device, commandId, timeoutMs = liveCaptureStopAckTimeoutMs, metadata = {}) {
+    function waitForCommandResult(device, commandId, timeoutMs = liveCaptureStopAckTimeoutMs, metadata = {}) {
         const normalizedCommandId = safeString(commandId, 128);
         const waiterKey = buildPendingCommandResultWaiterKey(
             device?.deviceId,
@@ -3106,13 +3106,13 @@ export function createRemoteHub(options = {}) {
                     error: 'command-result-wait-replaced'
                 });
             }
-            const waiterRecord = {
-                deviceId: device.deviceId,
-                sessionId: device.sessionId,
-                commandId: normalizedCommandId,
-                channel: safeString(metadata.channel, 24),
-                operationId: safeString(metadata.operationId, 128),
-                timer: null,
+            const waiterRecord = {
+                deviceId: device.deviceId,
+                sessionId: device.sessionId,
+                commandId: normalizedCommandId,
+                channel: safeString(metadata.channel, 24),
+                operationId: safeString(metadata.operationId, 128),
+                timer: null,
                 deadlineImmediate: null,
                 resolve
             };
@@ -3145,246 +3145,246 @@ export function createRemoteHub(options = {}) {
                 });
             }, timeoutMs);
             waiterRecord.timer.unref?.();
-            pendingCommandResultWaiters.set(waiterKey, waiterRecord);
-        });
-    }
-
-    function buildClipboardOperationKey(deviceId, sessionId, operationId) {
-        const normalizedDeviceId = safeString(deviceId, 160);
-        const normalizedSessionId = safeString(sessionId, 160);
-        const normalizedOperationId = safeString(operationId, 128);
-        return normalizedDeviceId && normalizedSessionId && normalizedOperationId
-            ? `${normalizedDeviceId.length}:${normalizedDeviceId}`
-                + `${normalizedSessionId.length}:${normalizedSessionId}`
-                + `${normalizedOperationId.length}:${normalizedOperationId}`
-            : '';
-    }
-
-    function queueClipboardAgentCleanup(device, operation, reason) {
-        if (operation?.inFlight || !device?.fileSocket || device.fileSocket.destroyed) {
-            return false;
-        }
-        const cleanupCommand = operation.direction === 'paste'
-            ? 'clipboard.paste.cancel'
-            : 'clipboard.copy.end';
-        const commandId = crypto.randomUUID();
-        try {
-            writeJsonLine(device.fileSocket, {
-                type: 'command',
-                commandId,
-                command: cleanupCommand,
-                payload: {
-                    operationId: operation.operationId,
-                    reason: safeString(reason, 120) || 'clipboard-owner-closed'
-                },
-                issuedAt: new Date().toISOString()
-            });
-            device.counters.commandsSent += 1;
-            emitRemoteEvent('RemoteCommandQueued', device, {
-                commandId,
-                command: cleanupCommand,
-                channel: 'file',
-                operationId: operation.operationId,
-                cleanup: true
-            });
-            return true;
-        } catch {
-            // The exact side channel is already closing. Native session
-            // teardown remains the authoritative cleanup.
-            return false;
-        }
-    }
-
-    function clearClipboardOperationsForDevice(device, reason = 'clipboard-owner-closed', ownerConnectionId = '') {
-        const requestedOwner = safeString(ownerConnectionId, 128);
-        let cleared = 0;
-        for (const [key, operation] of clipboardOperations) {
-            if (operation.deviceId !== device?.deviceId
-                || operation.sessionId !== device?.sessionId
-                || (requestedOwner && operation.hubConnectionId !== requestedOwner)) {
-                continue;
-            }
-            queueClipboardAgentCleanup(device, operation, reason);
-            clipboardOperations.delete(key);
-            cleared += 1;
-        }
-        if (cleared > 0) {
-            emitRemoteEvent('RemoteClipboardOperationsCleared', device, {
-                reason,
-                ownerConnectionId: requestedOwner,
-                count: cleared
-            });
-        }
-        return cleared;
-    }
-
-    function pruneClipboardOperations(nowMs = Date.now()) {
-        for (const [key, operation] of clipboardOperations) {
-            const currentDevice = devices.get(operation.deviceId);
-            const expired = nowMs - Number(operation.touchedAt || 0)
-                > REMOTE_CLIPBOARD_LIMITS.operationIdleTimeoutMs;
-            const staleOwner = !currentDevice
-                || currentDevice.sessionId !== operation.sessionId
-                || safeString(currentDevice.inputOwnerConnectionId, 128) !== operation.hubConnectionId;
-            if (expired || staleOwner) {
-                if (currentDevice?.sessionId === operation.sessionId) {
-                    queueClipboardAgentCleanup(
-                        currentDevice,
-                        operation,
-                        expired ? 'clipboard-operation-expired' : 'clipboard-owner-stale');
-                }
-                clipboardOperations.delete(key);
-            }
-        }
-    }
-
-    function clipboardCapabilityError(device, direction, contentKind = 'text') {
-        const capabilities = device?.capabilities || {};
-        if (capabilities.clipboardProtocol !== REMOTE_CLIPBOARD_PROTOCOL
-            || capabilities.clipboardText !== true) {
-            return 'device-clipboard-text-unavailable';
-        }
-        if (capabilities.sessionBoundSideChannels !== true) {
-            return 'device-clipboard-session-bound-channel-unavailable';
-        }
-        if (direction === 'copy' && capabilities.clipboardCopy !== true) {
-            return 'device-clipboard-copy-unavailable';
-        }
-        if (direction === 'paste' && capabilities.clipboardPaste !== true) {
-            return 'device-clipboard-paste-unavailable';
-        }
-        if (contentKind === 'image' && capabilities.clipboardImage !== true) {
-            return 'device-clipboard-image-unavailable';
-        }
-        if (contentKind === 'files' && capabilities.clipboardFiles !== true) {
-            return 'device-clipboard-files-unavailable';
-        }
-        for (const key of ['clipboardMaxTextBytes', 'clipboardMaxTotalBytes', 'clipboardMaxChunkBytes']) {
-            if (!Number.isSafeInteger(Number(capabilities[key])) || Number(capabilities[key]) <= 0) {
-                return 'device-clipboard-limits-unavailable';
-            }
-        }
-        if (Number(capabilities.clipboardMaxChunkBytes) < REMOTE_CLIPBOARD_LIMITS.maxChunkBytes) {
-            return 'device-clipboard-chunk-limit-unavailable';
-        }
-        if (contentKind === 'image'
-            && (!Number.isSafeInteger(Number(
-                capabilities.clipboardMaxImageBytes ?? capabilities.clipboardMaxPngBytes))
-                || Number(capabilities.clipboardMaxImageBytes ?? capabilities.clipboardMaxPngBytes) <= 0)) {
-            return 'device-clipboard-limits-unavailable';
-        }
-        if (contentKind === 'files'
-            && (!Number.isSafeInteger(Number(capabilities.clipboardMaxFiles))
-                || Number(capabilities.clipboardMaxFiles) <= 0)) {
-            return 'device-clipboard-limits-unavailable';
-        }
-        return '';
-    }
-
-    function clipboardManifestCapabilityError(device, manifest) {
-        if (!manifest) {
-            return '';
-        }
-        const capabilities = device?.capabilities || {};
-        if (manifest.totalBytes > Number(capabilities.clipboardMaxTotalBytes || 0)) {
-            return 'device-clipboard-total-limit-exceeded';
-        }
-        if (manifest.contentKind === 'text'
-            && manifest.totalBytes > Number(capabilities.clipboardMaxTextBytes || 0)) {
-            return 'device-clipboard-text-limit-exceeded';
-        }
-        if (manifest.contentKind === 'image'
-            && manifest.totalBytes > Number(
-                capabilities.clipboardMaxImageBytes ?? capabilities.clipboardMaxPngBytes ?? 0)) {
-            return 'device-clipboard-image-limit-exceeded';
-        }
-        if (manifest.contentKind === 'files'
-            && manifest.items.length > Number(capabilities.clipboardMaxFiles || 0)) {
-            return 'device-clipboard-file-count-limit-exceeded';
-        }
-        return '';
-    }
-
-    function validateCurrentClipboardBinding(deviceId, request = {}, contentKind = 'text', options = {}) {
-        const device = devices.get(String(deviceId || ''));
-        if (!device) {
-            return { ok: false, error: 'device-not-found' };
-        }
-        if (device.synthetic === true) {
-            return { ok: false, error: 'device-clipboard-unavailable' };
-        }
-        if (device.connected && !isDeviceConnectionFresh(device)) {
-            retireStaleDeviceConnection(device, 'status-heartbeat-timeout');
-            return { ok: false, error: 'device-not-connected' };
-        }
-        if (!device.connected || !device.socket || device.socket.destroyed) {
-            return { ok: false, error: 'device-not-connected' };
-        }
-
-        const policy = getDevicePolicy(device);
-        if (policy.accessMode === 'block-remote-access') {
-            return { ok: false, error: 'remote-access-blocked-by-settings' };
-        }
-        if (policy.allowControl !== true) {
-            return { ok: false, error: 'allowControl-blocked-by-settings' };
-        }
-        if (policy.allowClipboardText !== true) {
-            return { ok: false, error: 'allowClipboardText-blocked-by-settings' };
-        }
-        if (remoteClipboardContentNeedsFileTransfer(contentKind)
-            && policy.allowFileTransfer !== true) {
-            return { ok: false, error: 'allowFileTransfer-blocked-by-settings' };
-        }
-
-        const direction = request.clipboardDirection
-            || (String(request.action || '').includes('.paste') ? 'paste' : 'copy');
-        const capabilityError = clipboardCapabilityError(device, direction, contentKind);
-        if (capabilityError) {
-            return { ok: false, error: capabilityError };
-        }
-        const manifestCapabilityError = clipboardManifestCapabilityError(
-            device,
-            request.payload?.manifest || request.manifest);
-        if (manifestCapabilityError) {
-            return { ok: false, error: manifestCapabilityError };
-        }
-
-        const controlStream = getActiveControlStream(device);
-        if (!controlStream
-            || !liveStreamHasCurrentFrame(controlStream)
-            || !safeString(controlStream.commandId, 128)
-            || Number(controlStream.captureGeneration || 0) <= 0) {
-            return { ok: false, error: 'CONTROL_NOT_READY' };
-        }
-        if (getPendingLiveStreamDescriptor(controlStream)) {
-            return { ok: false, error: 'CAPTURE_TRANSITION_IN_PROGRESS' };
-        }
-        const binding = request.binding || request;
-        if (safeString(binding.controlSessionId || binding.sessionId, 160)
-            !== safeString(device.sessionId, 160)
-            || safeString(binding.controlCommandId || binding.commandId, 128)
-            !== safeString(controlStream.commandId, 128)) {
-            return { ok: false, error: 'STALE_CONTROL_SESSION' };
-        }
-        if (Number(binding.captureGeneration || 0)
-            !== Number(controlStream.captureGeneration || 0)) {
-            return { ok: false, error: 'STALE_CAPTURE_GENERATION' };
-        }
-        const activeMonitorIndex = normalizeMonitorIndex(controlStream.monitorIndex);
-        if (Number(binding.monitorIndex) !== activeMonitorIndex) {
-            return { ok: false, error: 'STALE_CONTROL_MONITOR' };
-        }
-        const hubConnectionId = safeString(request.hubConnectionId, 128);
-        if (!hubConnectionId
-            || hubConnectionId !== safeString(device.inputOwnerConnectionId, 128)) {
-            return { ok: false, error: 'input-owner-not-current' };
-        }
-        if (options.requireFileSocket === true
-            && (!device.fileSocket || device.fileSocket.destroyed)) {
-            return { ok: false, error: 'clipboard-file-channel-unavailable' };
-        }
-        return { ok: true, device, controlStream, activeMonitorIndex, policy };
-    }
+            pendingCommandResultWaiters.set(waiterKey, waiterRecord);
+        });
+    }
+
+    function buildClipboardOperationKey(deviceId, sessionId, operationId) {
+        const normalizedDeviceId = safeString(deviceId, 160);
+        const normalizedSessionId = safeString(sessionId, 160);
+        const normalizedOperationId = safeString(operationId, 128);
+        return normalizedDeviceId && normalizedSessionId && normalizedOperationId
+            ? `${normalizedDeviceId.length}:${normalizedDeviceId}`
+                + `${normalizedSessionId.length}:${normalizedSessionId}`
+                + `${normalizedOperationId.length}:${normalizedOperationId}`
+            : '';
+    }
+
+    function queueClipboardAgentCleanup(device, operation, reason) {
+        if (operation?.inFlight || !device?.fileSocket || device.fileSocket.destroyed) {
+            return false;
+        }
+        const cleanupCommand = operation.direction === 'paste'
+            ? 'clipboard.paste.cancel'
+            : 'clipboard.copy.end';
+        const commandId = crypto.randomUUID();
+        try {
+            writeJsonLine(device.fileSocket, {
+                type: 'command',
+                commandId,
+                command: cleanupCommand,
+                payload: {
+                    operationId: operation.operationId,
+                    reason: safeString(reason, 120) || 'clipboard-owner-closed'
+                },
+                issuedAt: new Date().toISOString()
+            });
+            device.counters.commandsSent += 1;
+            emitRemoteEvent('RemoteCommandQueued', device, {
+                commandId,
+                command: cleanupCommand,
+                channel: 'file',
+                operationId: operation.operationId,
+                cleanup: true
+            });
+            return true;
+        } catch {
+            // The exact side channel is already closing. Native session
+            // teardown remains the authoritative cleanup.
+            return false;
+        }
+    }
+
+    function clearClipboardOperationsForDevice(device, reason = 'clipboard-owner-closed', ownerConnectionId = '') {
+        const requestedOwner = safeString(ownerConnectionId, 128);
+        let cleared = 0;
+        for (const [key, operation] of clipboardOperations) {
+            if (operation.deviceId !== device?.deviceId
+                || operation.sessionId !== device?.sessionId
+                || (requestedOwner && operation.hubConnectionId !== requestedOwner)) {
+                continue;
+            }
+            queueClipboardAgentCleanup(device, operation, reason);
+            clipboardOperations.delete(key);
+            cleared += 1;
+        }
+        if (cleared > 0) {
+            emitRemoteEvent('RemoteClipboardOperationsCleared', device, {
+                reason,
+                ownerConnectionId: requestedOwner,
+                count: cleared
+            });
+        }
+        return cleared;
+    }
+
+    function pruneClipboardOperations(nowMs = Date.now()) {
+        for (const [key, operation] of clipboardOperations) {
+            const currentDevice = devices.get(operation.deviceId);
+            const expired = nowMs - Number(operation.touchedAt || 0)
+                > REMOTE_CLIPBOARD_LIMITS.operationIdleTimeoutMs;
+            const staleOwner = !currentDevice
+                || currentDevice.sessionId !== operation.sessionId
+                || safeString(currentDevice.inputOwnerConnectionId, 128) !== operation.hubConnectionId;
+            if (expired || staleOwner) {
+                if (currentDevice?.sessionId === operation.sessionId) {
+                    queueClipboardAgentCleanup(
+                        currentDevice,
+                        operation,
+                        expired ? 'clipboard-operation-expired' : 'clipboard-owner-stale');
+                }
+                clipboardOperations.delete(key);
+            }
+        }
+    }
+
+    function clipboardCapabilityError(device, direction, contentKind = 'text') {
+        const capabilities = device?.capabilities || {};
+        if (capabilities.clipboardProtocol !== REMOTE_CLIPBOARD_PROTOCOL
+            || capabilities.clipboardText !== true) {
+            return 'device-clipboard-text-unavailable';
+        }
+        if (capabilities.sessionBoundSideChannels !== true) {
+            return 'device-clipboard-session-bound-channel-unavailable';
+        }
+        if (direction === 'copy' && capabilities.clipboardCopy !== true) {
+            return 'device-clipboard-copy-unavailable';
+        }
+        if (direction === 'paste' && capabilities.clipboardPaste !== true) {
+            return 'device-clipboard-paste-unavailable';
+        }
+        if (contentKind === 'image' && capabilities.clipboardImage !== true) {
+            return 'device-clipboard-image-unavailable';
+        }
+        if (contentKind === 'files' && capabilities.clipboardFiles !== true) {
+            return 'device-clipboard-files-unavailable';
+        }
+        for (const key of ['clipboardMaxTextBytes', 'clipboardMaxTotalBytes', 'clipboardMaxChunkBytes']) {
+            if (!Number.isSafeInteger(Number(capabilities[key])) || Number(capabilities[key]) <= 0) {
+                return 'device-clipboard-limits-unavailable';
+            }
+        }
+        if (Number(capabilities.clipboardMaxChunkBytes) < REMOTE_CLIPBOARD_LIMITS.maxChunkBytes) {
+            return 'device-clipboard-chunk-limit-unavailable';
+        }
+        if (contentKind === 'image'
+            && (!Number.isSafeInteger(Number(
+                capabilities.clipboardMaxImageBytes ?? capabilities.clipboardMaxPngBytes))
+                || Number(capabilities.clipboardMaxImageBytes ?? capabilities.clipboardMaxPngBytes) <= 0)) {
+            return 'device-clipboard-limits-unavailable';
+        }
+        if (contentKind === 'files'
+            && (!Number.isSafeInteger(Number(capabilities.clipboardMaxFiles))
+                || Number(capabilities.clipboardMaxFiles) <= 0)) {
+            return 'device-clipboard-limits-unavailable';
+        }
+        return '';
+    }
+
+    function clipboardManifestCapabilityError(device, manifest) {
+        if (!manifest) {
+            return '';
+        }
+        const capabilities = device?.capabilities || {};
+        if (manifest.totalBytes > Number(capabilities.clipboardMaxTotalBytes || 0)) {
+            return 'device-clipboard-total-limit-exceeded';
+        }
+        if (manifest.contentKind === 'text'
+            && manifest.totalBytes > Number(capabilities.clipboardMaxTextBytes || 0)) {
+            return 'device-clipboard-text-limit-exceeded';
+        }
+        if (manifest.contentKind === 'image'
+            && manifest.totalBytes > Number(
+                capabilities.clipboardMaxImageBytes ?? capabilities.clipboardMaxPngBytes ?? 0)) {
+            return 'device-clipboard-image-limit-exceeded';
+        }
+        if (manifest.contentKind === 'files'
+            && manifest.items.length > Number(capabilities.clipboardMaxFiles || 0)) {
+            return 'device-clipboard-file-count-limit-exceeded';
+        }
+        return '';
+    }
+
+    function validateCurrentClipboardBinding(deviceId, request = {}, contentKind = 'text', options = {}) {
+        const device = devices.get(String(deviceId || ''));
+        if (!device) {
+            return { ok: false, error: 'device-not-found' };
+        }
+        if (device.synthetic === true) {
+            return { ok: false, error: 'device-clipboard-unavailable' };
+        }
+        if (device.connected && !isDeviceConnectionFresh(device)) {
+            retireStaleDeviceConnection(device, 'status-heartbeat-timeout');
+            return { ok: false, error: 'device-not-connected' };
+        }
+        if (!device.connected || !device.socket || device.socket.destroyed) {
+            return { ok: false, error: 'device-not-connected' };
+        }
+
+        const policy = getDevicePolicy(device);
+        if (policy.accessMode === 'block-remote-access') {
+            return { ok: false, error: 'remote-access-blocked-by-settings' };
+        }
+        if (policy.allowControl !== true) {
+            return { ok: false, error: 'allowControl-blocked-by-settings' };
+        }
+        if (policy.allowClipboardText !== true) {
+            return { ok: false, error: 'allowClipboardText-blocked-by-settings' };
+        }
+        if (remoteClipboardContentNeedsFileTransfer(contentKind)
+            && policy.allowFileTransfer !== true) {
+            return { ok: false, error: 'allowFileTransfer-blocked-by-settings' };
+        }
+
+        const direction = request.clipboardDirection
+            || (String(request.action || '').includes('.paste') ? 'paste' : 'copy');
+        const capabilityError = clipboardCapabilityError(device, direction, contentKind);
+        if (capabilityError) {
+            return { ok: false, error: capabilityError };
+        }
+        const manifestCapabilityError = clipboardManifestCapabilityError(
+            device,
+            request.payload?.manifest || request.manifest);
+        if (manifestCapabilityError) {
+            return { ok: false, error: manifestCapabilityError };
+        }
+
+        const controlStream = getActiveControlStream(device);
+        if (!controlStream
+            || !liveStreamHasCurrentFrame(controlStream)
+            || !safeString(controlStream.commandId, 128)
+            || Number(controlStream.captureGeneration || 0) <= 0) {
+            return { ok: false, error: 'CONTROL_NOT_READY' };
+        }
+        if (getPendingLiveStreamDescriptor(controlStream)) {
+            return { ok: false, error: 'CAPTURE_TRANSITION_IN_PROGRESS' };
+        }
+        const binding = request.binding || request;
+        if (safeString(binding.controlSessionId || binding.sessionId, 160)
+            !== safeString(device.sessionId, 160)
+            || safeString(binding.controlCommandId || binding.commandId, 128)
+            !== safeString(controlStream.commandId, 128)) {
+            return { ok: false, error: 'STALE_CONTROL_SESSION' };
+        }
+        if (Number(binding.captureGeneration || 0)
+            !== Number(controlStream.captureGeneration || 0)) {
+            return { ok: false, error: 'STALE_CAPTURE_GENERATION' };
+        }
+        const activeMonitorIndex = normalizeMonitorIndex(controlStream.monitorIndex);
+        if (Number(binding.monitorIndex) !== activeMonitorIndex) {
+            return { ok: false, error: 'STALE_CONTROL_MONITOR' };
+        }
+        const hubConnectionId = safeString(request.hubConnectionId, 128);
+        if (!hubConnectionId
+            || hubConnectionId !== safeString(device.inputOwnerConnectionId, 128)) {
+            return { ok: false, error: 'input-owner-not-current' };
+        }
+        if (options.requireFileSocket === true
+            && (!device.fileSocket || device.fileSocket.destroyed)) {
+            return { ok: false, error: 'clipboard-file-channel-unavailable' };
+        }
+        return { ok: true, device, controlStream, activeMonitorIndex, policy };
+    }
 
     function inspectAnnexBH264(payload) {
         if (!Buffer.isBuffer(payload) || payload.length < 5) {
@@ -4266,15 +4266,15 @@ export function createRemoteHub(options = {}) {
         }
     }
 
-    function closeFileSocket(device, reason = 'file-socket-closed') {
-        const socket = device?.fileSocket;
-        if (!socket) {
-            return;
-        }
-
-        clearClipboardOperationsForDevice(device, reason);
-        failPendingFileCommandResultWaiters(device, 'clipboard-file-channel-disconnected');
-        device.fileSocket = null;
+    function closeFileSocket(device, reason = 'file-socket-closed') {
+        const socket = device?.fileSocket;
+        if (!socket) {
+            return;
+        }
+
+        clearClipboardOperationsForDevice(device, reason);
+        failPendingFileCommandResultWaiters(device, 'clipboard-file-channel-disconnected');
+        device.fileSocket = null;
         fileSockets.delete(socket);
         try {
             writeJsonLine(socket, { type: 'disconnect', channel: 'file', reason });
@@ -4288,22 +4288,24 @@ export function createRemoteHub(options = {}) {
         }
     }
 
-    function closeInputSocket(device, reason = 'input-socket-closed') {
+    function closeInputSocket(device, reason = 'input-socket-closed') {
         const socket = device?.inputSocket;
         if (!socket) {
             return;
         }
 
-        const writeOwner = device.inputWriteOwner;
-        clearClipboardOperationsForDevice(device, reason);
+        const writeOwner = device.inputWriteOwner;
+        clearClipboardOperationsForDevice(device, reason);
         device.inputSocket = null;
         device.inputWriteOwner = null;
         device.inputSocketConnectionId = '';
         device.inputOwnerConnectionId = '';
-        device.inputOwnerBindingKey = '';
-        inputSockets.delete(socket);
-        writeOwner?.close?.(reason);
-        try {
+        device.inputOwnerBindingKey = '';
+        inputSockets.delete(socket);
+        writeOwner?.close?.(reason);
+        device.inputLastSeenAt = new Date().toISOString();
+        emitRemoteEvent('RemoteInputSocketDisconnected', device, { reason });
+        try {
             writeJsonLine(socket, { type: 'disconnect', reason });
         } catch {
             // Best-effort notice before closing the side channel.
@@ -4315,7 +4317,7 @@ export function createRemoteHub(options = {}) {
         }
     }
 
-    function detachInputSocket(socket, reason = 'input-socket-closed') {
+    function detachInputSocket(socket, reason = 'input-socket-closed') {
         const deviceId = inputSockets.get(socket);
         inputSockets.delete(socket);
         if (!deviceId) {
@@ -4327,8 +4329,8 @@ export function createRemoteHub(options = {}) {
             return;
         }
 
-        const writeOwner = device.inputWriteOwner;
-        clearClipboardOperationsForDevice(device, reason);
+        const writeOwner = device.inputWriteOwner;
+        clearClipboardOperationsForDevice(device, reason);
         device.inputSocket = null;
         device.inputWriteOwner = null;
         device.inputSocketConnectionId = '';
@@ -4373,7 +4375,7 @@ export function createRemoteHub(options = {}) {
         emitRemoteEvent('RemoteAudioSocketDisconnected', device, { reason });
     }
 
-    function detachFileSocket(socket, reason = 'file-socket-closed') {
+    function detachFileSocket(socket, reason = 'file-socket-closed') {
         const deviceId = fileSockets.get(socket);
         fileSockets.delete(socket);
         if (!deviceId) {
@@ -4381,107 +4383,107 @@ export function createRemoteHub(options = {}) {
         }
 
         const device = devices.get(deviceId);
-        if (!device || device.fileSocket !== socket) {
-            return;
-        }
-
-        clearClipboardOperationsForDevice(device, reason);
-        failPendingFileCommandResultWaiters(device, 'clipboard-file-channel-disconnected');
-        device.fileSocket = null;
+        if (!device || device.fileSocket !== socket) {
+            return;
+        }
+
+        clearClipboardOperationsForDevice(device, reason);
+        failPendingFileCommandResultWaiters(device, 'clipboard-file-channel-disconnected');
+        device.fileSocket = null;
         device.fileLastSeenAt = new Date().toISOString();
-        emitRemoteEvent('RemoteFileSocketDisconnected', device, { reason });
-    }
-
-    function getDeviceConnectionHeartbeatMs(device) {
-        return Date.parse(device?.lastStatusAt || '')
-            || Date.parse(device?.connectedAt || '')
-            || 0;
-    }
-
-    function isDeviceConnectionFresh(device, nowMs = Date.now()) {
+        emitRemoteEvent('RemoteFileSocketDisconnected', device, { reason });
+    }
+
+    function getDeviceConnectionHeartbeatMs(device) {
+        return Date.parse(device?.lastStatusAt || '')
+            || Date.parse(device?.connectedAt || '')
+            || 0;
+    }
+
+    function isDeviceConnectionFresh(device, nowMs = Date.now()) {
         if (!device?.connected || !device.socket || device.socket.destroyed) {
-            return false;
-        }
-
-        const lastHeartbeatMs = getDeviceConnectionHeartbeatMs(device);
-        if (!lastHeartbeatMs) {
-            return true;
-        }
-
-        return nowMs - lastHeartbeatMs <= deviceConnectionStaleMs;
-    }
-
-    function retireStaleDeviceConnection(device, reason = 'status-heartbeat-timeout') {
-        const deviceId = safeString(device?.deviceId, 160);
-        const sessionId = safeString(device?.sessionId, 160);
-        const socket = device?.socket;
-        if (!deviceId
-            || !sessionId
-            || !socket
-            || socket.destroyed
-            || devices.get(deviceId) !== device
-            || device.socket !== socket
-            || device.sessionId !== sessionId) {
-            return false;
-        }
-
-        closeInputSocket(device, reason);
-        closeFrameSocket(device, reason);
-        closeAudioSocket(device, reason);
-        closeFileSocket(device, reason);
-        try {
-            writeJsonLine(socket, { type: 'disconnect', reason, sessionId });
-        } catch {
-            // The stale connection is retired below even if the final notice fails.
-        }
-        detachSocket(socket, reason);
-        try {
-            socket.destroy?.();
-        } catch {
-            // detachSocket already made the exact session terminal.
-        }
-        return true;
-    }
-
-    function sweepStaleDeviceConnections(nowMs = Date.now()) {
-        pruneClipboardOperations(nowMs);
-        let retired = 0;
-        for (const device of devices.values()) {
-            if (device?.synthetic === true || isDeviceConnectionFresh(device, nowMs)) {
-                continue;
-            }
-            if (!device?.connected || !device.socket || device.socket.destroyed) {
-                continue;
-            }
-            const ageMs = Math.max(0, nowMs - getDeviceConnectionHeartbeatMs(device));
-            if (retireStaleDeviceConnection(device, 'status-heartbeat-timeout')) {
-                retired += 1;
-                logWarn(
-                    'remote',
-                    `retired stale device session ${device.deviceName} (${device.deviceId}) `
-                        + `session=${device.sessionId} heartbeatAgeMs=${ageMs} `
-                        + `staleAfterMs=${deviceConnectionStaleMs}`);
-            }
-        }
-        return retired;
-    }
-
-    function scheduleDeviceConnectionSweep() {
-        if (!started || deviceConnectionSweepTimer) {
-            return;
-        }
-        deviceConnectionSweepTimer = setTimeout(() => {
-            deviceConnectionSweepTimer = null;
-            if (!started) {
-                return;
-            }
-            sweepStaleDeviceConnections();
-            scheduleDeviceConnectionSweep();
-        }, deviceConnectionSweepMs);
-        deviceConnectionSweepTimer.unref?.();
-    }
-
-    function rejectDuplicateActiveDevice(socket, existing, attemptedSessionId) {
+            return false;
+        }
+
+        const lastHeartbeatMs = getDeviceConnectionHeartbeatMs(device);
+        if (!lastHeartbeatMs) {
+            return true;
+        }
+
+        return nowMs - lastHeartbeatMs <= deviceConnectionStaleMs;
+    }
+
+    function retireStaleDeviceConnection(device, reason = 'status-heartbeat-timeout') {
+        const deviceId = safeString(device?.deviceId, 160);
+        const sessionId = safeString(device?.sessionId, 160);
+        const socket = device?.socket;
+        if (!deviceId
+            || !sessionId
+            || !socket
+            || socket.destroyed
+            || devices.get(deviceId) !== device
+            || device.socket !== socket
+            || device.sessionId !== sessionId) {
+            return false;
+        }
+
+        closeInputSocket(device, reason);
+        closeFrameSocket(device, reason);
+        closeAudioSocket(device, reason);
+        closeFileSocket(device, reason);
+        try {
+            writeJsonLine(socket, { type: 'disconnect', reason, sessionId });
+        } catch {
+            // The stale connection is retired below even if the final notice fails.
+        }
+        detachSocket(socket, reason);
+        try {
+            socket.destroy?.();
+        } catch {
+            // detachSocket already made the exact session terminal.
+        }
+        return true;
+    }
+
+    function sweepStaleDeviceConnections(nowMs = Date.now()) {
+        pruneClipboardOperations(nowMs);
+        let retired = 0;
+        for (const device of devices.values()) {
+            if (device?.synthetic === true || isDeviceConnectionFresh(device, nowMs)) {
+                continue;
+            }
+            if (!device?.connected || !device.socket || device.socket.destroyed) {
+                continue;
+            }
+            const ageMs = Math.max(0, nowMs - getDeviceConnectionHeartbeatMs(device));
+            if (retireStaleDeviceConnection(device, 'status-heartbeat-timeout')) {
+                retired += 1;
+                logWarn(
+                    'remote',
+                    `retired stale device session ${device.deviceName} (${device.deviceId}) `
+                        + `session=${device.sessionId} heartbeatAgeMs=${ageMs} `
+                        + `staleAfterMs=${deviceConnectionStaleMs}`);
+            }
+        }
+        return retired;
+    }
+
+    function scheduleDeviceConnectionSweep() {
+        if (!started || deviceConnectionSweepTimer) {
+            return;
+        }
+        deviceConnectionSweepTimer = setTimeout(() => {
+            deviceConnectionSweepTimer = null;
+            if (!started) {
+                return;
+            }
+            sweepStaleDeviceConnections();
+            scheduleDeviceConnectionSweep();
+        }, deviceConnectionSweepMs);
+        deviceConnectionSweepTimer.unref?.();
+    }
+
+    function rejectDuplicateActiveDevice(socket, existing, attemptedSessionId) {
         const retryAfterMs = Math.max(heartbeatMs, duplicateDeviceRetryAfterMs);
         writeJsonLine(socket, {
             type: 'disconnect',
@@ -4933,20 +4935,20 @@ export function createRemoteHub(options = {}) {
         return device;
     }
 
-    function attachInputSocket(socket, hello) {
-        const deviceId = normalizeDeviceId(hello.deviceId);
-        const device = devices.get(deviceId);
+    function attachInputSocket(socket, hello) {
+        const deviceId = normalizeDeviceId(hello.deviceId);
+        const device = devices.get(deviceId);
         if (!device || !device.connected || !device.socket || device.socket.destroyed) {
             writeJsonLine(socket, { type: 'error', error: 'device-not-connected' });
             socket.destroy();
-            return null;
-        }
-        if (safeString(hello.parentSessionId, 160) !== safeString(device.sessionId, 160)) {
-            writeJsonLineAndClose(socket, { type: 'error', error: 'side-channel-parent-session-stale' });
-            return null;
-        }
-
-        closeInputSocket(device, 'replaced-by-new-input-socket');
+            return null;
+        }
+        if (safeString(hello.parentSessionId, 160) !== safeString(device.sessionId, 160)) {
+            writeJsonLineAndClose(socket, { type: 'error', error: 'side-channel-parent-session-stale' });
+            return null;
+        }
+
+        closeInputSocket(device, 'replaced-by-new-input-socket');
 
         const now = new Date().toISOString();
         const inputSocketConnectionId = crypto.randomUUID();
@@ -5060,20 +5062,20 @@ export function createRemoteHub(options = {}) {
         return device;
     }
 
-    function attachFileSocket(socket, hello) {
-        const deviceId = normalizeDeviceId(hello.deviceId);
-        const device = devices.get(deviceId);
+    function attachFileSocket(socket, hello) {
+        const deviceId = normalizeDeviceId(hello.deviceId);
+        const device = devices.get(deviceId);
         if (!device || !device.connected || !device.socket || device.socket.destroyed) {
             writeJsonLine(socket, { type: 'error', error: 'device-not-connected' });
             socket.destroy();
-            return null;
-        }
-        if (safeString(hello.parentSessionId, 160) !== safeString(device.sessionId, 160)) {
-            writeJsonLineAndClose(socket, { type: 'error', error: 'side-channel-parent-session-stale' });
-            return null;
-        }
-
-        closeFileSocket(device, 'replaced-by-new-file-socket');
+            return null;
+        }
+        if (safeString(hello.parentSessionId, 160) !== safeString(device.sessionId, 160)) {
+            writeJsonLineAndClose(socket, { type: 'error', error: 'side-channel-parent-session-stale' });
+            return null;
+        }
+
+        closeFileSocket(device, 'replaced-by-new-file-socket');
         const now = new Date().toISOString();
         device.fileSocket = socket;
         device.fileConnectedAt = now;
@@ -8376,9 +8378,9 @@ export function createRemoteHub(options = {}) {
                 started = true;
                 boundPort = candidateServer.address()?.port || port;
                 lastError = '';
-                logEvent('remote', `LiveDesk Hub client endpoint listening on tcp://${host}:${boundPort}`, 'success');
+                logEvent('remote', `VuvoDesk Hub client endpoint listening on tcp://${host}:${boundPort}`, 'success');
                 if (host === '0.0.0.0' || host === '::') {
-                    logWarn('remote', 'LiveDesk Hub client endpoint is externally reachable. Use a strong pairing token and trusted network.');
+                    logWarn('remote', 'VuvoDesk Hub client endpoint is externally reachable. Use a strong pairing token and trusted network.');
                 }
                 emitRemoteEvent('RemoteHubStarted', null);
                 resolve();
@@ -8396,14 +8398,14 @@ export function createRemoteHub(options = {}) {
             await listenOnPort(requestedPort);
             try {
                 await relayControl?.start?.();
-            } catch {
-                logWarn('relay', 'Encrypted relay control could not start; direct TCP remains available.');
-            }
-            scheduleDeviceConnectionSweep();
-        } catch (error) {
-            if (error?.code === 'EADDRINUSE') {
-                const conflict = new Error(
-                    `LiveDesk Hub requires client endpoint TCP ${requestedPort}, but that port is already in use. Close the owning process or start Hub with an explicit --remote-port value.`);
+            } catch {
+                logWarn('relay', 'Encrypted relay control could not start; direct TCP remains available.');
+            }
+            scheduleDeviceConnectionSweep();
+        } catch (error) {
+            if (error?.code === 'EADDRINUSE') {
+                const conflict = new Error(
+                    `VuvoDesk Hub requires client endpoint TCP ${requestedPort}, but that port is already in use. Close the owning process or start Hub with an explicit --remote-port value.`);
                 conflict.code = 'EADDRINUSE';
                 conflict.port = requestedPort;
                 conflict.cause = error;
@@ -8414,16 +8416,16 @@ export function createRemoteHub(options = {}) {
         }
 
         return getStatus({ includeSecrets: false });
-    }
-
-    async function close() {
-        if (deviceConnectionSweepTimer) {
-            clearTimeout(deviceConnectionSweepTimer);
-            deviceConnectionSweepTimer = null;
-        }
-        for (const state of [...agentBinaryIngressStates]) {
-            closeAgentBinaryIngress(state, 'hub-shutdown');
-        }
+    }
+
+    async function close() {
+        if (deviceConnectionSweepTimer) {
+            clearTimeout(deviceConnectionSweepTimer);
+            deviceConnectionSweepTimer = null;
+        }
+        for (const state of [...agentBinaryIngressStates]) {
+            closeAgentBinaryIngress(state, 'hub-shutdown');
+        }
 
         for (const device of devices.values()) {
             abortTransportDiagnosticsForDevice(device, 'hub-shutdown');
@@ -8558,12 +8560,12 @@ export function createRemoteHub(options = {}) {
         };
     }
 
-    function sendCommand(deviceId, command) {
-        const device = devices.get(String(deviceId || ''));
-        const commandName = safeString(command?.command || 'ping', 80);
-        if (REMOTE_CLIPBOARD_FILE_ACTIONS.has(commandName)) {
-            return { ok: false, error: 'clipboard-command-requires-awaited-file-channel' };
-        }
+    function sendCommand(deviceId, command) {
+        const device = devices.get(String(deviceId || ''));
+        const commandName = safeString(command?.command || 'ping', 80);
+        if (REMOTE_CLIPBOARD_FILE_ACTIONS.has(commandName)) {
+            return { ok: false, error: 'clipboard-command-requires-awaited-file-channel' };
+        }
         const requiredPermission = commandName === 'input.control'
             ? 'allowControl'
             : commandName === 'system.power'
@@ -8599,16 +8601,16 @@ export function createRemoteHub(options = {}) {
                 result: { ok: true, synthetic: true },
                 error: ''
             });
-            return { ok: true, commandId, synthetic: true };
-        }
-
-        if (device?.connected && !isDeviceConnectionFresh(device)) {
-            retireStaleDeviceConnection(device, 'status-heartbeat-timeout');
-            return { ok: false, error: 'device-not-connected' };
-        }
-        if (!device?.socket || device.socket.destroyed || !device.connected) {
-            return { ok: false, error: 'device-not-connected' };
-        }
+            return { ok: true, commandId, synthetic: true };
+        }
+
+        if (device?.connected && !isDeviceConnectionFresh(device)) {
+            retireStaleDeviceConnection(device, 'status-heartbeat-timeout');
+            return { ok: false, error: 'device-not-connected' };
+        }
+        if (!device?.socket || device.socket.destroyed || !device.connected) {
+            return { ok: false, error: 'device-not-connected' };
+        }
 
         const commandId = safeString(command?.commandId, 128) || crypto.randomUUID();
         const payload = {
@@ -8621,300 +8623,300 @@ export function createRemoteHub(options = {}) {
 
         const dedicatedFileSocket = commandName.startsWith('file.transfer')
             && device.fileSocket
-            && !device.fileSocket.destroyed
-            ? device.fileSocket
-            : null;
-        try {
-            writeJsonLine(dedicatedFileSocket || device.socket, payload);
-        } catch {
-            retireStaleDeviceConnection(device, 'command-channel-write-failed');
-            return { ok: false, error: 'device-not-connected' };
-        }
-        device.counters.commandsSent += 1;
-        emitRemoteEvent('RemoteCommandQueued', device, {
-            commandId,
+            && !device.fileSocket.destroyed
+            ? device.fileSocket
+            : null;
+        try {
+            writeJsonLine(dedicatedFileSocket || device.socket, payload);
+        } catch {
+            retireStaleDeviceConnection(device, 'command-channel-write-failed');
+            return { ok: false, error: 'device-not-connected' };
+        }
+        device.counters.commandsSent += 1;
+        emitRemoteEvent('RemoteCommandQueued', device, {
+            commandId,
             command: payload.command,
             channel: dedicatedFileSocket ? 'file' : 'control'
         });
-        return { ok: true, commandId };
-    }
-
-    async function sendClipboardCommand(deviceId, request = {}) {
-        pruneClipboardOperations();
-        const action = safeString(request.action, 80).toLowerCase();
-        if (!REMOTE_CLIPBOARD_FILE_ACTIONS.has(action)) {
-            return { ok: false, error: 'clipboard-file-action-invalid' };
-        }
-        const operationId = safeString(request.operationId, 128);
-        if (!operationId) {
-            return { ok: false, error: 'clipboard-operation-id-invalid' };
-        }
-
-        const direction = action.startsWith('clipboard.paste.')
-            ? 'paste'
-            : action.startsWith('clipboard.copy.')
-                ? 'copy'
-                : '';
-        const operationKey = buildClipboardOperationKey(deviceId, request.binding?.controlSessionId, operationId);
-        let operation = clipboardOperations.get(operationKey);
-        const beginsOperation = action === 'clipboard.copy.begin' || action === 'clipboard.paste.begin';
-        const endsOperation = action === 'clipboard.copy.end' || action === 'clipboard.paste.cancel';
-        const requestedManifest = request.payload?.manifest || null;
-
-        if (beginsOperation) {
-            if (operation) {
-                return { ok: false, error: 'clipboard-operation-already-exists' };
-            }
-            const activeForDevice = [...clipboardOperations.values()].filter(candidate =>
-                candidate.deviceId === String(deviceId || '')
-                && candidate.sessionId === request.binding?.controlSessionId);
-            if (activeForDevice.some(candidate => candidate.direction === direction)) {
-                return { ok: false, error: 'clipboard-operation-direction-busy' };
-            }
-            if (activeForDevice.length >= REMOTE_CLIPBOARD_LIMITS.maxOperationsPerDevice) {
-                return { ok: false, error: 'clipboard-operation-capacity-reached' };
-            }
-            operation = {
-                deviceId: String(deviceId || ''),
-                sessionId: safeString(request.binding?.controlSessionId, 160),
-                operationId,
-                direction,
-                hubConnectionId: safeString(request.hubConnectionId, 128),
-                controlCommandId: safeString(request.binding?.controlCommandId, 128),
-                captureGeneration: Number(request.binding?.captureGeneration || 0),
-                monitorIndex: Number(request.binding?.monitorIndex),
-                contentKind: requestedManifest?.contentKind || 'text',
-                manifest: requestedManifest,
-                offsets: new Map(),
-                status: action === 'clipboard.paste.begin' ? 'preparing' : 'copying',
-                inFlight: false,
-                touchedAt: Date.now()
-            };
-            clipboardOperations.set(operationKey, operation);
-        } else {
-            if (!operation) {
-                return { ok: false, error: 'clipboard-operation-not-found' };
-            }
-            const requestedDirection = direction || operation.direction;
-            if (operation.direction !== requestedDirection
-                || operation.hubConnectionId !== safeString(request.hubConnectionId, 128)
-                || operation.controlCommandId !== safeString(request.binding?.controlCommandId, 128)
-                || operation.captureGeneration !== Number(request.binding?.captureGeneration || 0)
-                || operation.monitorIndex !== Number(request.binding?.monitorIndex)) {
-                return { ok: false, error: 'clipboard-operation-owner-stale' };
-            }
-        }
-
-        if (operation.inFlight) {
-            return { ok: false, error: 'clipboard-operation-busy' };
-        }
-
-        const contentKind = operation.contentKind || requestedManifest?.contentKind || 'text';
-        const bindingResult = validateCurrentClipboardBinding(
-            deviceId,
-            { ...request, clipboardDirection: operation.direction },
-            contentKind,
-            { requireFileSocket: true });
-        if (!bindingResult.ok) {
-            if (beginsOperation || bindingResult.error?.startsWith('STALE_') || bindingResult.error === 'input-owner-not-current') {
-                clipboardOperations.delete(operationKey);
-            }
-            return bindingResult;
-        }
-
-        const { device } = bindingResult;
-        const fileSocket = device.fileSocket;
-        const itemIndex = request.payload?.itemIndex;
-        const expectedOffset = Number.isInteger(itemIndex)
-            ? Number(operation.offsets.get(itemIndex) || 0)
-            : 0;
-        let outgoingChunkBytes = 0;
-        if (action === 'clipboard.copy.chunk' || action === 'clipboard.paste.chunk') {
-            const item = operation.manifest?.items?.[itemIndex];
-            if (!item) {
-                return { ok: false, error: 'clipboard-item-not-found' };
-            }
-            if (request.payload.offset !== expectedOffset) {
-                return { ok: false, error: 'clipboard-chunk-offset-stale', expectedOffset };
-            }
-            if (action === 'clipboard.copy.chunk'
-                && request.payload.maxBytes > Number(device.capabilities?.clipboardMaxChunkBytes || 0)) {
-                return { ok: false, error: 'device-clipboard-chunk-limit-exceeded' };
-            }
-            if (action === 'clipboard.paste.chunk') {
-                outgoingChunkBytes = Buffer.from(request.payload.dataBase64, 'base64').length;
-                if (outgoingChunkBytes > Number(device.capabilities?.clipboardMaxChunkBytes || 0)) {
-                    return { ok: false, error: 'device-clipboard-chunk-limit-exceeded' };
-                }
-                const nextOffset = expectedOffset + outgoingChunkBytes;
-                if (outgoingChunkBytes === 0
-                    && !(item.size === 0 && expectedOffset === 0 && request.payload.final === true)) {
-                    return { ok: false, error: 'clipboard-empty-chunk-invalid' };
-                }
-                if (nextOffset > item.size
-                    || request.payload.final !== (nextOffset === item.size)) {
-                    return { ok: false, error: 'clipboard-chunk-boundary-invalid' };
-                }
-            }
-        }
-
-        operation.inFlight = true;
-        operation.touchedAt = Date.now();
-        let commandCompleted = false;
-        const commandId = crypto.randomUUID();
-        const resultPromise = waitForCommandResult(
-            device,
-            commandId,
-            REMOTE_CLIPBOARD_LIMITS.commandTimeoutMs,
-            { channel: 'file', operationId });
-        const commandPayload = {
-            type: 'command',
-            commandId,
-            command: action,
-            payload: {
-                operationId,
-                controlSessionId: operation.sessionId,
-                controlCommandId: operation.controlCommandId,
-                captureGeneration: operation.captureGeneration,
-                monitorIndex: operation.monitorIndex,
-                hubConnectionId: operation.hubConnectionId,
-                ...(request.payload || {})
-            },
-            issuedAt: new Date().toISOString()
-        };
-
-        try {
-            try {
-                // Clipboard payloads are never allowed onto the concurrent
-                // main command socket. The dedicated file side channel owns
-                // the one bounded command and its exact-session waiter.
-                writeJsonLine(fileSocket, commandPayload);
-            } catch {
-                failPendingCommandResultWaiter(device, commandId, 'clipboard-file-channel-write-failed');
-                if (device.fileSocket === fileSocket) {
-                    closeFileSocket(device, 'clipboard-file-channel-write-failed');
-                }
-                return { ok: false, error: 'clipboard-file-channel-unavailable' };
-            }
-            device.counters.commandsSent += 1;
-            emitRemoteEvent('RemoteCommandQueued', device, {
-                commandId,
-                command: action,
-                channel: 'file',
-                operationId
-            });
-
-            const awaited = await resultPromise;
-            if (!awaited.ok) {
-                return {
-                    ok: false,
-                    error: awaited.error || 'clipboard-command-failed',
-                    commandId
-                };
-            }
-            if (device.fileSocket !== fileSocket) {
-                return { ok: false, error: 'clipboard-file-channel-owner-changed' };
-            }
-            const currentBinding = validateCurrentClipboardBinding(
-                deviceId,
-                { ...request, clipboardDirection: operation.direction },
-                operation.contentKind || 'text',
-                { requireFileSocket: true });
-            if (!currentBinding.ok) {
-                return currentBinding;
-            }
-
-            let response;
-            try {
-                response = normalizeRemoteClipboardCommandResult(action, operationId, awaited.result);
-            } catch (error) {
-                return {
-                    ok: false,
-                    error: safeString(error?.code || error?.message, 160) || 'clipboard-response-invalid'
-                };
-            }
-            if (response.manifest) {
-                const responseManifestLimitError = clipboardManifestCapabilityError(device, response.manifest);
-                if (responseManifestLimitError) {
-                    clipboardOperations.delete(operationKey);
-                    return { ok: false, error: responseManifestLimitError };
-                }
-                const responsePolicy = validateCurrentClipboardBinding(
-                    deviceId,
-                    { ...request, clipboardDirection: operation.direction },
-                    response.manifest.contentKind,
-                    { requireFileSocket: true });
-                if (!responsePolicy.ok) {
-                    clipboardOperations.delete(operationKey);
-                    return responsePolicy;
-                }
-                operation.manifest = response.manifest;
-                operation.contentKind = response.manifest.contentKind;
-            }
-            if (action === 'clipboard.copy.chunk') {
-                const item = operation.manifest?.items?.[response.itemIndex];
-                const nextOffset = response.offset + response.bytes;
-                if (!item
-                    || response.itemIndex !== itemIndex
-                    || response.offset !== expectedOffset
-                    || (response.bytes === 0
-                        && !(item.size === 0 && response.offset === 0 && response.final === true))
-                    || nextOffset > item.size
-                    || response.final !== (nextOffset === item.size)) {
-                    return { ok: false, error: 'clipboard-chunk-response-boundary-invalid' };
-                }
-                if (response.bytes > Number(device.capabilities?.clipboardMaxChunkBytes || 0)) {
-                    return { ok: false, error: 'device-clipboard-chunk-limit-exceeded' };
-                }
-                operation.offsets.set(response.itemIndex, nextOffset);
-            } else if (action === 'clipboard.paste.chunk') {
-                if (response.itemIndex !== itemIndex
-                    || response.offset !== expectedOffset
-                    || response.bytes !== outgoingChunkBytes
-                    || response.totalBytes !== operation.manifest.items[itemIndex].size
-                    || response.final !== request.payload.final) {
-                    return { ok: false, error: 'clipboard-chunk-response-boundary-invalid' };
-                }
-                operation.offsets.set(itemIndex, expectedOffset + outgoingChunkBytes);
-            }
-            operation.status = response.status || operation.status;
-            operation.touchedAt = Date.now();
-            if (action === 'clipboard.operation.status' && operation.status === 'not-found') {
-                clipboardOperations.delete(operationKey);
-                return { ok: false, error: 'clipboard-operation-not-found' };
-            }
-            if (action === 'clipboard.operation.status'
-                && ['completed', 'complete', 'applied', 'pasted', 'cancelled', 'cleaned', 'failed', 'expired', 'already-ended']
-                    .includes(operation.status)) {
-                clipboardOperations.delete(operationKey);
-            }
-            commandCompleted = true;
-            return response;
-        } finally {
-            const currentOperation = clipboardOperations.get(operationKey);
-            if (currentOperation === operation) {
-                operation.inFlight = false;
-                if (endsOperation || (beginsOperation && !commandCompleted)) {
-                    clipboardOperations.delete(operationKey);
-                }
-            }
-        }
-    }
-
-    function refreshDevicePolicies(deviceIds = undefined) {
+        return { ok: true, commandId };
+    }
+
+    async function sendClipboardCommand(deviceId, request = {}) {
+        pruneClipboardOperations();
+        const action = safeString(request.action, 80).toLowerCase();
+        if (!REMOTE_CLIPBOARD_FILE_ACTIONS.has(action)) {
+            return { ok: false, error: 'clipboard-file-action-invalid' };
+        }
+        const operationId = safeString(request.operationId, 128);
+        if (!operationId) {
+            return { ok: false, error: 'clipboard-operation-id-invalid' };
+        }
+
+        const direction = action.startsWith('clipboard.paste.')
+            ? 'paste'
+            : action.startsWith('clipboard.copy.')
+                ? 'copy'
+                : '';
+        const operationKey = buildClipboardOperationKey(deviceId, request.binding?.controlSessionId, operationId);
+        let operation = clipboardOperations.get(operationKey);
+        const beginsOperation = action === 'clipboard.copy.begin' || action === 'clipboard.paste.begin';
+        const endsOperation = action === 'clipboard.copy.end' || action === 'clipboard.paste.cancel';
+        const requestedManifest = request.payload?.manifest || null;
+
+        if (beginsOperation) {
+            if (operation) {
+                return { ok: false, error: 'clipboard-operation-already-exists' };
+            }
+            const activeForDevice = [...clipboardOperations.values()].filter(candidate =>
+                candidate.deviceId === String(deviceId || '')
+                && candidate.sessionId === request.binding?.controlSessionId);
+            if (activeForDevice.some(candidate => candidate.direction === direction)) {
+                return { ok: false, error: 'clipboard-operation-direction-busy' };
+            }
+            if (activeForDevice.length >= REMOTE_CLIPBOARD_LIMITS.maxOperationsPerDevice) {
+                return { ok: false, error: 'clipboard-operation-capacity-reached' };
+            }
+            operation = {
+                deviceId: String(deviceId || ''),
+                sessionId: safeString(request.binding?.controlSessionId, 160),
+                operationId,
+                direction,
+                hubConnectionId: safeString(request.hubConnectionId, 128),
+                controlCommandId: safeString(request.binding?.controlCommandId, 128),
+                captureGeneration: Number(request.binding?.captureGeneration || 0),
+                monitorIndex: Number(request.binding?.monitorIndex),
+                contentKind: requestedManifest?.contentKind || 'text',
+                manifest: requestedManifest,
+                offsets: new Map(),
+                status: action === 'clipboard.paste.begin' ? 'preparing' : 'copying',
+                inFlight: false,
+                touchedAt: Date.now()
+            };
+            clipboardOperations.set(operationKey, operation);
+        } else {
+            if (!operation) {
+                return { ok: false, error: 'clipboard-operation-not-found' };
+            }
+            const requestedDirection = direction || operation.direction;
+            if (operation.direction !== requestedDirection
+                || operation.hubConnectionId !== safeString(request.hubConnectionId, 128)
+                || operation.controlCommandId !== safeString(request.binding?.controlCommandId, 128)
+                || operation.captureGeneration !== Number(request.binding?.captureGeneration || 0)
+                || operation.monitorIndex !== Number(request.binding?.monitorIndex)) {
+                return { ok: false, error: 'clipboard-operation-owner-stale' };
+            }
+        }
+
+        if (operation.inFlight) {
+            return { ok: false, error: 'clipboard-operation-busy' };
+        }
+
+        const contentKind = operation.contentKind || requestedManifest?.contentKind || 'text';
+        const bindingResult = validateCurrentClipboardBinding(
+            deviceId,
+            { ...request, clipboardDirection: operation.direction },
+            contentKind,
+            { requireFileSocket: true });
+        if (!bindingResult.ok) {
+            if (beginsOperation || bindingResult.error?.startsWith('STALE_') || bindingResult.error === 'input-owner-not-current') {
+                clipboardOperations.delete(operationKey);
+            }
+            return bindingResult;
+        }
+
+        const { device } = bindingResult;
+        const fileSocket = device.fileSocket;
+        const itemIndex = request.payload?.itemIndex;
+        const expectedOffset = Number.isInteger(itemIndex)
+            ? Number(operation.offsets.get(itemIndex) || 0)
+            : 0;
+        let outgoingChunkBytes = 0;
+        if (action === 'clipboard.copy.chunk' || action === 'clipboard.paste.chunk') {
+            const item = operation.manifest?.items?.[itemIndex];
+            if (!item) {
+                return { ok: false, error: 'clipboard-item-not-found' };
+            }
+            if (request.payload.offset !== expectedOffset) {
+                return { ok: false, error: 'clipboard-chunk-offset-stale', expectedOffset };
+            }
+            if (action === 'clipboard.copy.chunk'
+                && request.payload.maxBytes > Number(device.capabilities?.clipboardMaxChunkBytes || 0)) {
+                return { ok: false, error: 'device-clipboard-chunk-limit-exceeded' };
+            }
+            if (action === 'clipboard.paste.chunk') {
+                outgoingChunkBytes = Buffer.from(request.payload.dataBase64, 'base64').length;
+                if (outgoingChunkBytes > Number(device.capabilities?.clipboardMaxChunkBytes || 0)) {
+                    return { ok: false, error: 'device-clipboard-chunk-limit-exceeded' };
+                }
+                const nextOffset = expectedOffset + outgoingChunkBytes;
+                if (outgoingChunkBytes === 0
+                    && !(item.size === 0 && expectedOffset === 0 && request.payload.final === true)) {
+                    return { ok: false, error: 'clipboard-empty-chunk-invalid' };
+                }
+                if (nextOffset > item.size
+                    || request.payload.final !== (nextOffset === item.size)) {
+                    return { ok: false, error: 'clipboard-chunk-boundary-invalid' };
+                }
+            }
+        }
+
+        operation.inFlight = true;
+        operation.touchedAt = Date.now();
+        let commandCompleted = false;
+        const commandId = crypto.randomUUID();
+        const resultPromise = waitForCommandResult(
+            device,
+            commandId,
+            REMOTE_CLIPBOARD_LIMITS.commandTimeoutMs,
+            { channel: 'file', operationId });
+        const commandPayload = {
+            type: 'command',
+            commandId,
+            command: action,
+            payload: {
+                operationId,
+                controlSessionId: operation.sessionId,
+                controlCommandId: operation.controlCommandId,
+                captureGeneration: operation.captureGeneration,
+                monitorIndex: operation.monitorIndex,
+                hubConnectionId: operation.hubConnectionId,
+                ...(request.payload || {})
+            },
+            issuedAt: new Date().toISOString()
+        };
+
+        try {
+            try {
+                // Clipboard payloads are never allowed onto the concurrent
+                // main command socket. The dedicated file side channel owns
+                // the one bounded command and its exact-session waiter.
+                writeJsonLine(fileSocket, commandPayload);
+            } catch {
+                failPendingCommandResultWaiter(device, commandId, 'clipboard-file-channel-write-failed');
+                if (device.fileSocket === fileSocket) {
+                    closeFileSocket(device, 'clipboard-file-channel-write-failed');
+                }
+                return { ok: false, error: 'clipboard-file-channel-unavailable' };
+            }
+            device.counters.commandsSent += 1;
+            emitRemoteEvent('RemoteCommandQueued', device, {
+                commandId,
+                command: action,
+                channel: 'file',
+                operationId
+            });
+
+            const awaited = await resultPromise;
+            if (!awaited.ok) {
+                return {
+                    ok: false,
+                    error: awaited.error || 'clipboard-command-failed',
+                    commandId
+                };
+            }
+            if (device.fileSocket !== fileSocket) {
+                return { ok: false, error: 'clipboard-file-channel-owner-changed' };
+            }
+            const currentBinding = validateCurrentClipboardBinding(
+                deviceId,
+                { ...request, clipboardDirection: operation.direction },
+                operation.contentKind || 'text',
+                { requireFileSocket: true });
+            if (!currentBinding.ok) {
+                return currentBinding;
+            }
+
+            let response;
+            try {
+                response = normalizeRemoteClipboardCommandResult(action, operationId, awaited.result);
+            } catch (error) {
+                return {
+                    ok: false,
+                    error: safeString(error?.code || error?.message, 160) || 'clipboard-response-invalid'
+                };
+            }
+            if (response.manifest) {
+                const responseManifestLimitError = clipboardManifestCapabilityError(device, response.manifest);
+                if (responseManifestLimitError) {
+                    clipboardOperations.delete(operationKey);
+                    return { ok: false, error: responseManifestLimitError };
+                }
+                const responsePolicy = validateCurrentClipboardBinding(
+                    deviceId,
+                    { ...request, clipboardDirection: operation.direction },
+                    response.manifest.contentKind,
+                    { requireFileSocket: true });
+                if (!responsePolicy.ok) {
+                    clipboardOperations.delete(operationKey);
+                    return responsePolicy;
+                }
+                operation.manifest = response.manifest;
+                operation.contentKind = response.manifest.contentKind;
+            }
+            if (action === 'clipboard.copy.chunk') {
+                const item = operation.manifest?.items?.[response.itemIndex];
+                const nextOffset = response.offset + response.bytes;
+                if (!item
+                    || response.itemIndex !== itemIndex
+                    || response.offset !== expectedOffset
+                    || (response.bytes === 0
+                        && !(item.size === 0 && response.offset === 0 && response.final === true))
+                    || nextOffset > item.size
+                    || response.final !== (nextOffset === item.size)) {
+                    return { ok: false, error: 'clipboard-chunk-response-boundary-invalid' };
+                }
+                if (response.bytes > Number(device.capabilities?.clipboardMaxChunkBytes || 0)) {
+                    return { ok: false, error: 'device-clipboard-chunk-limit-exceeded' };
+                }
+                operation.offsets.set(response.itemIndex, nextOffset);
+            } else if (action === 'clipboard.paste.chunk') {
+                if (response.itemIndex !== itemIndex
+                    || response.offset !== expectedOffset
+                    || response.bytes !== outgoingChunkBytes
+                    || response.totalBytes !== operation.manifest.items[itemIndex].size
+                    || response.final !== request.payload.final) {
+                    return { ok: false, error: 'clipboard-chunk-response-boundary-invalid' };
+                }
+                operation.offsets.set(itemIndex, expectedOffset + outgoingChunkBytes);
+            }
+            operation.status = response.status || operation.status;
+            operation.touchedAt = Date.now();
+            if (action === 'clipboard.operation.status' && operation.status === 'not-found') {
+                clipboardOperations.delete(operationKey);
+                return { ok: false, error: 'clipboard-operation-not-found' };
+            }
+            if (action === 'clipboard.operation.status'
+                && ['completed', 'complete', 'applied', 'pasted', 'cancelled', 'cleaned', 'failed', 'expired', 'already-ended']
+                    .includes(operation.status)) {
+                clipboardOperations.delete(operationKey);
+            }
+            commandCompleted = true;
+            return response;
+        } finally {
+            const currentOperation = clipboardOperations.get(operationKey);
+            if (currentOperation === operation) {
+                operation.inFlight = false;
+                if (endsOperation || (beginsOperation && !commandCompleted)) {
+                    clipboardOperations.delete(operationKey);
+                }
+            }
+        }
+    }
+
+    function refreshDevicePolicies(deviceIds = undefined) {
         const requestedIds = Array.isArray(deviceIds) && deviceIds.length > 0
             ? new Set(deviceIds.map(deviceId => safeString(deviceId, 160)).filter(Boolean))
             : null;
         let updated = 0;
         let total = 0;
-        for (const device of devices.values()) {
-            if (requestedIds && !requestedIds.has(device.deviceId)) continue;
-            if (!device?.socket || device.socket.destroyed || !device.connected) continue;
-            if (device.synthetic !== true && !isDeviceConnectionFresh(device)) {
-                retireStaleDeviceConnection(device, 'status-heartbeat-timeout');
-                continue;
-            }
-            total += 1;
+        for (const device of devices.values()) {
+            if (requestedIds && !requestedIds.has(device.deviceId)) continue;
+            if (!device?.socket || device.socket.destroyed || !device.connected) continue;
+            if (device.synthetic !== true && !isDeviceConnectionFresh(device)) {
+                retireStaleDeviceConnection(device, 'status-heartbeat-timeout');
+                continue;
+            }
+            total += 1;
             const effectivePolicy = getDevicePolicy(device);
             if (writeJsonLine(device.socket, {
                 type: 'policy.update',
@@ -8933,14 +8935,14 @@ export function createRemoteHub(options = {}) {
         const device = devices.get(String(deviceId || ''));
         const denied = policyError(device);
         if (denied) return { ok: false, error: denied };
-        if (!device) return { ok: false, error: 'device-not-found' };
-        if (device.synthetic !== true
-            && device.connected
-            && !isDeviceConnectionFresh(device)) {
-            retireStaleDeviceConnection(device, 'status-heartbeat-timeout');
-            return { ok: false, error: 'device-not-connected' };
-        }
-        if (!device.socket || device.socket.destroyed || !device.connected) {
+        if (!device) return { ok: false, error: 'device-not-found' };
+        if (device.synthetic !== true
+            && device.connected
+            && !isDeviceConnectionFresh(device)) {
+            retireStaleDeviceConnection(device, 'status-heartbeat-timeout');
+            return { ok: false, error: 'device-not-connected' };
+        }
+        if (!device.socket || device.socket.destroyed || !device.connected) {
             return { ok: false, error: 'device-not-connected' };
         }
 
@@ -9026,40 +9028,65 @@ export function createRemoteHub(options = {}) {
         };
     }
 
-    function getCurrentInputWriteOwner(device) {
+    function getCurrentInputWriteOwner(device) {
         if (!device?.inputSocket
             || device.inputSocket.destroyed
             || !device.inputWriteOwner
             || !safeString(device.inputSocketConnectionId, 128)) {
             return null;
         }
-        return device.inputWriteOwner;
-    }
-
-    function sendInputControl(deviceId, input = {}) {
+        return device.inputWriteOwner;
+    }
+
+    function getInputRouteState(deviceId) {
         const device = devices.get(String(deviceId || ''));
-        if (!device) {
-            return { ok: false, error: 'device-not-found' };
+        if (!device || !device.connected || !device.socket || device.socket.destroyed) {
+            return {
+                deviceId: safeString(deviceId, 160),
+                ready: false,
+                dedicatedInputChannel: false,
+                reason: 'device-not-connected'
+            };
         }
 
-        if (device.synthetic !== true
-            && device.connected
-            && !isDeviceConnectionFresh(device)) {
-            retireStaleDeviceConnection(device, 'status-heartbeat-timeout');
-            return { ok: false, error: 'device-not-connected' };
-        }
-        if (!device.connected) {
-            return { ok: false, error: 'device-not-connected' };
-        }
+        const dedicatedInputChannel = readCapabilityFlag(
+            device.capabilities,
+            'dedicatedInputChannel');
+        const ready = dedicatedInputChannel
+            ? !!getCurrentInputWriteOwner(device)
+            : true;
+        return {
+            deviceId: device.deviceId,
+            ready,
+            dedicatedInputChannel,
+            reason: ready ? 'ready' : 'input-channel-not-connected'
+        };
+    }
+
+    function sendInputControl(deviceId, input = {}) {
+        const device = devices.get(String(deviceId || ''));
+        if (!device) {
+            return { ok: false, error: 'device-not-found' };
+        }
+
+        if (device.synthetic !== true
+            && device.connected
+            && !isDeviceConnectionFresh(device)) {
+            retireStaleDeviceConnection(device, 'status-heartbeat-timeout');
+            return { ok: false, error: 'device-not-connected' };
+        }
+        if (!device.connected) {
+            return { ok: false, error: 'device-not-connected' };
+        }
 
         const normalized = normalizeRemoteInputEvent(input);
         if (!normalized.type) {
             return { ok: false, error: 'missing-input-type' };
         }
 
-        // A reset only releases native key state. The current browser input
-        // owner must be able to send it even when its former Control binding
-        // has just become stale during a monitor/capture-generation switch.
+        // A reset releases native mouse-button and keyboard state. The
+        // current browser input owner must be able to send it even when its
+        // former Control binding has just become stale during a monitor/capture-generation switch.
         const currentInputOwner = safeString(device.inputOwnerConnectionId, 128);
         const isCurrentOwnerKeyboardReset = normalized.type.toLowerCase() === 'keyboard.reset'
             && normalized.hubConnectionId
@@ -9116,51 +9143,51 @@ export function createRemoteHub(options = {}) {
             || device.capabilities?.accessibilityPermission === false) {
             return { ok: false, error: 'INPUT_PERMISSION_DENIED' };
         }
-        if (!readCapabilityFlag(device.capabilities, 'control')) {
-            return { ok: false, error: 'device-input-control-unavailable' };
-        }
-
-        const normalizedInputType = normalized.type.toLowerCase();
-        const isClipboardInput = normalizedInputType === 'clipboard.prepare'
-            || normalizedInputType === 'clipboard.copy'
-            || normalizedInputType === 'clipboard.paste';
-        let clipboardManifest = null;
-        if (isClipboardInput) {
-            if (!normalized.clipboardOperationId) {
-                return { ok: false, error: 'clipboard-operation-id-invalid' };
-            }
-            if (!['copy', 'paste'].includes(normalized.clipboardDirection)) {
-                return { ok: false, error: 'clipboard-direction-required' };
-            }
-            if ((normalizedInputType === 'clipboard.copy' && normalized.clipboardDirection !== 'copy')
-                || (normalizedInputType === 'clipboard.paste' && normalized.clipboardDirection !== 'paste')) {
-                return { ok: false, error: 'clipboard-direction-mismatch' };
-            }
-            try {
-                clipboardManifest = normalized.manifest
-                    ? normalizeRemoteClipboardManifest(normalized.manifest, normalized.clipboardOperationId)
-                    : null;
-            } catch (error) {
-                return { ok: false, error: safeString(error?.code || error?.message, 160) || 'clipboard-manifest-invalid' };
-            }
-            const clipboardPolicy = getDevicePolicy(device);
-            if (clipboardPolicy.allowClipboardText !== true) {
-                return { ok: false, error: 'allowClipboardText-blocked-by-settings' };
-            }
-            const contentKind = clipboardManifest?.contentKind || normalized.contentKind || 'text';
-            if (remoteClipboardContentNeedsFileTransfer(contentKind)
-                && clipboardPolicy.allowFileTransfer !== true) {
-                return { ok: false, error: 'allowFileTransfer-blocked-by-settings' };
-            }
-            const clipboardCapabilityDenied = clipboardCapabilityError(
-                device,
-                normalized.clipboardDirection,
-                contentKind);
-            if (clipboardCapabilityDenied) {
-                return { ok: false, error: clipboardCapabilityDenied };
-            }
-            normalized.manifest = clipboardManifest;
-        }
+        if (!readCapabilityFlag(device.capabilities, 'control')) {
+            return { ok: false, error: 'device-input-control-unavailable' };
+        }
+
+        const normalizedInputType = normalized.type.toLowerCase();
+        const isClipboardInput = normalizedInputType === 'clipboard.prepare'
+            || normalizedInputType === 'clipboard.copy'
+            || normalizedInputType === 'clipboard.paste';
+        let clipboardManifest = null;
+        if (isClipboardInput) {
+            if (!normalized.clipboardOperationId) {
+                return { ok: false, error: 'clipboard-operation-id-invalid' };
+            }
+            if (!['copy', 'paste'].includes(normalized.clipboardDirection)) {
+                return { ok: false, error: 'clipboard-direction-required' };
+            }
+            if ((normalizedInputType === 'clipboard.copy' && normalized.clipboardDirection !== 'copy')
+                || (normalizedInputType === 'clipboard.paste' && normalized.clipboardDirection !== 'paste')) {
+                return { ok: false, error: 'clipboard-direction-mismatch' };
+            }
+            try {
+                clipboardManifest = normalized.manifest
+                    ? normalizeRemoteClipboardManifest(normalized.manifest, normalized.clipboardOperationId)
+                    : null;
+            } catch (error) {
+                return { ok: false, error: safeString(error?.code || error?.message, 160) || 'clipboard-manifest-invalid' };
+            }
+            const clipboardPolicy = getDevicePolicy(device);
+            if (clipboardPolicy.allowClipboardText !== true) {
+                return { ok: false, error: 'allowClipboardText-blocked-by-settings' };
+            }
+            const contentKind = clipboardManifest?.contentKind || normalized.contentKind || 'text';
+            if (remoteClipboardContentNeedsFileTransfer(contentKind)
+                && clipboardPolicy.allowFileTransfer !== true) {
+                return { ok: false, error: 'allowFileTransfer-blocked-by-settings' };
+            }
+            const clipboardCapabilityDenied = clipboardCapabilityError(
+                device,
+                normalized.clipboardDirection,
+                contentKind);
+            if (clipboardCapabilityDenied) {
+                return { ok: false, error: clipboardCapabilityDenied };
+            }
+            normalized.manifest = clipboardManifest;
+        }
 
         const controlStream = getActiveControlStream(device);
         if (!controlStream
@@ -9196,32 +9223,32 @@ export function createRemoteHub(options = {}) {
             };
         }
         const activeMonitorIndex = normalizeMonitorIndex(controlStream.monitorIndex);
-        if (!Number.isInteger(normalized.monitorIndex)
-            || normalized.monitorIndex !== activeMonitorIndex) {
+        if (!Number.isInteger(normalized.monitorIndex)
+            || normalized.monitorIndex !== activeMonitorIndex) {
             return {
                 ok: false,
                 error: 'STALE_CONTROL_MONITOR',
-                activeMonitorIndex
-            };
-        }
-
-        let clipboardOperationKey = '';
-        if (normalizedInputType === 'clipboard.paste') {
-            clipboardOperationKey = buildClipboardOperationKey(
-                device.deviceId,
-                device.sessionId,
-                normalized.clipboardOperationId);
-            const operation = clipboardOperations.get(clipboardOperationKey);
-            if (!operation
-                || operation.direction !== 'paste'
-                || operation.hubConnectionId !== normalized.hubConnectionId
-                || operation.controlCommandId !== normalized.controlCommandId
-                || operation.captureGeneration !== normalized.captureGeneration
-                || operation.monitorIndex !== normalized.monitorIndex
-                || operation.status !== 'ready') {
-                return { ok: false, error: 'clipboard-paste-not-ready' };
-            }
-        }
+                activeMonitorIndex
+            };
+        }
+
+        let clipboardOperationKey = '';
+        if (normalizedInputType === 'clipboard.paste') {
+            clipboardOperationKey = buildClipboardOperationKey(
+                device.deviceId,
+                device.sessionId,
+                normalized.clipboardOperationId);
+            const operation = clipboardOperations.get(clipboardOperationKey);
+            if (!operation
+                || operation.direction !== 'paste'
+                || operation.hubConnectionId !== normalized.hubConnectionId
+                || operation.controlCommandId !== normalized.controlCommandId
+                || operation.captureGeneration !== normalized.captureGeneration
+                || operation.monitorIndex !== normalized.monitorIndex
+                || operation.status !== 'ready') {
+                return { ok: false, error: 'clipboard-paste-not-ready' };
+            }
+        }
 
         const inputSocket = device.inputSocket;
         const inputWriteOwner = getCurrentInputWriteOwner(device);
@@ -9238,17 +9265,17 @@ export function createRemoteHub(options = {}) {
                 && normalized.hubConnectionId !== previousOwnerConnectionId;
             const bindingChanged = previousInputBindingKey
                 && previousInputBindingKey !== activeInputBindingKey;
-            const writeBindingChanged = inputWriteOwner.getBindingKey() !== activeInputBindingKey;
-            if (ownerChanged || bindingChanged || writeBindingChanged) {
-                if (ownerChanged) {
-                    clearClipboardOperationsForDevice(
-                        device,
-                        'browser-input-owner-changed',
-                        previousOwnerConnectionId);
-                } else if (bindingChanged || writeBindingChanged) {
-                    clearClipboardOperationsForDevice(device, 'control-input-binding-changed');
-                }
-                const resetSent = inputWriteOwner.replaceBinding(
+            const writeBindingChanged = inputWriteOwner.getBindingKey() !== activeInputBindingKey;
+            if (ownerChanged || bindingChanged || writeBindingChanged) {
+                if (ownerChanged) {
+                    clearClipboardOperationsForDevice(
+                        device,
+                        'browser-input-owner-changed',
+                        previousOwnerConnectionId);
+                } else if (bindingChanged || writeBindingChanged) {
+                    clearClipboardOperationsForDevice(device, 'control-input-binding-changed');
+                }
+                const resetSent = inputWriteOwner.replaceBinding(
                     activeInputBindingKey,
                     buildRemoteInputResetMessage(
                         device,
@@ -9278,16 +9305,16 @@ export function createRemoteHub(options = {}) {
                     device.inputOwnerConnectionId = normalized.hubConnectionId;
                 }
                 device.inputOwnerBindingKey = activeInputBindingKey;
-                device.counters.commandsSent += 1;
-                device.inputLastSeenAt = new Date().toISOString();
-                if (clipboardOperationKey) {
-                    const operation = clipboardOperations.get(clipboardOperationKey);
-                    if (operation) {
-                        operation.status = 'pasting';
-                        operation.touchedAt = Date.now();
-                    }
-                }
-                return {
+                device.counters.commandsSent += 1;
+                device.inputLastSeenAt = new Date().toISOString();
+                if (clipboardOperationKey) {
+                    const operation = clipboardOperations.get(clipboardOperationKey);
+                    if (operation) {
+                        operation.status = 'pasting';
+                        operation.touchedAt = Date.now();
+                    }
+                }
+                return {
                     ok: true,
                     inputSocket: true,
                     sessionId: device.sessionId,
@@ -9322,7 +9349,7 @@ export function createRemoteHub(options = {}) {
                 issuedAt: normalized.issuedAt || new Date().toISOString()
             }
         });
-        if (fallback.ok && normalized.requestAck && normalized.inputSeq > 0) {
+        if (fallback.ok && normalized.requestAck && normalized.inputSeq > 0) {
             schedulePendingInputFallback(device, {
                 commandId: fallback.commandId,
                 inputSeq: normalized.inputSeq,
@@ -9334,16 +9361,16 @@ export function createRemoteHub(options = {}) {
                 hubReceivedAtEpochMs: normalized.hubReceivedAtEpochMs,
                 hubForwardedAtEpochMs,
                 fallback: true,
-                timeoutTimer: null
-            });
-        }
-        if (fallback.ok && clipboardOperationKey) {
-            const operation = clipboardOperations.get(clipboardOperationKey);
-            if (operation) {
-                operation.status = 'pasting';
-                operation.touchedAt = Date.now();
-            }
-        }
+                timeoutTimer: null
+            });
+        }
+        if (fallback.ok && clipboardOperationKey) {
+            const operation = clipboardOperations.get(clipboardOperationKey);
+            if (operation) {
+                operation.status = 'pasting';
+                operation.touchedAt = Date.now();
+            }
+        }
         return fallback.ok
             ? {
                 ...fallback,
@@ -9363,15 +9390,15 @@ export function createRemoteHub(options = {}) {
             };
     }
 
-    function releaseInputOwner(deviceId, ownerConnectionId, reason = 'browser-input-owner-closed') {
+    function releaseInputOwner(deviceId, ownerConnectionId, reason = 'browser-input-owner-closed') {
         const device = devices.get(String(deviceId || ''));
         const owner = safeString(ownerConnectionId, 128);
-        if (!device || !owner || safeString(device.inputOwnerConnectionId, 128) !== owner) {
-            return { ok: false, error: 'input-owner-not-current' };
-        }
-
-        clearClipboardOperationsForDevice(device, reason, owner);
-        device.inputOwnerConnectionId = '';
+        if (!device || !owner || safeString(device.inputOwnerConnectionId, 128) !== owner) {
+            return { ok: false, error: 'input-owner-not-current' };
+        }
+
+        clearClipboardOperationsForDevice(device, reason, owner);
+        device.inputOwnerConnectionId = '';
         device.inputOwnerBindingKey = '';
         const inputSocket = device.inputSocket;
         const inputWriteOwner = getCurrentInputWriteOwner(device);
@@ -9415,12 +9442,12 @@ export function createRemoteHub(options = {}) {
         };
         const results = targets.map(deviceId => {
             const device = devices.get(deviceId);
-            if (device?.synthetic === true && device.connected) return { deviceId, ok: true, synthetic: true };
-            if (device?.connected && !isDeviceConnectionFresh(device)) {
-                retireStaleDeviceConnection(device, 'status-heartbeat-timeout');
-                return { deviceId, ok: false, error: 'device-not-connected' };
-            }
-            if (!device?.connected || !device.socket || device.socket.destroyed) {
+            if (device?.synthetic === true && device.connected) return { deviceId, ok: true, synthetic: true };
+            if (device?.connected && !isDeviceConnectionFresh(device)) {
+                retireStaleDeviceConnection(device, 'status-heartbeat-timeout');
+                return { deviceId, ok: false, error: 'device-not-connected' };
+            }
+            if (!device?.connected || !device.socket || device.socket.destroyed) {
                 return { deviceId, ok: false, error: 'device-not-connected' };
             }
             return writeJsonLine(device.socket, payload)
@@ -9452,7 +9479,7 @@ export function createRemoteHub(options = {}) {
         const denied = policyError(device, 'allowAgent');
         if (denied) return { ok: false, error: denied };
 
-        if (device?.synthetic === true && device.connected) {
+        if (device?.synthetic === true && device.connected) {
             const instruction = safeText(options.instruction, MAX_AGENT_TASK_CHARS);
             if (!instruction) {
                 return { ok: false, error: 'missing-instruction' };
@@ -9512,14 +9539,14 @@ export function createRemoteHub(options = {}) {
                 error: '',
                 synthetic: true
             });
-            return { ok: true, commandId, taskId, approvalLevel, synthetic: true };
-        }
-
-        if (device.connected && !isDeviceConnectionFresh(device)) {
-            retireStaleDeviceConnection(device, 'status-heartbeat-timeout');
-            return { ok: false, error: 'device-not-connected' };
-        }
-        if (!device?.socket || device.socket.destroyed || !device.connected) {
+            return { ok: true, commandId, taskId, approvalLevel, synthetic: true };
+        }
+
+        if (device.connected && !isDeviceConnectionFresh(device)) {
+            retireStaleDeviceConnection(device, 'status-heartbeat-timeout');
+            return { ok: false, error: 'device-not-connected' };
+        }
+        if (!device?.socket || device.socket.destroyed || !device.connected) {
             return { ok: false, error: 'device-not-connected' };
         }
 
@@ -10380,17 +10407,17 @@ export function createRemoteHub(options = {}) {
         };
     }
 
-    function startLiveStream(deviceId, options = {}) {
-        const device = devices.get(String(deviceId || ''));
-        const denied = policyError(device);
-        if (denied) return { ok: false, error: denied };
-        if (device?.synthetic !== true
-            && device?.connected
-            && !isDeviceConnectionFresh(device)) {
-            retireStaleDeviceConnection(device, 'status-heartbeat-timeout');
-            return { ok: false, error: 'device-not-connected' };
-        }
-        if (device?.liveCapturePause?.token) {
+    function startLiveStream(deviceId, options = {}) {
+        const device = devices.get(String(deviceId || ''));
+        const denied = policyError(device);
+        if (denied) return { ok: false, error: denied };
+        if (device?.synthetic !== true
+            && device?.connected
+            && !isDeviceConnectionFresh(device)) {
+            retireStaleDeviceConnection(device, 'status-heartbeat-timeout');
+            return { ok: false, error: 'device-not-connected' };
+        }
+        if (device?.liveCapturePause?.token) {
             return {
                 ok: false,
                 error: 'LIVE_CAPTURE_PAUSED',
@@ -10821,15 +10848,15 @@ export function createRemoteHub(options = {}) {
         };
     }
 
-    function stopLiveStream(deviceId, options = {}) {
-        const device = devices.get(String(deviceId || ''));
-        if (device?.synthetic !== true
-            && device?.connected
-            && !isDeviceConnectionFresh(device)) {
-            retireStaleDeviceConnection(device, 'status-heartbeat-timeout');
-            return { ok: false, error: 'device-not-connected' };
-        }
-        const stopAll = options.stopAll === true;
+    function stopLiveStream(deviceId, options = {}) {
+        const device = devices.get(String(deviceId || ''));
+        if (device?.synthetic !== true
+            && device?.connected
+            && !isDeviceConnectionFresh(device)) {
+            retireStaleDeviceConnection(device, 'status-heartbeat-timeout');
+            return { ok: false, error: 'device-not-connected' };
+        }
+        const stopAll = options.stopAll === true;
         const streamPurpose = safeString(options.streamPurpose || options.purpose, 24).toLowerCase();
         const requestedStreamId = safeString(options.streamId, 128);
         const purposeStreams = !stopAll && !requestedStreamId && streamPurpose && device
@@ -11430,18 +11457,18 @@ export function createRemoteHub(options = {}) {
         };
     }
 
-    function startAudioStream(deviceId, options = {}) {
-        const device = devices.get(String(deviceId || ''));
-        if (!device) {
-            return { ok: false, error: 'device-not-found' };
-        }
-        if (device.synthetic !== true
-            && device.connected
-            && !isDeviceConnectionFresh(device)) {
-            retireStaleDeviceConnection(device, 'status-heartbeat-timeout');
-            return { ok: false, error: 'device-not-connected' };
-        }
-        if (!device.connected) {
+    function startAudioStream(deviceId, options = {}) {
+        const device = devices.get(String(deviceId || ''));
+        if (!device) {
+            return { ok: false, error: 'device-not-found' };
+        }
+        if (device.synthetic !== true
+            && device.connected
+            && !isDeviceConnectionFresh(device)) {
+            retireStaleDeviceConnection(device, 'status-heartbeat-timeout');
+            return { ok: false, error: 'device-not-connected' };
+        }
+        if (!device.connected) {
             return { ok: false, error: 'device-not-connected' };
         }
         const denied = policyError(device, 'allowRemoteAudio');
@@ -11518,18 +11545,18 @@ export function createRemoteHub(options = {}) {
         return { ok: true, commandId, streamId };
     }
 
-    function stopAudioStream(deviceId, options = {}) {
-        const device = devices.get(String(deviceId || ''));
-        if (!device) {
-            return { ok: false, error: 'device-not-found' };
-        }
-        if (device.synthetic !== true
-            && device.connected
-            && !isDeviceConnectionFresh(device)) {
-            retireStaleDeviceConnection(device, 'status-heartbeat-timeout');
-            return { ok: false, error: 'device-not-connected' };
-        }
-        if (!device.connected) {
+    function stopAudioStream(deviceId, options = {}) {
+        const device = devices.get(String(deviceId || ''));
+        if (!device) {
+            return { ok: false, error: 'device-not-found' };
+        }
+        if (device.synthetic !== true
+            && device.connected
+            && !isDeviceConnectionFresh(device)) {
+            retireStaleDeviceConnection(device, 'status-heartbeat-timeout');
+            return { ok: false, error: 'device-not-connected' };
+        }
+        if (!device.connected) {
             return { ok: false, error: 'device-not-connected' };
         }
         if (device.synthetic === true || !device.socket || device.socket.destroyed) {
@@ -11742,14 +11769,14 @@ export function createRemoteHub(options = {}) {
                 replacementTimerCount: device.liveStreamReplacementTimers instanceof Map
                     ? device.liveStreamReplacementTimers.size
                     : 0,
-                commandResultWaiterCount: [...pendingCommandResultWaiters.values()]
-                    .filter(waiter => waiter.deviceId === device.deviceId
-                        && waiter.sessionId === device.sessionId)
-                    .length,
-                clipboardOperationCount: [...clipboardOperations.values()]
-                    .filter(operation => operation.deviceId === device.deviceId
-                        && operation.sessionId === device.sessionId)
-                    .length,
+                commandResultWaiterCount: [...pendingCommandResultWaiters.values()]
+                    .filter(waiter => waiter.deviceId === device.deviceId
+                        && waiter.sessionId === device.sessionId)
+                    .length,
+                clipboardOperationCount: [...clipboardOperations.values()]
+                    .filter(operation => operation.deviceId === device.deviceId
+                        && operation.sessionId === device.sessionId)
+                    .length,
                 retainedPayloadCount: retainedPayloads.size,
                 retainedPayloadBytes: [...retainedPayloads].reduce(
                     (total, payload) => total + payload.length,
@@ -11759,9 +11786,9 @@ export function createRemoteHub(options = {}) {
                 && snapshot.stopPendingCount === 0
                 && snapshot.pendingStartCount === 0
                 && snapshot.pendingStopPromiseCount === 0
-                && snapshot.replacementTimerCount === 0
-                && snapshot.commandResultWaiterCount === 0
-                && snapshot.clipboardOperationCount === 0
+                && snapshot.replacementTimerCount === 0
+                && snapshot.commandResultWaiterCount === 0
+                && snapshot.clipboardOperationCount === 0
                 && snapshot.retainedPayloadCount === 0
                 && snapshot.retainedPayloadBytes === 0;
             return snapshot;
@@ -11773,9 +11800,9 @@ export function createRemoteHub(options = {}) {
                 'stopPendingCount',
                 'pendingStartCount',
                 'pendingStopPromiseCount',
-                'replacementTimerCount',
-                'commandResultWaiterCount',
-                'clipboardOperationCount',
+                'replacementTimerCount',
+                'commandResultWaiterCount',
+                'clipboardOperationCount',
                 'retainedPayloadCount',
                 'retainedPayloadBytes'
             ]) {
@@ -11788,10 +11815,10 @@ export function createRemoteHub(options = {}) {
             stopPendingCount: 0,
             pendingStartCount: 0,
             pendingStopPromiseCount: 0,
-            replacementTimerCount: 0,
-            commandResultWaiterCount: 0,
-            clipboardOperationCount: 0,
-            retainedPayloadCount: 0,
+            replacementTimerCount: 0,
+            commandResultWaiterCount: 0,
+            clipboardOperationCount: 0,
+            retainedPayloadCount: 0,
             retainedPayloadBytes: 0
         });
         return {
@@ -11831,12 +11858,13 @@ export function createRemoteHub(options = {}) {
         listDeviceFrames,
         disconnectDevice,
         assignDeviceSlot,
-        sendCommand,
-        sendClipboardCommand,
-        refreshDevicePolicies,
+        sendCommand,
+        sendClipboardCommand,
+        refreshDevicePolicies,
         sendLegacyClientUpdate,
-        sendInputControl,
-        releaseInputOwner,
+        sendInputControl,
+        getInputRouteState,
+        releaseInputOwner,
         notifyAgentProgress,
         requestAgentTask,
         requestAgentTaskBatch,