@mindexec/cli 0.2.396 → 0.2.398

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindexec/cli",
-  "version": "0.2.396",
+  "version": "0.2.398",
   "description": "MindExec local runtime and bridge CLI",
   "main": "server.js",
   "type": "module",

package/remote-hub.js

@@ -90,7 +90,8 @@ const REMOTE_FRAME_MODE_ALIASES = new Map([
 const MAX_SYNTHETIC_DEVICES = 1000;
 const DEFAULT_HOST_TARGET_LEASE_MS = 30000;
 const DUPLICATE_DEVICE_ACTIVE_REJECT_MS = 15000;
-const DUPLICATE_DEVICE_LOG_THROTTLE_MS = 5000;
+const DUPLICATE_DEVICE_LOG_THROTTLE_MS = 60000;
+const DUPLICATE_DEVICE_RETRY_AFTER_MS = 30000;
 const SYNTHETIC_FRAME_DATA_URL = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAABCAYAAAD0In+KAAAADElEQVR42mP8z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC';
 const SYNTHETIC_FRAME_PAYLOAD = Buffer.from(SYNTHETIC_FRAME_DATA_URL.split(',')[1], 'base64');
 const SYNTHETIC_FRAME_HASH = crypto.createHash('sha256').update(SYNTHETIC_FRAME_PAYLOAD).digest('hex').slice(0, 16);
@@ -1060,6 +1061,16 @@ export function createRemoteHub(options = {}) {
     const pairToken = safeString(
         options.pairToken || env.REMOTE_HUB_PAIR_TOKEN || env.MINDEXEC_REMOTE_PAIR_TOKEN || crypto.randomBytes(6).toString('hex'),
         256);
+    const duplicateDeviceLogThrottleMs = clampNumber(
+        env.MINDEXEC_REMOTE_DUPLICATE_DEVICE_LOG_MS || env.REMOTE_HUB_DUPLICATE_DEVICE_LOG_MS,
+        5000,
+        10 * 60 * 1000,
+        DUPLICATE_DEVICE_LOG_THROTTLE_MS);
+    const duplicateDeviceRetryAfterMs = clampNumber(
+        env.MINDEXEC_REMOTE_DUPLICATE_DEVICE_RETRY_MS || env.REMOTE_HUB_DUPLICATE_DEVICE_RETRY_MS,
+        5000,
+        10 * 60 * 1000,
+        DUPLICATE_DEVICE_RETRY_AFTER_MS);
 
     const devices = new Map();
     const taskBatches = new Map();
@@ -1500,7 +1511,7 @@ export function createRemoteHub(options = {}) {
     }
 
     function rejectDuplicateActiveDevice(socket, existing, attemptedSessionId) {
-        const retryAfterMs = Math.max(DUPLICATE_DEVICE_LOG_THROTTLE_MS, Math.min(30000, heartbeatMs));
+        const retryAfterMs = Math.max(heartbeatMs, duplicateDeviceRetryAfterMs);
         writeJsonLine(socket, {
             type: 'disconnect',
             reason: 'duplicate-device-active',
@@ -1512,11 +1523,12 @@ export function createRemoteHub(options = {}) {
         existing.counters.duplicateConnectionsRejected = (existing.counters.duplicateConnectionsRejected || 0) + 1;
         const nowMs = Date.now();
         const lastLoggedAt = duplicateDeviceLogAt.get(existing.deviceId) || 0;
-        if (nowMs - lastLoggedAt >= DUPLICATE_DEVICE_LOG_THROTTLE_MS) {
+        if (nowMs - lastLoggedAt >= duplicateDeviceLogThrottleMs) {
             duplicateDeviceLogAt.set(existing.deviceId, nowMs);
-            logWarn(
+            logEvent(
                 'remote',
-                `duplicate device connection suppressed ${existing.deviceName} (${existing.deviceId}); keeping active session ${existing.sessionId}`);
+                `duplicate device connection suppressed ${existing.deviceName} (${existing.deviceId}); keeping active session ${existing.sessionId}`,
+                'remote');
         }
 
         try {

package/scripts/remote-agent-managed-smoke.mjs

@@ -251,6 +251,29 @@ async function main() {
         assert.equal(secondAgent.managerCandidates?.[0], managerEndpoint, JSON.stringify(secondAgent.managerCandidates));
         assert.equal(secondAgent.managerCandidates?.length, 1, JSON.stringify(secondAgent.managerCandidates));
 
+        const duplicateReport = await fetchJson(`${clientBridge.baseUrl}/api/remote/agent/sync-report`, {
+            method: 'POST',
+            body: JSON.stringify({
+                ok: false,
+                attempted: true,
+                disconnected: true,
+                authenticated: true,
+                reason: 'connect-failed',
+                error: 'duplicate-device-active',
+                targetActive: true,
+                targetEndpoint: managerEndpoint,
+                targetEndpointCandidates: [managerEndpoint, staleEndpoint],
+                targetLeaseId: LEASE_ID,
+                targetNodeId: 'remote-agent-managed-smoke-node'
+            })
+        });
+        assert.equal(duplicateReport.ok, true, JSON.stringify(duplicateReport.payload));
+        assert.equal(duplicateReport.payload?.wake?.reason, 'duplicate-device-active', JSON.stringify(duplicateReport.payload));
+
+        const duplicateState = await fetchJson(`${clientBridge.baseUrl}/api/remote/agent/status`);
+        assert.equal(duplicateState.payload?.ready, true, JSON.stringify(duplicateState.payload));
+        assert.equal(duplicateState.payload?.needsReconnect, false, JSON.stringify(duplicateState.payload));
+
         const staleReport = await fetchJson(`${clientBridge.baseUrl}/api/remote/agent/sync-report`, {
             method: 'POST',
             body: JSON.stringify({

package/scripts/remote-hub-smoke.mjs

@@ -602,7 +602,7 @@ try {
     ), 1000);
     assert.equal(duplicateDisconnect.reason, 'duplicate-device-active');
     assert.equal(duplicateDisconnect.activeSessionId, oldSessionId);
-    assert.equal(duplicateDisconnect.retryAfterMs >= 1000, true);
+    assert.equal(duplicateDisconnect.retryAfterMs >= 30000, true);
     await wait(100);
     const duplicateRejectedDevice = hub.listDevices()[0];
     assert.equal(duplicateRejectedDevice.sessionId, oldSessionId);

package/scripts/remote-registry-follower-smoke.mjs

@@ -533,6 +533,37 @@ async function main() {
         const renewStatus = await fetchJson(`${renewHost.baseUrl}/api/status`);
         assert.equal(renewStatus.payload?.remoteHostTargetRenew?.status, 'active', JSON.stringify(renewStatus.payload?.remoteHostTargetRenew));
         assert.equal(renewStatus.payload?.remoteHostTargetRenew?.endpoint, renewPublicEndpoint, JSON.stringify(renewStatus.payload?.remoteHostTargetRenew));
+        const currentLeaseId = currentTarget?.lease_id;
+        const currentHostInstanceId = currentTarget?.host_instance_id;
+        currentTarget = {
+            ...currentTarget,
+            pair_token: 'stale-local-pair-token',
+            lease_id: 'stale-local-lease',
+            host_instance_id: 'stale-local-host-instance',
+            expires_at: new Date(Date.now() + 60_000).toISOString()
+        };
+        const staleLocalResume = await fetchJson(`${renewHost.baseUrl}/api/remote/system/resume`, {
+            method: 'POST',
+            token: BRIDGE_TOKEN,
+            body: JSON.stringify({
+                driftMs: 65000
+            })
+        });
+        assert.equal(staleLocalResume.ok, true, JSON.stringify(staleLocalResume.payload));
+        assert.equal(staleLocalResume.payload?.ok, true, JSON.stringify(staleLocalResume.payload));
+        await waitFor(() => {
+            return currentTarget?.pair_token === PAIR_TOKEN
+                && currentTarget?.lease_id === currentLeaseId
+                && currentTarget?.host_instance_id === currentHostInstanceId
+                ? currentTarget
+                : null;
+        }, 8000, `stale local host target republish\n${renewHost.details()}`);
+        const republishedStatus = await fetchJson(`${renewHost.baseUrl}/api/status`);
+        assert.equal(republishedStatus.payload?.remoteHub?.hostTargetActive, true, JSON.stringify(republishedStatus.payload?.remoteHub));
+        assert.equal(republishedStatus.payload?.remoteHostTargetRenew?.status, 'active', JSON.stringify(republishedStatus.payload?.remoteHostTargetRenew));
+        assert.equal(republishedStatus.payload?.remoteHostTargetRenew?.reason, 'local-monitor-host-republished', JSON.stringify(republishedStatus.payload?.remoteHostTargetRenew));
+        const renewAgent = await fetchJson(`${renewHost.baseUrl}/api/remote/agent/status`);
+        assert.equal(renewAgent.payload?.running, false, JSON.stringify(renewAgent.payload));
 
         const renewClear = await fetchJson(`${renewHost.baseUrl}/api/remote/host-target`, {
             method: 'DELETE',

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,6 +3659,10 @@ 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 = Math.max(
@@ -3680,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();
@@ -3846,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;
@@ -3858,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;
     }
@@ -3996,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;
     }
@@ -4039,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'
@@ -4051,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,
@@ -4091,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');
@@ -4436,6 +4587,7 @@ function getRemoteAgentRunningAgeMs(agent = remoteAgentState) {
 function isRemoteAgentRunningButNotReadyStale() {
     return isRemoteAgentRegistryOwned()
         && remoteAgentState.ready !== true
+        && !isRemoteAgentDuplicateActiveState(remoteAgentState)
         && getRemoteAgentRunningAgeMs(remoteAgentState) >= REMOTE_AGENT_READY_STALE_MS;
 }
 
@@ -4947,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;
@@ -5151,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,
@@ -5219,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;
@@ -6328,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', '*');
@@ -6401,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) {
@@ -6890,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
@@ -7021,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) {
@@ -7208,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)) {
@@ -12180,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) {