@mindexec/cli 0.2.395 → 0.2.397

package/server.js

@@ -42,6 +42,8 @@ const BRIDGE_INSTANCE_ID = String(process.env.MINDEXEC_BRIDGE_INSTANCE_ID || REM
 const REMOTE_HUB_PAIR_TOKEN = String(process.env.REMOTE_HUB_PAIR_TOKEN || process.env.MINDEXEC_REMOTE_PAIR_TOKEN || REMOTE_HUB_IDENTITY.pairToken || crypto.randomBytes(18).toString('hex')).trim() || crypto.randomBytes(18).toString('hex');
 const TREE_SITTER_GRAMMAR_DIR = path.join(BRIDGE_ROOT, 'tree-sitter-grammars');
 const VERBOSE_CODEX_TRACE = /^(1|true|yes|on)$/i.test(String(process.env.BRIDGE_VERBOSE_CODEX || ''));
+const VERBOSE_REMOTE_HTTP_LOGS = /^(1|true|yes|on)$/i.test(String(process.env.MINDEXEC_VERBOSE_REMOTE_HTTP || process.env.BRIDGE_VERBOSE_REMOTE_HTTP || ''));
+const VERBOSE_REMOTE_AGENT_LOGS = /^(1|true|yes|on)$/i.test(String(process.env.MINDEXEC_VERBOSE_REMOTE_AGENT || process.env.BRIDGE_VERBOSE_REMOTE_AGENT || ''));
 const COLOR_LOGS_ENABLED = Boolean(process.stdout.isTTY) && !process.env.NO_COLOR;
 const DEFAULT_WEB_APP_ROOT = path.join(BRIDGE_ROOT, 'wwwroot');
 
@@ -331,7 +333,7 @@ function logSection(title, lines = []) {
     }
 }
 
-function logHttpRequest(method, requestPath) {
+function logHttpRequest(method, requestPath) {
     let methodTone = 'bridge';
     switch (String(method || '').toUpperCase()) {
         case 'POST':
@@ -353,10 +355,32 @@ function logHttpRequest(method, requestPath) {
     }
 
     const methodLabel = tone(String(method || 'REQ').padEnd(6, ' '), methodTone);
-    console.log(`${formatLogTime()} ${formatScope('http', 'muted')} ${methodLabel} ${requestPath}`);
-}
-
-function normalizeWorkspaceStylePath(inputPath) {
+    console.log(`${formatLogTime()} ${formatScope('http', 'muted')} ${methodLabel} ${requestPath}`);
+}
+
+function shouldLogHttpRequest(method, requestPath) {
+    if (VERBOSE_REMOTE_HTTP_LOGS) {
+        return true;
+    }
+
+    const normalizedPath = String(requestPath || '').toLowerCase();
+    if (normalizedPath === '/api/remote/status'
+        || normalizedPath === '/api/remote/devices'
+        || normalizedPath === '/api/remote/frames'
+        || normalizedPath === '/api/remote/agent/status'
+        || normalizedPath === '/api/remote/agent/connect'
+        || normalizedPath === '/api/remote/agent/sync-report') {
+        return false;
+    }
+
+    if (!normalizedPath.startsWith('/api/remote/devices/')) {
+        return true;
+    }
+
+    return !(/\/(thumbnail|thumbnail\/request|live\/frame|live\/start|live\/stop)$/i.test(normalizedPath));
+}
+
+function normalizeWorkspaceStylePath(inputPath) {
     return String(inputPath || '').replaceAll('\\', '/').trim();
 }
 
@@ -2117,11 +2141,13 @@ app.use('/assets/thumbs', async (req, res) => {
     });
 });
 
