@mindexec/cli 0.2.132 → 0.2.134

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindexec/cli",
-  "version": "0.2.132",
+  "version": "0.2.134",
   "description": "MindExec local runtime and bridge CLI",
   "main": "server.js",
   "type": "module",
@@ -21,7 +21,7 @@
   "scripts": {
     "start": "node launch-bridge.cjs",
     "dev": "node launch-bridge.cjs --watch",
-    "test:syntax": "node --check server.js && node --check remote-hub.js && node --check codex-runtime.js && node --check launch-bridge.cjs && node --check port-guard.cjs && node --check scripts/setup-tree-sitter-grammars.mjs && node --check scripts/auth-session-smoke.mjs && node --check scripts/remote-hub-smoke.mjs && node --check scripts/remote-hub-scale-smoke.mjs && node --check scripts/remote-fleet-render-smoke.mjs && node --check scripts/remote-http-smoke.mjs && node --check scripts/remote-frame-ws-smoke.mjs && node --check scripts/remote-agent-ws-smoke.mjs && node --check scripts/remote-agent-managed-smoke.mjs && node --check scripts/remote-agent-package-smoke.mjs && node --check scripts/remote-fast-live-rate-smoke.mjs && node --check scripts/remote-fast-mdm-browser-smoke.mjs",
+    "test:syntax": "node --check server.js && node --check remote-hub.js && node --check codex-runtime.js && node --check launch-bridge.cjs && node --check port-guard.cjs && node --check scripts/setup-tree-sitter-grammars.mjs && node --check scripts/auth-session-smoke.mjs && node --check scripts/remote-hub-smoke.mjs && node --check scripts/remote-hub-scale-smoke.mjs && node --check scripts/remote-fleet-render-smoke.mjs && node --check scripts/remote-http-smoke.mjs && node --check scripts/remote-frame-ws-smoke.mjs && node --check scripts/remote-agent-ws-smoke.mjs && node --check scripts/remote-agent-managed-smoke.mjs && node --check scripts/remote-registry-follower-smoke.mjs && node --check scripts/remote-agent-package-smoke.mjs && node --check scripts/remote-fast-live-rate-smoke.mjs && node --check scripts/remote-fast-mdm-browser-smoke.mjs",
     "test:auth": "node scripts/auth-session-smoke.mjs",
     "test:remote": "node scripts/remote-hub-smoke.mjs",
     "test:remote:scale": "node scripts/remote-hub-scale-smoke.mjs",
@@ -30,6 +30,7 @@
     "test:remote:frame-ws": "node scripts/remote-frame-ws-smoke.mjs",
     "test:remote:agent-ws": "node scripts/remote-agent-ws-smoke.mjs",
     "test:remote:managed": "node scripts/remote-agent-managed-smoke.mjs",
+    "test:remote:registry": "node scripts/remote-registry-follower-smoke.mjs",
     "test:remote:package": "node scripts/remote-agent-package-smoke.mjs",
     "test:remote:live-rate": "node scripts/remote-fast-live-rate-smoke.mjs",
     "test:remote:mdm-browser": "node scripts/remote-fast-mdm-browser-smoke.mjs",

package/scripts/remote-fast-live-rate-smoke.mjs

@@ -13,9 +13,9 @@ const BRIDGE_TOKEN = 'remote-fast-live-rate-smoke-token';
 const PAIR_TOKEN = 'remote-fast-live-rate-pair-token';
 const LEASE_ID = 'remote-fast-live-rate-lease';
 const LOCAL_BRIDGE_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const REQUESTED_FPS = Number(process.env.MINDEXEC_REMOTE_LIVE_RATE_REQUEST_FPS || 10);
+const REQUESTED_FPS = Number(process.env.MINDEXEC_REMOTE_LIVE_RATE_REQUEST_FPS || 12);
 const SAMPLE_MS = Number(process.env.MINDEXEC_REMOTE_LIVE_RATE_SAMPLE_MS || 3500);
-const MIN_EFFECTIVE_FPS = Number(process.env.MINDEXEC_REMOTE_LIVE_RATE_MIN_FPS || 8);
+const MIN_EFFECTIVE_FPS = Number(process.env.MINDEXEC_REMOTE_LIVE_RATE_MIN_FPS || 10);
 
 function wait(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));

package/scripts/remote-fast-mdm-browser-smoke.mjs

@@ -12,7 +12,7 @@ const BRIDGE_TOKEN = 'remote-fast-mdm-browser-smoke-token';
 const PAIR_TOKEN = 'remote-fast-mdm-browser-pair-token';
 const LEASE_ID = 'remote-fast-mdm-browser-lease';
 const LOCAL_BRIDGE_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const REQUESTED_FPS = Number(process.env.MINDEXEC_REMOTE_MDM_BROWSER_REQUEST_FPS || 10);
+const REQUESTED_FPS = Number(process.env.MINDEXEC_REMOTE_MDM_BROWSER_REQUEST_FPS || 12);
 
 function wait(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));

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

