invixco 1.0.6

package/main.js

@@ -0,0 +1,1609 @@
+// ═══════════════════════════════════════════
+//  GLOBAL STEALTH BOOT (MUST BE FIRST)
+// ═══════════════════════════════════════════
+process.on('uncaughtException', (err) => {
+    if (err.code === 'EPIPE') return;
+    try { console.error('Unhandled:', err); } catch(e) {}
+});
+
+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');
+
+// ═══════════════════════════════════════════
+//  GHOST TYPER NATIVE HOOKS
+// ═══════════════════════════════════════════
+const user32_global = koffi.load('user32.dll');
+const SendInput = user32_global.func('uint32_t __stdcall SendInput(uint32_t cInputs, void *pInputs, int cbSize)');
+
+let ghostTypingLines = []; // Queue of lines to type
+let isGhostTyping = false; // Mutex lock
+
+function ghostTypeLine() {
+    if (ghostTypingLines.length === 0 || isGhostTyping) return;
+    isGhostTyping = true;
+    
+    const line = ghostTypingLines.shift();
+    // 🛡️ AUTO-INDENT FIX: Strip leading spaces so we don't double-indent when the editor auto-indents!
+    const charsToType = line.trimStart(); 
+    const totalInputs = (charsToType.length * 2) + 2; // +2 for Enter KeyDown/KeyUp
+    const buffer = Buffer.alloc(40 * totalInputs);
+    
+    for (let i = 0; i < charsToType.length; i++) {
+        const charCode = charsToType.charCodeAt(i);
+        const offsetDown = i * 2 * 40;
+        const offsetUp = (i * 2 + 1) * 40;
+        
+        // Unicode KeyDown
+        buffer.writeUInt32LE(1, offsetDown);
+        buffer.writeUInt16LE(0, offsetDown + 8);
+        buffer.writeUInt16LE(charCode, offsetDown + 10);
+        buffer.writeUInt32LE(0x0004, offsetDown + 12);
+        
+        // Unicode KeyUp
+        buffer.writeUInt32LE(1, offsetUp);
+        buffer.writeUInt16LE(0, offsetUp + 8);
+        buffer.writeUInt16LE(charCode, offsetUp + 10);
+        buffer.writeUInt32LE(0x0004 | 0x0002, offsetUp + 12);
+    }
+    
+    // Hardware Enter KeyDown
+    const enterOffsetDown = charsToType.length * 2 * 40;
+    buffer.writeUInt32LE(1, enterOffsetDown);
+    buffer.writeUInt16LE(0x0D, enterOffsetDown + 8); // VK_RETURN
+    buffer.writeUInt16LE(0, enterOffsetDown + 10); 
+    buffer.writeUInt32LE(0, enterOffsetDown + 12); // Standard Key (Not Unicode)
+    
+    // Hardware Enter KeyUp
+    const enterOffsetUp = enterOffsetDown + 40;
+    buffer.writeUInt32LE(1, enterOffsetUp);
+    buffer.writeUInt16LE(0x0D, enterOffsetUp + 8); 
+    buffer.writeUInt16LE(0, enterOffsetUp + 10); 
+    buffer.writeUInt32LE(0x0002, enterOffsetUp + 12); // KEYEVENTF_KEYUP
+    
+    SendInput(totalInputs, buffer, 40);
+    isGhostTyping = false;
+    
+    if (ghostTypingLines.length === 0) {
+        console.log('[GHOST] Finished typing queue.');
+    }
+}
+
+// ═══════════════════════════════════════════
+//  PROJECT PHANTOM-BATCH v12.0 🛸 (Lex200 Sealed)
+// ═══════════════════════════════════════════
+
+let overlayWindow = null;
+let chatgptWin = 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 WITHOUT ANY COMMENTS. 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, have NO COMMENTS, 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. DO NOT INCLUDE ANY COMMENTS IN THE CODE. 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 WITHOUT ANY COMMENTS. 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 = "";
+
+
+// ═══════════════════════════════════════════
+//  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;
+    } 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) {
+    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 (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: EVASION REFINED
+        // We permanently maintain WDA_EXCLUDEFROMCAPTURE. Newer Windows versions make this
+        // fully transparent to screen capture APIs (WebRTC, BitBlt, etc) rather than black boxes.
+        // Dropping this flag would immediately expose the HUD to Testpad.
+
+    } 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)
+    setUltimateStealth(win);
+    
+    // High-Trust Chrome User Agent (ChatGPT blocks old Firefox UAs)
+    // Ultra-Modern Chrome User Agent (Bypasses many login-walls)
+    const highTrustUA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36";
+    const sess = session.fromPartition(`persist:${partition}`);
+    sess.setUserAgent(highTrustUA);
+    
+    // Fix ChatGPT "something went wrong" — inject proper Sec-CH-UA headers
+    sess.webRequest.onBeforeSendHeaders({ urls: ['*://*.openai.com/*', '*://*.chatgpt.com/*'] }, (details, callback) => {
+        details.requestHeaders['Sec-CH-UA'] = '"Chromium";v="124", "Google Chrome";v="124", "Not-A.Brand";v="99"';
+        details.requestHeaders['Sec-CH-UA-Mobile'] = '?0';
+        details.requestHeaders['Sec-CH-UA-Platform'] = '"Windows"';
+        details.requestHeaders['Accept-Language'] = 'en-US,en;q=0.9';
+        callback({ requestHeaders: details.requestHeaders });
+    });
+    
+    sess.setPermissionRequestHandler((webContents, permission, callback) => {
+        if (permission === 'notifications') return callback(false);
+        callback(true);
+    });
+
+    win.webContents.setUserAgent(highTrustUA);
+
+    // Deep Stealth Fingerprint (Enhanced for Resilience)
+    win.webContents.on('dom-ready', () => {
+        win.webContents.executeJavaScript(`
+            // Security/Bot Detection Bypass
+            Object.defineProperty(navigator, 'webdriver', { get: () => false });
+            Object.defineProperty(navigator, 'platform', { get: () => 'Win32' });
+            Object.defineProperty(navigator, 'deviceMemory', { get: () => 16 });
+            
+            // 🛡️ AUTO-BYPASS LOGIN WALLS (For "No Account" usage)
+            setInterval(() => {
+                try {
+                    // Look for "Stay logged out", "Dismiss", or "Start chatting" buttons
+                    const buttons = Array.from(document.querySelectorAll('button, a'));
+                    const bypass = buttons.find(b => 
+                        b.innerText.includes('Stay logged out') || 
+                        b.innerText.includes('Not now') ||
+                        b.innerText.includes('Dismiss')
+                    );
+                    if (bypass) {
+                        bypass.click();
+                        console.log('[STEALTH] Bypassed login prompt.');
+                    }
+                } catch(e) {}
+            }, 2000);
+
+            // Mask Visibility API (Force "Running" state)
+            Object.defineProperty(document, 'visibilityState', { get: () => 'visible', configurable: true });
+            Object.defineProperty(document, 'hidden', { get: () => false, configurable: true });
+            document.dispatchEvent(new Event('visibilitychange'));
+
+            // State Force Injection
+            window.isSleeping = false;
+            window.isRunning = true;
+
+            // Animation Heartbeat (Prevents renderer sleep)
+            setInterval(() => {
+                window.dispatchEvent(new Event('mousemove'));
+                if (window.requestAnimationFrame) {
+                    window.requestAnimationFrame(() => {});
+                }
+            }, 1000);
+
+            // Mock Focus
+            try { document.hasFocus = () => true; } catch(e) {}
+            
+            "Injection Success";
+        `).catch(err => console.error("[DOM-READY ERR]", err));
+    });
+
+    win.loadURL(url);
+
+    win.on('close', (e) => {
+        e.preventDefault();
+        win.setBounds({ x: -10000, y: -10000, width: 1100, height: 850 });
+        isAdminVisible = false;
+    });
+    return win;
+}
+
+// 🛡️ TESTPAD EVASION: ChatGPT 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();
+    if (!url.includes('chat.openai.com') && !url.includes('chatgpt.com')) {
+        console.log('[STEALTH] Reconnecting to ChatGPT (was unloaded)...');
+        await chatgptWin.loadURL('https://chatgpt.com/?model=auto');
+        // Reduced wait: page is pre-cached after first load — 1s is enough
+        await new Promise(r => setTimeout(r, 1000));
+    }
+    // If already on chatgpt.com, 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.focus(); 
+                
+                // 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.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"]');
+                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) => {
+                        const extracted = extractFinalAnswer(ans.replace(/\n+$/, '').trim());
+                        
+                        // Populate Ghost Typer queue if this is the completed final answer
+                        if (!isGenerating && i === allAnswers.length - 1 && lastText.length > 20) {
+                            ghostTypingLines = extracted.split('\n');
+                            console.log(`[GHOST] Typer queue loaded with ${ghostTypingLines.length} lines.`);
+                        }
+
+                        return {
+                            qNum: sentBatches[i] ? sentBatches[i].label : `[Q${i+1}]`,
+                            answer: extracted
+                        };
+                    });
+                    
+                    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('invixco');
+
+    // \u{1F6E1}\uFE0F FIREWALL SHIELD: Apply Proxy if specified
+    if (PROXY_RULE) {
+        console.log(`[PROXY] Routing traffic through: ${PROXY_RULE}`);
+        let proxyUrl = PROXY_RULE;
+        let proxyAuth = null;
+        
+        // Handle authenticated proxies (http://user:pass@ip:port)
+        if (PROXY_RULE.includes('@')) {
+            try {
+                const fullUrl = PROXY_RULE.startsWith('http') ? PROXY_RULE : 'http://' + PROXY_RULE;
+                const parsed = new URL(fullUrl);
+                if (parsed.username || parsed.password) {
+                    proxyAuth = { username: decodeURIComponent(parsed.username), password: decodeURIComponent(parsed.password) };
+                    proxyUrl = `${parsed.protocol}//${parsed.host}`;
+                    
+                    app.on('login', (event, webContents, request, authInfo, callback) => {
+                        if (authInfo.isProxy) {
+                            event.preventDefault();
+                            callback(proxyAuth.username, proxyAuth.password);
+                        }
+                    });
+                }
+            } catch(e) {
+                console.error('[PROXY] Invalid proxy URL format. Failed to parse auth.');
+            }
+        }
+
+        const proxyConfig = { proxyRules: proxyUrl };
+        await session.defaultSession.setProxy(proxyConfig);
+        const gptSess = session.fromPartition('persist:chatgpt');
+        await gptSess.setProxy(proxyConfig);
+    }
+
+    // 🍪 SESSION TOKEN INJECTION: Bypass Cloudflare/Login
+    if (CHATGPT_SESSION_TOKEN && CHATGPT_SESSION_TOKEN !== "PASTE_YOUR_SESSION_TOKEN_HERE") {
+        console.log(`[AUTH] Injecting secure session token for ChatGPT...`);
+        const gptSess = session.fromPartition('persist:chatgpt');
+        const tokens = Array.isArray(CHATGPT_SESSION_TOKEN) ? CHATGPT_SESSION_TOKEN : [CHATGPT_SESSION_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';
+            const cookie = {
+                url: 'https://chatgpt.com',
+                name: cookieName,
+                value: tokens[i],
+                secure: true,
+                httpOnly: true,
+                sameSite: 'lax',
+                domain: '.chatgpt.com'
+            };
+            await gptSess.cookies.set(cookie);
+            // Also set for openai.com just in case
+            cookie.url = 'https://chat.openai.com';
+            cookie.domain = '.openai.com';
+            await gptSess.cookies.set(cookie);
+        }
+    }
+
+    createOverlayWindow();
+    // 🚀 PRE-WARM: Load ChatGPT at startup so first strike is instant (no cold-load delay)
+    chatgptWin = createBridge('chatgpt', 'https://chatgpt.com/', 'chatgpt');
+    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 = [];
+                ghostTypingLines = []; // Also clear ghost typing queue
+                updateUI();
+                if (overlayWindow && !overlayWindow.isDestroyed()) {
+                    overlayWindow.webContents.send('update-ans', JSON.stringify({ type: 'cleared' }));
+                }
+                isDownPressed = false; isRightPressed = false;
+                setTimeout(() => { isChordLocked = false; }, 1000);
+            }
+
+            // 7. GHOST TYPER TRIGGER (Caps Lock = 58)
+            if (e.keycode === 58) {
+                if (ghostTypingLines && ghostTypingLines.length > 0) {
+                    ghostTypeLine();
+                }
+            }
+        });
+    });
+
+    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);
+});