-// Logging middleware
-app.use((req, res, next) => {
-    logHttpRequest(req.method, req.path);
-    next();
-});
+// Logging middleware
+app.use((req, res, next) => {
+    if (shouldLogHttpRequest(req.method, req.path)) {
+        logHttpRequest(req.method, req.path);
+    }
+    next();
+});
 
 const PROTECTED_BRIDGE_ROUTES = [
     { method: 'POST', exact: '/api/workspace/browse' },
@@ -3633,9 +3659,15 @@ const REMOTE_AGENT_OUTPUT_RECONNECT_GRACE_MS = Math.max(
     Number(process.env.MINDEXEC_REMOTE_AGENT_OUTPUT_RECONNECT_GRACE_MS || 6000) || 6000);
 const REMOTE_AGENT_DEFAULT_ENGINE = 'auto';
 const REMOTE_AGENT_SYNC_REPORT_LOG_REPEAT_MS = 30000;
+const REMOTE_AGENT_DUPLICATE_ACTIVE_LOG_REPEAT_MS = 60000;
+const REMOTE_AGENT_SOFT_SYNC_REPORT_LOG_REPEAT_MS = Math.max(
+    REMOTE_AGENT_SYNC_REPORT_LOG_REPEAT_MS,
+    Number(process.env.MINDEXEC_REMOTE_AGENT_SOFT_SYNC_REPORT_LOG_MS || 300000) || 300000);
 const REMOTE_AGENT_SYNC_REPORT_WAKE_MS = Math.max(500, Number(process.env.MINDEXEC_REMOTE_AGENT_SYNC_REPORT_WAKE_MS || 1500) || 1500);
 const REMOTE_AGENT_RACE_START_STAGGER_MS = Math.max(0, Number(process.env.MINDEXEC_REMOTE_AGENT_RACE_STAGGER_MS ?? 0) || 0);
-const REMOTE_AGENT_MAX_PARALLEL_CANDIDATES = 6;
+const REMOTE_AGENT_MAX_PARALLEL_CANDIDATES = Math.max(
+    1,
+    Math.min(6, Number(process.env.MINDEXEC_REMOTE_AGENT_MAX_PARALLEL_CANDIDATES || 1) || 1));
 const REMOTE_AGENT_RECENT_MANAGER_CACHE_TTL_MS = 30 * 24 * 60 * 60 * 1000;
 const REMOTE_AGENT_RECENT_MANAGER_CACHE_LIMIT = 64;
 const REMOTE_AGENT_RECENT_MANAGER_DEFAULT_KEY = 'default';
@@ -3678,6 +3710,8 @@ let remoteAgentSyncReportState = null;
 let remoteAgentSyncReportLogKey = '';
 let remoteAgentSyncReportLogAt = 0;
 let remoteAgentSyncReportWakeAt = 0;
+let remoteAgentConnectFailureLogKey = '';
+let remoteAgentConnectFailureLogAt = 0;
 let remoteAgentConnectPromise = null;
 const remoteAgentIntentionalStopKeys = new Set();
 const remoteAgentRecentSuccessfulManagers = new Map();
@@ -3844,6 +3878,66 @@ function createRemoteAgentSyncReport(body = {}) {
     };
 }
 