@@ -0,0 +1,322 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { createServer } from 'node:http';
+import net from 'node:net';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const BRIDGE_TOKEN = 'remote-registry-follower-smoke-token';
+const PAIR_TOKEN = 'remote-registry-follower-pair-token';
+const USER_ID = '11111111-2222-4333-8444-555555555555';
+const SUPABASE_KEY = 'remote-registry-follower-key';
+const ACCESS_TOKEN = 'remote-registry-follower-access-token';
+const LOCAL_BRIDGE_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+
+function wait(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+async function findFreePort() {
+    return await new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.unref();
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', () => {
+            const address = server.address();
+            const port = typeof address === 'object' && address ? address.port : 0;
+            server.close(() => resolve(port));
+        });
+    });
+}
+
+async function fetchJson(url, options = {}) {
+    const response = await fetch(url, {
+        ...options,
+        headers: {
+            ...(options.body ? { 'Content-Type': 'application/json' } : {}),
+            'X-Bridge-Token': options.token || BRIDGE_TOKEN,
+            ...(options.headers || {})
+        }
+    });
+    let payload = null;
+    try {
+        payload = await response.json();
+    } catch {
+        // Empty responses are allowed in failure diagnostics.
+    }
+    return { ok: response.ok, status: response.status, payload };
+}
+
+async function waitFor(predicate, timeoutMs, label) {
+    const startedAt = Date.now();
+    let lastError = null;
+    while (Date.now() - startedAt < timeoutMs) {
+        try {
+            const value = await predicate();
+            if (value) {
+                return value;
+            }
+        } catch (error) {
+            lastError = error;
+        }
+        await wait(100);
+    }
+    throw new Error(`Timed out waiting for ${label}${lastError ? `: ${lastError.message}` : ''}.`);
+}
+
+function createRegistryTarget({ endpoint, endpointCandidates, leaseId, active = true }) {
+    return {
+        user_id: USER_ID,
+        active,
+        endpoint,
+        endpoint_candidates: endpointCandidates,
+        pair_token: PAIR_TOKEN,
+        lease_id: leaseId,
+        node_id: 'remote-registry-follower-node',
+        host_instance_id: `host-${leaseId}`,
+        expires_at: new Date(Date.now() + 60_000).toISOString()
+    };
+}
+
+function startFakeSupabase(getTarget) {
+    const requests = [];
+    const server = createServer((req, res) => {
+        const parsed = new URL(req.url || '/', 'http://127.0.0.1');
+        requests.push({
+            method: req.method,
+            pathname: parsed.pathname,
+            authorization: req.headers.authorization || '',
+            apikey: req.headers.apikey || ''
+        });
+
+        if (req.method === 'GET' && parsed.pathname === '/rest/v1/remote_host_targets') {
+            assert.equal(String(req.headers.apikey || ''), SUPABASE_KEY);
+            assert.equal(String(req.headers.authorization || ''), `Bearer ${ACCESS_TOKEN}`);
+            res.writeHead(200, {
+                'Content-Type': 'application/json',
+                'Cache-Control': 'no-store'
+            });
+            const target = getTarget();
+            res.end(JSON.stringify(target ? [target] : []));
+            return;
+        }
+
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'not-found' }));
+    });
+
+    return new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', () => {
+            const address = server.address();
+            const port = typeof address === 'object' && address ? address.port : 0;
+            resolve({
+                url: `http://127.0.0.1:${port}`,
+                requests,
+                stop: () => new Promise(done => server.close(done))
+            });
+        });
+    });
+}
+
+function spawnBridge({ bridgePort, remoteHubPort, workspacePath, authRoot, label, supabaseUrl = '', follower = false }) {
+    const child = spawn(process.execPath, ['server.js'], {
+        cwd: LOCAL_BRIDGE_DIR,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        windowsHide: true,
+        env: {
+            ...process.env,
+            BRIDGE_PORT: String(bridgePort),
+            BRIDGE_TOKEN,
+            BRIDGE_REQUIRE_TOKEN: '1',
+            MINDEXEC_REMOTE_HUB: '1',
+            REMOTE_HUB_HOST: '127.0.0.1',
+            REMOTE_HUB_PORT: String(remoteHubPort),
+            REMOTE_HUB_PAIR_TOKEN: PAIR_TOKEN,
+            WORKSPACE_PATH: workspacePath,
+            MINDEXEC_AUTH_DATA_ROOT: authRoot,
+            MINDEXEC_REMOTE_REGISTRY_FOLLOWER: follower ? '1' : '0',
+            MINDEXEC_REMOTE_REGISTRY_POLL_MS: '500',
+            MINDEXEC_REMOTE_REGISTRY_FAST_RETRY_MS: '250',
+            SUPABASE_URL: supabaseUrl,
+            SUPABASE_KEY,
+            NO_COLOR: '1'
+        }
+    });
+
+    let stdout = '';
+    let stderr = '';
+    child.stdout.on('data', chunk => {
+        stdout += chunk.toString();
+    });
+    child.stderr.on('data', chunk => {
+        stderr += chunk.toString();
+    });
+
+    const exitPromise = new Promise(resolve => child.once('exit', resolve));
+    const details = () => `${label} stdout=${stdout}\n${label} stderr=${stderr}`;
+    const stop = async () => {
+        if (child.exitCode === null && !child.killed) {
+            child.kill('SIGTERM');
+            await Promise.race([exitPromise, wait(5000)]);
+            if (child.exitCode === null && !child.killed) {
+                child.kill('SIGKILL');
+            }
+        }
+    };
+
+    return {
+        baseUrl: `http://127.0.0.1:${bridgePort}`,
+        child,
+        details,
+        stop
+    };
+}
+
+async function waitForBridge(bridge) {
+    return await waitFor(async () => {
+        const result = await fetchJson(`${bridge.baseUrl}/api/status`);
+        return result.ok && result.payload?.status === 'ok' ? result.payload : null;
+    }, 30000, `bridge startup\n${bridge.details()}`);
+}
+
+async function writeSession(authRoot) {
+    await mkdir(authRoot, { recursive: true });
+    await writeFile(path.join(authRoot, 'supabase-session.json'), JSON.stringify({
+        access_token: ACCESS_TOKEN,
+        expires_at: Math.floor(Date.now() / 1000) + 3600,
+        user: {
+            id: USER_ID,
+            email: 'remote-registry-follower@example.test'
+        }
+    }), 'utf8');
+}
+
+async function waitForManagedAgent(bridge, managerEndpoint, label) {
+    return await waitFor(async () => {
+        const result = await fetchJson(`${bridge.baseUrl}/api/remote/agent/status`);
+        const agent = result.payload;
+        return agent?.running === true
+            && agent?.ready === true
+            && String(agent.manager || '') === managerEndpoint
+            ? agent
+            : null;
+    }, 20000, `${label} managed agent\n${bridge.details()}`);
+}
+
+async function waitForConnectedDevice(bridge, label) {
+    return await waitFor(async () => {
+        const result = await fetchJson(`${bridge.baseUrl}/api/remote/devices`);
+        return result.payload?.devices?.find(device => device.connected === true) || null;
+    }, 12000, `${label} connected device\n${bridge.details()}`);
+}
+
+async function main() {
+    const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'mindexec-remote-registry-smoke-'));
+    let fakeSupabase = null;
+    let hostA = null;
+    let hostB = null;
+    let client = null;
+
+    const hostABridgePort = await findFreePort();
+    const hostARemotePort = await findFreePort();
+    const hostBBridgePort = await findFreePort();
+    const hostBRemotePort = await findFreePort();
+    const clientBridgePort = await findFreePort();
+    const clientRemotePort = await findFreePort();
+    const stalePort = await findFreePort();
+    const hostAEndpoint = `127.0.0.1:${hostARemotePort}`;
+    const hostBEndpoint = `127.0.0.1:${hostBRemotePort}`;
+    const staleEndpoint = `127.0.0.1:${stalePort}`;
+    let currentTarget = createRegistryTarget({
+        endpoint: hostAEndpoint,
+        endpointCandidates: [staleEndpoint, hostAEndpoint],
+        leaseId: 'lease-a'
+    });
+
+    try {
+        fakeSupabase = await startFakeSupabase(() => currentTarget);
+
+        const hostAAuth = path.join(tempRoot, 'auth-host-a');
+        const hostBAuth = path.join(tempRoot, 'auth-host-b');
+        const clientAuth = path.join(tempRoot, 'auth-client');
+        await writeSession(clientAuth);
+
+        hostA = spawnBridge({
+            bridgePort: hostABridgePort,
+            remoteHubPort: hostARemotePort,
+            workspacePath: path.join(tempRoot, 'host-a'),
+            authRoot: hostAAuth,
+            label: 'host-a'
+        });
+        hostB = spawnBridge({
+            bridgePort: hostBBridgePort,
+            remoteHubPort: hostBRemotePort,
+            workspacePath: path.join(tempRoot, 'host-b'),
+            authRoot: hostBAuth,
+            label: 'host-b'
+        });
+        await waitForBridge(hostA);
+        await waitForBridge(hostB);
+
+        client = spawnBridge({
+            bridgePort: clientBridgePort,
+            remoteHubPort: clientRemotePort,
+            workspacePath: path.join(tempRoot, 'client'),
+            authRoot: clientAuth,
+            label: 'client',
+            supabaseUrl: fakeSupabase.url,
+            follower: true
+        });
+        await waitForBridge(client);
+
+        const firstAgent = await waitForManagedAgent(client, hostAEndpoint, 'host-a');
+        assert.equal(firstAgent.usingNpx, false, JSON.stringify(firstAgent));
+        assert.match(String(firstAgent.launcher || ''), /mindexec-remote-fast/i);
+        assert.equal(firstAgent.manager, hostAEndpoint);
+        assert.equal(firstAgent.managerCandidates?.[0], staleEndpoint, JSON.stringify(firstAgent.managerCandidates));
+        await waitForConnectedDevice(hostA, 'host-a');
+
+        currentTarget = createRegistryTarget({
+            endpoint: hostBEndpoint,
+            endpointCandidates: [hostBEndpoint],
+            leaseId: 'lease-b'
+        });
+
+        const secondAgent = await waitForManagedAgent(client, hostBEndpoint, 'host-b');
+        assert.equal(secondAgent.usingNpx, false, JSON.stringify(secondAgent));
+        assert.match(String(secondAgent.launcher || ''), /mindexec-remote-fast/i);
+        assert.equal(secondAgent.manager, hostBEndpoint);
+        assert.equal(secondAgent.leaseId, 'lease-b');
+        await waitForConnectedDevice(hostB, 'host-b');
+
+        currentTarget = {
+            ...currentTarget,
+            active: false,
+            expires_at: new Date(Date.now() - 1000).toISOString()
+        };
+
+        await waitFor(async () => {
+            const result = await fetchJson(`${client.baseUrl}/api/remote/agent/status`);
+            return result.payload?.running === false
+                && String(result.payload?.lastError || '') === 'registry-inactive'
+                ? result.payload
+                : null;
+        }, 15000, `registry inactive stop\n${client.details()}`);
+
+        assert.ok(fakeSupabase.requests.length >= 2, JSON.stringify(fakeSupabase.requests));
+        console.log('Remote registry follower smoke OK');
+    } finally {
+        if (client) await client.stop();
+        if (hostB) await hostB.stop();
+        if (hostA) await hostA.stop();
+        if (fakeSupabase) await fakeSupabase.stop();
+        await rm(tempRoot, { recursive: true, force: true });
+    }
+}
+
+await main();

