@mindexec/cli 0.2.457 → 0.2.458

package/wwwroot/_content/MindExecution.Shared/js/mind-map-css3d-manager.js

@@ -14627,8 +14627,6 @@
     const REMOTE_FLEET_BINARY_FRAME_CACHE_MS = 10000;
     const REMOTE_FLEET_BINARY_FRAME_CACHE_LIMIT = 240;
     const REMOTE_FLEET_BINARY_FRAME_SESSION_IDLE_MS = 8000;
-    const REMOTE_FLEET_AUTO_LIVE_START_MAX_PARALLEL = 8;
-    const REMOTE_FLEET_AUTO_LIVE_START_COOLDOWN_MS = 3000;
     const REMOTE_FLEET_TASK_FOLLOW_INITIAL_MS = 250;
     const REMOTE_FLEET_TASK_FOLLOW_REFRESH_MS = 2000;
     const REMOTE_FLEET_TASK_FOLLOW_MAX_TICKS = 60;
@@ -18969,8 +18967,7 @@
 
     function renderRemoteFleetMonitor(bodyView, nodeModel) {
         if (!bodyView) return;
-        clearRemoteFleetTimers(bodyView, { keepBinaryFrameSocket: true });
-        const preservedFrameSurfaces = collectRemoteFleetPreviewFrameSurfaces(bodyView);
+        clearRemoteFleetTimers(bodyView);
 
         const nodeId = String(nodeModel?.id ?? nodeModel?.Id ?? '');
         const searchState = bodyView.dataset.remoteFleetSearch || '';
@@ -18980,7 +18977,6 @@
         const densityState = normalizeRemoteFleetMonitorSize(bodyView.dataset.remoteFleetDensity || 'cards');
         const aiAssistState = bodyView.dataset.remoteFleetAiAssist === 'true';
         const autoMonitorState = bodyView.dataset.remoteFleetAutoMonitor !== 'false';
-        const focusState = bodyView.dataset.remoteFleetFocusDeviceId || '';
         const latestTaskBatch = parseRemoteFleetLatestTaskBatch(nodeModel);
         const recentTaskBatches = parseRemoteFleetRecentTaskBatches(nodeModel);
         const latestTaskBatchKey = getRemoteFleetTaskBatchKey(latestTaskBatch);
@@ -18999,18 +18995,10 @@
             : [...sortedDevices].sort((left, right) =>
                 compareRemoteFleetGroups(left, right, groupState)
                 || compareRemoteFleetDevices(left, right, sortState));
-        const hasActiveLiveStream = devices.some(isRemoteFleetLiveActive);
         const hasMonitorTargets = devices.some(device =>
             isRemoteFleetDeviceConnected(device) && isRemoteFleetThumbnailCapable(device));
-        const focusedDevice = devices.find(device => getRemoteFleetDeviceId(device) === focusState)
-            || devices.find(device => isRemoteFleetLiveActive(device))
-            || null;
-        if (focusedDevice) {
-            bodyView.dataset.remoteFleetFocusDeviceId = getRemoteFleetDeviceId(focusedDevice);
-        }
-        const selectedState = bodyView.dataset.remoteFleetSelectedDeviceId || focusState || '';
+        const selectedState = bodyView.dataset.remoteFleetSelectedDeviceId || '';
         const selectedDevice = devices.find(device => getRemoteFleetDeviceId(device) === selectedState)
-            || focusedDevice
             || devices[0]
             || null;
         if (selectedDevice) {
@@ -19162,8 +19150,7 @@
             { value: 'offline', label: 'Offline' },
             { value: 'task', label: 'Task' },
             { value: 'ai', label: 'AI' },
-            { value: 'live', label: 'Live' },
-            { value: 'frames', label: 'Frames' },
+            { value: 'frames', label: 'Thumbnails' },
             { value: 'issues', label: 'Issues' }
         ], filterState, 'Device filter');
 
@@ -19276,7 +19263,7 @@
         aiToggleText.textContent = 'AI';
         aiToggleLabel.appendChild(aiToggle);
         aiToggleLabel.appendChild(aiToggleText);
-        const sendVisibleButton = createRemoteFleetButton('Send visible', 'Dispatch task to visible connected task-capable devices', 'task-visible');
+        const sendVisibleButton = createRemoteFleetButton('Send selected', 'Dispatch task to the selected agent', 'task-selected');
         sendVisibleButton.style.height = '54px';
         const sendConnectedButton = createRemoteFleetButton('Send all', 'Dispatch task to all connected task-capable devices', 'task-connected');
         sendConnectedButton.style.height = '54px';
