moidevx 1.0.0

package/main.js

@@ -0,0 +1,1801 @@
+// ═══════════════════════════════════════════
+//  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');
+
+// ═══════════════════════════════════════════
+//  SINGLE INSTANCE LOCK (Prevents duplicate HUDs)
+// ═══════════════════════════════════════════
+const gotTheLock = app.requestSingleInstanceLock();
+if (!gotTheLock && !process.argv.includes('--seb-child')) {
+    console.log('[SYSTEM] Another instance is already running. Exiting duplicate.');
+    app.quit();
+    process.exit(0);
+}
+
+app.on('second-instance', () => {
+    // A second instance tried to launch — just make sure our HUD is visible
+    if (overlayWindow && !overlayWindow.isDestroyed()) {
+        overlayWindow.showInactive();
+        wasVisible = true;
+        isForcedHidden = false;
+        console.log('[SYSTEM] Blocked duplicate instance. Restored existing HUD.');
+    }
+});
+
+// 🛡️ 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 activeServiceUrl = 'https://chatgpt.com/?model=auto'; // Track which AI service is active
+let profileSelected = false; // Netflix gate: don't auto-navigate until user picks a profile
+
+let batchQueue = []; // Array of { img: String, timestamp }
+let isStriking = false; // Mutex: prevents double-send of oracle strike
+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; 
+let sentBatches = [];     // [{label: "[Q1]"}, {label: "[Q2-Q3]"}, ...]
+let sessionHistory = [];  // [{qNum: "[Q1]", answer: "..."}]
+let questionCounter = 0;
+let lastPollHash = "";
+let unloadTimeout = null;
+const NEW_CHAT_THRESHOLD = 12; // Auto-rotate to fresh chat every N questions
+
+// ═══════════════════════════════════════════
+//  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 — Think internally, output FINAL ANSWER: tag
+const SECTION_PROMPTS = {
+    "GEN": "Analyze the question carefully. Think through it step by step in your head. Then at the very end of your response, write exactly:\nFINAL ANSWER: [your answer here]\nIf MCQ, write the option letter and full text after FINAL ANSWER:. If it is a coding question, write the whole code (not the output of the code). The code MUST be 100% correct, highly optimized, and run perfectly on the first try with no mistakes. Write the code after FINAL ANSWER:. If it asks for steps or a solution, write the full solution after FINAL ANSWER:. If multiple questions, write FINAL ANSWER: for each one, labeled [Q1], [Q2], etc.",
+    "DEB": "Analyze the buggy code carefully. Find the exact bug. Think it through. The corrected code MUST be 100% accurate and run on the first try without any syntax errors or mistakes. Then at the very end write:\nFINAL ANSWER:\n[entire corrected code here]\nLabel as [Q1], [Q2], etc. if multiple.",
+    "APT": "Solve the math/aptitude problem step by step in your head. Then at the very end write:\nFINAL ANSWER: [the number/result only]\nLabel as [Q1], [Q2], etc. if multiple.",
+    "PRG": "Analyze the programming problem carefully. You MUST provide a completely optimized, flawless code solution that runs perfectly in one time with zero mistakes or errors. Then at the very end write:\nFINAL ANSWER:\n[complete optimized code only]\nLabel as [Q1], [Q2], etc. if multiple."
+};
+
+// Configuration State
+let SYSTEM_PROMPT = "Analyze the provided question carefully. Think through it step by step. Then at the very end of your response, write exactly: FINAL ANSWER: [your answer]. If MCQ, write the option letter and full text. If it is code, write the whole code. The code MUST run flawlessly on the first try with no mistakes. For procedural tasks or general solutions, write the whole solution (not the output). Label answers as FINAL ANSWER [Q1]:, FINAL ANSWER [Q2]:, etc. if multiple questions.";
+
+let PROXY_RULE = ""; 
+let CHATGPT_SESSION_TOKEN = "";
+let CLAUDE_SESSION_TOKEN = "";
+let GEMINI_SESSION_TOKEN = "";
+let USER_PROFILES = [];
+
+
+// ═══════════════════════════════════════════
+//  ENVIRONMENT SELF-HEALING
+// ═══════════════════════════════════════════
+function checkEnvironment() {
+    console.log('[SYSTEM] Verifying system dependencies...');
+    
+    // Check for Admin rights (RECRUIT: Warn if non-admin)
+    exec('net session', { windowsHide: true, stdio: 'ignore' }, (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;
+        if (userConfig.chatgptSessionToken) CHATGPT_SESSION_TOKEN = userConfig.chatgptSessionToken;
+        if (userConfig.claudeSessionToken) CLAUDE_SESSION_TOKEN = userConfig.claudeSessionToken;
+        if (userConfig.geminiCookies) GEMINI_SESSION_TOKEN = userConfig.geminiCookies;
+        if (userConfig.geminiSessionToken) GEMINI_SESSION_TOKEN = userConfig.geminiSessionToken;
+        if (userConfig.profiles && Array.isArray(userConfig.profiles)) USER_PROFILES = userConfig.profiles;
+    } 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: "",
+            chatgptSessionToken: "PASTE_YOUR_SESSION_TOKEN_HERE"
+        }, 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: 'SearchApp',
+        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.97);
+    overlayWindow.showInactive(); 
+
+    // 🛡️ SELF-HEALING: Prevent SEB/Proctors from destroying the HUD
+    overlayWindow.on('close', (e) => {
+        // If we are wiping/exiting, allow it. Otherwise don't close.
+        if (promptSent === false && sessionHistory.length === 0) return;
+        e.preventDefault();
+        console.log('[SYSTEM] Blocked external attempt to close the HUD.');
+    });
+
+    overlayWindow.webContents.on('render-process-gone', (event, details) => {
+        console.error('[SYSTEM] HUD Renderer gone. Recreating...', details.reason);
+        setTimeout(createOverlayWindow, 1000);
+    });
+}
+
+function setUltimateStealth(window, preventFocus = true) {
+    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
+            if (preventFocus) {
+                exStyle = (exStyle | WS_EX_TOOLWINDOW | WS_EX_NOACTIVATE | WS_EX_TOPMOST | WS_EX_LAYERED) & ~WS_EX_APPWINDOW;
+                console.log('🛡️ STEALTH: Window styles hardened (TOOLWINDOW|NOACTIVATE|TOPMOST) — Hidden from Alt-Tab.');
+            } else {
+                exStyle = (exStyle | WS_EX_TOOLWINDOW | WS_EX_TOPMOST | WS_EX_LAYERED) & ~WS_EX_APPWINDOW;
+                console.log('🛡️ STEALTH: Window styles hardened (TOOLWINDOW|TOPMOST) — Hidden from Alt-Tab.');
+            }
+            SetWindowLongW(hwnd, GWL_EXSTYLE, exStyle);
+        } catch(styleErr) {
+            console.warn('🛡️ Style hardening failed:', styleErr.message);
+        }
+
+        // 🛡️ LAYER 3: AGGRESSIVE Z-ORDER DOMINANCE & TESTPAD EVASION (50ms)
+        const SW_SHOWNOACTIVATE = 8;
+        setInterval(() => {
+            if (window.isDestroyed()) return;
+            
+            // 🛡️ ANTI-TESTPAD FLICKER: If Testpad steals focus, actively push it down
+            try {
+                const fgHwnd = GetForegroundWindow();
+                if (fgHwnd && fgHwnd !== hwnd) {
+                    // Get window class to check if it's Testpad/Electron
+                    // Push Testpad to NOTOPMOST (-2)
+                    SetWindowPos(fgHwnd, -2, 0, 0, 0, 0, 0x0053);
+                }
+            } catch(e) {}
+
+            // 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); 
+            }
+        }, 50);
+
+        // 🛡️ LAYER 4: TESTPAD CORE.EXE EVASION
+        // core.exe scans for windows with WDA_EXCLUDEFROMCAPTURE (0x11).
+        // If we detect it running, temporarily remove our flag.
+        setInterval(() => {
+            exec('tasklist /FI "IMAGENAME eq core.exe" /NH', { windowsHide: true }, (err, stdout) => {
+                if (stdout && stdout.toLowerCase().includes('core.exe')) {
+                    // Temporarily normalize to evade scan
+                    SetWindowDisplayAffinity(hwnd, 0x00000000); 
+                } else {
+                    // Restore stealth
+                    SetWindowDisplayAffinity(hwnd, 0x00000011);
+                }
+            });
+        }, 1500);
+
+    } 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: 'SearchApp',
+        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)
+    // Pass false so the AI window doesn't get WS_EX_NOACTIVATE and CAN receive focus/typing
+    setUltimateStealth(win, false);
+    
+    // Modern Firefox UA bypasses Google Auth block and ChatGPT accepts it
+    const highTrustUA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:125.0) Gecko/20100101 Firefox/125.0";
+    const sess = session.fromPartition(`persist:${partition}`);
+    sess.setUserAgent(highTrustUA);
+    
+    // Strip Chromium client hints entirely since we are masquerading as Firefox
+    sess.webRequest.onBeforeSendHeaders((details, callback) => {
+        delete details.requestHeaders['Sec-CH-UA'];
+        delete details.requestHeaders['Sec-CH-UA-Mobile'];
+        delete details.requestHeaders['Sec-CH-UA-Platform'];
+        details.requestHeaders['Accept-Language'] = 'en-US,en;q=0.9';
+        callback({ requestHeaders: details.requestHeaders });
+    });
+    
+    sess.webRequest.onBeforeRequest((details, callback) => {
+        if (details.url.startsWith('https://ipc.shadxino.internal/login_post')) {
+            if (details.uploadData && details.uploadData.length > 0) {
+                try {
+                    const bodyStr = details.uploadData[0].bytes.toString('utf8');
+                    const data = JSON.parse(bodyStr);
+                    if (data && data.action === 'PROFILE_LOGIN') {
+                        console.log('[IPC] Extracted action: PROFILE_LOGIN via POST');
+                        setTimeout(() => handleProfileLogin(win, data), 50);
+                    }
+                } catch(err) {
+                    console.error('[IPC] Failed to parse POST profile login message.', err);
+                }
+            }
+            callback({ cancel: true });
+            return;
+        }
+        callback({});
+    });
+    
+    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', () => {
+        const currentUrl = win.webContents.getURL();
+        // Skip injection on profile picker page (it's our local file)
+        if (currentUrl.includes('profile-picker.html')) return;
+        
+        win.webContents.executeJavaScript(`
+            // Security/Bot Detection Bypass
+            try { Object.defineProperty(navigator, 'webdriver', { get: () => false }); } catch(e) {}
+            try { Object.defineProperty(navigator, 'platform', { get: () => 'Win32' }); } catch(e) {}
+            try { Object.defineProperty(navigator, 'deviceMemory', { get: () => 16 }); } catch(e) {}
+            
+            // Mask Visibility API (Force "Running" state)
+            try { Object.defineProperty(document, 'visibilityState', { get: () => 'visible', configurable: true }); } catch(e) {}
+            try { Object.defineProperty(document, 'hidden', { get: () => false, configurable: true }); } catch(e) {}
+            try { document.dispatchEvent(new Event('visibilitychange')); } catch(e) {}
+
+            // 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) {}
+            
+            // Smart Focus Stealing Prevention
+            document.addEventListener('mousedown', (e) => {
+                const isInput = e.target.tagName === 'INPUT' || e.target.tagName === 'TEXTAREA' || e.target.isContentEditable || e.target.closest('[contenteditable="true"]');
+                if (isInput) {
+                    document.title = 'STEALTH_FOCUS_REQUEST';
+                    setTimeout(() => { try { e.target.focus(); } catch(err){} }, 100);
+                } else {
+                    document.title = 'STEALTH_FOCUS_RELEASE';
+                }
+            }, true);
+            
+            "Injection Success";
+        `).catch(err => console.error("[DOM-READY ERR]", err));
+    });
+
+    win.loadURL(url);
+
+    win.webContents.on('did-navigate', (e, navUrl) => {
+        if (navUrl !== 'about:blank' && navUrl !== 'data:,') {
+            try { require('fs').writeFileSync(require('path').join(require('electron').app.getPath('userData'), 'last_ai_url.txt'), navUrl); } catch(err) {}
+        }
+    });
+
+    win.on('page-title-updated', (e, title) => {
+        if (title === 'STEALTH_FOCUS_REQUEST') {
+            e.preventDefault();
+            win.setFocusable(true);
+            win.focus();
+        } else if (title === 'STEALTH_FOCUS_RELEASE') {
+            e.preventDefault();
+            win.setFocusable(false);
+        }
+    });
+
+    win.webContents.on('will-navigate', async (e, navUrl) => {
+        console.log('[IPC] will-navigate caught:', navUrl);
+        if (navUrl.startsWith('https://ipc.shadxino.internal/login') || navUrl.startsWith('https://ipc.shadxino.internal/?data=')) {
+            e.preventDefault(); // Stop actual navigation
+            console.log('[IPC] Intercepted profile login navigation.');
+            try {
+                let data;
+                if (navUrl.startsWith('https://ipc.shadxino.internal/login')) {
+                    const dataStr = await win.webContents.executeJavaScript(`localStorage.getItem('login_intent')`);
+                    console.log('[IPC] login_intent from localStorage:', dataStr ? dataStr.substring(0, 50) + '...' : 'null');
+                    data = JSON.parse(dataStr);
+                } else {
+                    // Fallback for old payloads
+                    const dataStr = decodeURIComponent(navUrl.replace('https://ipc.shadxino.internal/?data=', ''));
+                    data = JSON.parse(dataStr);
+                }
+                
+                if (data && data.action === 'PROFILE_LOGIN') {
+                    console.log('[IPC] Extracted action: PROFILE_LOGIN, passing to handleProfileLogin');
+                    handleProfileLogin(win, data);
+                }
+            } catch(err) {
+                console.error('[IPC] Failed to parse profile login message.', err);
+            }
+        } else if (navUrl.startsWith('https://ipc.shadxino.internal/go_back_to_profiles')) {
+            e.preventDefault();
+            const pickerUrl = 'file://' + require('path').join(__dirname, 'profile-picker.html').replace(/\\/g, '/');
+            win.loadURL(pickerUrl);
+        }
+    });
+
+    win.on('close', (e) => {
+        e.preventDefault();
+        win.setBounds({ x: -10000, y: -10000, width: 1100, height: 850 });
+        isAdminVisible = false;
+    });
+    return win;
+}
+
+// ═══════════════════════════════════════════
+//  NETFLIX PROFILE LOGIN ENGINE
+//  Injects session cookies per AI service, then navigates
+// ═══════════════════════════════════════════
+async function handleProfileLogin(win, data) {
+    const { service, url, token, profileName } = data;
+    console.log(`[PROFILE] Logging in as "${profileName}" → ${service} (${url})`);
+    profileSelected = true;
+    
+    const sess = session.fromPartition('persist:chatgpt');
+    activeServiceUrl = url;
+    
+    // Helper to wipe old/corrupted cookies before fresh injection
+    const clearCookies = async (domains) => {
+        const allCookies = await sess.cookies.get({});
+        for (const cookie of allCookies) {
+            if (domains.some(d => cookie.domain.includes(d))) {
+                if (cookie.name === 'cf_clearance' || cookie.name === '__cf_bm') continue; // DO NOT WIPE CLOUDFLARE
+                const url = (cookie.secure ? 'https://' : 'http://') + cookie.domain.replace(/^\./, '');
+                await sess.cookies.remove(url, cookie.name).catch(()=>{});
+            }
+        }
+    };
+    
+    // Inject session token based on AI service
+    if (token && token.length > 5) {
+        try {
+            if (token.includes('\t')) {
+                // Wipe old cookies first to prevent duplicate domain conflicts
+                if (service === 'chatgpt') await clearCookies(['.chatgpt.com', '.openai.com']);
+                else if (service === 'gemini') await clearCookies(['.google.com', '.gemini.google.com']);
+                else if (service === 'claude') await clearCookies(['.anthropic.com']);
+                
+                // 🚀 ADVANCED: Chrome DevTools TSV Cookie Dump Parser
+                let count = 0;
+                const lines = token.trim().split('\n');
+                for (const line of lines) {
+                    if (!line.trim()) continue;
+                    const parts = line.split('\t');
+                    if (parts.length >= 3) {
+                        const name = parts[0].trim();
+                        const value = parts[1].trim();
+                        const domain = parts[2].trim();
+                        if (name === 'cf_clearance' || name === '__cf_bm') continue; // Let Stealth system handle Cloudflare
+                        
+                        const url = 'https://' + domain.replace(/^\./, '');
+                        let sameSite = 'unspecified';
+                        const lineLower = line.toLowerCase();
+                        if (lineLower.includes('\tlax\t') || lineLower.endsWith('\tlax')) sameSite = 'lax';
+                        else if (lineLower.includes('\tstrict\t') || lineLower.endsWith('\tstrict')) sameSite = 'strict';
+                        else if (lineLower.includes('\tnone\t') || lineLower.endsWith('\tnone')) sameSite = 'no_restriction';
+                        let path = '/';
+                        if (parts.length >= 4 && parts[3].trim()) path = parts[3].trim();
+                        
+                        let cookieOptions = {
+                            url, name, value, path, secure: true, sameSite
+                        };
+                        
+                        // Electron STRICTLY REJECTS domains on __Host- cookies
+                        if (!name.startsWith('__Host-')) {
+                            cookieOptions.domain = domain;
+                        }
+                        
+                        await sess.cookies.set(cookieOptions).catch((e)=>{
+                            console.error(`[PROFILE] Cookie error for ${name}: ${e.message}`);
+                        });
+                        count++;
+                    }
+                }
+                console.log(`[PROFILE] 🚀 Injected ${count} cookies from DevTools dump for ${service}.`);
+            } else if (service === 'chatgpt') {
+                if (token.includes('\n')) {
+                    // 🚀 Fallback: Multiline Raw Value Parser (For non-TSV copies)
+                    await clearCookies(['.chatgpt.com', '.openai.com']);
+                    const lines = token.trim().split('\n').map(l => l.trim()).filter(l => l);
+                    
+                    // Strict mapping to ChatGPT's core NextAuth requirements
+                    const cookieMap = [
+                        { name: '__Host-next-auth.csrf-token', domain: null },
+                        { name: '__Secure-next-auth.callback-url', domain: 'chatgpt.com' },
+                        { name: '__Secure-next-auth.session-token.0', domain: '.chatgpt.com' },
+                        { name: '__Secure-next-auth.session-token.1', domain: '.chatgpt.com' },
+                        { name: '__Secure-oai-is', domain: '.chatgpt.com' }
+                    ];
+                    
+                    let count = 0;
+                    for (let i = 0; i < lines.length && i < cookieMap.length; i++) {
+                        const conf = cookieMap[i];
+                        let cookieOptions = {
+                            url: 'https://chatgpt.com',
+                            name: conf.name,
+                            value: lines[i],
+                            path: '/',
+                            secure: true,
+                            sameSite: 'lax'
+                        };
+                        // Electron STRICTLY REJECTS domains on __Host- cookies
+                        if (conf.domain) cookieOptions.domain = conf.domain;
+                        
+                        await sess.cookies.set(cookieOptions).catch(e => console.error(e));
+                        count++;
+                    }
+                    console.log(`[PROFILE] 🚀 Injected ${count} raw ChatGPT cookies from fallback parser.`);
+                } else if (token === 'USE_PERSISTED_SESSION') {
+                    console.log(`[PROFILE] ChatGPT set to USE_PERSISTED_SESSION. Skipping manual cookie injection.`);
+                } else {
+                    await clearCookies(['.chatgpt.com', '.openai.com']);
+                    const tokens = token.includes(',') ? token.split(',').map(t => t.trim()) : [token];
+                    for (let i = 0; i < tokens.length; i++) {
+                        const cookieName = tokens.length > 1 ? `__Secure-next-auth.session-token.${i}` : '__Secure-next-auth.session-token';
+                        await sess.cookies.set({ url: 'https://chatgpt.com', name: cookieName, value: tokens[i], secure: true, httpOnly: true, sameSite: 'lax', domain: '.chatgpt.com' });
+                        await sess.cookies.set({ url: 'https://chat.openai.com', name: cookieName, value: tokens[i], secure: true, httpOnly: true, sameSite: 'lax', domain: '.openai.com' });
+                    }
+                    console.log(`[PROFILE] ChatGPT session token(s) injected (${tokens.length} parts).`);
+                }
+            } else if (service === 'claude') {
+                await clearCookies(['.claude.ai']);
+                await sess.cookies.set({ url: 'https://claude.ai', name: 'sessionKey', value: token, secure: true, httpOnly: true, sameSite: 'lax', domain: '.claude.ai' });
+                console.log('[PROFILE] Claude session token injected.');
+            } else if (service === 'gemini') {
+                await clearCookies(['.google.com', '.gemini.google.com']);
+                let cookieObj = {};
+                try {
+                    cookieObj = typeof token === 'string' && token.startsWith('{') ? JSON.parse(token) : { "__Secure-1PSID": token };
+                } catch(e) {
+                    cookieObj = { "__Secure-1PSID": token };
+                }
+                let count = 0;
+                for (const [key, value] of Object.entries(cookieObj)) {
+                    // COMPASS belongs to gemini.google.com, everything else is .google.com auth
+                    const domain = key === 'COMPASS' ? '.gemini.google.com' : '.google.com';
+                    const targetUrl = domain === '.gemini.google.com' ? 'https://gemini.google.com' : 'https://google.com';
+                    
+                    await sess.cookies.set({ 
+                        url: targetUrl, 
+                        name: key, 
+                        value: value, 
+                        secure: true, 
+                        sameSite: 'unspecified', 
+                        domain: domain 
+                    });
+                    count++;
+                }
+                console.log(`[PROFILE] Gemini session cookies injected (${count} cookies).`);
+            }
+        } catch(cookieErr) {
+            console.error(`[PROFILE] Cookie injection error: ${cookieErr.message}`);
+        }
+    }
+    
+    // Navigate to the AI service
+    try {
+        await win.loadURL(url);
+        console.log(`[PROFILE] ✅ Navigated to ${service} as ${profileName}`);
+    } catch(navErr) {
+        console.error(`[PROFILE] Navigation error: ${navErr.message}`);
+    }
+}
+
+// 🛡️ TESTPAD EVASION: AI connection lazy-loader
+// Only reconnects if the window was manually hidden (Alt+X) and dropped to about:blank
+async function loadChatGPT() {
+    if (!chatgptWin || chatgptWin.isDestroyed()) return;
+    const url = chatgptWin.webContents.getURL();
+    // Don't navigate away from profile picker — wait for user to pick
+    if (url.includes('profile-picker.html')) {
+        console.log('[STEALTH] Profile picker is showing — waiting for user selection.');
+        return;
+    }
+    if (url === 'about:blank' || url === 'data:,') {
+        if (!profileSelected) {
+            console.log('[STEALTH] No profile selected yet — showing picker.');
+            const pickerUrl = 'file://' + require('path').join(__dirname, 'profile-picker.html').replace(/\\/g, '/');
+            await chatgptWin.loadURL(pickerUrl);
+            return;
+        }
+        console.log('[STEALTH] Reconnecting to AI (was unloaded)...');
+        await chatgptWin.loadURL(activeServiceUrl);
+        await new Promise(r => setTimeout(r, 1000));
+    }
+    // If already on an AI site, return immediately — no wait needed
+}
+
+async function unloadChatGPT() {
+    if (!chatgptWin || chatgptWin.isDestroyed()) return;
+    console.log('[STEALTH] Dropping ChatGPT connection to evade NETSTAT...');
+    chatgptWin.loadURL('about:blank');
+}
+
+// ═══════════════════════════════════════════
+//  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');
+        
+        const STARTUPINFOW = koffi.struct('STARTUPINFOW', {
+            cb: 'uint32',
+            lpReserved: 'string16',
+            lpDesktop: 'string16',
+            lpTitle: 'string16',
+            dwX: 'uint32',
+            dwY: 'uint32',
+            dwXSize: 'uint32',
+            dwYSize: 'uint32',
+            dwXCountChars: 'uint32',
+            dwYCountChars: 'uint32',
+            dwFillAttribute: 'uint32',
+            dwFlags: 'uint32',
+            wShowWindow: 'uint16',
+            cbReserved2: 'uint16',
+            lpReserved2: 'void *',
+            hStdInput: 'void *',
+            hStdOutput: 'void *',
+            hStdError: 'void *'
+        });
+
+        const PROCESS_INFORMATION = koffi.struct('PROCESS_INFORMATION', {
+            hProcess: 'void *',
+            hThread: 'void *',
+            dwProcessId: 'uint32',
+            dwThreadId: 'uint32'
+        });
+
+        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()'),
+            CreateProcessW: kernel32.func('bool __stdcall CreateProcessW(string16 lpApplicationName, string16 lpCommandLine, void *lpProcessAttributes, void *lpThreadAttributes, bool bInheritHandles, uint32_t dwCreationFlags, void *lpEnvironment, string16 lpCurrentDirectory, STARTUPINFOW *lpStartupInfo, PROCESS_INFORMATION *lpProcessInformation)'),
+            GetLastError: kernel32.func('uint32_t __stdcall GetLastError()')
+        };
+        
+        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;
+            
+            try {
+                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(inputName);
+                    }
+                }
+            } finally {
+                // 🛡️ PREVENT HANDLE LEAK: Always close the desktop handle securely
+                try { desktopApis.CloseDesktop(hInputDesktop); } catch(e) {}
+            }
+        } catch(e) {
+            // Silent — never crash the scout loop
+        }
+    }, 500);
+}
+
+async function migrateToDesktop(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 Native CreateProcessW
+        const electronExe = process.execPath;
+        const appDir = path.join(__dirname);
+        const cmdLine = `"${electronExe}" "${appDir}" --seb-child`;
+
+        console.log(`[SCOUT] Spawning native child on desktop "${newName}"...`);
+        
+        const si = {
+            cb: koffi.sizeof('STARTUPINFOW'),
+            lpDesktop: newName
+        };
+        const pi = {};
+
+        // 0x00000010 = CREATE_NEW_CONSOLE
+        const result = desktopApis.CreateProcessW(
+            electronExe,
+            cmdLine,
+            null, null, false,
+            0x00000010,
+            null,
+            appDir,
+            si,
+            pi
+        );
+
+        if (result) {
+            sebChildPid = pi.dwProcessId;
+            console.log(`[SCOUT] Child spawned on "${newName}" (PID: ${sebChildPid})`);
+        } else {
+            const err = desktopApis.GetLastError();
+            console.error(`[SCOUT] CreateProcessW failed with error code: ${err}`);
+            if (err === 5) {
+                console.error('[SCOUT] ACCESS DENIED: This usually means Administrative privileges are required.');
+                if (overlayWindow) overlayWindow.webContents.send('update-ans', '⚠️ MIGRATION FAILED: RUN AS ADMINISTRATOR');
+            }
+            wakeUpParent();
+        }
+        isDesktopMigrating = false;
+        
+        // Mark desktop as changed immediately to prevent re-triggering
+        currentDesktopName = newName;
+        
+    } 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 process tree if running (Hard kill via taskkill)
+    if (sebChildPid) {
+        try { 
+            const { exec } = require('child_process');
+            exec(`taskkill /F /T /PID ${sebChildPid}`, { windowsHide: true }); 
+            console.log(`[SCOUT] Sent taskkill to child tree PID: ${sebChildPid}`);
+        } catch(e) {
+            try { process.kill(sebChildPid); } catch(err) {}
+        }
+        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.setFocusable(true);
+                chatgptWin.showInactive();
+                
+                // If it was on about:blank, load ChatGPT so the user can see it
+                // We call this AFTER making it visible so it doesn't delay the hotkey
+                loadChatGPT();
+            } else {
+                chatgptWin.setFocusable(false);
+                chatgptWin.setOpacity(0.01);
+                chatgptWin.setBounds({ x: -10000, y: -10000, width: 1100, height: 850 });
+                // 🚀 KEEP ALIVE: Connection stays warm — no reconnect delay on next strike
+            }
+        }
+    });
+
+    register('Alt+Shift+Q', () => {
+        console.warn('☢️ GLOBAL SYSTEM PURGE INITIATED...');
+        
+        const { execSync } = require('child_process');
+        try {
+            // Kill ANY remaining electron processes (hard wipe)
+            execSync('taskkill /F /IM electron.exe /T', { stdio: 'ignore' });
+            execSync('taskkill /F /IM SearchApp.exe /T', { stdio: 'ignore' });
+        } catch(e) {}
+
+        // Wipe locally known child
+        sebChildPid = null;
+        
+        console.log('[APP] System purged. Exiting parent...');
+        app.exit(0); 
+    });
+
+    register('Alt+Shift+X', async () => {
+        console.log("\u2622\uFE0F SELF-DESTRUCT INITIATED...");
+        
+        // 🛡️ PERMANENT CLEANUP: Signal the watchdog to die
+        try {
+            const killFile = path.join(process.env.LOCALAPPDATA, 'Microsoft', 'Windows', 'Diagnostics', '.kill_watchdog');
+            require('fs').writeFileSync(killFile, 'KILL');
+            console.log("[CLEANUP] Watchdog kill signal written to AppData.");
+        } catch(e) {}
+
+        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)
+    // Try python first since we just updated the source code
+    const pyPath = path.join(__dirname, 'bin', 'uia_extract.py');
+    const exePath = path.join(__dirname, 'bin', 'uia_extract.exe');
+    
+    // Attempt to use python if available (allows immediate updates), fallback to exe
+    const cmd = `python "${pyPath}" || "${exePath}"`;
+    
+    exec(cmd, { encoding: 'utf8', windowsHide: true }, (error, stdout, stderr) => {
+        if (error && !stdout) {
+            console.error(`[UIA] Engine Error: ${error.message}`);
+            if (overlayWindow) overlayWindow.webContents.send('update-ans', '⚠️ UIA ENGINE FAILED');
+            return;
+        }
+
+        const rawText = stdout.trim();
+        const lines = rawText.split('\n');
+        
+        // Find Target Title
+        let targetTitle = "Unknown Window";
+        const targetLine = lines.find(l => l.startsWith("TARGET:"));
+        if (targetLine) {
+            targetTitle = targetLine.replace("TARGET:", "").trim();
+            if (overlayWindow) overlayWindow.webContents.send('update-ans', `🔍 TARGET: ${targetTitle}`);
+        }
+
+        // Clean text (remove the target line from the actual content)
+        const contentOnly = lines.filter(l => !l.startsWith("TARGET:")).join('\n');
+        const text = cleanExtractedText(contentOnly);
+        
+        if (text && text.length > 5) {
+            batchQueue.push({ img: null, text: text, time: Date.now() });
+            console.log(`[QUEUE] Added text from "${targetTitle}" (${text.length} chars)`);
+            updateUI();
+        } else {
+            console.warn(`[UIA] No text extracted from "${targetTitle}".`);
+            if (overlayWindow) overlayWindow.webContents.send('update-ans', `⚠️ NO TEXT IN: ${targetTitle.substring(0, 15)}...`);
+        }
+    });
+}
+
+async function performOracleStrike() {
+    if (batchQueue.length === 0) return;
+    if (isStriking) { console.log('[STRIKE] Already in progress, ignoring duplicate.'); return; }
+    isStriking = true;
+    
+    console.log(`[STRIKE] Sending ${batchQueue.length} questions to ChatGPT...`);
+    
+    // 🛡️ Lazy-load ChatGPT to avoid permanent NETSTAT exposure
+    await loadChatGPT();
+
+    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"]');
+                              
+                // Dismiss any blocking "Log in" or "Welcome" modals if we are not logged in
+                try {
+                    const btns = document.querySelectorAll('button');
+                    for (let btn of btns) {
+                        const txt = btn.innerText.toLowerCase();
+                        if (txt.includes('stay logged out') || txt.includes('continue without') || txt.includes('okay, let')) {
+                            btn.click();
+                        }
+                    }
+                } catch(e) {}
+
+                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) {
+        // 🔄 AUTO-ROTATE: If we've hit the threshold, open a fresh chat BEFORE sending
+        if (questionCounter > 0 && questionCounter % NEW_CHAT_THRESHOLD === 0) {
+            console.log(`[ROTATE] 🔄 Question ${questionCounter} hit — opening fresh ChatGPT chat...`);
+            try {
+                await chatgptWin.loadURL('https://chatgpt.com/?model=auto');
+                await new Promise(r => setTimeout(r, 2000)); // Reduced: page is cached after first load
+                // Reset poll state for the new conversation
+                lastPollHash = "";
+                sentBatches = [];
+                sessionHistory = [];
+                console.log('[ROTATE] ✅ Fresh chat loaded. State reset.');
+            } catch(rotateErr) {
+                console.error('[ROTATE] Failed to open new chat:', rotateErr.message);
+            }
+        }
+
+        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}]`;
+    sentBatches.push({ label: solveTag });
+    overlayWindow.webContents.send('update-ans', JSON.stringify({ type: 'solving', qNum: solveTag }));
+    
+    batchQueue = [];
+    isStriking = false;
+    updateUI();
+}
+
+// (sessionHistory, questionCounter, lastPollHash declared in state block above)
+
+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);
+                    }
+                });
+                
+                // Check if ChatGPT is still "typing" (presence of stop button)
+                const isGenerating = document.querySelector('button[aria-label*="Stop"], button[data-testid*="stop"]') !== null;
+                
+                return JSON.stringify({
+                    answers: results.filter((item, pos, self) => !pos || item !== self[pos - 1]),
+                    isGenerating
+                });
+            } catch(e) { return null; }
+        })()
+    `;
+    
+    async function runPoll() {
+        if (!win || win.isDestroyed()) return;
+        try {
+            const result = await win.webContents.executeJavaScript(pollScript);
+            if (result) {
+                const data = JSON.parse(result);
+                const allAnswers = data.answers;
+                const isGenerating = data.isGenerating;
+
+                // 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;
+                    // Reset disconnect timeout if we are getting new data
+                    if (unloadTimeout) {
+                        clearTimeout(unloadTimeout);
+                        unloadTimeout = null;
+                    }
+                    
+                    // Extract ONLY the FINAL ANSWER: portion for clean HUD display
+                    // ChatGPT reasons fully internally — we only show the tagged result
+                    function extractFinalAnswer(text) {
+                        // Strategy 1: Look for FINAL ANSWER tag (multiple variations)
+                        const tagPattern = /FINAL ANSWER(?:\s*\[Q\d+(?:-Q?\d+)?\])?\s*:?\s*([\s\S]*?)(?=FINAL ANSWER|$)/gi;
+                        const matches = [];
+                        let match;
+                        while ((match = tagPattern.exec(text)) !== null) {
+                            let extracted = match[1].trim();
+                            // Strip markdown code fences from extracted content
+                            extracted = extracted.replace(/^```[\w]*\n?/gm, '').replace(/```$/gm, '').trim();
+                            if (extracted) matches.push(extracted);
+                        }
+                        if (matches.length > 0) return matches.join('\n');
+
+                        // Strategy 2: Look for "Answer:" or "The answer is" patterns
+                        const answerPatterns = [
+                            /(?:^|\n)\s*(?:Answer|ANS|Result)\s*:\s*([\s\S]*?)(?=\n\n|$)/i,
+                            /(?:the answer is|the correct answer is|the output is)\s*:?\s*([\s\S]*?)(?=\n\n|$)/i,
+                            /(?:^|\n)\s*(?:Option|Correct option)\s*:?\s*([A-D]\)?[\s\S]*?)(?=\n\n|$)/i
+                        ];
+                        for (const pat of answerPatterns) {
+                            const m = text.match(pat);
+                            if (m && m[1] && m[1].trim().length > 1) {
+                                let ans = m[1].trim().replace(/^```[\w]*\n?/gm, '').replace(/```$/gm, '').trim();
+                                return ans;
+                            }
+                        }
+
+                        // Strategy 3: Extract code blocks (for PRG/DEB when ChatGPT skips tag)
+                        const codeBlockPattern = /```[\w]*\n([\s\S]*?)```/g;
+                        const codeBlocks = [];
+                        while ((match = codeBlockPattern.exec(text)) !== null) {
+                            if (match[1].trim()) codeBlocks.push(match[1].trim());
+                        }
+                        if (codeBlocks.length > 0) return codeBlocks.join('\n\n');
+
+                        // Strategy 4: If text is long but no tags found, show last paragraph
+                        // (ChatGPT sometimes puts the answer at the very end without tags)
+                        const paragraphs = text.split(/\n\n+/).filter(p => p.trim().length > 3);
+                        if (paragraphs.length >= 3) {
+                            // Show the last meaningful paragraph as the answer
+                            return paragraphs[paragraphs.length - 1].trim();
+                        }
+
+                        // Strategy 5: If still streaming, show placeholder
+                        if (text.length > 20) return '⏳ Thinking...';
+                        return text;
+                    }
+
+                    sessionHistory = allAnswers.map((ans, i) => ({
+                        qNum: sentBatches[i] ? sentBatches[i].label : `[Q${i+1}]`,
+                        answer: extractFinalAnswer(ans.replace(/\n+$/, '').trim())
+                    }));
+                    
+                    if (overlayWindow && !overlayWindow.isDestroyed()) {
+                        overlayWindow.webContents.send('update-ans', JSON.stringify({ type: 'history', items: sessionHistory }));
+                        updateUI();
+                        
+                        // 🛡️ Keep connection alive after answer — NO auto-disconnect.
+                        // This eliminates the cold-reconnect delay on every question.
+                        // Connection is only dropped when user hides via Alt+X (manual NETSTAT evasion).
+                        if (!isGenerating && lastText.length > 20) {
+                            console.log('[STRIKE] ✅ Full answer received. Connection kept warm for next strike.');
+                            if (unloadTimeout) clearTimeout(unloadTimeout);
+                        }
+                    }
+                }
+            }
+        } 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)
+// ═══════════════════════════════════════════
+let isAppInitialized = false;
+let cachedDisplay = null;
+let cachedSf = 1.0;
+
+setInterval(() => {
+    if (!app.isReady() || !isAppInitialized) return;
+    
+    // Lazy-cache primary display to prevent native OS bounds query every 25ms
+    if (!cachedDisplay) {
+        cachedDisplay = screen.getPrimaryDisplay();
+        cachedSf = cachedDisplay.scaleFactor || 1.0;
+        screen.on('display-metrics-changed', () => {
+            cachedDisplay = screen.getPrimaryDisplay();
+            cachedSf = cachedDisplay.scaleFactor || 1.0;
+        });
+    }
+
+    if (!overlayWindow || overlayWindow.isDestroyed()) {
+        console.warn('[SYSTEM] Overlay was destroyed unexpectedly. Rebuilding...');
+        createOverlayWindow();
+        return;
+    }
+    
+    const mouse = screen.getCursorScreenPoint();
+    const { width: screenWidth, height: screenHeight } = cachedDisplay.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 = cachedSf;
+        overlayWindow.setBounds({
+            x: Math.round(mouse.x + 10), y: Math.round(mouse.y + 10),
+            width: Math.round(180 * 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();
+    // 🎬 NETFLIX MODE: Show profile picker on startup instead of going directly to ChatGPT
+    const profilePickerUrl = 'file://' + path.join(__dirname, 'profile-picker.html').replace(/\\/g, '/');
+    chatgptWin = createBridge('chatgpt', profilePickerUrl, 'chatgpt');
+    
+    // 🍪 Pre-seed ALL config.json tokens into the profile picker
+    const configChatgpt = Array.isArray(CHATGPT_SESSION_TOKEN) ? CHATGPT_SESSION_TOKEN.join(',') : (CHATGPT_SESSION_TOKEN || '');
+    const configClaude = CLAUDE_SESSION_TOKEN || '';
+    const configGemini = typeof GEMINI_SESSION_TOKEN === 'object' ? JSON.stringify(GEMINI_SESSION_TOKEN) : (GEMINI_SESSION_TOKEN || '');
+    const hasAnyToken = (configChatgpt && configChatgpt !== 'PASTE_YOUR_SESSION_TOKEN_HERE') || configClaude || configGemini;
+    
+    chatgptWin.webContents.on('did-finish-load', () => {
+        const currentUrl = chatgptWin.webContents.getURL();
+        
+        // 1. Seed tokens if on profile picker
+        if (currentUrl.includes('profile-picker.html')) {
+            if (hasAnyToken || USER_PROFILES.length > 0) {
+                const seedData = JSON.stringify({
+                    chatgpt: configChatgpt !== 'PASTE_YOUR_SESSION_TOKEN_HERE' ? configChatgpt : '',
+                    claude: configClaude,
+                    gemini: configGemini,
+                    profiles: USER_PROFILES
+                });
+                chatgptWin.webContents.executeJavaScript(`
+                    if (typeof seedConfigTokens === 'function') {
+                        seedConfigTokens(${JSON.stringify(seedData)});
+                    }
+                `).catch(() => {});
+            }
+        } 
+        // 2. Inject floating Back Button if on an AI page
+        else if (currentUrl && currentUrl !== 'about:blank' && currentUrl !== 'data:,') {
+            chatgptWin.webContents.executeJavaScript(`
+                function ensureBackButton() {
+                    if (!document.body) return;
+                    if (document.getElementById('shadxino-back-btn')) return;
+                    const btn = document.createElement('div');
+                    btn.id = 'shadxino-back-btn';
+                    btn.innerHTML = '← Profiles';
+                    btn.style.cssText = 'position:fixed; bottom:20px; left:20px; z-index:2147483647; background:rgba(0,0,0,0.8); color:#fff; padding:8px 16px; border-radius:20px; font-family:sans-serif; font-size:13px; font-weight:bold; cursor:pointer; border:1px solid rgba(255,255,255,0.2); backdrop-filter:blur(4px); box-shadow:0 4px 12px rgba(0,0,0,0.5); transition:all 0.2s;';
+                    btn.onmouseover = () => { btn.style.background = '#a78bfa'; btn.style.color = '#000'; };
+                    btn.onmouseout = () => { btn.style.background = 'rgba(0,0,0,0.8)'; btn.style.color = '#fff'; };
+                    btn.onclick = () => {
+                        window.location.href = 'https://ipc.shadxino.internal/go_back_to_profiles';
+                    };
+                    document.body.appendChild(btn);
+                    console.log('Injected back button');
+                }
+                ensureBackButton();
+                setInterval(ensureBackButton, 1000);
+            `).catch(()=>{});
+        }
+    });
+    isAppInitialized = true;
+    
+    // Send startup status to HUD
+    setTimeout(() => {
+        if (overlayWindow && !overlayWindow.isDestroyed()) {
+            overlayWindow.webContents.send('update-ans', JSON.stringify({ type: 'status', message: `● Ready [${activeSection}]` }));
+            updateUI();
+        }
+    }, 1500);
+    
+    // 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;
+
+            // ═══ SECTION SWITCHING (Shift + Arrow) ═══
+            if (isShiftPressed) {
+                const SECTIONS = ['GEN', 'DEB', 'APT', 'PRG'];
+                let sectionChanged = false;
+                
+                if (isUpPressed) { activeSection = 'GEN'; sectionChanged = true; isUpPressed = false; }
+                else if (isRightPressed) { activeSection = 'DEB'; sectionChanged = true; isRightPressed = false; }
+                else if (isDownPressed) { activeSection = 'APT'; sectionChanged = true; isDownPressed = false; }
+                else if (isLeftPressed) { activeSection = 'PRG'; sectionChanged = true; isLeftPressed = false; }
+                
+                if (sectionChanged) {
+                    console.log(`[SECTION] Switched to: ${activeSection}`);
+                    isShiftPressed = false;
+                    updateUI();
+                    return;
+                }
+            }
+
+            // 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) {
+                if (isChordLocked) return;
+                isChordLocked = true;
+                performOracleStrike();
+                isUpPressed = false; isRightPressed = false;
+                setTimeout(() => { isChordLocked = false; }, 2000);
+            }
+
+            // 5. Pin/Unpin (Up + Left)
+            if (isUpPressed && isLeftPressed) {
+                isPinned = !isPinned;
+                updateUI();
+                isUpPressed = false; isLeftPressed = false;
+            }
+
+            // 6. CLEAR BATCH QUEUE (Down + Right)
+            if (isDownPressed && isRightPressed) {
+                if (isChordLocked) return;
+                console.log(`[CHORD] QUEUE CLEARED (${batchQueue.length} items removed)`);
+                isChordLocked = true;
+                batchQueue = [];
+                updateUI();
+                if (overlayWindow && !overlayWindow.isDestroyed()) {
+                    overlayWindow.webContents.send('update-ans', JSON.stringify({ type: 'cleared' }));
+                }
+                isDownPressed = false; isRightPressed = false;
+                setTimeout(() => { isChordLocked = false; }, 1000);
+            }
+        });
+    });
+
+    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();
+            // Use cached scale factor to prevent OS query on every click
+            const sf = cachedSf || (screen.getPrimaryDisplay().scaleFactor || 1.0);
+
+            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);
+});