+function isRemoteAgentDuplicateActiveText(value) {
+    return /duplicate-device-active/i.test(String(value || ''));
+}
+
+function isRemoteAgentDuplicateActiveReport(report) {
+    return !!report
+        && (isRemoteAgentDuplicateActiveText(report.reason)
+            || isRemoteAgentDuplicateActiveText(report.error));
+}
+
+function isRemoteAgentSoftSyncReportReason(reason) {
+    return /^(local-monitor-is-host|local-monitor-host-revived|local-monitor-host-republished|local-monitor-host-republish-[\w-]+|same-host|local-host-superseded)$/i
+        .test(String(reason || '').trim());
+}
+
+function isRemoteAgentDuplicateActiveState(state = remoteAgentState) {
+    return isRemoteAgentDuplicateActiveText(state?.lastError)
+        || isRemoteAgentDuplicateActiveText(state?.reconnectReason)
+        || isRemoteAgentDuplicateActiveText(state?.stderrTail)
+        || isRemoteAgentDuplicateActiveText(state?.stdoutTail);
+}
+
+function findRemoteAgentDuplicateActiveAttempt(attempts = []) {
+    return attempts.find(attempt =>
+        attempt?.child
+        && attempt.child.exitCode === null
+        && !attempt.child.killed
+        && isRemoteAgentDuplicateActiveState(attempt.state));
+}
+
+function logRemoteAgentConnectFailure(manager, error = 'unknown') {
+    const duplicateActive = isRemoteAgentDuplicateActiveText(error);
+    const safeManager = normalizeRemoteManagerEndpoint(manager) || 'invalid';
+    const safeError = duplicateActive
+        ? 'duplicate-device-active'
+        : safeRemoteAgentField(error || 'unknown', 700);
+    const key = `${duplicateActive ? 'duplicate-active' : 'connect-failed'}|${safeManager}|${safeError}`;
+    const intervalMs = duplicateActive
+        ? REMOTE_AGENT_DUPLICATE_ACTIVE_LOG_REPEAT_MS
+        : REMOTE_AGENT_SYNC_REPORT_LOG_REPEAT_MS;
+    const now = Date.now();
+    if (key === remoteAgentConnectFailureLogKey
+        && now - remoteAgentConnectFailureLogAt < intervalMs) {
+        return;
+    }
+
+    remoteAgentConnectFailureLogKey = key;
+    remoteAgentConnectFailureLogAt = now;
+
+    if (duplicateActive) {
+        logEvent(
+            'remote',
+            `managed RemoteAgent duplicate active; keeping existing session ${formatKeyValue('manager', safeManager)}`,
+            'remote');
+        return;
+    }
+
+    logWarn('remote', `managed RemoteAgent connect failed ${formatKeyValue('manager', safeManager)} ${formatKeyValue('error', safeError)}`);
+}
+
 function isRemoteAgentSyncReportReconnectSignal(report) {
     if (!report || report.connected === true) {
         return false;
@@ -3856,6 +3950,10 @@ function isRemoteAgentSyncReportReconnectSignal(report) {
         return false;
     }
 
+    if (isRemoteAgentDuplicateActiveText(text)) {
+        return false;
+    }
+
     if (/(throttled|registry-not-authenticated|registry-auth-pending|session-expired|no-active-target|registry-inactive|local-monitor-is-host|local-host-superseded|same-host|target-missing-endpoint-or-pair)/i.test(text)) {
         return false;
     }
@@ -3994,6 +4092,10 @@ function isRemoteAgentOutputReconnectSignal(text) {
         return false;
     }
 
+    if (isRemoteAgentDuplicateActiveText(normalized)) {
+        return false;
+    }
+
     if (/connected to remotehub/i.test(normalized) && !/(disconnect|closed|failed|econnreset|etimedout|epipe|socket|websocket|remotehub.*error)/i.test(normalized)) {
         return false;
     }
@@ -4037,6 +4139,21 @@ function rememberRemoteAgentSyncReport(report) {
     }
 
     remoteAgentSyncReportState = report;
+    if (isRemoteAgentDuplicateActiveReport(report)) {
+        const now = Date.now();
+        const key = `duplicate-active|${report.targetEndpoint || ''}|${report.targetLeaseId || ''}`;
+        if (key !== remoteAgentSyncReportLogKey
+            || now - remoteAgentSyncReportLogAt >= REMOTE_AGENT_DUPLICATE_ACTIVE_LOG_REPEAT_MS) {
+            remoteAgentSyncReportLogKey = key;
+            remoteAgentSyncReportLogAt = now;
+            logEvent(
+                'remote',
+                `registry sync duplicate active ${formatKeyValue('target', report.targetEndpoint || '-')} ${formatKeyValue('auth', report.authenticated ? 'yes' : 'no')} ${formatKeyValue('note', 'existing-session-kept')}`,
+                'remote');
+        }
+        return true;
+    }
+
     const reason = report.reason || report.error || (report.ok ? 'ok' : 'failed');
     const status = report.connected
         ? 'connected'
@@ -4049,6 +4166,34 @@ function rememberRemoteAgentSyncReport(report) {
         : report.ok
             ? 'ok'
             : 'failed';
+
+    if (isRemoteAgentSoftSyncReportReason(reason)) {
+        const key = [
+            'soft',
+            status,
+            reason,
+            report.targetEndpoint || '',
+            report.targetLeaseId || '',
+            report.localHostTargetActive ? 'local-host' : ''
+        ].join('|');
+        const now = Date.now();
+        const repeatMs = VERBOSE_REMOTE_AGENT_LOGS
+            ? REMOTE_AGENT_SYNC_REPORT_LOG_REPEAT_MS
+            : REMOTE_AGENT_SOFT_SYNC_REPORT_LOG_REPEAT_MS;
+        if (key === remoteAgentSyncReportLogKey
+            && now - remoteAgentSyncReportLogAt < repeatMs) {
+            return true;
+        }
+
+        remoteAgentSyncReportLogKey = key;
+        remoteAgentSyncReportLogAt = now;
+        logEvent(
+            'remote',
+            `registry sync ${status} ${formatKeyValue('reason', reason)} ${formatKeyValue('target', report.targetEndpoint || '-')} ${formatKeyValue('auth', report.authenticated ? 'yes' : 'no')}`,
+            'remote');
+        return true;
+    }
+
     markRemoteAgentReconnectNeededFromReport(report);
     const key = [
         status,
@@ -4089,6 +4234,14 @@ function appendRemoteAgentOutput(stream, chunk, stateConnectionKey = '') {
         remoteAgentState.needsReconnect = false;
         remoteAgentState.reconnectReason = '';
         remoteAgentState.reconnectRequestedAt = '';
+        remoteAgentState.lastError = '';
+    }
+    if (isRemoteAgentDuplicateActiveText(text)) {
+        remoteAgentState.ready = false;
+        remoteAgentState.needsReconnect = false;
+        remoteAgentState.reconnectReason = '';
+        remoteAgentState.reconnectRequestedAt = '';
+        remoteAgentState.lastError = 'duplicate-device-active';
     }
     if (isRemoteAgentOutputReconnectSignal(text)) {
         markRemoteAgentReconnectNeeded('process-output-disconnected', 'agent-process-output-disconnected');
@@ -4434,6 +4587,7 @@ function getRemoteAgentRunningAgeMs(agent = remoteAgentState) {
 function isRemoteAgentRunningButNotReadyStale() {
     return isRemoteAgentRegistryOwned()
         && remoteAgentState.ready !== true
+        && !isRemoteAgentDuplicateActiveState(remoteAgentState)
         && getRemoteAgentRunningAgeMs(remoteAgentState) >= REMOTE_AGENT_READY_STALE_MS;
 }
 
@@ -4945,6 +5099,15 @@ function appendRemoteAgentAttemptOutput(attempt, stream, chunk) {
         attempt.state.connectedAt = new Date().toISOString();
         attempt.state.needsReconnect = false;
         attempt.state.reconnectReason = '';
+        attempt.state.reconnectRequestedAt = '';
+        attempt.state.lastError = '';
+    }
+    if (isRemoteAgentDuplicateActiveText(text)) {
+        attempt.state.ready = false;
+        attempt.state.needsReconnect = false;
+        attempt.state.reconnectReason = '';
+        attempt.state.reconnectRequestedAt = '';
+        attempt.state.lastError = 'duplicate-device-active';
     }
     if (isRemoteAgentOutputReconnectSignal(text)) {
         attempt.state.ready = false;
@@ -5149,10 +5312,12 @@ async function startRemoteAgentConnectionRace(options = {}) {
     const attempts = [];
     for (let index = 0; index < managers.length; index += 1) {
         const manager = managers[index];
-        logEvent(
-            'remote',
-            `managed RemoteAgent race ${index + 1}/${managers.length} ${formatKeyValue('manager', manager)}`,
-            'remote');
+        if (VERBOSE_REMOTE_AGENT_LOGS || managers.length > 1) {
+            logEvent(
+                'remote',
+                `managed RemoteAgent race ${index + 1}/${managers.length} ${formatKeyValue('manager', manager)}`,
+                'remote');
+        }
 
         const attempt = createRemoteAgentAttempt({
             manager,
@@ -5217,6 +5382,33 @@ async function startRemoteAgentConnectionRace(options = {}) {
         return { ok: true, alreadyRunning: false, agent: serializeRemoteAgentState() };
     }
 
+    const duplicateActiveAttempt = findRemoteAgentDuplicateActiveAttempt(attempts);
+    if (duplicateActiveAttempt) {
+        for (const attempt of attempts) {
+            if (attempt !== duplicateActiveAttempt) {
+                await stopRemoteAgentAttempt(attempt, 'race-lost-duplicate-active');
+            }
+        }
+
+        remoteAgentState = duplicateActiveAttempt.state;
+        remoteAgentState.status = 'running';
+        remoteAgentState.proc = duplicateActiveAttempt.child;
+        remoteAgentState.ready = false;
+        remoteAgentState.needsReconnect = false;
+        remoteAgentState.reconnectReason = '';
+        remoteAgentState.reconnectRequestedAt = '';
+        remoteAgentState.lastError = 'duplicate-device-active';
+        remoteAgentState.updatedAt = new Date().toISOString();
+        emitBridgeEvent('RemoteAgentWaiting', serializeRemoteAgentState());
+        logRemoteAgentConnectFailure(duplicateActiveAttempt.manager, 'duplicate-device-active');
+        return {
+            ok: true,
+            waiting: true,
+            reason: 'duplicate-device-active',
+            agent: serializeRemoteAgentState()
+        };
+    }
+
     const lastAttempt = attempts.findLast?.(attempt => attempt?.error || attempt?.state?.lastError)
         || attempts[attempts.length - 1]
         || null;
@@ -6326,6 +6518,14 @@ function isRemoteRegistryTargetEndpointLocal(localHub, target) {
     return targetEndpoints.some(endpoint => localSet.has(endpoint.toLowerCase()));
 }
 
+function shouldRepublishLocalHostForRegistryTarget(localHub, target) {
+    return localHub?.hostTargetActive === true
+        && target?.active === true
+        && !isRemoteRegistryTargetExpired(target)
+        && !isRemoteRegistryTargetSameAsLocalHost(localHub, target)
+        && isRemoteRegistryTargetEndpointLocal(localHub, target);
+}
+
 async function fetchRemoteRegistryTarget(config, session) {
     const url = new URL('/rest/v1/remote_host_targets', config.url);
     url.searchParams.set('select', '*');
@@ -6399,6 +6599,32 @@ async function readRemoteRegistryContext() {
     return { ok: true, config, session };
 }
 
+async function readCurrentRemoteRegistryTarget() {
+    const context = await readRemoteRegistryContext();
+    if (!context.ok) {
+        return {
+            ok: false,
+            reason: context.reason,
+            target: null
+        };
+    }
+
+    try {
+        return {
+            ok: true,
+            reason: 'ok',
+            target: await fetchRemoteRegistryTarget(context.config, context.session)
+        };
+    } catch (error) {
+        return {
+            ok: false,
+            reason: getRemoteHostTargetRegistryErrorReason(error),
+            error: error?.message || String(error || 'registry-fetch-failed'),
+            target: null
+        };
+    }
+}
+
 function getRemoteHostTargetEndpointReason(endpoint) {
     const normalized = normalizeRemoteManagerEndpoint(endpoint);
     if (!normalized) {
@@ -6888,6 +7114,37 @@ async function runRemoteHostTargetRenewOnce(trigger = 'timer', options = {}) {
         });
 
         if (registry.stale) {
+            const registryTarget = await readCurrentRemoteRegistryTarget();
+            if (shouldRepublishLocalHostForRegistryTarget(hub, registryTarget.target)) {
+                const takeoverRegistry = await publishLocalRemoteHostTargetToRegistry(hub, { takeover: true });
+                const reason = takeoverRegistry.ok
+                    ? 'local-monitor-host-republished'
+                    : `local-monitor-host-republish-${takeoverRegistry.reason || 'registry-publish-failed'}`;
+                updateRemoteHostTargetRenewState({
+                    status: takeoverRegistry.ok ? 'active' : 'skipped',
+                    reason,
+                    nodeId: hub.hostTargetNodeId,
+                    leaseId: hub.hostTargetLeaseId,
+                    hostInstanceId: hub.hostTargetHostInstanceId || hub.hostInstanceId,
+                    endpoint: takeoverRegistry.endpoint || hub.hostTargetEndpoint,
+                    endpointCandidates: takeoverRegistry.endpointCandidates || hub.hostTargetEndpointCandidates || [],
+                    expiresAt: hub.hostTargetExpiresAt,
+                    lastAttemptAt: attemptedAt,
+                    lastSuccessAt: takeoverRegistry.ok ? new Date().toISOString() : remoteHostTargetRenewState.lastSuccessAt,
+                    lastError: takeoverRegistry.ok || isRemoteHostTargetRenewSoftSkipReason(takeoverRegistry.reason)
+                        ? ''
+                        : (takeoverRegistry.reason || 'registry-publish-failed')
+                });
+                logRemoteHostTargetRenew(takeoverRegistry.ok ? 'ok' : 'skipped', reason, takeoverRegistry.endpoint || hub.hostTargetEndpoint);
+                scheduleRemoteHostTargetRenew(
+                    takeoverRegistry.ok || isRemoteHostTargetRenewSoftSkipReason(takeoverRegistry.reason)
+                        ? REMOTE_HOST_TARGET_RENEW_MS
+                        : REMOTE_REGISTRY_FOLLOWER_FAST_RETRY_MS,
+                    takeoverRegistry.ok ? 'local-host-republished' : 'local-host-republish-retry');
+                wakeRemoteRegistryFollower('local-host-republished').catch(() => {});
+                return serializeRemoteHostTargetRenewState();
+            }
+
             remoteHub.setHostTarget({
                 enabled: false,
                 nodeId: hub.hostTargetNodeId
@@ -7019,6 +7276,14 @@ function scheduleRemoteRegistryWakeFromSyncReport(report) {
         };
     }
 
+    if (isRemoteAgentDuplicateActiveReport(report)) {
+        return {
+            follower: false,
+            hostRenew: false,
+            reason: 'duplicate-device-active'
+        };
+    }
+
     const now = Date.now();
     let follower = false;
     if (now - remoteAgentSyncReportWakeAt >= REMOTE_AGENT_SYNC_REPORT_WAKE_MS) {
@@ -7206,6 +7471,55 @@ async function runRemoteRegistryFollowerOnce(trigger = 'timer') {
 
         if (localHub?.hostTargetActive === true) {
             resetRemoteRegistryInactiveTargetGrace();
+            if (shouldRepublishLocalHostForRegistryTarget(localHub, target)) {
+                const renewed = remoteHub.setHostTarget({
+                    enabled: true,
+                    nodeId: localHub.hostTargetNodeId || target.nodeId,
+                    leaseMs: REMOTE_HOST_TARGET_LEASE_MS
+                });
+                const republishedHub = remoteHub.getStatus({ includeSecrets: true });
+                const registry = renewed?.ok === true
+                    ? await publishLocalRemoteHostTargetToRegistry(republishedHub, { takeover: true })
+                    : {
+                        ok: false,
+                        reason: renewed?.error || 'local-host-renew-failed',
+                        endpoint: target.endpoint,
+                        endpointCandidates: target.endpointCandidates
+                    };
+                const reason = registry.ok
+                    ? 'local-monitor-host-republished'
+                    : `local-monitor-host-republish-${registry.reason || 'registry-publish-failed'}`;
+                updateRemoteRegistryFollowerState({
+                    status: 'skipped',
+                    reason,
+                    authenticated: true,
+                    lastAttemptAt: attemptedAt,
+                    lastSuccessAt: attemptedAt,
+                    targetEndpoint: registry.endpoint || target.endpoint,
+                    targetEndpointCandidates: registry.endpointCandidates?.length ? registry.endpointCandidates : target.endpointCandidates,
+                    targetLeaseId: republishedHub.hostTargetLeaseId || localHub.hostTargetLeaseId,
+                    targetNodeId: republishedHub.hostTargetNodeId || localHub.hostTargetNodeId,
+                    lastError: registry.ok || isRemoteHostTargetRenewSoftSkipReason(registry.reason) ? '' : (registry.reason || 'host-target-republish-failed')
+                });
+                await reportRemoteRegistryFollowerSync({
+                    ok: registry.ok !== false,
+                    skipped: true,
+                    reason,
+                    trigger,
+                    authenticated: true,
+                    localHostTargetActive: true,
+                    targetActive: true,
+                    targetEndpoint: registry.endpoint || target.endpoint,
+                    targetEndpointCandidates: registry.endpointCandidates?.length ? registry.endpointCandidates : target.endpointCandidates,
+                    targetLeaseId: republishedHub.hostTargetLeaseId || localHub.hostTargetLeaseId,
+                    targetNodeId: republishedHub.hostTargetNodeId || localHub.hostTargetNodeId,
+                    targetExpiresAt: republishedHub.hostTargetExpiresAt || localHub.hostTargetExpiresAt
+                });
+                scheduleRemoteHostTargetRenewWake('local-host-republished', { takeover: true });
+                scheduleRemoteRegistryFollower(REMOTE_REGISTRY_FOLLOWER_POLL_MS, 'local-host-republished');
+                return serializeRemoteRegistryFollowerState();
+            }
+
             if (target?.active === true
                 && !isRemoteRegistryTargetExpired(target)
                 && !isRemoteRegistryTargetSameAsLocalHost(localHub, target)) {
@@ -7407,7 +7721,7 @@ async function runRemoteRegistryFollowerOnce(trigger = 'timer') {
         }
 
         const connect = await startRemoteAgentConnection({
-            manager: target.endpointCandidates[0],
+            manager: target.endpoint,
             managerCandidates: target.endpointCandidates,
             pairToken: target.pairToken,
             leaseId: target.leaseId,
@@ -12178,7 +12492,7 @@ app.post('/api/remote/agent/connect', async (req, res) => {
             source: req.body?.source || 'registry'
         });
         if (!result.ok) {
-            logWarn('remote', `managed RemoteAgent connect failed ${formatKeyValue('manager', requestedManager || 'invalid')} ${formatKeyValue('error', result.error || 'unknown')}`);
+            logRemoteAgentConnectFailure(requestedManager || 'invalid', result.error || 'unknown');
         }
         res.status(result.ok ? 200 : 400).json(result);
     } catch (err) {

package/wwwroot/_content/MindExecution.Shared/css/mind-map-overrides.css

@@ -2600,11 +2600,19 @@ html body .css3d-resolution-wrapper.lod-low.node-type-csv-table .csv-table td {
 
 .css3d-resolution-wrapper.node-type-templatelauncher > .map-node-template-card {
     border: 1px solid #111827 !important;
-    border-radius: 8px !important;
+    border-radius: 0 !important;
     background: #f8fafc;
     box-shadow: none !important;
 }
 
+.css3d-resolution-wrapper.node-type-templatelauncher > .map-node-template-card.map-node-remote-fleet {
+    border: 0 !important;
+}
+
+.css3d-resolution-wrapper.node-type-templatelauncher.selected > .map-node-template-card.map-node-remote-fleet {
+    border: 2px solid var(--node-selection-edge, #2563eb) !important;
+}
+
 /* Template launcher and Multi Desktop Monitor own their visual chrome on the
    card itself. Keep the CSS3D wrapper neutral so motion CSS3D and the passive
    DOM overlay do not stack different selection chrome. */
@@ -2627,12 +2635,16 @@ html body .css3d-resolution-wrapper.lod-low.node-type-csv-table .csv-table td {
 
 .map-node-template-card {
     border: 1px solid #111827 !important;
-    border-radius: 8px;
+    border-radius: 0;
     color: #10212f;
     font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
     box-shadow: none !important;
 }
 
+.map-node-template-card.map-node-remote-fleet {
+    border: 0 !important;
+}
+
 .template-card__shell {
     display: flex;
     flex-direction: column;
@@ -2641,7 +2653,7 @@ html body .css3d-resolution-wrapper.lod-low.node-type-csv-table .csv-table td {
     gap: 12px;
     padding: 18px;
     border: 0;
-    border-radius: 8px;
+    border-radius: 0;
     background: #f8fafc;
     overflow: hidden;
 }

package/wwwroot/_content/MindExecution.Shared/js/mind-map-core.js

@@ -77,7 +77,7 @@
     });
     const CanvasPhaseSet = new Set(Object.values(CanvasPhase));
     const VIEWPORT_METRICS_POLL_INTERVAL = 480;
-    const PASSIVE_DOM_OVERLAY_RUNTIME_ENABLED = true;
+    const PASSIVE_DOM_OVERLAY_RUNTIME_ENABLED = false;
     const PASSIVE_OVERLAY_ZOOM_DEFER_VISIBLE_THRESHOLD = 24;
     const PASSIVE_OVERLAY_INTERACTIVE_REFRESH_INTERVAL_MS = 48;
     const PASSIVE_OVERLAY_INTERACTIVE_DENSE_REFRESH_INTERVAL_MS = 72;
@@ -516,8 +516,11 @@
     }
 
     function hasPassiveOverlayMotionWork(module) {
-        return PASSIVE_DOM_OVERLAY_RUNTIME_ENABLED === true ||
-            hasPassiveOverlaySelectionSurface(module) === true;
+        if (PASSIVE_DOM_OVERLAY_RUNTIME_ENABLED !== true) {
+            return false;
+        }
+
+        return hasPassiveOverlaySelectionSurface(module) === true;
     }
 
     function deferPassiveOverlayForCameraMotion(module, nowMs = 0, delayMs = PASSIVE_OVERLAY_IDLE_DELAY_MS) {
@@ -676,10 +679,10 @@
     const DEFAULT_RENDER_DEBUG_FLAGS = Object.freeze({
         enableCss3d: true,
         enableCss3dTransformSync: true,
-        enableDomOverlay: true,
-        enablePassiveOverlayForVisibleNodes: true,
-        enableOverlayCssZoom: true,
-        enableSharedNodeViewOverlay: true,
+        enableDomOverlay: false,
+        enablePassiveOverlayForVisibleNodes: false,
+        enableOverlayCssZoom: false,
+        enableSharedNodeViewOverlay: false,
         preferOverlayNodeViewHost: false,
         enableVisibilityCulling: true,
         enableLodUpdate: true,
@@ -1067,6 +1070,12 @@
             }
         });
 
+        next.enableDomOverlay = false;
+        next.enablePassiveOverlayForVisibleNodes = false;
+        next.enableOverlayCssZoom = false;
+        next.enableSharedNodeViewOverlay = false;
+        next.preferOverlayNodeViewHost = false;
+
         return next;
     }
 
@@ -1370,16 +1379,10 @@
         const overlayPlacementZoomCount = Number(moduleInstance._overlayDebugPlacementZoomCount || 0);
         const overlayPlacementTransformCount = Number(moduleInstance._overlayDebugPlacementTransformCount || 0);
         const currentLodBand = String(moduleInstance.lodRenderer?._currentLodBand || '').trim().toUpperCase();
-        const overlayScaleMode = flags.enableOverlayCssZoom === false
-            ? 'transform only'
-            : (overlayPlacementZoomCount > 0
-                ? 'css zoom + transform fallback'
-                : 'transform only (text cards)');
-        const overlayCandidateMode = currentLodBand && currentLodBand !== 'NEAR'
+        const overlayScaleMode = 'css3d only';
+        const overlayCandidateMode = currentLodBand
             ? `css3d only (${currentLodBand.toLowerCase()} band)`
-            : (flags.enablePassiveOverlayForVisibleNodes !== false
-                ? 'all-visible passive'
-                : 'selected/editing only');
+            : 'css3d only';
         const shouldBuildResidentDirtySnapshot =
             flags.enableFramePerfProbe === true ||
             flags.enableNodeFrameDebug === true;
@@ -3081,8 +3084,8 @@ ${summaryLines.map(line => `<div>${escapeNodeFrameDebugHtml(line)}</div>`).join(
             this._overlayDirty = true;
             this._lastOverlayKey = '';
             this._lastOverlaySelectionKey = '';
-            this.useTextOverlayV2 = true;
-            this.useDomTextOverlay = true;
+            this.useTextOverlayV2 = false;
+            this.useDomTextOverlay = false;
             this.renderDebugFlags = getRenderDebugFlagsSnapshot();
             this._framePerfPeakProfile = createEmptyFramePerfPeakProfile();
 
@@ -6016,11 +6019,11 @@ ${summaryLines.map(line => `<div>${escapeNodeFrameDebugHtml(line)}</div>`).join(
                     ? String(this._textOverlayV2State?.editing?.nodeId || '').trim()
                     : String(this._editingOverlayState?.nodeId || '').trim();
                 const hasFocusedTextOverlay = !!selectableOverlayNodeId;
-                const hasEditingOverlay = !!editingOverlayNodeId;
+                const hasActualTextOverlay = !!selectableOverlayNodeId || !!editingOverlayNodeId;
+                const hasEditingOverlay = !!editingOverlayNodeId || this.isEditingNote === true;
                 const shouldTrackTextOverlayDirty =
                     isPassiveDomOverlayRuntimeEnabled === true ||
-                    hasFocusedTextOverlay === true ||
-                    hasEditingOverlay === true;
+                    hasActualTextOverlay === true;
                 const selectedOverlayNodeId = String(this.selectedNodeIdJs || '').trim();
                 const overlaySelectionKey = `${selectedOverlayNodeId}|${selectableOverlayNodeId}|${editingOverlayNodeId}|${useTextOverlayV2 ? 'v2' : 'legacy'}`;
                 if (overlaySelectionKey !== this._lastOverlaySelectionKey) {