package/server.js

@@ -41,7 +41,7 @@ const VERBOSE_CODEX_TRACE = /^(1|true|yes|on)$/i.test(String(process.env.BRIDGE_
 const COLOR_LOGS_ENABLED = Boolean(process.stdout.isTTY) && !process.env.NO_COLOR;
 const DEFAULT_WEB_APP_ROOT = path.join(BRIDGE_ROOT, 'wwwroot');
 
-const ANSI = {
+const ANSI = {
     reset: '\x1b[0m',
     bold: '\x1b[1m',
     dim: '\x1b[2m',
@@ -52,8 +52,10 @@ const ANSI = {
     blue: '\x1b[34m',
     magenta: '\x1b[35m',
     cyan: '\x1b[36m',
-    white: '\x1b[37m'
-};
+    white: '\x1b[37m'
+};
+
+let isShuttingDown = false;
 
 function paint(text, ...styles) {
     const value = String(text ?? '');
@@ -2042,6 +2044,7 @@ app.post('/api/auth/session', async (req, res) => {
     try {
         const content = req.body?.content;
         await writeStableAuthSessionPayload(content);
+        await wakeRemoteRegistryFollower('auth-session-saved');
         res.json({
             success: true
         });
@@ -2058,6 +2061,7 @@ app.post('/api/auth/session', async (req, res) => {
 app.delete('/api/auth/session', async (req, res) => {
     try {
         await deleteStableAuthSessionPayload();
+        await wakeRemoteRegistryFollower('auth-session-cleared');
         res.json({
             success: true
         });
@@ -2912,6 +2916,10 @@ const REMOTE_AGENT_MAX_PARALLEL_CANDIDATES = 6;
 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';
+const REMOTE_REGISTRY_FOLLOWER_ENABLED = !/^(0|false|no|off)$/i.test(String(process.env.MINDEXEC_REMOTE_REGISTRY_FOLLOWER || 'true'));
+const REMOTE_REGISTRY_FOLLOWER_POLL_MS = Math.max(1500, Number(process.env.MINDEXEC_REMOTE_REGISTRY_POLL_MS || 5000) || 5000);
+const REMOTE_REGISTRY_FOLLOWER_FAST_RETRY_MS = Math.max(500, Number(process.env.MINDEXEC_REMOTE_REGISTRY_FAST_RETRY_MS || 1200) || 1200);
+const REMOTE_REGISTRY_FOLLOWER_MISSING_SESSION_STOP_COUNT = 3;
 let remoteAgentState = createRemoteAgentIdleState();
 let remoteAgentSyncReportState = null;
 let remoteAgentSyncReportLogKey = '';
@@ -2920,6 +2928,23 @@ let remoteAgentConnectPromise = null;
 const remoteAgentRecentSuccessfulManagers = new Map();
 let remoteAgentRecentSuccessfulManagersLoaded = false;
 let remoteAgentRecentSuccessfulManagersSavePromise = null;
+let remoteRegistryFollowerTimer = null;
+let remoteRegistryFollowerInFlight = false;
+let remoteRegistryFollowerStarted = false;
+let remoteRegistryFollowerConsecutiveMissingSession = 0;
+let remoteRegistryFollowerState = {
+    enabled: REMOTE_REGISTRY_FOLLOWER_ENABLED,
+    status: REMOTE_REGISTRY_FOLLOWER_ENABLED ? 'idle' : 'disabled',
+    reason: '',
+    lastAttemptAt: '',
+    lastSuccessAt: '',
+    lastError: '',
+    targetEndpoint: '',
+    targetEndpointCandidates: [],
+    targetLeaseId: '',
+    targetNodeId: '',
+    authenticated: false
+};
 
 function createRemoteAgentIdleState(overrides = {}) {
     return {
@@ -4154,11 +4179,569 @@ async function startRemoteAgentConnectionAttempt(options = {}) {
     return { ok: true, alreadyRunning: false, agent: serializeRemoteAgentState() };
 }
 
+function serializeRemoteRegistryFollowerState() {
+    return {
+        ...remoteRegistryFollowerState,
+        pollMs: REMOTE_REGISTRY_FOLLOWER_POLL_MS,
+        fastRetryMs: REMOTE_REGISTRY_FOLLOWER_FAST_RETRY_MS
+    };
+}
+
+function updateRemoteRegistryFollowerState(patch = {}) {
+    remoteRegistryFollowerState = {
+        ...remoteRegistryFollowerState,
+        ...patch,
+        enabled: REMOTE_REGISTRY_FOLLOWER_ENABLED
+    };
+    emitBridgeEvent('RemoteRegistryFollowerUpdated', serializeRemoteRegistryFollowerState());
+}
+
+function readSupabaseRuntimeConfig() {
+    const envUrl = String(process.env.SUPABASE_URL || process.env.MINDEXEC_SUPABASE_URL || '').trim();
+    const envKey = String(
+        process.env.SUPABASE_KEY
+        || process.env.SUPABASE_ANON_KEY
+        || process.env.SUPABASE_PUBLISHABLE_KEY
+        || process.env.MINDEXEC_SUPABASE_KEY
+        || '').trim();
+    if (envUrl && envKey) {
+        return { url: envUrl.replace(/\/+$/, ''), key: envKey };
+    }
+
+    const candidates = [
+        path.join(WEB_APP_ROOT || '', 'appsettings.json'),
+        path.join(DEFAULT_WEB_APP_ROOT, 'appsettings.json'),
+        path.resolve(BRIDGE_ROOT, '..', 'MindExecution.Web', 'wwwroot', 'appsettings.json')
+    ].filter(Boolean);
+
+    for (const candidate of Array.from(new Set(candidates.map(item => path.resolve(item))))) {
+        try {
+            const payload = JSON.parse(readFileSync(candidate, 'utf8'));
+            const url = String(payload?.Supabase?.Url || '').trim().replace(/\/+$/, '');
+            const key = String(payload?.Supabase?.Key || payload?.Supabase?.AnonKey || payload?.Supabase?.PublishableKey || '').trim();
+            if (url && key) {
+                return { url, key };
+            }
+        } catch {
+            // Try the next appsettings candidate.
+        }
+    }
+
+    return { url: '', key: '' };
+}
+
+function readSupabaseSessionField(source, ...keys) {
+    for (const key of keys) {
+        const value = source?.[key];
+        if (value !== undefined && value !== null && String(value).trim()) {
+            return value;
+        }
+    }
+    return '';
+}
+
+function parseSupabaseSessionForRegistry(content) {
+    let session = null;
+    try {
+        session = JSON.parse(String(content || ''));
+    } catch {
+        return null;
+    }
+
+    const user = session?.user || session?.User || {};
+    const accessToken = String(readSupabaseSessionField(session, 'access_token', 'accessToken', 'AccessToken')).trim();
+    const userId = String(
+        readSupabaseSessionField(user, 'id', 'Id')
+        || readSupabaseSessionField(session, 'user_id', 'userId', 'UserId')).trim();
+    const expiresAtRaw = Number(readSupabaseSessionField(session, 'expires_at', 'expiresAt', 'ExpiresAt') || 0);
+    const expiresAtMs = Number.isFinite(expiresAtRaw) && expiresAtRaw > 0
+        ? (expiresAtRaw > 9999999999 ? expiresAtRaw : expiresAtRaw * 1000)
+        : 0;
+
+    if (!accessToken || !userId) {
+        return null;
+    }
+
+    return {
+        accessToken,
+        userId,
+        expiresAtMs
+    };
+}
+
+function readRegistryTargetField(target, ...keys) {
+    for (const key of keys) {
+        const value = target?.[key];
+        if (value !== undefined && value !== null) {
+            return value;
+        }
+    }
+    return '';
+}
+
+function parseRegistryEndpointCandidates(value) {
+    if (Array.isArray(value)) {
+        return value.map(item => String(item || '').trim()).filter(Boolean);
+    }
+
+    const text = String(value || '').trim();
+    if (!text) {
+        return [];
+    }
+
+    try {
+        const parsed = JSON.parse(text);
+        if (Array.isArray(parsed)) {
+            return parsed.map(item => String(item || '').trim()).filter(Boolean);
+        }
+    } catch {
+        // Fall through to comma/newline split.
+    }
+
+    return text.split(/[,\n]/g).map(item => item.trim()).filter(Boolean);
+}
+
+function normalizeRemoteRegistryTarget(row) {
+    if (!row || typeof row !== 'object') {
+        return null;
+    }
+
+    const activeRaw = readRegistryTargetField(row, 'active', 'Active');
+    const active = activeRaw === true || /^(1|true|yes|on)$/i.test(String(activeRaw || ''));
+    const endpoint = String(readRegistryTargetField(row, 'endpoint', 'Endpoint') || '').trim();
+    const endpointCandidates = normalizeRemoteManagerEndpointList(
+        parseRegistryEndpointCandidates(readRegistryTargetField(row, 'endpoint_candidates', 'endpointCandidates', 'EndpointCandidates')),
+        endpoint);
+    const pairToken = String(readRegistryTargetField(row, 'pair_token', 'pairToken', 'PairToken') || '').trim();
+    const leaseId = String(readRegistryTargetField(row, 'lease_id', 'leaseId', 'LeaseId') || '').trim();
+    const nodeId = String(readRegistryTargetField(row, 'node_id', 'nodeId', 'NodeId') || '').trim();
+    const hostInstanceId = String(readRegistryTargetField(row, 'host_instance_id', 'hostInstanceId', 'HostInstanceId') || '').trim();
+    const expiresAt = String(readRegistryTargetField(row, 'expires_at', 'expiresAt', 'ExpiresAt') || '').trim();
+    const expiresAtMs = Date.parse(expiresAt);
+
+    return {
+        active,
+        endpoint,
+        endpointCandidates,
+        pairToken,
+        leaseId,
+        nodeId,
+        hostInstanceId,
+        expiresAt,
+        expiresAtMs: Number.isFinite(expiresAtMs) ? expiresAtMs : 0
+    };
+}
+
+function isRemoteRegistryTargetExpired(target) {
+    return !target?.expiresAtMs || target.expiresAtMs <= Date.now();
+}
+
+function isRemoteRegistryTargetSameAsLocalHost(localHub, target) {
+    const localLeaseId = safeRemoteAgentField(localHub?.hostTargetLeaseId, 128);
+    const localHostInstanceId = safeRemoteAgentField(localHub?.hostTargetHostInstanceId || localHub?.hostInstanceId, 128);
+    return !!localLeaseId
+        && !!localHostInstanceId
+        && !!target?.leaseId
+        && !!target?.hostInstanceId
+        && localLeaseId.toLowerCase() === String(target.leaseId).toLowerCase()
+        && localHostInstanceId.toLowerCase() === String(target.hostInstanceId).toLowerCase();
+}
+
+async function fetchRemoteRegistryTarget(config, session) {
+    const url = new URL('/rest/v1/remote_host_targets', config.url);
+    url.searchParams.set('select', '*');
+    url.searchParams.set('user_id', `eq.${session.userId}`);
+    url.searchParams.set('limit', '1');
+
+    const response = await fetch(url.toString(), {
+        method: 'GET',
+        headers: {
+            apikey: config.key,
+            Authorization: `Bearer ${session.accessToken}`,
+            Accept: 'application/json'
+        }
+    });
+
+    if (!response.ok) {
+        const text = await response.text().catch(() => '');
+        const error = new Error(`registry-rest-${response.status}${text ? `:${shortenText(text, 160)}` : ''}`);
+        error.statusCode = response.status;
+        throw error;
+    }
+
+    const payload = await response.json();
+    return normalizeRemoteRegistryTarget(Array.isArray(payload) ? payload[0] : payload);
+}
+
+async function reportRemoteRegistryFollowerSync(payload = {}) {
+    const report = createRemoteAgentSyncReport(payload);
+    rememberRemoteAgentSyncReport(report);
+    return report;
+}
+
+function scheduleRemoteRegistryFollower(delayMs = REMOTE_REGISTRY_FOLLOWER_POLL_MS, reason = 'timer') {
+    if (!REMOTE_REGISTRY_FOLLOWER_ENABLED || isShuttingDown) {
+        return;
+    }
+
+    if (remoteRegistryFollowerTimer) {
+        clearTimeout(remoteRegistryFollowerTimer);
+        remoteRegistryFollowerTimer = null;
+    }
+
+    remoteRegistryFollowerTimer = setTimeout(() => {
+        remoteRegistryFollowerTimer = null;
+        runRemoteRegistryFollowerOnce(reason).catch(error => {
+            logWarn('remote', `registry follower failed: ${error?.message || error}`);
+            updateRemoteRegistryFollowerState({
+                status: 'error',
+                reason: 'follower-error',
+                lastError: error?.message || String(error || ''),
+                lastAttemptAt: new Date().toISOString()
+            });
+            scheduleRemoteRegistryFollower(REMOTE_REGISTRY_FOLLOWER_FAST_RETRY_MS, 'error-retry');
+        });
+    }, Math.max(0, Number(delayMs) || 0));
+    remoteRegistryFollowerTimer?.unref?.();
+}
+
+async function wakeRemoteRegistryFollower(reason = 'wake') {
+    if (!REMOTE_REGISTRY_FOLLOWER_ENABLED) {
+        return;
+    }
+    scheduleRemoteRegistryFollower(0, reason);
+}
+
+async function runRemoteRegistryFollowerOnce(trigger = 'timer') {
+    if (!REMOTE_REGISTRY_FOLLOWER_ENABLED || remoteRegistryFollowerInFlight) {
+        return serializeRemoteRegistryFollowerState();
+    }
+
+    remoteRegistryFollowerInFlight = true;
+    const attemptedAt = new Date().toISOString();
+    try {
+        const config = readSupabaseRuntimeConfig();
+        if (!config.url || !config.key) {
+            updateRemoteRegistryFollowerState({
+                status: 'skipped',
+                reason: 'supabase-config-missing',
+                authenticated: false,
+                lastAttemptAt: attemptedAt,
+                lastError: ''
+            });
+            await reportRemoteRegistryFollowerSync({
+                ok: false,
+                skipped: true,
+                reason: 'supabase-config-missing',
+                trigger,
+                authenticated: false
+            });
+            scheduleRemoteRegistryFollower(REMOTE_REGISTRY_FOLLOWER_POLL_MS, 'config-missing');
+            return serializeRemoteRegistryFollowerState();
+        }
+
+        const sessionPayload = await readStableAuthSessionPayload();
+        const session = sessionPayload.found ? parseSupabaseSessionForRegistry(sessionPayload.content) : null;
+        if (!session) {
+            remoteRegistryFollowerConsecutiveMissingSession += 1;
+            if (remoteRegistryFollowerConsecutiveMissingSession >= REMOTE_REGISTRY_FOLLOWER_MISSING_SESSION_STOP_COUNT
+                && isRemoteAgentProcessRunning()) {
+                await stopRemoteAgentConnection('registry-not-authenticated');
+            }
+
+            updateRemoteRegistryFollowerState({
+                status: 'skipped',
+                reason: 'registry-not-authenticated',
+                authenticated: false,
+                lastAttemptAt: attemptedAt,
+                lastError: '',
+                targetEndpoint: '',
+                targetEndpointCandidates: [],
+                targetLeaseId: '',
+                targetNodeId: ''
+            });
+            await reportRemoteRegistryFollowerSync({
+                ok: true,
+                skipped: true,
+                reason: 'registry-not-authenticated',
+                trigger,
+                authenticated: false
+            });
+            scheduleRemoteRegistryFollower(REMOTE_REGISTRY_FOLLOWER_POLL_MS, 'auth-missing');
+            return serializeRemoteRegistryFollowerState();
+        }
+
+        remoteRegistryFollowerConsecutiveMissingSession = 0;
+        if (session.expiresAtMs && session.expiresAtMs <= Date.now()) {
+            updateRemoteRegistryFollowerState({
+                status: 'skipped',
+                reason: 'session-expired',
+                authenticated: false,
+                lastAttemptAt: attemptedAt,
+                lastError: ''
+            });
+            await reportRemoteRegistryFollowerSync({
+                ok: true,
+                skipped: true,
+                reason: 'session-expired',
+                trigger,
+                authenticated: false
+            });
+            scheduleRemoteRegistryFollower(REMOTE_REGISTRY_FOLLOWER_POLL_MS, 'session-expired');
+            return serializeRemoteRegistryFollowerState();
+        }
+
+        const localHub = remoteHub.getStatus({ includeSecrets: false });
+        const target = await fetchRemoteRegistryTarget(config, session);
+
+        if (localHub?.hostTargetActive === true) {
+            if (target?.active === true
+                && !isRemoteRegistryTargetExpired(target)
+                && !isRemoteRegistryTargetSameAsLocalHost(localHub, target)) {
+                remoteHub.setHostTarget({
+                    enabled: false,
+                    nodeId: localHub.hostTargetNodeId
+                });
+                updateRemoteRegistryFollowerState({
+                    status: 'local-host-superseded',
+                    reason: 'local-host-superseded',
+                    authenticated: true,
+                    lastAttemptAt: attemptedAt,
+                    lastSuccessAt: attemptedAt,
+                    targetEndpoint: target.endpoint,
+                    targetEndpointCandidates: target.endpointCandidates,
+                    targetLeaseId: target.leaseId,
+                    targetNodeId: target.nodeId,
+                    lastError: ''
+                });
+                await reportRemoteRegistryFollowerSync({
+                    ok: true,
+                    attempted: true,
+                    disconnected: true,
+                    reason: 'local-host-superseded',
+                    trigger,
+                    authenticated: true,
+                    targetActive: true,
+                    targetEndpoint: target.endpoint,
+                    targetEndpointCandidates: target.endpointCandidates,
+                    targetLeaseId: target.leaseId,
+                    targetNodeId: target.nodeId,
+                    targetExpiresAt: target.expiresAt
+                });
+                scheduleRemoteRegistryFollower(REMOTE_REGISTRY_FOLLOWER_FAST_RETRY_MS, 'local-host-cleared');
+                return serializeRemoteRegistryFollowerState();
+            }
+
+            if (isRemoteAgentProcessRunning()) {
+                await stopRemoteAgentConnection('local-host-target-active');
+            }
+            updateRemoteRegistryFollowerState({
+                status: 'skipped',
+                reason: 'local-monitor-is-host',
+                authenticated: true,
+                lastAttemptAt: attemptedAt,
+                lastSuccessAt: attemptedAt,
+                lastError: ''
+            });
+            await reportRemoteRegistryFollowerSync({
+                ok: true,
+                skipped: true,
+                reason: 'local-monitor-is-host',
+                trigger,
+                authenticated: true,
+                localHostTargetActive: true,
+                localHostTargetLeaseId: localHub.hostTargetLeaseId,
+                localHostTargetNodeId: localHub.hostTargetNodeId
+            });
+            scheduleRemoteRegistryFollower(REMOTE_REGISTRY_FOLLOWER_POLL_MS, 'local-host');
+            return serializeRemoteRegistryFollowerState();
+        }
+
+        if (!target?.active || isRemoteRegistryTargetExpired(target)) {
+            if (isRemoteAgentProcessRunning()) {
+                await stopRemoteAgentConnection('registry-inactive');
+            }
+            updateRemoteRegistryFollowerState({
+                status: 'idle',
+                reason: 'no-active-target',
+                authenticated: true,
+                lastAttemptAt: attemptedAt,
+                lastSuccessAt: attemptedAt,
+                targetEndpoint: '',
+                targetEndpointCandidates: [],
+                targetLeaseId: '',
+                targetNodeId: '',
+                lastError: ''
+            });
+            await reportRemoteRegistryFollowerSync({
+                ok: true,
+                skipped: true,
+                reason: 'no-active-target',
+                trigger,
+                authenticated: true
+            });
+            scheduleRemoteRegistryFollower(REMOTE_REGISTRY_FOLLOWER_POLL_MS, 'no-target');
+            return serializeRemoteRegistryFollowerState();
+        }
+
+        if (isRemoteRegistryTargetSameAsLocalHost(localHub, target)) {
+            updateRemoteRegistryFollowerState({
+                status: 'skipped',
+                reason: 'same-host-lease',
+                authenticated: true,
+                lastAttemptAt: attemptedAt,
+                lastSuccessAt: attemptedAt,
+                targetEndpoint: target.endpoint,
+                targetEndpointCandidates: target.endpointCandidates,
+                targetLeaseId: target.leaseId,
+                targetNodeId: target.nodeId,
+                lastError: ''
+            });
+            await reportRemoteRegistryFollowerSync({
+                ok: true,
+                skipped: true,
+                reason: 'same-host-lease',
+                trigger,
+                authenticated: true,
+                targetActive: true,
+                targetEndpoint: target.endpoint,
+                targetEndpointCandidates: target.endpointCandidates,
+                targetLeaseId: target.leaseId,
+                targetNodeId: target.nodeId,
+                targetExpiresAt: target.expiresAt
+            });
+            scheduleRemoteRegistryFollower(REMOTE_REGISTRY_FOLLOWER_POLL_MS, 'same-host');
+            return serializeRemoteRegistryFollowerState();
+        }
+
+        if (target.endpointCandidates.length === 0 || !target.pairToken) {
+            updateRemoteRegistryFollowerState({
+                status: 'skipped',
+                reason: 'target-missing-endpoint-or-pair',
+                authenticated: true,
+                lastAttemptAt: attemptedAt,
+                lastSuccessAt: attemptedAt,
+                targetEndpoint: target.endpoint,
+                targetEndpointCandidates: target.endpointCandidates,
+                targetLeaseId: target.leaseId,
+                targetNodeId: target.nodeId,
+                lastError: ''
+            });
+            await reportRemoteRegistryFollowerSync({
+                ok: true,
+                skipped: true,
+                reason: 'target-missing-endpoint-or-pair',
+                trigger,
+                authenticated: true,
+                targetActive: true,
+                targetEndpoint: target.endpoint,
+                targetEndpointCandidates: target.endpointCandidates,
+                targetLeaseId: target.leaseId,
+                targetNodeId: target.nodeId,
+                targetExpiresAt: target.expiresAt
+            });
+            scheduleRemoteRegistryFollower(REMOTE_REGISTRY_FOLLOWER_POLL_MS, 'target-incomplete');
+            return serializeRemoteRegistryFollowerState();
+        }
+
+        const connect = await startRemoteAgentConnection({
+            manager: target.endpointCandidates[0],
+            managerCandidates: target.endpointCandidates,
+            pairToken: target.pairToken,
+            leaseId: target.leaseId,
+            nodeId: target.nodeId,
+            engine: 'auto',
+            source: 'local-bridge-registry'
+        });
+
+        const ok = connect?.ok === true;
+        updateRemoteRegistryFollowerState({
+            status: ok ? 'connected' : 'connect-failed',
+            reason: ok ? (connect.alreadyRunning ? 'already-running' : 'connected') : 'connect-failed',
+            authenticated: true,
+            lastAttemptAt: attemptedAt,
+            lastSuccessAt: ok ? new Date().toISOString() : remoteRegistryFollowerState.lastSuccessAt,
+            targetEndpoint: target.endpointCandidates[0],
+            targetEndpointCandidates: target.endpointCandidates,
+            targetLeaseId: target.leaseId,
+            targetNodeId: target.nodeId,
+            lastError: ok ? '' : (connect?.error || 'remote-agent-connect-failed')
+        });
+        await reportRemoteRegistryFollowerSync({
+            ok,
+            attempted: true,
+            connected: ok,
+            skipped: connect?.alreadyRunning === true,
+            reason: ok ? (connect.alreadyRunning ? 'already-running' : 'connected') : 'connect-failed',
+            error: ok ? '' : connect?.error,
+            trigger,
+            authenticated: true,
+            targetActive: true,
+            targetEndpoint: target.endpointCandidates[0],
+            targetEndpointCandidates: target.endpointCandidates,
+            targetLeaseId: target.leaseId,
+            targetNodeId: target.nodeId,
+            targetExpiresAt: target.expiresAt
+        });
+
+        scheduleRemoteRegistryFollower(ok ? REMOTE_REGISTRY_FOLLOWER_POLL_MS : REMOTE_REGISTRY_FOLLOWER_FAST_RETRY_MS, ok ? 'connected' : 'connect-failed');
+        return serializeRemoteRegistryFollowerState();
+    } catch (error) {
+        const transientAuth = error?.statusCode === 401 || error?.statusCode === 403;
+        updateRemoteRegistryFollowerState({
+            status: transientAuth ? 'auth-pending' : 'error',
+            reason: transientAuth ? 'registry-auth-pending' : 'registry-sync-failed',
+            authenticated: false,
+            lastAttemptAt: attemptedAt,
+            lastError: error?.message || String(error || '')
+        });
+        await reportRemoteRegistryFollowerSync({
+            ok: isRemoteAgentProcessRunning(),
+            skipped: true,
+            reason: transientAuth ? 'registry-auth-pending-agent-kept' : 'registry-sync-failed',
+            error: error?.message || String(error || ''),
+            trigger,
+            authenticated: false
+        });
+        scheduleRemoteRegistryFollower(REMOTE_REGISTRY_FOLLOWER_FAST_RETRY_MS, transientAuth ? 'auth-pending' : 'sync-error');
+        return serializeRemoteRegistryFollowerState();
+    } finally {
+        remoteRegistryFollowerInFlight = false;
+    }
+}
+
+function startRemoteRegistryFollower() {
+    if (!REMOTE_REGISTRY_FOLLOWER_ENABLED || remoteRegistryFollowerStarted) {
+        return;
+    }
+
+    remoteRegistryFollowerStarted = true;
+    updateRemoteRegistryFollowerState({
+        status: 'starting',
+        reason: 'startup',
+        lastAttemptAt: '',
+        lastError: ''
+    });
+    scheduleRemoteRegistryFollower(250, 'startup');
+}
+
+function stopRemoteRegistryFollower() {
+    if (remoteRegistryFollowerTimer) {
+        clearTimeout(remoteRegistryFollowerTimer);
+        remoteRegistryFollowerTimer = null;
+    }
+    remoteRegistryFollowerStarted = false;
+    updateRemoteRegistryFollowerState({
+        status: REMOTE_REGISTRY_FOLLOWER_ENABLED ? 'stopped' : 'disabled',
+        reason: 'bridge-shutdown'
+    });
+}
+
 function trimShellOutput(value, maxLength) {
     const text = String(value || '');
     if (text.length <= maxLength) {
-        return text;
-    }
+        return text;
+    }
 
     return text.slice(text.length - maxLength);
 }
@@ -8610,6 +9193,7 @@ app.get('/api/status', async (req, res) => {
         bridgeAuthRequired,
         remoteHub: remoteHub.getStatus({ includeSecrets: false }),
         remoteAgent: serializeRemoteAgentState(),
+        remoteRegistryFollower: serializeRemoteRegistryFollowerState(),
         shellJobsPath: '/api/shell/jobs',
         companyCore: {
             baseUrl: companyCoreBaseUrl,
@@ -10400,15 +10984,14 @@ async function startBridgeServer() {
             `${tone('listen', 'muted')}   ${tone(`http://127.0.0.1:${PORT}`, 'path')}`,
             `${tone('stop', 'muted')}     Ctrl+C`
         ]);
+        startRemoteRegistryFollower();
     });
 }
 
 await startBridgeServer();
 
-// Graceful shutdown
-let isShuttingDown = false;
-
-async function shutdownBridge(signal) {
+// Graceful shutdown
+async function shutdownBridge(signal) {
     if (isShuttingDown) return;
     isShuttingDown = true;
 
@@ -10435,6 +11018,12 @@ async function shutdownBridge(signal) {
         // Ignore if already closed
     }
 
+    try {
+        stopRemoteRegistryFollower();
+    } catch {
+        // Ignore registry follower shutdown errors
+    }
+
     try {
         await stopRemoteAgentConnection('bridge-shutdown');
     } catch {

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

@@ -13451,7 +13451,7 @@
     const REMOTE_FLEET_MONITOR_REFRESH_MS = 10000;
     const REMOTE_FLEET_EMPTY_MONITOR_REFRESH_MS = 2500;
     const REMOTE_FLEET_LIVE_REFRESH_MS = 30000;
-    const REMOTE_FLEET_MONITOR_LIVE_FPS = 10;
+    const REMOTE_FLEET_MONITOR_LIVE_FPS = 12;
     const REMOTE_FLEET_LIVE_FRAME_REFRESH_MS = Math.round(1000 / REMOTE_FLEET_MONITOR_LIVE_FPS);
     const REMOTE_FLEET_CONTROL_LIVE_FPS = 20;
     const REMOTE_FLEET_CONTROL_FRAME_REFRESH_MS = Math.round(1000 / REMOTE_FLEET_CONTROL_LIVE_FPS);

package/wwwroot/_framework/blazor.boot.json

@@ -1,7 +1,7 @@
 {
   "mainAssemblyName": "MindExecution.Web",
   "resources": {
-    "hash": "sha256-aGxH2r2LOpixHAksGBYXRcA86Dv8rGHPIhoagHBUV2M=",
+    "hash": "sha256-exyWukcppwSmHQvoV122RgnUj4KZOvdS3LHrc3Z6BTY=",
     "fingerprinting": {
       "Google.Protobuf.9h59ukbel7.dll": "Google.Protobuf.dll",
       "Markdig.d1j7v41cl1.dll": "Markdig.dll",
@@ -127,12 +127,12 @@
       "MindExecution.Kernel.3zom09ir6j.dll": "MindExecution.Kernel.dll",
       "MindExecution.Plugins.Admin.bk23zzy6wc.dll": "MindExecution.Plugins.Admin.dll",
       "MindExecution.Plugins.Business.zwcvc8wufe.dll": "MindExecution.Plugins.Business.dll",
-      "MindExecution.Plugins.Concept.lxunwcdjgq.dll": "MindExecution.Plugins.Concept.dll",
+      "MindExecution.Plugins.Concept.5gltgdqyo3.dll": "MindExecution.Plugins.Concept.dll",
       "MindExecution.Plugins.Directory.jc0g7fvyzv.dll": "MindExecution.Plugins.Directory.dll",
-      "MindExecution.Plugins.PlanMaster.2sugb66h95.dll": "MindExecution.Plugins.PlanMaster.dll",
-      "MindExecution.Plugins.YouTube.vy0nsbcoo4.dll": "MindExecution.Plugins.YouTube.dll",
-      "MindExecution.Shared.vki6dm13ef.dll": "MindExecution.Shared.dll",
-      "MindExecution.Web.994sb3nzuy.dll": "MindExecution.Web.dll",
+      "MindExecution.Plugins.PlanMaster.cn6ppe6qoz.dll": "MindExecution.Plugins.PlanMaster.dll",
+      "MindExecution.Plugins.YouTube.d7nnsxrftv.dll": "MindExecution.Plugins.YouTube.dll",
+      "MindExecution.Shared.mnpwk5h86c.dll": "MindExecution.Shared.dll",
+      "MindExecution.Web.ygql0sg6b3.dll": "MindExecution.Web.dll",
       "dotnet.js": "dotnet.js",
       "dotnet.native.qc8g39g30v.js": "dotnet.native.js",
       "dotnet.native.boem75ye5i.wasm": "dotnet.native.wasm",
@@ -280,16 +280,16 @@
       "netstandard.yvr3prsx0x.dll": "sha256-EksNn8Luo4bOWqJ6X7dIe9qG9oOqwOVzjH2xYyMNi+E=",
       "MindExecution.Core.asayb4hw1o.dll": "sha256-5gla4JTR/zbvkGpneSt6S7ItE51+MjWgjW6L+B6Yevk=",
       "MindExecution.Kernel.3zom09ir6j.dll": "sha256-78vR2SNkF9FwdQv0fEItSyz4HzgyzwGUROJAnpripPA=",
-      "MindExecution.Plugins.Concept.lxunwcdjgq.dll": "sha256-WVyvjaxW6UoGQvGW0icChLsXwYVCcdn0BLTftzlkCKc=",
-      "MindExecution.Plugins.PlanMaster.2sugb66h95.dll": "sha256-Lp0AieRHDo2H4Yl0Il1pPruy9nFUHJsX9t1AblXGD6Y=",
-      "MindExecution.Shared.vki6dm13ef.dll": "sha256-cUcgQfOJa1LaZuLSXdrmi1RrrueXoKuP49M/cjsbguU=",
-      "MindExecution.Web.994sb3nzuy.dll": "sha256-jQshtLmhEC4xenzdD9PqHjaCuKvJf/frzaKBi2weDAg="
+      "MindExecution.Plugins.Concept.5gltgdqyo3.dll": "sha256-1ZVpFoyPoidSyJz38jH40AFealONt+qQpToJKgqoWW8=",
+      "MindExecution.Plugins.PlanMaster.cn6ppe6qoz.dll": "sha256-GIFH/f4ilVTFDJVEDLLiWkkI7yGeeQl/T5/iuivI87Q=",
+      "MindExecution.Shared.mnpwk5h86c.dll": "sha256-Ht4Kl9nQePXwyDEwL4jBxo2K3F9R4B2OGnSuhHmZ+eU=",
+      "MindExecution.Web.ygql0sg6b3.dll": "sha256-vhb5mjLTaEStzJ9ggN4jBqtd1Z7FAkKHp7bx6Pz33Mc="
     },
     "lazyAssembly": {
       "MindExecution.Plugins.Admin.bk23zzy6wc.dll": "sha256-uz7Nz0OZ8BBESp2Nr9YocyzV0dUrn7szPuD4/m/RWL8=",
       "MindExecution.Plugins.Business.zwcvc8wufe.dll": "sha256-3YDsB2/uNI+feWqJk+cesLHgNt8s2/8hXxGPO6CRZZE=",
       "MindExecution.Plugins.Directory.jc0g7fvyzv.dll": "sha256-PSe7135JPpTBmu4j+rGLF0Dc/6w/wDJNPi8zlfTmSMk=",
-      "MindExecution.Plugins.YouTube.vy0nsbcoo4.dll": "sha256-p8w1TI9Ri41EAG/j0MJCiuEcJdr4x/Hr5Spd2oluZjM="
+      "MindExecution.Plugins.YouTube.d7nnsxrftv.dll": "sha256-OQVjt1f240FGxRV8b2FpxDv4i3U4a7GGA+dBBiZBih8="
     }
   },
   "cacheBootResources": true,

package/wwwroot/index.html

@@ -7,8 +7,8 @@
     <title>MindExec | Run your ideas as AI task graphs</title>
     <meta name="description" content="MindExec is an AI execution canvas for solo builders, researchers, developers, and creators. Start with free browser tools, then move serious work into saved MindCanvas projects." />
     <base href="/" />
-    <link rel="stylesheet" href="_content/MindExecution.Shared/css/app.css?v=20260616-mdm-binary-canvas-v578" />
-    <link rel="stylesheet" href="_content/MindExecution.Shared/css/mind-map-overrides.css?v=20260616-mdm-binary-canvas-v578" />
+    <link rel="stylesheet" href="_content/MindExecution.Shared/css/app.css?v=20260616-mdm-binary-canvas-v579" />
+    <link rel="stylesheet" href="_content/MindExecution.Shared/css/mind-map-overrides.css?v=20260616-mdm-binary-canvas-v579" />
     <!-- ?쇄뼹??Font Awesome (local) ?쇄뼹??-->
     <link rel="stylesheet" href="_content/MindExecution.Shared/lib/font-awesome/css/all.min.css" />
     <!-- ?꿎뼯??-->
@@ -579,7 +579,7 @@
             }
 
             const base = '_content/MindExecution.Shared/js/';
-        const scriptVersion = '20260616-mdm-binary-canvas-v578';
+        const scriptVersion = '20260616-mdm-binary-canvas-v579';
             const scriptUrl = (script) => `${base}${script}?v=${scriptVersion}`;
             console.log(`[Script Loader] Shared JS version: ${scriptVersion}`);
             const criticalScripts = [

package/wwwroot/service-worker-assets.js

@@ -1,5 +1,5 @@
 self.assetsManifest = {
-    "version":  "ssCNFqYX",
+    "version":  "yUK/iR3X",
     "assets":  [
                    {
                        "hash":  "sha256-+CSYMcqLNTsq3VnH11jgYyOCCdxvHzL74CBmo4sCmMU=",
@@ -86,7 +86,7 @@
                        "url":  "_content/MindExecution.Shared/js/mind-map-core.js.backup"
                    },
                    {
-                       "hash":  "sha256-cegQeRNPVyy9IFW9kOgLE0bhe4QOA0+Q72z3bheV0hc=",
+                       "hash":  "sha256-RLe5Ta1um44TU9QYuOpzKHrl8t1tOWQdkL+zwH79MFA=",
                        "url":  "_content/MindExecution.Shared/js/mind-map-css3d-manager.js"
                    },
                    {
@@ -426,28 +426,28 @@
                        "url":  "_framework/MindExecution.Plugins.Business.zwcvc8wufe.dll"
                    },
                    {
-                       "hash":  "sha256-WVyvjaxW6UoGQvGW0icChLsXwYVCcdn0BLTftzlkCKc=",
-                       "url":  "_framework/MindExecution.Plugins.Concept.lxunwcdjgq.dll"
+                       "hash":  "sha256-1ZVpFoyPoidSyJz38jH40AFealONt+qQpToJKgqoWW8=",
+                       "url":  "_framework/MindExecution.Plugins.Concept.5gltgdqyo3.dll"
                    },
                    {
                        "hash":  "sha256-PSe7135JPpTBmu4j+rGLF0Dc/6w/wDJNPi8zlfTmSMk=",
                        "url":  "_framework/MindExecution.Plugins.Directory.jc0g7fvyzv.dll"
                    },
                    {
-                       "hash":  "sha256-Lp0AieRHDo2H4Yl0Il1pPruy9nFUHJsX9t1AblXGD6Y=",
-                       "url":  "_framework/MindExecution.Plugins.PlanMaster.2sugb66h95.dll"
+                       "hash":  "sha256-GIFH/f4ilVTFDJVEDLLiWkkI7yGeeQl/T5/iuivI87Q=",
+                       "url":  "_framework/MindExecution.Plugins.PlanMaster.cn6ppe6qoz.dll"
                    },
                    {
-                       "hash":  "sha256-p8w1TI9Ri41EAG/j0MJCiuEcJdr4x/Hr5Spd2oluZjM=",
-                       "url":  "_framework/MindExecution.Plugins.YouTube.vy0nsbcoo4.dll"
+                       "hash":  "sha256-OQVjt1f240FGxRV8b2FpxDv4i3U4a7GGA+dBBiZBih8=",
+                       "url":  "_framework/MindExecution.Plugins.YouTube.d7nnsxrftv.dll"
                    },
                    {
-                       "hash":  "sha256-cUcgQfOJa1LaZuLSXdrmi1RrrueXoKuP49M/cjsbguU=",
-                       "url":  "_framework/MindExecution.Shared.vki6dm13ef.dll"
+                       "hash":  "sha256-Ht4Kl9nQePXwyDEwL4jBxo2K3F9R4B2OGnSuhHmZ+eU=",
+                       "url":  "_framework/MindExecution.Shared.mnpwk5h86c.dll"
                    },
                    {
-                       "hash":  "sha256-jQshtLmhEC4xenzdD9PqHjaCuKvJf/frzaKBi2weDAg=",
-                       "url":  "_framework/MindExecution.Web.994sb3nzuy.dll"
+                       "hash":  "sha256-vhb5mjLTaEStzJ9ggN4jBqtd1Z7FAkKHp7bx6Pz33Mc=",
+                       "url":  "_framework/MindExecution.Web.ygql0sg6b3.dll"
                    },
                    {
                        "hash":  "sha256-IsZJ91/OW+fHzNqIgEc7Y072ns8z9dGritiSyvR9Wgc=",
@@ -770,7 +770,7 @@
                        "url":  "_framework/Websocket.Client.vapounvmnl.dll"
                    },
                    {
-                       "hash":  "sha256-RIddmeeu4/GO5kDBZ6kmWUv1o1+x8NzfFxWruTBtPec=",
+                       "hash":  "sha256-FgsKNE/RFoMI9OioRZ4cgImxpXXkbc2D4LpHp7W2L7A=",
                        "url":  "_framework/blazor.boot.json"
                    },
                    {
@@ -834,7 +834,7 @@
                        "url":  "image-manifest.json"
                    },
                    {
-                       "hash":  "sha256-xRw/+Q0xTn1kYsE6nXsqd3DUoiZOzocvU7tivvgtQfQ=",
+                       "hash":  "sha256-0O54YE8cYfnYOu/2NbpFuJs/cJRKBw/OAc963M3JI6E=",
                        "url":  "index.html"
                    },
                    {

package/wwwroot/service-worker.js

@@ -1,4 +1,4 @@
-/* Manifest version: ssCNFqYX */
+/* Manifest version: yUK/iR3X */
 // Hosted deployments should prefer the network over stale offline caches.
 // This service worker immediately clears old Blazor offline caches and unregisters itself.