exiouss 1.0.5

package/main.js

@@ -0,0 +1,1161 @@
+// ═══════════════════════════════════════════
+//  GLOBAL STEALTH BOOT (MUST BE FIRST)
+// ═══════════════════════════════════════════
+const { app, BrowserWindow, screen, ipcMain, globalShortcut, clipboard, nativeImage, desktopCapturer, session } = require('electron');
+app.commandLine.appendSwitch('disable-blink-features', 'AutomationControlled');
+app.commandLine.appendSwitch('disable-features', 'UserAgentClientHint');
+app.commandLine.appendSwitch('no-sandbox'); 
+app.commandLine.appendSwitch('disable-site-isolation-trials');
+
+// CRITICAL: Prevent Chromium from pausing DOM updates when window is "hidden"
+app.commandLine.appendSwitch('disable-renderer-backgrounding');
+app.commandLine.appendSwitch('disable-background-timer-throttling');
+app.commandLine.appendSwitch('disable-backgrounding-occluded-windows');
+app.commandLine.appendSwitch('disable-features', 'CalculateNativeWinOcclusion');
+
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const { exec } = require('child_process');
+const { powerSaveBlocker } = require('electron');
+
+// 🛡️ POWER SHIELD: Prevent system/renderer suspension
+powerSaveBlocker.start('prevent-app-suspension');
+
+// 🔋 PROCESS PRIORITY: High Priority to fight proctoring CPU throttling
+try {
+    os.setPriority(0, -14); // HIGH_PRIORITY_CLASS
+    console.log('[SYSTEM] Process priority boosted to HIGH.');
+} catch(e) {
+    console.warn('[SYSTEM] Could not boost priority (need Admin):', e.message);
+}
+
+// ═══════════════════════════════════════════
+//  PROJECT GHOST-MODE 🛸 (Native Stealth)
+// ═══════════════════════════════════════════
+const { uIOhook } = require('uiohook-napi');
+const koffi = require('koffi');
+
+// ═══════════════════════════════════════════
+//  PROJECT PHANTOM-BATCH v12.0 🛸 (Lex200 Sealed)
+// ═══════════════════════════════════════════
+
+let overlayWindow = null;
+let chatgptWin = null;
+
+let batchQueue = []; // Array of { img: String, timestamp }
+let isForcedHidden = false; // Start VISIBLE
+let isUiHidden = false; // Alt+E toggle
+let isAdminVisible = false;
+let isPinned = false; 
+let isAlwaysOnTop = true;
+let isCombatMode = false; // "Click-Through" Mode (Lex200 Defense)
+let activeSection = "GEN"; // GEN, DEB, APT, PRG
+let promptSent = false; 
+
+// ═══════════════════════════════════════════
+//  DESKTOP SCOUT STATE (Cross-Desktop Migration)
+// ═══════════════════════════════════════════
+let desktopApis = null;
+let currentDesktopName = 'Default';
+let isDesktopMigrating = false;
+let sebChildPid = null; // PID of child process on SEB desktop
+const isSebChild = process.argv.includes('--seb-child'); // Are we the child spawned on SEB desktop?
+
+
+// AMCAT Specialized Prompts — Ignore all page noise, solve ONLY the question
+const SECTION_PROMPTS = {
+    "GEN": "IGNORE all navigation, sidebar, comments, similar questions, and UI noise in the text. Focus ONLY on the actual problem/question. Solve with 100% accuracy. Think step-by-step internally. RESPOND WITH ONLY THE FINAL ANSWER on the first line. If MCQ, give the option letter and the option text (e.g., A. Answer Text). If coding, give only the code. Brief explanation below if needed. Please label answers as [Q1], [Q2], etc. if multiple questions were provided. and if the question is like telling the steps then write as a human and step by step ans okay",
+    "DEB": "IGNORE page noise. Focus ONLY on the code with the bug. Find the bug. RESPOND WITH ONLY THE CORRECTED CODE on the first line. Label the answer with its question ID (e.g., [Q1]).",
+    "APT": "IGNORE page noise. Focus ONLY on the math/aptitude problem. Solve step-by-step internally. RESPOND WITH ONLY THE FINAL NUMBER on the first line. Label as [Q1], [Q2], etc.",
+    "PRG": "IGNORE page noise. Focus ONLY on the programming problem statement, examples, and constraints. Write a complete, optimized, correct solution in C++ as a LeetCode Solution class with the correct function signature. The code must be ready to paste directly into LeetCode. RESPOND WITH ONLY THE CODE. Label as [Q1], [Q2], etc."
+};
+
+// Configuration State
+let SYSTEM_PROMPT = "IGNORE all UI noise. Solve with 100% accuracy. If the question is an MCQ, provide the option letter along with the full option text in your answer. For procedural tasks or configuration steps (like AWS, Linux, Networking), RESPOND WITH HUMAN-LIKE, STEP-BY-STEP INSTRUCTIONS. Each step should be a clear action. Label answers as [Q1], [Q2], etc. inside your response.";
+
+let PROXY_RULE = ""; 
+
+// ═══════════════════════════════════════════
+//  ENVIRONMENT SELF-HEALING
+// ═══════════════════════════════════════════
+function checkEnvironment() {
+    console.log('[SYSTEM] Verifying system dependencies...');
+    
+    // Check for Admin rights (RECRUIT: Warn if non-admin)
+    exec('net session', (err) => {
+        if (err) {
+            console.warn('[SECURITY] App not running as Administrator.');
+        } else {
+            console.log('[SECURITY] Running with Administrator privileges.');
+        }
+    });
+}
+
+const configPath = path.join(process.cwd(), 'config.json');
+
+// Load User Config if exists
+if (fs.existsSync(configPath)) {
+    try {
+        const userConfig = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        if (userConfig.prompt) SYSTEM_PROMPT = userConfig.prompt;
+        if (userConfig.proxy) PROXY_RULE = userConfig.proxy;
+    } catch (e) {
+        console.error('[CONFIG] Failed to parse config.json, using default prompt.');
+    }
+} else {
+    // Create default config if missing
+    try {
+        fs.writeFileSync(configPath, JSON.stringify({
+            prompt: SYSTEM_PROMPT,
+            proxy: ""
+        }, null, 4));
+        console.log('[CONFIG] Default config.json created.');
+    } catch (e) {
+        console.error('[CONFIG] Failed to create default config.json');
+    }
+}
+
+// Override with CLI Arg if provided (--prompt="..." or --proxy="...")
+const promptArg = process.argv.find(arg => arg.startsWith('--prompt='));
+if (promptArg) SYSTEM_PROMPT = promptArg.split('=')[1];
+
+const proxyArg = process.argv.find(arg => arg.startsWith('--proxy='));
+if (proxyArg) PROXY_RULE = proxyArg.split('=')[1];
+
+// Mouse Analytics
+let lastMousePos = { x: 0, y: 0 };
+let edgeCooldown = 0;
+let edgeActive = { left: false, right: false }; // Track if mouse is currently on edge
+let wasVisible = true; // Sync state
+// UI State
+let lastOpacity = -1;
+
+
+// ═══════════════════════════════════════════
+//  WINDOW CREATION
+// ═══════════════════════════════════════════
+
+function createOverlayWindow() {
+    const iconPath = path.join(__dirname, 'public', 'icon.ico');
+    overlayWindow = new BrowserWindow({
+        width: 140, height: 180, transparent: true, frame: false, alwaysOnTop: true,
+        skipTaskbar: true, resizable: false, focusable: false,
+        icon: iconPath,
+        title: 'testpad',
+        webPreferences: { nodeIntegration: true, contextIsolation: false }
+    });
+    overlayWindow.loadFile('index.html');
+    
+    // Layer 1: System Level Stealth
+    overlayWindow.setAlwaysOnTop(true, 'screen-saver', 100);
+    overlayWindow.setVisibleOnAllWorkspaces(true, { visibleOnFullScreen: true });
+    
+    // Layer 2: Ultimate Stealth (True Invisibility)
+    setUltimateStealth(overlayWindow);
+    
+    overlayWindow.setOpacity(0.9);
+    overlayWindow.showInactive(); 
+}
+
+function setUltimateStealth(window) {
+    if (!window || process.platform !== 'win32') return;
+    try {
+        const user32 = koffi.load('user32.dll');
+        const SetWindowDisplayAffinity = user32.func('bool __stdcall SetWindowDisplayAffinity(intptr hWnd, uint32_t dwAffinity)');
+        const SetWindowPos = user32.func('bool __stdcall SetWindowPos(intptr hWnd, intptr hWndInsertAfter, int x, int y, int cx, int cy, uint uFlags)');
+        const GetForegroundWindow = user32.func('intptr __stdcall GetForegroundWindow()');
+        const GetWindowLongW = user32.func('long __stdcall GetWindowLongW(intptr hWnd, int nIndex)');
+        const SetWindowLongW = user32.func('long __stdcall SetWindowLongW(intptr hWnd, int nIndex, long dwNewLong)');
+        const ShowWindow = user32.func('bool __stdcall ShowWindow(intptr hWnd, int nCmdShow)');
+        const IsWindowVisible = user32.func('bool __stdcall IsWindowVisible(intptr hWnd)');
+        
+        // Define mouse_event globally
+        global.mouse_event = user32.func('void __stdcall mouse_event(uint32_t dwFlags, uint32_t dx, uint32_t dy, uint32_t dwData, uintptr dwExtraInfo)');
+        global.MOUSEEVENTF_WHEEL = 0x0800;
+
+        const handle = window.getNativeWindowHandle();
+        const hwnd = handle.readUInt32LE();
+
+        // 🛡️ LAYER 1: Capture Protection (invisible to screenshots/screen share)
+        const result = SetWindowDisplayAffinity(hwnd, 0x00000011);
+        if (result) {
+            console.log('🛡️ STEALTH: WDA_EXCLUDEFROMCAPTURE Activated.');
+        } else {
+            window.setContentProtection(true);
+        }
+
+        // 🛡️ LAYER 2: WINDOW STYLE HARDENING (No Alt-Tab, No Taskbar, No Focus Steal)
+        const GWL_EXSTYLE = -20;
+        const WS_EX_TOOLWINDOW  = 0x00000080;  // Hide from Alt-Tab
+        const WS_EX_NOACTIVATE  = 0x08000000;  // NEVER steal focus
+        const WS_EX_TOPMOST     = 0x00000008;  // Native always-on-top
+        const WS_EX_LAYERED     = 0x00080000;  // Layered window support
+        const WS_EX_APPWINDOW   = 0x00040000;  // REMOVE this (hides from taskbar)
+        const WS_EX_TRANSPARENT = 0x00000020;  // Click-through at native level
+
+        try {
+            let exStyle = GetWindowLongW(hwnd, GWL_EXSTYLE);
+            // Apply stealth flags, remove APPWINDOW flag
+            exStyle = (exStyle | WS_EX_TOOLWINDOW | WS_EX_NOACTIVATE | WS_EX_TOPMOST | WS_EX_LAYERED) & ~WS_EX_APPWINDOW;
+            SetWindowLongW(hwnd, GWL_EXSTYLE, exStyle);
+            console.log('🛡️ STEALTH: Window styles hardened (TOOLWINDOW|NOACTIVATE|TOPMOST) — Hidden from Alt-Tab.');
+        } catch(styleErr) {
+            console.warn('🛡️ Style hardening failed:', styleErr.message);
+        }
+
+        // 🛡️ LAYER 3: AGGRESSIVE Z-ORDER DOMINANCE (25ms — outpaces all proctors)
+        // Proctoring software tries to be topmost every 50-200ms. We fight at 25ms.
+        const SW_SHOWNOACTIVATE = 8;
+        setInterval(() => {
+            if (window.isDestroyed()) return;
+            
+            // SWP_NOSIZE | SWP_NOMOVE | SWP_SHOWWINDOW | SWP_NOACTIVATE = 0x0053
+            // HWND_TOPMOST = -1
+            SetWindowPos(hwnd, -1, 0, 0, 0, 0, 0x0053);
+            
+            // 🛡️ SELF-HEALING: If proctor hid our window, force-restore WITHOUT stealing focus
+            if (!IsWindowVisible(hwnd)) {
+                ShowWindow(hwnd, SW_SHOWNOACTIVATE);
+                console.log('🛡️ SELF-HEAL: Window restored from hidden state.');
+            }
+            
+            // Re-assert alwaysOnTop for Chromium's internal logic
+            if (isAlwaysOnTop) {
+                window.setAlwaysOnTop(true, 'screen-saver', 100); 
+            }
+        }, 25);
+
+    } catch (e) {
+        console.warn('🛡️ koffi Stealth Failure:', e.message);
+        window.setContentProtection(true);
+    }
+}
+
+// ═══════════════════════════════════════════
+//  STEALTH HANDSHAKE (Active Stealth Bridge)
+// ═══════════════════════════════════════════
+
+function createBridge(name, url, partition) {
+    const iconPath = path.join(__dirname, 'public', 'icon.ico');
+    const win = new BrowserWindow({
+        width: 1100, height: 850, x: -10000, y: -10000, show: true,
+        skipTaskbar: true, frame: false, transparent: true, opacity: 0.01,
+        icon: iconPath,
+        title: 'testpad',
+        webPreferences: { 
+            partition: `persist:${partition}`, 
+            contextIsolation: true, 
+            nodeIntegration: false,
+            javascript: true,
+            webSecurity: true, 
+            backgroundThrottling: false,
+            offscreen: false 
+        }
+    });
+    
+    // 🛡️ ULTIMATE STEALTH: Hide from all capture tools even while at (0,0)
+    setUltimateStealth(win);
+    
+    // High-Trust Chrome User Agent (ChatGPT blocks old Firefox UAs)
+    const highTrustUA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36";
+    const sess = session.fromPartition(`persist:${partition}`);
+    sess.setUserAgent(highTrustUA);
+    
+    // Fix ChatGPT "something went wrong" — inject proper Sec-CH-UA headers
+    sess.webRequest.onBeforeSendHeaders({ urls: ['*://*.openai.com/*', '*://*.chatgpt.com/*'] }, (details, callback) => {
+        details.requestHeaders['Sec-CH-UA'] = '"Chromium";v="124", "Google Chrome";v="124", "Not-A.Brand";v="99"';
+        details.requestHeaders['Sec-CH-UA-Mobile'] = '?0';
+        details.requestHeaders['Sec-CH-UA-Platform'] = '"Windows"';
+        details.requestHeaders['Accept-Language'] = 'en-US,en;q=0.9';
+        callback({ requestHeaders: details.requestHeaders });
+    });
+    
+    sess.setPermissionRequestHandler((webContents, permission, callback) => {
+        if (permission === 'notifications') return callback(false);
+        callback(true);
+    });
+
+    win.webContents.setUserAgent(highTrustUA);
+
+    // Deep Stealth Fingerprint (Enhanced for Resilience)
+    win.webContents.on('dom-ready', () => {
+        win.webContents.executeJavaScript(`
+            // Security/Bot Detection Bypass
+            Object.defineProperty(navigator, 'webdriver', { get: () => false });
+            Object.defineProperty(navigator, 'platform', { get: () => 'Win32' });
+            Object.defineProperty(navigator, 'deviceMemory', { get: () => 16 });
+            
+            // Mask Visibility API (Force "Running" state)
+            Object.defineProperty(document, 'visibilityState', { get: () => 'visible', configurable: true });
+            Object.defineProperty(document, 'hidden', { get: () => false, configurable: true });
+            document.dispatchEvent(new Event('visibilitychange'));
+
+            // State Force Injection
+            window.isSleeping = false;
+            window.isRunning = true;
+
+            // Animation Heartbeat (Prevents renderer sleep)
+            setInterval(() => {
+                window.dispatchEvent(new Event('mousemove'));
+                if (window.requestAnimationFrame) {
+                    window.requestAnimationFrame(() => {});
+                }
+            }, 1000);
+
+            // Mock Focus
+            try { document.hasFocus = () => true; } catch(e) {}
+            
+            "Injection Success";
+        `).catch(err => console.error("[DOM-READY ERR]", err));
+    });
+
+    win.loadURL(url);
+
+    win.on('close', (e) => {
+        e.preventDefault();
+        win.setBounds({ x: -10000, y: -10000, width: 1100, height: 850 });
+        isAdminVisible = false;
+    });
+    return win;
+}
+
+// ═══════════════════════════════════════════
+//  DESKTOP SCOUT v1.0 (Cross-Desktop Migration)
+//  Detects SEB/proctor desktop switches and migrates
+// ═══════════════════════════════════════════
+
+function initDesktopScout() {
+    try {
+        const user32 = koffi.load('user32.dll');
+        const kernel32 = koffi.load('kernel32.dll');
+        
+        desktopApis = {
+            OpenInputDesktop: user32.func('intptr __stdcall OpenInputDesktop(uint32_t dwFlags, bool fInherit, uint32_t dwDesiredAccess)'),
+            SetThreadDesktop: user32.func('bool __stdcall SetThreadDesktop(intptr hDesktop)'),
+            CloseDesktop: user32.func('bool __stdcall CloseDesktop(intptr hDesktop)'),
+            GetThreadDesktop: user32.func('intptr __stdcall GetThreadDesktop(uint32_t dwThreadId)'),
+            GetUserObjectInformationW: user32.func('bool __stdcall GetUserObjectInformationW(intptr hObj, int nIndex, void *pvInfo, uint32_t nLength, uint32_t *lpnLengthNeeded)'),
+            GetCurrentThreadId: kernel32.func('uint32_t __stdcall GetCurrentThreadId()'),
+        };
+        
+        console.log('[SCOUT] Desktop Scout APIs loaded.');
+        return true;
+    } catch(e) {
+        console.error('[SCOUT] Failed to load Desktop APIs:', e.message);
+        return false;
+    }
+}
+
+function getDesktopName(hDesktop) {
+    if (!hDesktop || !desktopApis) return 'unknown';
+    try {
+        const UOI_NAME = 2;
+        const neededBuf = Buffer.alloc(4);
+        desktopApis.GetUserObjectInformationW(hDesktop, UOI_NAME, null, 0, neededBuf);
+        
+        const size = neededBuf.readUInt32LE();
+        if (size === 0) return 'unknown';
+        
+        const nameBuf = Buffer.alloc(size);
+        if (desktopApis.GetUserObjectInformationW(hDesktop, UOI_NAME, nameBuf, size, neededBuf)) {
+            return nameBuf.toString('utf16le').replace(/\0/g, '');
+        }
+    } catch(e) {}
+    return 'unknown';
+}
+
+function startDesktopScout() {
+    if (isSebChild) {
+        console.log('[SCOUT] Running as SEB child \u2014 Scout disabled (parent handles it).');
+        return;
+    }
+    if (!desktopApis && !initDesktopScout()) return;
+    
+    const threadId = desktopApis.GetCurrentThreadId();
+    const initialDesktop = desktopApis.GetThreadDesktop(threadId);
+    currentDesktopName = getDesktopName(initialDesktop);
+    console.log(`[SCOUT] \u{1F441} Watching from desktop: "${currentDesktopName}"`);
+    
+    // Poll for desktop switches every 500ms
+    setInterval(() => {
+        if (isDesktopMigrating) return;
+        
+        try {
+            // DESKTOP_READOBJECTS | DESKTOP_CREATEWINDOW | DESKTOP_WRITEOBJECTS | DESKTOP_SWITCHDESKTOP
+            const DESIRED_ACCESS = 0x0001 | 0x0002 | 0x0080 | 0x0100;
+            const hInputDesktop = desktopApis.OpenInputDesktop(0, false, DESIRED_ACCESS);
+            
+            if (!hInputDesktop) return;
+            
+            const inputName = getDesktopName(hInputDesktop);
+            
+            if (inputName !== currentDesktopName && inputName !== 'unknown') {
+                // Desktop changed — check if we need to migrate or wake up
+                if (inputName === 'Default' && sebChildPid) {
+                    // SEB closed — we're back on Default. Kill child and wake up.
+                    console.log(`[SCOUT] \u{1F6A8} DESKTOP RETURNED to "Default" \u2014 killing child and waking up.`);
+                    wakeUpParent();
+                    currentDesktopName = 'Default';
+                } else if (!sebChildPid) {
+                    // New secure desktop detected — spawn child there
+                    console.log(`[SCOUT] \u{1F6A8} DESKTOP SWITCH: "${currentDesktopName}" \u{2192} "${inputName}"`);
+                    migrateToDesktop(hInputDesktop, inputName);
+                } else {
+                    try { desktopApis.CloseDesktop(hInputDesktop); } catch(e) {}
+                }
+            } else {
+                try { desktopApis.CloseDesktop(hInputDesktop); } catch(e) {}
+            }
+        } catch(e) {
+            // Silent — never crash the scout loop
+        }
+    }, 500);
+}
+
+async function migrateToDesktop(hNewDesktop, newName) {
+    isDesktopMigrating = true;
+    console.log('[SCOUT] INITIATING MIGRATION to "' + newName + '"...');
+    
+    try {
+        // STRATEGY: Spawn a NEW electron process on the target desktop
+        // via CreateProcessW (PowerShell helper). Parent stays alive and goes dormant.
+        
+        // Step 1: If we have an old child, kill it first
+        if (sebChildPid) {
+            try { process.kill(sebChildPid); } catch(e) {}
+            sebChildPid = null;
+        }
+        
+        // Step 2: Go dormant (hide overlay, stop hooks - but DON'T destroy windows)
+        if (overlayWindow && !overlayWindow.isDestroyed()) {
+            overlayWindow.hide();
+        }
+        try { uIOhook.stop(); } catch(e) {}
+        globalShortcut.unregisterAll();
+        console.log('[SCOUT] Parent going dormant.');
+        
+        // Step 3: Spawn child electron on target desktop via CreateProcessW
+        const psPath = path.join(__dirname, 'bin', 'spawn_on_desktop.ps1');
+        const electronExe = process.execPath;
+        const appDir = path.join(__dirname);
+        
+        // Write params to temp JSON file (avoids all shell quoting issues)
+        const paramFile = path.join(appDir, 'bin', '_spawn_params.json');
+        const params = {
+            desktop: newName,
+            appPath: electronExe,
+            appArgs: '"' + appDir + '" --seb-child',
+            workingDir: appDir
+        };
+        fs.writeFileSync(paramFile, JSON.stringify(params));
+        
+        const cmd = 'powershell -ExecutionPolicy Bypass -File "' + psPath + '" -ParamFile "' + paramFile + '"';
+        
+        console.log('[SCOUT] Spawning child on desktop "' + newName + '"...');
+        console.log('[SCOUT] Electron: ' + electronExe);
+        
+        exec(cmd, { windowsHide: true, timeout: 15000 }, (error, stdout, stderr) => {
+            isDesktopMigrating = false; // Clear lock now that callback fired
+            if (error) {
+                console.error('[SCOUT] Spawn error:', error.message);
+                wakeUpParent();
+                return;
+            }
+            
+            const output = stdout.trim();
+            console.log('[SCOUT] Spawn result:', output);
+            
+            if (output.startsWith('PID:')) {
+                sebChildPid = parseInt(output.split(':')[1]);
+                console.log('[SCOUT] Child spawned on "' + newName + '" (PID: ' + sebChildPid + ')');
+            } else {
+                console.error('[SCOUT] CreateProcessW failed:', output);
+                wakeUpParent();
+            }
+        });
+        
+        // Mark desktop as changed immediately to prevent re-triggering
+        currentDesktopName = newName;
+        
+        // Close the desktop handle
+        try { desktopApis.CloseDesktop(hNewDesktop); } catch(e) {}
+        
+    } catch(e) {
+        console.error('[SCOUT] Migration error:', e.message);
+        isDesktopMigrating = false;
+        wakeUpParent();
+    }
+    // NOTE: isDesktopMigrating is cleared inside the exec callback, NOT here
+}
+
+// Wake up the parent process (restore overlay + hooks after SEB closes)
+function wakeUpParent() {
+    console.log('[SCOUT] Waking up parent...');
+    
+    // Kill child if running
+    if (sebChildPid) {
+        try { process.kill(sebChildPid); } catch(e) {}
+        sebChildPid = null;
+    }
+    
+    // Restore overlay
+    if (overlayWindow && !overlayWindow.isDestroyed()) {
+        overlayWindow.showInactive();
+        wasVisible = true;
+    } else {
+        createOverlayWindow();
+    }
+    
+    // Restore chatgpt bridge if needed
+    if (!chatgptWin || chatgptWin.isDestroyed()) {
+        chatgptWin = createBridge('chatgpt', 'https://chat.openai.com', 'chatgpt');
+    }
+    
+    // Re-register hotkeys and hooks
+    registerAllHotkeys();
+    setTimeout(() => {
+        try { uIOhook.start(); } catch(e) {}
+        console.log('[SCOUT] Parent fully awake.');
+    }, 500);
+}
+
+// ═══════════════════════════════════════════
+//  REUSABLE HOTKEY REGISTRATION
+//  (Extracted so it can be called after desktop migration)
+// ═══════════════════════════════════════════
+
+function registerAllHotkeys() {
+    const register = (key, fn) => {
+        const success = globalShortcut.register(key, fn);
+        console.log(`[KEY] ${key} registration: ${success ? 'OK' : 'FAILED'}`);
+        return success;
+    };
+
+    register('Alt+C', () => { 
+        isCombatMode = !isCombatMode; 
+        updateUI(); 
+        console.log(`[APP] Combat Mode (Lex200 Defense): ${isCombatMode}`); 
+    });
+
+    register('Alt+X', () => {
+        if (isCombatMode) return;
+        isAdminVisible = !isAdminVisible;
+        if (chatgptWin) {
+            if (isAdminVisible) {
+                const { width, height } = screen.getPrimaryDisplay().workAreaSize;
+                chatgptWin.setOpacity(1.0);
+                chatgptWin.setBounds({ 
+                    x: Math.round(width/2 - 550), 
+                    y: Math.round(height/2 - 425), 
+                    width: 1100, height: 850 
+                });
+                chatgptWin.focus(); 
+            } else {
+                chatgptWin.setOpacity(0.01);
+                chatgptWin.setBounds({ x: -10000, y: -10000, width: 1100, height: 850 });
+            }
+        }
+    });
+
+    // \u2622\uFE0F DECONTAMINATION PROTOCOL (Alt + Shift + X)
+    register('Alt+Shift+X', async () => {
+        console.log("\u2622\uFE0F SELF-DESTRUCT INITIATED...");
+        const burnScript = `
+            (async function() {
+                try {
+                    const gptDelete = document.querySelector('nav .bg-red-500') || document.querySelector('[aria-label*="Delete"]');
+                    if (gptDelete) gptDelete.click();
+                    await new Promise(r => setTimeout(r, 500));
+                } catch(e) {}
+            })()
+        `;
+        if (chatgptWin) {
+            chatgptWin.webContents.executeJavaScript(burnScript).catch(e => {});
+            await chatgptWin.webContents.session.clearStorageData();
+        }
+        promptSent = false;
+        await session.defaultSession.clearStorageData();
+        console.log("\u2622\uFE0F WIPE COMPLETE. EXITING.");
+        app.exit(0);
+    });
+}
+
+// ═══════════════════════════════════════════
+//  CORE WORKFLOW: CAPTURE -> BATCH -> STRIKE
+// ═══════════════════════════════════════════
+
+async function captureImageQuestion() {
+    if (batchQueue.length >= 10) return; 
+    console.log(`[CAPTURE] Using Stealth GDI Memory Capture (Zero-Screenshot)...`);
+    
+    const psPath = path.join(__dirname, 'bin', 'stealth_capture.ps1');
+    const cmd = `powershell -ExecutionPolicy Bypass -File "${psPath}"`;
+    
+    // Increase buffer size for Base64 image data and PREVENT CONSOLE FLASH
+    exec(cmd, { maxBuffer: 1024 * 1024 * 10, windowsHide: true }, (error, stdout, stderr) => {
+        if (error) {
+            console.error(`[CAPTURE] GDI Error: ${error.message}`);
+            return;
+        }
+        const dataUrl = stdout.trim();
+        if (dataUrl && dataUrl.startsWith("data:image")) {
+            batchQueue.push({ img: dataUrl, text: null, time: Date.now() });
+            console.log(`[QUEUE] Added stealth image ${batchQueue.length}/10`);
+            updateUI();
+        } else {
+            console.warn(`[CAPTURE] Failed to get pixel data: ${dataUrl}`);
+        }
+    });
+}
+
+// ═══════════════════════════════════════════
+//  TEXT CLEANING (Strip page noise before sending to AI)
+// ═══════════════════════════════════════════
+function cleanExtractedText(raw) {
+    if (!raw) return raw;
+    
+    const lines = raw.split('\n');
+    let cleaned = [];
+    let hitCutoff = false;
+    
+    // Patterns that signal "end of real question content" (less strict to avoid cutting MCQs)
+    const CUTOFF_PATTERNS = [
+        /discussion\s*\(/i,
+        /^similar questions$/i,
+        /^comments?$/i,
+        /^sort by$/i,
+        /daily question tag/i,
+        /\d+ days? badge/i,
+    ];
+    
+    // Lines to always skip (Boilerplate UI Noise)
+    const SKIP_PATTERNS = [
+        // Browser chrome
+        /^(back|forward|reload|extensions|bookmark|new tab|mute tab|restore)$/i,
+        /^address and search bar|search tabs|tab content shared|memory usage$/i,
+        /^view site information|control your music$/i,
+        /^install app|installing\.\.\.$/i,
+        
+        // LeetCode noise
+        /^(prev question|next question|pick one|expand panel|upgrade to premium)$/i,
+        /^(ask leet|layouts|settings|stopwatch|invite|user menu|premium lock)$/i,
+        /^(leetcode logo|online|saved|ln \d+|col \d+)$/i,
+        /^\d+ minutes?.*seconds?$/i, 
+        /^(accepted|acceptance rate|seen this question)$/i,
+        /^(hint \d|topics|companies)$/i,
+        /^\w+\s+(easy|med\.|medium|hard)$/i,
+        /^\d+\.\s+\w+.*\s+(easy|med\.|medium|hard)$/i,
+        
+        // TestPad / Chitkara noise (sidebar, calendar, nav, share)
+        /^(dashboard|attempts|playground|python notebook|test courses|bookmarks)$/i,
+        /^(settings|logout|nothing selected|close|goto today)$/i,
+        /^(sun|mon|tue|wed|thu|fri|sat)$/i,
+        /^\d{1,2}$/,  // Calendar day numbers
+        /^(january|february|march|april|may|june|july|august|september|october|november|december)\s+\d{4}$/i,
+        /^(whatsapp|twitter|reddit|facebook|linkedin)$/i,
+        /^share this with your friends\??$/i,
+        /^(this is a success message|hurray|this section is complete)\.?!?$/i,
+        /^are you sure want to delete this\.?$/i,
+        /^(yes|no)$/i,
+        /^\d+\s+(tutorial|coding|mcq)\s+/i,  // Sidebar course listing items
+        /^\d+%\s+covered$/i,
+        /^how do you like the content\??$/i,
+        /^your feedback is very essential/i,
+        /^result is incorrect$/i,
+        /^(submit|report a problem|previous|next|clear selection)$/i,
+        /^bookmark_border$/i,
+        /^close-icon$/i,
+        /^logo$/i,
+        /^enter issue$/i,
+        /^choose any one$/i,
+        /^question attempts$/i,
+        /^student\s+\w$/i,
+        /^sagar$/i,
+        /^\d+cs\d+/i,  // Course codes like 25CS020
+        /^(graphs?|all classes)\s*\d*$/i,
+    ];
+    
+    // SECOND PASS: Extract code editor template from FULL text (priority)
+    const codePatterns = [
+        /class\s+Solution[\s\S]*?\{[\s\S]*?\};?/,         // LeetCode C++/Java Class
+        /def\s+\w+\(self[\s\S]*?\):/,                     // Python
+        /function\s+\w+\([\s\S]*?\)\s*\{/,                // JS
+        /public\s+[\s\S]*?class\s+\w+[\s\S]*?\{/,          // General Java
+    ];
+    
+    let template = "";
+    for (const pat of codePatterns) {
+        const match = raw.match(pat);
+        if (match) { template = match[0].trim(); break; }
+    }
+    
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        
+        // Check cutoff
+        for (const pat of CUTOFF_PATTERNS) {
+            if (pat.test(trimmed)) { hitCutoff = true; break; }
+        }
+        if (hitCutoff) break;
+        
+        // Check skip
+        let skip = false;
+        for (const pat of SKIP_PATTERNS) {
+            if (pat.test(trimmed)) { skip = true; break; }
+        }
+        if (skip) continue;
+        
+        cleaned.push(trimmed);
+    }
+    
+    // Cap description at 8000 chars for modern LLMs
+    let description = cleaned.join('\n');
+    if (description.length > 8000) {
+        description = description.substring(0, 8000) + '\n[...Description Truncated...]';
+    }
+    
+    // Final assembly: Template FIRST so AI definitely sees what function to fix
+    let final = "";
+    if (template) final += "--- CODE TEMPLATE (DO NOT CHANGE SIGNATURE) ---\n" + template + "\n\n";
+    final += "--- PROBLEM DESCRIPTION ---\n" + description;
+    
+    return final;
+}
+
+async function captureTextQuestion() {
+    if (batchQueue.length >= 10) return;
+    console.log(`[CAPTURE] Using Standalone UIA Engine (.exe)...`);
+    
+    // Call the compiled executable (zero-dependency, skips Electron windows)
+    const exePath = path.join(__dirname, 'bin', 'uia_extract.exe');
+    const cmd = `"${exePath}"`;
+    
+    // Ensure no terminal pops up and steals focus
+    exec(cmd, { encoding: 'utf8', windowsHide: true }, (error, stdout, stderr) => {
+        if (error) {
+            console.error(`[UIA] Engine Error: ${error.message}`);
+            return;
+        }
+        const rawText = stdout.trim();
+        
+        // --- DEBUG REPORTING ---
+        try {
+            fs.writeFileSync(path.join(__dirname, 'uia_debug.txt'), rawText);
+        } catch(e) {}
+        
+        const text = cleanExtractedText(rawText);
+        
+        // Save cleaned text too for comparison
+        try {
+            fs.writeFileSync(path.join(__dirname, 'uia_cleanup.txt'), text);
+        } catch(e) {}
+
+        if (text && !text.startsWith("ERROR") && !text.startsWith("TARGET:")) {
+            batchQueue.push({ img: null, text: text, time: Date.now() });
+            console.log(`[QUEUE] Added text question ${batchQueue.length}/10 (${text.length} chars, cleaned from ${rawText.length})`);
+            updateUI();
+        } else {
+            console.warn(`[UIA] No text extracted or fallback only: ${text}`);
+            if (overlayWindow) overlayWindow.webContents.send('update-ans', '⚠️ NO TEXT DETECTED (USE IMAGE CAPTURE)');
+        }
+    });
+}
+
+async function performOracleStrike() {
+    if (batchQueue.length === 0) return;
+    
+    console.log(`[STRIKE] Sending ${batchQueue.length} questions to ChatGPT...`);
+    
+    const images = batchQueue.filter(q => q.img).map(item => item.img); 
+    const textContext = batchQueue.filter(q => q.text).map(item => item.text).join('\n\n───\n\n');
+
+    // Build the correct prompt based on section
+    const finalPrompt = SECTION_PROMPTS[activeSection] || SYSTEM_PROMPT;
+
+    // Preparation Script
+    const injectionScript = `
+        (async function() {
+            try {
+                const imgs = ${JSON.stringify(images)};
+                const texts = ${JSON.stringify(textContext)};
+                const PROMPT = ${JSON.stringify(finalPrompt)};
+
+                const input = document.querySelector('div[contenteditable="true"]') || 
+                              document.querySelector('textarea') || 
+                              document.querySelector('.ProseMirror') || 
+                              document.querySelector('[aria-label*="message"]');
+                if (!input) return "Input Not Found";
+                
+                input.focus();
+                
+                // 1. Paste Images if any
+                for (const dataUrl of imgs) {
+                    const parts = dataUrl.split(',');
+                    const bstr = atob(parts[1]);
+                    let n = bstr.length;
+                    const u8arr = new Uint8Array(n);
+                    while(n--) u8arr[n] = bstr.charCodeAt(n);
+                    const file = new File([u8arr], "question.png", { type: "image/png" });
+                    const dt = new DataTransfer();
+                    dt.items.add(file);
+                    const pasteEvent = new ClipboardEvent('paste', { clipboardData: dt, bubbles: true, cancelable: true });
+                    input.dispatchEvent(pasteEvent);
+                    await new Promise(r => setTimeout(r, 800)); 
+                }
+
+                // 2. Insert Accumulated Text Context
+                if (texts) {
+                    document.execCommand('insertText', false, "CONTEXT FROM UIA:\\n" + texts + "\\n\\n");
+                    input.dispatchEvent(new Event('input', { bubbles: true }));
+                }
+
+                // 3. Dynamic User-Controlled Prompt
+                document.execCommand('insertText', false, PROMPT);
+                input.dispatchEvent(new Event('input', { bubbles: true }));
+                
+                // ☢️ STATE FORCE: Make React/ProseMirror recognize our text
+                input.dispatchEvent(new Event('input', { bubbles: true }));
+                input.dispatchEvent(new Event('change', { bubbles: true }));
+                
+                // 🎯 WAIT for Send button to become active, THEN press Enter
+                let attempts = 0;
+                while (attempts < 50) {
+                    await new Promise(r => setTimeout(r, 200));
+                    
+                    const sendBtn = document.querySelector('button[data-testid="send-button"]') || 
+                                    document.querySelector('button[aria-label*="Send"]');
+                    
+                    if (sendBtn && !sendBtn.disabled) {
+                        // Button is ready — fire Enter
+                        const enterDown = new KeyboardEvent('keydown', { 
+                            key: 'Enter', code: 'Enter', keyCode: 13, which: 13, 
+                            bubbles: true, cancelable: true 
+                        });
+                        const enterPress = new KeyboardEvent('keypress', { 
+                            key: 'Enter', code: 'Enter', keyCode: 13, which: 13, 
+                            bubbles: true, cancelable: true 
+                        });
+                        const enterUp = new KeyboardEvent('keyup', { 
+                            key: 'Enter', code: 'Enter', keyCode: 13, which: 13, 
+                            bubbles: true, cancelable: true 
+                        });
+                        
+                        input.focus();
+                        input.dispatchEvent(enterDown);
+                        input.dispatchEvent(enterPress);
+                        input.dispatchEvent(enterUp);
+                        
+                        return "Success (Enter after " + (attempts * 200) + "ms)";
+                    }
+                    attempts++;
+                }
+                return "Timeout - Send never activated";
+            } catch (err) { return "Error: " + err.message; }
+        })()
+    `;
+
+    if (chatgptWin) {
+        chatgptWin.webContents.executeJavaScript(injectionScript)
+            .then(result => console.log("[STRIKE] Script Result:", result))
+            .catch(err => console.error("[STRIKE ERROR] Failed to execute injection:", err));
+        
+        pollForResult(chatgptWin, 'chatgpt');
+        promptSent = true; 
+    }
+
+    // Increment question counter by batch size for accurate history tracking
+    const batchSize = batchQueue.length;
+    const startQ = questionCounter + 1;
+    const endQ = questionCounter + batchSize;
+    questionCounter = endQ;
+
+    const solveTag = batchSize > 1 ? `[Q${startQ}-${endQ}]` : `[Q${startQ}]`;
+    overlayWindow.webContents.send('update-ans', JSON.stringify({ type: 'solving', qNum: solveTag }));
+    
+    batchQueue = [];
+    updateUI();
+}
+
+let sessionHistory = [];  // [{qNum: 1, answer: "Option B"}, ...]
+let questionCounter = 0;
+let lastPollHash = "";
+
+let pollInterval = null;
+async function pollForResult(win) {
+    if (pollInterval) clearTimeout(pollInterval);
+    
+    // Grab ALL assistant response texts
+    const pollScript = `
+        (function() {
+            try {
+                // Target the specific assistant message content blocks
+                const assistantMsgs = document.querySelectorAll('[data-message-author-role="assistant"]');
+                const results = [];
+                
+                assistantMsgs.forEach(msg => {
+                    // Try to find the inner prose/markdown content first (cleanest)
+                    const content = msg.querySelector('.prose, .markdown') || msg;
+                    const text = content.innerText.trim();
+                    if (text && text.length > 3 && text !== "Thinking...") {
+                        results.push(text);
+                    }
+                });
+                
+                // Final safety: Remove identical consecutive duplicates
+                return JSON.stringify(results.filter((item, pos, self) => {
+                    return !pos || item !== self[pos - 1];
+                }));
+            } catch(e) { return null; }
+        })()
+    `;
+    
+    async function runPoll() {
+        if (!win || win.isDestroyed()) return;
+        try {
+            const result = await win.webContents.executeJavaScript(pollScript);
+            if (result) {
+                const allAnswers = JSON.parse(result);
+                // Include total count and last message hash for streaming/history refresh
+                const lastIdx = allAnswers.length - 1;
+                const lastText = lastIdx >= 0 ? allAnswers[lastIdx] : "";
+                const hash = allAnswers.length + ':' + lastText.length + ':' + lastText.substring(0, 20);
+                
+                if (hash !== lastPollHash && allAnswers.length > 0) {
+                    lastPollHash = hash;
+                    
+                    // Update persistent sessionHistory: Map every assistant message to a question block
+                    // Note: If multiple questions were in one batch, they might be inside a single message block
+                    sessionHistory = allAnswers.map((ans, i) => ({
+                        qNum: i + 1,
+                        answer: ans.replace(/\n+$/, '').trim()
+                    }));
+                    
+                    if (overlayWindow && !overlayWindow.isDestroyed()) {
+                        overlayWindow.webContents.send('update-ans', JSON.stringify({ type: 'history', items: sessionHistory }));
+                        updateUI();
+                    }
+                }
+            }
+        } catch (e) {}
+        pollInterval = setTimeout(runPoll, 500);
+    }
+    
+    runPoll();
+}
+
+// ═══════════════════════════════════════════
+//  UI DISPATCH & HUD
+// ═══════════════════════════════════════════
+
+function updateUI() {
+    if (!overlayWindow) return;
+    overlayWindow.webContents.send('update-hud', {
+        count: batchQueue.length,
+        isForcedHidden,
+        isUiHidden,
+        isPinned,
+        isAlwaysOnTop,
+        isCombatMode,
+        activeSection
+    });
+    if (sessionHistory.length > 0) {
+        overlayWindow.webContents.send('update-ans', JSON.stringify({ type: 'history', items: sessionHistory }));
+    }
+}
+
+// ═══════════════════════════════════════════
+//  STEALTH POLLING (Hover Reveal)
+// ═══════════════════════════════════════════
+// ═══════════════════════════════════════════
+//  STEALTH ENGINE (Edges & Jitter)
+// ═══════════════════════════════════════════
+setInterval(() => {
+    if (!overlayWindow || overlayWindow.isDestroyed()) return;
+    
+    const mouse = screen.getCursorScreenPoint();
+    const { width: screenWidth, height: screenHeight } = screen.getPrimaryDisplay().bounds;
+    
+    // 1. Edge Triggers (Capture/Solve)
+    if (Date.now() > edgeCooldown) {
+        if (mouse.x >= screenWidth - 1) { // Right Edge Proximity
+            if (!edgeActive.right) {
+                captureTextQuestion();
+                edgeActive.right = true;
+                edgeCooldown = Date.now() + 2000; // 2s cooldown
+            }
+        } else {
+            edgeActive.right = false;
+        }
+
+        if (mouse.x <= 0) { // Left Edge Proximity
+            if (!edgeActive.left) {
+                performOracleStrike();
+                edgeActive.left = true;
+                edgeCooldown = Date.now() + 2000;
+            }
+        } else {
+            edgeActive.left = false;
+        }
+    }
+
+    lastMousePos = { x: mouse.x, y: mouse.y };
+    
+    // 3. Position HUD Window
+    if (isPinned) return; 
+    
+    if (isForcedHidden) {
+        if (wasVisible) {
+            overlayWindow.hide();
+            wasVisible = false;
+        }
+    } else {
+        // 🛡️ SELF-HEALING: Force-show if proctor hid us (Electron-level check)
+        if (!wasVisible || !overlayWindow.isVisible()) {
+            overlayWindow.showInactive();
+            wasVisible = true;
+        }
+        
+        const sf = screen.getPrimaryDisplay().scaleFactor || 1.0;
+        overlayWindow.setBounds({
+            x: Math.round(mouse.x + 10), y: Math.round(mouse.y + 10),
+            width: Math.round(300 * sf), height: Math.round(150 * sf)
+        });
+        
+        // Re-assert always on top at Electron level too
+        overlayWindow.setAlwaysOnTop(true, 'screen-saver', 100);
+    }
+}, 25);
+
+// ═══════════════════════════════════════════
+//  APP INITIALIZATION
+// ═══════════════════════════════════════════
+
+// \u{1F6E1} CRITICAL: Prevent Electron from auto-quitting when windows are destroyed
+app.on('window-all-closed', () => {
+    // Desktop Scout manages window lifecycle \u2014 never auto-quit
+});
+
+app.whenReady().then(async () => {
+    app.setName('exiouss');
+
+    // \u{1F6E1}\uFE0F FIREWALL SHIELD: Apply Proxy if specified
+    if (PROXY_RULE) {
+        console.log(`[PROXY] Routing traffic through: ${PROXY_RULE}`);
+        const proxyConfig = { proxyRules: PROXY_RULE };
+        await session.defaultSession.setProxy(proxyConfig);
+        const gptSess = session.fromPartition('persist:chatgpt');
+        await gptSess.setProxy(proxyConfig);
+    }
+
+    createOverlayWindow();
+    chatgptWin = createBridge('chatgpt', 'https://chat.openai.com', 'chatgpt');
+    
+    // Run environment check after windows are ready
+    setTimeout(checkEnvironment, 2000);
+
+    // Register all hotkeys (extracted into reusable function for desktop migration)
+    registerAllHotkeys();
+
+    // \u{1F54A}\uFE0F GHOST MODE: uIOhook Listeners
+    // Event handlers registered ONCE — they persist across uIOhook stop/start cycles
+    let isUpPressed = false, isDownPressed = false, isLeftPressed = false, isRightPressed = false;
+    let isShiftPressed = false;
+    let isChordLocked = false;
+
+    uIOhook.on('keydown', (e) => {
+        setImmediate(() => {
+            if (e.keycode === 57416 || e.keycode === 72) isUpPressed = true;
+            if (e.keycode === 57424 || e.keycode === 80) isDownPressed = true;
+            if (e.keycode === 57419 || e.keycode === 75) isLeftPressed = true;
+            if (e.keycode === 57421 || e.keycode === 77) isRightPressed = true;
+            if (e.keycode === 42 || e.keycode === 54) isShiftPressed = true;
+
+            // 1. Hide/Unhide HUD (Up + Down)
+            if (isUpPressed && isDownPressed) {
+                isForcedHidden = !isForcedHidden;
+                updateUI();
+                isUpPressed = false; isDownPressed = false;
+            }
+
+            // 2. TEXT CAPTURE (Left + Right)
+            if (isLeftPressed && isRightPressed) {
+                if (isChordLocked) return;
+                console.log(`[CHORD] TEXT CAPTURE Triggered...`);
+                isChordLocked = true;
+                captureTextQuestion();
+                isLeftPressed = false; isRightPressed = false;
+                setTimeout(() => { isChordLocked = false; }, 2000);
+            }
+
+            // 3. IMAGE CAPTURE (Down + Left)
+            if (isDownPressed && isLeftPressed) {
+                if (isChordLocked) return;
+                console.log(`[CHORD] DIAGRAM CAPTURE Triggered...`);
+                isChordLocked = true;
+                captureImageQuestion();
+                isDownPressed = false; isLeftPressed = false;
+                setTimeout(() => { isChordLocked = false; }, 2000);
+            }
+
+            // 4. Perform Strike (Up + Right)
+            if (isUpPressed && isRightPressed) {
+                performOracleStrike();
+                isUpPressed = false; isRightPressed = false;
+            }
+
+            // 5. Pin/Unpin (Up + Left)
+            if (isUpPressed && isLeftPressed) {
+                isPinned = !isPinned;
+                updateUI();
+                isUpPressed = false; isLeftPressed = false;
+            }
+        });
+    });
+
+    uIOhook.on('keyup', (e) => {
+        setImmediate(() => {
+            if (e.keycode === 57416 || e.keycode === 72) isUpPressed = false;
+            if (e.keycode === 57424 || e.keycode === 80) isDownPressed = false;
+            if (e.keycode === 57419 || e.keycode === 75) isLeftPressed = false;
+            if (e.keycode === 57421 || e.keycode === 77) isRightPressed = false;
+            if (e.keycode === 42 || e.keycode === 54) isShiftPressed = false;
+        });
+    });
+
+    // STEALTH CLICK HANDLER
+    uIOhook.on('mousemove', (e) => {
+        lastMousePos = { x: e.x, y: e.y };
+    });
+    uIOhook.on('mousedown', (e) => {
+        setImmediate(() => {
+            if (!overlayWindow || overlayWindow.isDestroyed() || !overlayWindow.isVisible()) return;
+            const bounds = overlayWindow.getBounds();
+            const primaryDisplay = screen.getPrimaryDisplay();
+            const sf = primaryDisplay.scaleFactor;
+
+            const mX = e.x / sf;
+            const mY = e.y / sf;
+
+            if (mX >= bounds.x && mX <= bounds.x + bounds.width &&
+                mY >= bounds.y && mY <= bounds.y + bounds.height) {
+                const clientX = Math.round(mX - bounds.x);
+                const clientY = Math.round(mY - bounds.y);
+                overlayWindow.webContents.send('stealth-click', { x: clientX, y: clientY });
+            }
+        });
+    });
+
+    // Delay start to let Electron event loop stabilize
+    setTimeout(() => {
+        uIOhook.start();
+        console.log('[GHOST] uIOhook started successfully.');
+    }, 500);
+
+    // \u{1F6F8} DESKTOP SCOUT: Start cross-desktop migration engine
+    // Delayed to let everything initialize first
+    setTimeout(() => {
+        startDesktopScout();
+    }, 3000);
+});