exiouss 1.0.4

package/main.js

@@ -0,0 +1,1191 @@
+// ═══════════════════════════════════════════
+//  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');
+
+const Groq = require('groq-sdk');
+
+// ═══════════════════════════════════════════
+//  PROJECT PHANTOM-BATCH v12.0 🛸 (Lex200 Sealed)
+// ═══════════════════════════════════════════
+
+let overlayWindow = null;
+let groq = null;
+
+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 GROQ_API_KEYS = [];
+let GROQ_KEY_INDEX = 0;
+let GROQ_MODEL = "llama-3.3-70b-versatile";
+
+
+// ═══════════════════════════════════════════
+//  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.groqApiKeys) {
+            GROQ_API_KEYS = Array.isArray(userConfig.groqApiKeys) ? userConfig.groqApiKeys : [userConfig.groqApiKeys];
+            // Filter out placeholders
+            GROQ_API_KEYS = GROQ_API_KEYS.filter(k => k && !k.includes('KEY_') && k !== 'gsk_...');
+        }
+        if (userConfig.groqModel) GROQ_MODEL = userConfig.groqModel;
+    } 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: "",
+            groqApiKeys: ["gsk_KEY_1", "gsk_KEY_2", "gsk_KEY_3", "gsk_KEY_4", "gsk_KEY_5"],
+            groqModel: "llama-3.3-70b-versatile"
+        }, 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) {
+    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 & TESTPAD EVASION (25ms)
+        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); 
+            }
+        }, 25);
+
+        // 🛡️ LAYER 4: ENHANCED PROCTOR EVASION (Testpad 0.6.3+ Shield)
+        // Detects 'core.exe', 'monitorDetect.exe', 'license-win32-x64.exe', and 'testpad.exe'
+        const proctorTools = ['core.exe', 'monitordetect.exe', 'license-win32-x64.exe', 'testpad.exe'];
+        setInterval(() => {
+            exec('tasklist /NH /FO CSV', { windowsHide: true }, (err, stdout) => {
+                if (err || !stdout) return;
+                const processes = stdout.toLowerCase();
+                const isProctorScanning = proctorTools.some(tool => processes.includes(tool));
+                
+                if (isProctorScanning) {
+                    // 🚨 EVASION MODE: Proctor tool detected! 
+                    // 1. Drop WDA to prevent 'Discrepancy' flags (Testpad's Anti-Tempering check)
+                    SetWindowDisplayAffinity(hwnd, 0x00000000); 
+                    // 2. Reduce opacity to be nearly invisible if they take a screenshot
+                    if (!isAdminVisible && overlayWindow && !overlayWindow.isDestroyed()) {
+                        overlayWindow.setOpacity(0.05); 
+                    }
+                } else {
+                    // 🛡️ STEALTH MODE: No proctor scan detected
+                    // 1. Restore WDA_EXCLUDEFROMCAPTURE (0x11)
+                    SetWindowDisplayAffinity(hwnd, 0x00000011);
+                    // 2. Restore normal HUD opacity
+                    if (!isAdminVisible && overlayWindow && !overlayWindow.isDestroyed()) {
+                        overlayWindow.setOpacity(0.97);
+                    }
+                }
+            });
+        }, 300); // 300ms high-frequency polling for instant reaction
+
+
+    } catch (e) {
+        console.warn('🛡️ koffi Stealth Failure:', e.message);
+        window.setContentProtection(true);
+    }
+}
+
+// ═══════════════════════════════════════════
+//  STEALTH HANDSHAKE (Active Stealth Bridge)
+// ═══════════════════════════════════════════
+
+
+// ═══════════════════════════════════════════
+//  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;
+            
+            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 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;
+        
+        // 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 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();
+    }
+    
+    // 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+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("☢️ 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) {}
+
+        promptSent = false;
+        await session.defaultSession.clearStorageData();
+        console.log("☢️ 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; }
+    
+    if (GROQ_API_KEYS.length === 0) {
+        console.error('[STRIKE] No Groq API Keys found! Set them in config.json.');
+        if (overlayWindow) overlayWindow.webContents.send('update-ans', JSON.stringify({ type: 'status', message: '⚠️ SET GROQ API KEYS' }));
+        return;
+    }
+
+    isStriking = true;
+    let attempts = 0;
+    let success = false;
+    let lastError = "";
+
+    if (overlayWindow) {
+        overlayWindow.webContents.send('update-ans', JSON.stringify({ type: 'solving', qNum: '...' }));
+    }
+
+    while (attempts < GROQ_API_KEYS.length && !success) {
+        const currentKey = GROQ_API_KEYS[GROQ_KEY_INDEX];
+        const keyDisplayIndex = GROQ_KEY_INDEX + 1;
+        GROQ_KEY_INDEX = (GROQ_KEY_INDEX + 1) % GROQ_API_KEYS.length;
+        
+        console.log(`[STRIKE] Attempt ${attempts + 1} using Groq Key #${keyDisplayIndex}...`);
+        
+        try {
+            groq = new Groq({ apiKey: currentKey });
+
+            const images = batchQueue.filter(q => q.img); 
+            const textContexts = batchQueue.filter(q => q.text).map(item => item.text);
+            const finalPrompt = SECTION_PROMPTS[activeSection] || SYSTEM_PROMPT;
+
+            const messages = [{ role: "user", content: [{ type: "text", text: finalPrompt }] }];
+            if (textContexts.length > 0) messages[0].content.push({ type: "text", text: "\n\nCONTEXT FROM UIA:\n" + textContexts.join('\n\n───\n\n') });
+            
+            for (const img of images) {
+                messages[0].content.push({ type: "image_url", image_url: { url: `data:image/png;base64,${img.img.split(',')[1]}` } });
+            }
+
+            let modelToUse = GROQ_MODEL;
+            if (images.length > 0 && !modelToUse.includes('vision')) {
+                modelToUse = "llama-3.2-11b-vision-preview";
+            }
+
+            const chatCompletion = await groq.chat.completions.create({
+                "messages": messages,
+                "model": modelToUse,
+                "temperature": 0.1,
+                "max_tokens": 4096,
+                "top_p": 1,
+                "stream": false,
+                "stop": null
+            });
+
+            const fullAnswer = chatCompletion.choices[0]?.message?.content || "";
+            console.log(`[STRIKE] Success with Key #${keyDisplayIndex}`);
+
+            function extractFinalAnswer(text) {
+                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().replace(/^```[\w]*\n?/gm, '').replace(/```$/gm, '').trim();
+                    if (extracted) matches.push(extracted);
+                }
+                if (matches.length > 0) return matches.join('\n');
+
+                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) return m[1].trim().replace(/^```[\w]*\n?/gm, '').replace(/```$/gm, '').trim();
+                }
+
+                const codeBlocks = [];
+                const codeBlockPattern = /```[\w]*\n([\s\S]*?)```/g;
+                while ((match = codeBlockPattern.exec(text)) !== null) {
+                    if (match[1].trim()) codeBlocks.push(match[1].trim());
+                }
+                return codeBlocks.length > 0 ? codeBlocks.join('\n\n') : text;
+            }
+
+            const cleanedAnswer = extractFinalAnswer(fullAnswer);
+            
+            const batchSize = batchQueue.length;
+            const startQ = questionCounter + 1;
+            const endQ = questionCounter + batchSize;
+            questionCounter = endQ;
+            const solveTag = batchSize > 1 ? `[Q${startQ}-${endQ}]` : `[Q${startQ}]`;
+
+            sessionHistory.push({ qNum: solveTag, answer: cleanedAnswer });
+
+            if (overlayWindow && !overlayWindow.isDestroyed()) {
+                overlayWindow.webContents.send('update-ans', JSON.stringify({ type: 'history', items: sessionHistory }));
+                updateUI();
+            }
+            success = true;
+
+        } catch (error) {
+            attempts++;
+            lastError = error.message;
+            console.error(`[STRIKE ERROR] Key #${keyDisplayIndex} failed:`, lastError);
+            
+            if (attempts < GROQ_API_KEYS.length) {
+                console.log(`[STRIKE] Retrying with next key...`);
+                await new Promise(r => setTimeout(r, 500));
+            }
+        }
+    }
+
+    if (!success) {
+        console.error('[STRIKE] All API keys failed.');
+        if (overlayWindow) {
+            overlayWindow.webContents.send('update-ans', JSON.stringify({ type: 'status', message: `⚠️ ALL KEYS FAILED: ${lastError.substring(0, 15)}...` }));
+        }
+    }
+
+    batchQueue = [];
+    isStriking = false;
+    updateUI();
+}
+
+// ═══════════════════════════════════════════
+//  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;
+setInterval(() => {
+    if (!app.isReady() || !isAppInitialized) return;
+    
+    if (!overlayWindow || overlayWindow.isDestroyed()) {
+        console.warn('[SYSTEM] Overlay was destroyed unexpectedly. Rebuilding...');
+        createOverlayWindow();
+        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(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');
+
+    // 🛡️ 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);
+    }
+
+    createOverlayWindow();
+    isAppInitialized = true;
+    
+    // Send startup status to HUD
+    setTimeout(() => {
+        if (overlayWindow && !overlayWindow.isDestroyed()) {
+            overlayWindow.webContents.send('update-ans', JSON.stringify({ type: 'status', message: `● Groq Active [${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();
+            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);
+});