@@ -19476,23 +19463,16 @@
         const createDevicePreview = (device, mode = 'tile') => {
             const name = getRemoteFleetDeviceName(device);
             const connectedDevice = isRemoteFleetDeviceConnected(device);
-            const thumbnailCapturedAt = String(device?.thumbnailCapturedAt || device?.ThumbnailCapturedAt || '');
-            const liveFrameReceivedAt = String(device?.liveFrameReceivedAt || device?.LiveFrameReceivedAt || '');
             const hasThumbnail = hasRemoteFleetThumbnail(device);
-            const hasLiveFrame = hasRemoteFleetLiveFrame(device);
-            const previewSource = hasLiveFrame
-                ? getRemoteFleetFrameSource(device, 'live')
-                : getRemoteFleetFrameSource(device, 'thumbnail');
+            const previewSource = getRemoteFleetFrameSource(device, 'thumbnail');
             const hasPreviewSource = isRemoteFleetFrameSource(previewSource);
-            const isDetail = mode === 'detail';
 
             const preview = document.createElement('div');
             preview.dataset.remoteFleetDevicePreview = mode;
             preview.dataset.deviceId = getRemoteFleetDeviceId(device);
-            preview.dataset.remoteFleetFrameKind = hasLiveFrame ? 'live' : (hasThumbnail ? 'thumbnail' : '');
-            preview.dataset.remoteFleetFrameSeq = String(hasLiveFrame
-                ? getRemoteFleetDeviceField(device, 'liveFrameSeq', 'LiveFrameSeq', 0)
-                : getRemoteFleetDeviceField(device, 'thumbnailFrameSeq', 'ThumbnailFrameSeq', 0));
+            preview.dataset.remoteFleetFrameKind = hasThumbnail ? 'thumbnail' : '';
+            preview.dataset.remoteFleetFrameSeq = String(
+                getRemoteFleetDeviceField(device, 'thumbnailFrameSeq', 'ThumbnailFrameSeq', 0));
             preview.title = getRemoteFleetDeviceTooltip(device);
             preview.style.cssText = `
                 position: relative;
@@ -19508,13 +19488,13 @@
             `;
             ensureRemoteFleetFrameCanvas(preview);
 
-            if ((hasLiveFrame || hasThumbnail) && hasPreviewSource) {
+            if (hasThumbnail && hasPreviewSource) {
                 const image = document.createElement('img');
                 image.dataset.remoteFleetFrameImage = 'true';
-                image.dataset.remoteFleetFrameKind = hasLiveFrame ? 'live' : 'thumbnail';
+                image.dataset.remoteFleetFrameKind = 'thumbnail';
                 image.dataset.remoteFleetFrameSeq = preview.dataset.remoteFleetFrameSeq;
                 image.src = previewSource;
-                image.alt = hasLiveFrame ? `${name} live frame` : `${name} thumbnail`;
+                image.alt = `${name} thumbnail`;
                 image.loading = 'lazy';
                 image.decoding = 'async';
                 image.style.cssText = `
@@ -19535,7 +19515,6 @@
                 preview.appendChild(placeholder);
             }
 
-            restoreRemoteFleetPreviewFrameSurface(preview, preservedFrameSurfaces, getRemoteFleetDeviceId(device));
             return preview;
         };
 
@@ -19603,10 +19582,7 @@
                 const connectedDevice = isRemoteFleetDeviceConnected(device);
                 const name = getRemoteFleetDeviceName(device);
                 const deviceId = getRemoteFleetDeviceId(device);
-                const liveStreamEnabled = isRemoteFleetLiveCapable(device);
-                const liveStreamActive = isRemoteFleetLiveActive(device);
                 const hasThumbnail = hasRemoteFleetThumbnail(device);
-                const hasLiveFrame = hasRemoteFleetLiveFrame(device);
                 const taskEnabled = isRemoteFleetDeviceTaskCapable(device);
                 const aiAssistEnabled = isRemoteFleetDeviceAiCapable(device);
                 const latestTaskStatus = String(device?.latestTaskStatus || device?.LatestTaskStatus || '');
@@ -19654,15 +19630,13 @@
                 card.dataset.remoteFleetConnected = connectedDevice ? 'true' : 'false';
                 card.dataset.remoteFleetTaskCapable = taskEnabled ? 'true' : 'false';
                 card.dataset.remoteFleetAiCapable = aiAssistEnabled ? 'true' : 'false';
-                card.dataset.remoteFleetHasFrame = (hasThumbnail || hasLiveFrame) ? 'true' : 'false';
-                card.dataset.remoteFleetLiveCapable = liveStreamEnabled ? 'true' : 'false';
-                card.dataset.remoteFleetLiveActive = liveStreamActive ? 'true' : 'false';
+                card.dataset.remoteFleetHasFrame = hasThumbnail ? 'true' : 'false';
                 card.dataset.remoteFleetIssue = (!connectedDevice || latestTaskStatus === 'failed' || !!latestTaskError) ? 'true' : 'false';
                 card.dataset.remoteFleetSelected = isSelected ? 'true' : 'false';
                 card.dataset.remoteFleetAction = 'select-device';
                 card.setAttribute('role', 'button');
                 card.setAttribute('aria-pressed', isSelected ? 'true' : 'false');
-                card.setAttribute('aria-label', `Open remote workstation for ${name}`);
+                card.setAttribute('aria-label', `Select ${name} as the agent task target`);
                 card.tabIndex = 0;
                 card.title = getRemoteFleetDeviceTooltip(device);
                 card.style.cssText = `
@@ -19770,121 +19744,12 @@
         const readTaskInstruction = () => String(taskInput.value || '').trim();
         const useAiAssist = () => aiToggle.checked === true;
         const getDeviceCards = () => Array.from(grid.querySelectorAll('article[data-device-id]'));
-        const pushUniqueFrameDeviceId = (ids, device) => {
-            const id = getRemoteFleetDeviceId(device);
-            if (id && !ids.includes(id)) {
-                ids.push(id);
-            }
-        };
-        const getVisibleFrameDeviceIds = () => {
-            const ids = getDeviceCards()
+        const getVisibleFrameDeviceIds = () => Array.from(new Set(
+            getDeviceCards()
                 .filter(card => card.style.display !== 'none')
                 .map(card => String(card.dataset.deviceId || '').trim())
-                .filter(Boolean);
-            return Array.from(new Set(ids)).slice(0, 120);
-        };
-        const getVisibleLiveDevices = () => {
-            const visibleIds = new Set(getVisibleFrameDeviceIds());
-            return devices
-                .filter(device => {
-                    const id = getRemoteFleetDeviceId(device);
-                    return id
-                        && visibleIds.has(id)
-                        && isRemoteFleetDeviceConnected(device)
-                        && isRemoteFleetLiveCapable(device);
-                })
-                .slice(0, 120);
-        };
-        const getVisibleLiveFrameDeviceIds = () => {
-            const ids = [];
-            getVisibleLiveDevices().forEach(device => pushUniqueFrameDeviceId(ids, device));
-            devices
-                .filter(device => isRemoteFleetDeviceConnected(device) && isRemoteFleetLiveActive(device))
-                .forEach(device => pushUniqueFrameDeviceId(ids, device));
-            return ids.slice(0, 120);
-        };
-        const ensureVisibleRemoteFleetLiveStreams = async () => {
-            if (!(bodyView._remoteFleetAutoLiveStartInFlight instanceof Set)) {
-                bodyView._remoteFleetAutoLiveStartInFlight = new Set();
-            }
-            if (!(bodyView._remoteFleetAutoLiveStartAttemptAt instanceof Map)) {
-                bodyView._remoteFleetAutoLiveStartAttemptAt = new Map();
-            }
-            const now = Date.now();
-            const targets = getVisibleLiveDevices()
-                .filter(device => {
-                    const deviceId = getRemoteFleetDeviceId(device);
-                    const lastAttemptAt = Number(bodyView._remoteFleetAutoLiveStartAttemptAt.get(deviceId) || 0);
-                    return deviceId
-                        && !isRemoteFleetLiveActive(device)
-                        && !bodyView._remoteFleetAutoLiveStartInFlight.has(deviceId)
-                        && (now - lastAttemptAt >= REMOTE_FLEET_AUTO_LIVE_START_COOLDOWN_MS);
-                });
-            if (targets.length === 0) {
-                return null;
-            }
-
-            let started = 0;
-            let lastResult = null;
-            const queue = targets.slice(0, 120);
-            const startOne = async target => {
-                const deviceId = getRemoteFleetDeviceId(target);
-                if (!deviceId || bodyView._remoteFleetAutoLiveStartInFlight.has(deviceId)) {
-                    return;
-                }
-
-                bodyView._remoteFleetAutoLiveStartInFlight.add(deviceId);
-                bodyView._remoteFleetAutoLiveStartAttemptAt.set(deviceId, Date.now());
-                try {
-                    const result = await invokeDotNetAsync('StartRemoteFleetLiveStreamFromJs', nodeId, deviceId, REMOTE_FLEET_MONITOR_LIVE_FPS);
-                    lastResult = result;
-                    const success = isRemoteFleetResultSuccess(result);
-                    window.RuntimeTrace?.emit?.('remote.live.autoStart', {
-                        nodeId,
-                        deviceId,
-                        success,
-                        fps: result?.fps || result?.Fps || 0,
-                        mode: 'visible-grid',
-                        error: result?.error || result?.Error || ''
-                    });
-                    if (success) {
-                        started += 1;
-                    }
-                } finally {
-                    bodyView._remoteFleetAutoLiveStartInFlight.delete(deviceId);
-                }
-            };
-
-            const workerCount = Math.min(REMOTE_FLEET_AUTO_LIVE_START_MAX_PARALLEL, queue.length);
-            await Promise.all(Array.from({ length: workerCount }, async () => {
-                while (queue.length > 0) {
-                    const target = queue.shift();
-                    if (target) {
-                        await startOne(target);
-                    }
-                }
-            }));
-
-            if (started > 0) {
-                try {
-                    await refreshRemoteFleetNode();
-                } catch (error) {
-                    window.RuntimeTrace?.emit?.('remote.live.autoRefreshFailed', {
-                        nodeId,
-                        started,
-                        error: error?.message || String(error || '')
-                    });
-                }
-
-                window.RuntimeTrace?.emit?.('remote.live.awaitingBinaryFrames', {
-                    nodeId,
-                    started,
-                    transport: 'ws-binary'
-                });
-            }
-
-            return lastResult || { success: started > 0, started };
-        };
+                .filter(Boolean)))
+            .slice(0, 120);
         const refreshRemoteFleetNode = async () => {
             if (bodyView._remoteFleetRefreshInFlight === true) {
                 return null;
@@ -19901,7 +19766,9 @@
         };
         const refreshRemoteFleetVisibleFrames = async (requestThumbnails = false) => {
             const result = await invokeDotNetAsync('RefreshRemoteFleetFramesFromJs', nodeId, getVisibleFrameDeviceIds(), requestThumbnails === true);
-            applyRemoteFleetFramePatches(bodyView, normalizeRemoteFleetDeviceFramePatches(result));
+            const thumbnailPatches = normalizeRemoteFleetDeviceFramePatches(result)
+                .filter(frame => String(frame?.kind || '').toLowerCase() === 'thumbnail');
+            applyRemoteFleetFramePatches(bodyView, thumbnailPatches);
             return result;
         };
         const startRemoteFleetMonitorRefreshTimer = (intervalMs, reason = 'monitor') => {
@@ -20003,15 +19870,18 @@
                 scheduleRemoteFleetTaskFollow();
             }
         };
-        const getVisibleEligibleDeviceIds = () => {
+        const getSelectedEligibleDeviceId = () => {
+            const selectedId = String(bodyView.dataset.remoteFleetSelectedDeviceId || '').trim();
+            if (!selectedId) return '';
+            const card = getDeviceCards().find(item => String(item.dataset.deviceId || '').trim() === selectedId);
             const wantsAi = useAiAssist();
-            return getDeviceCards()
-                .filter(card => card.style.display !== 'none'
-                    && card.dataset.remoteFleetConnected === 'true'
-                    && card.dataset.remoteFleetTaskCapable === 'true'
-                    && (!wantsAi || card.dataset.remoteFleetAiCapable === 'true'))
-                .map(card => String(card.dataset.deviceId || '').trim())
-                .filter(Boolean);
+            return card
+                && card.style.display !== 'none'
+                && card.dataset.remoteFleetConnected === 'true'
+                && card.dataset.remoteFleetTaskCapable === 'true'
+                && (!wantsAi || card.dataset.remoteFleetAiCapable === 'true')
+                ? selectedId
+                : '';
         };
 
         const applyRemoteFleetFilters = () => {
@@ -20030,7 +19900,6 @@
                     || (filterMode === 'offline' && card.dataset.remoteFleetConnected !== 'true')
                     || (filterMode === 'task' && card.dataset.remoteFleetConnected === 'true' && card.dataset.remoteFleetTaskCapable === 'true')
                     || (filterMode === 'ai' && card.dataset.remoteFleetConnected === 'true' && card.dataset.remoteFleetAiCapable === 'true')
-                    || (filterMode === 'live' && card.dataset.remoteFleetLiveActive === 'true')
                     || (filterMode === 'frames' && card.dataset.remoteFleetHasFrame === 'true')
                     || (filterMode === 'issues' && card.dataset.remoteFleetIssue === 'true');
                 const show = matchesSearch && matchesMode;
@@ -20064,10 +19933,11 @@
 
             matchCount.textContent = `${visible}/${devices.length}`;
             matchCount.title = `${visible} visible, ${eligible} targetable`;
-            sendVisibleButton.disabled = eligible <= 0;
-            sendVisibleButton.title = eligible > 0
-                ? `Dispatch to ${eligible} visible target(s)`
-                : 'No visible targetable devices';
+            const selectedTargetId = getSelectedEligibleDeviceId();
+            sendVisibleButton.disabled = !selectedTargetId;
+            sendVisibleButton.title = selectedTargetId
+                ? `Dispatch to selected agent ${selectedTargetId}`
+                : 'Select an online task-capable agent';
             const allTargetCount = wantsAi ? aiCapableCount : taskCapableCount;
             sendConnectedButton.disabled = allTargetCount <= 0;
             sendConnectedButton.title = allTargetCount > 0
@@ -20141,6 +20011,7 @@
                 deviceId: normalizedSelectedId,
                 mode: 'dom-patch'
             });
+            applyRemoteFleetFilters();
         };
         getDeviceCards().forEach(card => {
             ['pointerdown', 'mousedown', 'mouseup'].forEach(eventName => {
@@ -20156,40 +20027,6 @@
                     event.stopImmediatePropagation?.();
                 });
             });
-            card.addEventListener('dblclick', event => {
-                event.preventDefault();
-                event.stopPropagation();
-                event.stopImmediatePropagation?.();
-                const deviceId = String(card.dataset.deviceId || '').trim();
-                if (!deviceId) return;
-                applySelectedDeviceVisualState(deviceId);
-                if (card.dataset.remoteFleetOpeningControlNode === 'true') {
-                    return;
-                }
-
-                card.dataset.remoteFleetOpeningControlNode = 'true';
-                invokeDotNetAsync('AddRemoteFleetDeviceNodeFromJs', nodeId, deviceId)
-                    .then(async result => {
-                        await syncRemoteFleetNodeStateFromResult(result);
-                        if (result?.success) {
-                            const controlNodeId = String(result.nodeId || result.NodeId || '').trim();
-                            if (controlNodeId) {
-                                window.mindMap?.focusNode?.(controlNodeId, { selectNode: true });
-                                window.mindMap?.selectNode?.(controlNodeId);
-                                invokeDotNetAsync('SelectNodeInBlazor', controlNodeId).catch(() => undefined);
-                            }
-                            setTaskFeedback('');
-                        } else {
-                            setTaskFeedback(result?.error || result?.Error || 'Remote workstation node failed.', 'error');
-                        }
-                    })
-                    .catch(error => {
-                        setTaskFeedback(error?.message || 'Remote workstation node failed.', 'error');
-                    })
-                    .finally(() => {
-                        delete card.dataset.remoteFleetOpeningControlNode;
-                    });
-            });
             const selectCard = event => {
                 event.preventDefault();
                 event.stopPropagation();
@@ -20225,8 +20062,6 @@
             scheduleRemoteFleetTaskFollow();
         }
 
-        primeRemoteFleetRenderedFrameSurfaces(bodyView, 'monitor-render');
-
         sendVisibleButton.addEventListener('click', async event => {
             event.preventDefault();
             event.stopPropagation();
@@ -20237,19 +20072,19 @@
                 return;
             }
 
-            const targetIds = getVisibleEligibleDeviceIds();
-            if (targetIds.length === 0) {
-                setTaskFeedback('No visible targetable devices.', 'error');
+            const targetId = getSelectedEligibleDeviceId();
+            if (!targetId) {
+                setTaskFeedback('Select an online task-capable agent.', 'error');
                 return;
             }
 
             sendVisibleButton.disabled = true;
-            setTaskFeedback('Dispatching task to visible devices...');
+            setTaskFeedback('Dispatching task to selected agent...');
             try {
-                const result = await invokeDotNetAsync('DispatchRemoteFleetTaskBatchFromJs', nodeId, targetIds, instruction, useAiAssist());
+                const result = await invokeDotNetAsync('DispatchRemoteFleetTaskFromJs', nodeId, targetId, instruction, useAiAssist());
                 await syncRemoteFleetNodeStateFromResult(result);
-                const mode = useAiAssist() ? 'visible AI task' : 'visible remote task';
-                const feedback = formatRemoteFleetDispatchFeedback(result, targetIds.length, mode);
+                const mode = useAiAssist() ? 'selected AI task' : 'selected agent task';
+                const feedback = formatRemoteFleetDispatchFeedback(result, 1, mode);
                 setTaskFeedback(feedback.text, feedback.tone);
                 startRemoteFleetTaskFollowFromResult(result);
             } finally {
@@ -20373,84 +20208,6 @@
             });
         });
 
-        bodyView.querySelectorAll('[data-remote-fleet-action="pin-device"]').forEach(button => {
-            button.addEventListener('click', async event => {
-                event.preventDefault();
-                event.stopPropagation();
-                const deviceId = String(button.dataset.deviceId || '').trim();
-                if (!deviceId) return;
-                button.disabled = true;
-                setTaskFeedback('Pinning device to canvas...');
-                try {
-                    const result = await invokeDotNetAsync('AddRemoteFleetDeviceNodeFromJs', nodeId, deviceId);
-                    await syncRemoteFleetNodeStateFromResult(result);
-                    if (result?.success) {
-                        setTaskFeedback('Pinned device node.', 'success');
-                    } else {
-                        setTaskFeedback(result?.error || 'Pin failed.', 'error');
-                    }
-                } finally {
-                    button.disabled = false;
-                }
-            });
-        });
-
-        bodyView.querySelectorAll('[data-remote-fleet-action="live-focus"]').forEach(button => {
-            button.addEventListener('click', event => {
-                event.preventDefault();
-                event.stopPropagation();
-                const deviceId = String(button.dataset.deviceId || '').trim();
-                if (!deviceId) return;
-                bodyView.dataset.remoteFleetFocusDeviceId = deviceId;
-                renderRemoteFleetMonitor(bodyView, nodeModel);
-            });
-        });
-
-        bodyView.querySelectorAll('[data-remote-fleet-action="live-start"]').forEach(button => {
-            button.addEventListener('click', async event => {
-                event.preventDefault();
-                event.stopPropagation();
-                const deviceId = String(button.dataset.deviceId || '').trim();
-                if (!deviceId) return;
-                bodyView.dataset.remoteFleetFocusDeviceId = deviceId;
-                button.disabled = true;
-                setTaskFeedback('Starting focused live stream...');
-                try {
-                    const result = await invokeDotNetAsync('StartRemoteFleetLiveStreamFromJs', nodeId, deviceId);
-                    await syncRemoteFleetNodeStateFromResult(result);
-                    if (result?.success) {
-                        setTaskFeedback('Focused live stream started.', 'success');
-                    } else {
-                        setTaskFeedback(result?.error || 'Live stream start failed.', 'error');
-                    }
-                } finally {
-                    button.disabled = false;
-                }
-            });
-        });
-
-        bodyView.querySelectorAll('[data-remote-fleet-action="live-stop"]').forEach(button => {
-            button.addEventListener('click', async event => {
-                event.preventDefault();
-                event.stopPropagation();
-                const deviceId = String(button.dataset.deviceId || '').trim();
-                if (!deviceId) return;
-                button.disabled = true;
-                setTaskFeedback('Stopping focused live stream...');
-                try {
-                    const result = await invokeDotNetAsync('StopRemoteFleetLiveStreamFromJs', nodeId, deviceId, button.dataset.streamId || '');
-                    await syncRemoteFleetNodeStateFromResult(result);
-                    if (result?.success) {
-                        setTaskFeedback('Focused live stream stopped.', 'success');
-                    } else {
-                        setTaskFeedback(result?.error || 'Live stream stop failed.', 'error');
-                    }
-                } finally {
-                    button.disabled = false;
-                }
-            });
-        });
-
         bodyView.querySelectorAll('[data-remote-fleet-action="ping-device"]').forEach(button => {
             button.addEventListener('click', async event => {
                 event.preventDefault();
@@ -20517,65 +20274,13 @@
             }, 250);
         }
 
-        const visibleFrameDeviceIds = getVisibleFrameDeviceIds();
-        const hasVisibleFrameTarget = visibleFrameDeviceIds.length > 0;
-        const hasVisibleLiveTarget = getVisibleLiveFrameDeviceIds().length > 0
-            || devices.some(device => isRemoteFleetDeviceConnected(device) && isRemoteFleetLiveCapable(device));
-        const shouldUseBinaryFrameSocket = hasVisibleLiveTarget
-            || hasActiveLiveStream
-            || (autoMonitorState && hasVisibleFrameTarget);
-        if (shouldUseBinaryFrameSocket) {
-            const atlasSocketStarted = startRemoteFleetAtlasSocket(bodyView, () => {
-                const liveIds = getVisibleLiveFrameDeviceIds();
-                return liveIds.length > 0 ? liveIds : getVisibleFrameDeviceIds();
-            }, {
-                fps: REMOTE_FLEET_MONITOR_LIVE_FPS,
-                width: 1920,
-                height: 1080,
-                tileWidth: 320,
-                tileHeight: 180
-            });
-            if (!atlasSocketStarted) {
-                window.RuntimeTrace?.emit?.('remote.frame.wsUnavailable', {
-                    nodeId,
-                    reason: 'atlas-frame-socket-not-started'
-                });
-                ensureVisibleRemoteFleetLiveStreams().catch(error => {
-                    window.RuntimeTrace?.emit?.('remote.live.autoStartFailed', {
-                        nodeId,
-                        error: error?.message || String(error || '')
-                    });
-                });
-            } else {
-                window.RuntimeTrace?.emit?.('remote.live.wsAutoStartRequested', {
-                    nodeId,
-                    transport: 'ws-atlas-h264',
-                    fps: REMOTE_FLEET_MONITOR_LIVE_FPS,
-                    visibleFrameTargets: visibleFrameDeviceIds.length,
-                    visibleLiveTargets: getVisibleLiveFrameDeviceIds().length
-                });
-            }
-            bodyView._remoteFleetLiveRefreshTimer = setInterval(async () => {
-                if (!document.body.contains(bodyView)) {
-                    clearRemoteFleetTimers(bodyView);
-                    return;
-                }
-
-                try {
-                    await refreshRemoteFleetNode();
-                } catch {
-                    clearRemoteFleetTimers(bodyView);
-                }
-            }, REMOTE_FLEET_LIVE_REFRESH_MS);
-        } else {
-            releaseRemoteFleetBinaryFrameSocket(bodyView);
-            releaseRemoteFleetAtlasSocket(bodyView);
-            if (autoMonitorState && hasMonitorTargets) {
-                startRemoteFleetFrameLoop(bodyView, REMOTE_FLEET_THUMBNAIL_FRAME_REFRESH_MS, () => refreshRemoteFleetVisibleFrames(true));
-                startRemoteFleetMonitorRefreshTimer(REMOTE_FLEET_MONITOR_REFRESH_MS, 'visible-devices');
-            } else if (autoMonitorState) {
-                startRemoteFleetMonitorRefreshTimer(REMOTE_FLEET_EMPTY_MONITOR_REFRESH_MS, 'empty-discovery');
-            }
+        releaseRemoteFleetBinaryFrameSocket(bodyView);
+        releaseRemoteFleetAtlasSocket(bodyView);
+        if (autoMonitorState && hasMonitorTargets) {
+            startRemoteFleetFrameLoop(bodyView, REMOTE_FLEET_THUMBNAIL_FRAME_REFRESH_MS, () => refreshRemoteFleetVisibleFrames(true));
+            startRemoteFleetMonitorRefreshTimer(REMOTE_FLEET_MONITOR_REFRESH_MS, 'thumbnail-only');
+        } else if (autoMonitorState) {
+            startRemoteFleetMonitorRefreshTimer(REMOTE_FLEET_EMPTY_MONITOR_REFRESH_MS, 'empty-discovery');
         }
     }