exiouss 1.0.1

package/main.js

@@ -0,0 +1,833 @@
+// ═══════════════════════════════════════════
+//  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 { exec } = require('child_process');
+const { powerSaveBlocker } = require('electron');
+
+// 🛡️ POWER SHIELD: Prevent system/renderer suspension
+powerSaveBlocker.start('prevent-app-suspension');
+
+// ═══════════════════════════════════════════
+//  PROJECT GHOST-MODE 🛸 (Native Stealth)
+// ═══════════════════════════════════════════
+const { uIOhook } = require('uiohook-napi');
+const koffi = require('koffi');
+
+// ═══════════════════════════════════════════
+//  PROJECT PHANTOM-BATCH v12.0 🛸 (Lex200 Sealed)
+// ═══════════════════════════════════════════
+
+let overlayWindow = null;
+let chatgptWin = null;
+
+let batchQueue = []; // Array of { img: String, timestamp }
+let isForcedHidden = false; // Start VISIBLE
+let isUiHidden = false; // Alt+E toggle
+let isAdminVisible = false;
+let isPinned = false; 
+let isAlwaysOnTop = true;
+let isCombatMode = false; // "Click-Through" Mode (Lex200 Defense)
+let activeSection = "GEN"; // GEN, DEB, APT, PRG
+let promptSent = false; 
+
+// AMCAT Specialized Prompts — Ignore all page noise, solve ONLY the question
+const SECTION_PROMPTS = {
+    "GEN": "IGNORE all navigation, sidebar, comments, similar questions, and UI noise in the text. Focus ONLY on the actual problem/question. Solve with 100% accuracy. Think step-by-step internally. RESPOND WITH ONLY THE FINAL ANSWER on the first line. If MCQ, give only the option letter. If coding, give only the code. Brief explanation below if needed. Please label answers as [Q1], [Q2], etc. if multiple questions were provided.",
+    "DEB": "IGNORE page noise. Focus ONLY on the code with the bug. Find the bug. RESPOND WITH ONLY THE CORRECTED CODE on the first line. Label the answer with its question ID (e.g., [Q1]).",
+    "APT": "IGNORE page noise. Focus ONLY on the math/aptitude problem. Solve step-by-step internally. RESPOND WITH ONLY THE FINAL NUMBER on the first line. Label as [Q1], [Q2], etc.",
+    "PRG": "IGNORE page noise. Focus ONLY on the programming problem statement, examples, and constraints. Write a complete, optimized, correct solution in C++ as a LeetCode Solution class with the correct function signature. The code must be ready to paste directly into LeetCode. RESPOND WITH ONLY THE CODE. Label as [Q1], [Q2], etc."
+};
+
+// Configuration State
+let SYSTEM_PROMPT = "IGNORE all UI noise. Solve with 100% accuracy. For procedural tasks or configuration steps (like AWS, Linux, Networking), RESPOND WITH HUMAN-LIKE, STEP-BY-STEP INSTRUCTIONS. Each step should be a clear action. Label answers as [Q1], [Q2], etc. inside your response.";
+
+let PROXY_RULE = ""; 
+
+// ═══════════════════════════════════════════
+//  ENVIRONMENT SELF-HEALING
+// ═══════════════════════════════════════════
+function checkEnvironment() {
+    console.log('[SYSTEM] Verifying system dependencies...');
+    
+    // Check for Admin rights (RECRUIT: Warn if non-admin)
+    exec('net session', (err) => {
+        if (err) {
+            console.warn('[SECURITY] App not running as Administrator.');
+        } else {
+            console.log('[SECURITY] Running with Administrator privileges.');
+        }
+    });
+}
+
+const configPath = path.join(process.cwd(), 'config.json');
+
+// Load User Config if exists
+if (fs.existsSync(configPath)) {
+    try {
+        const userConfig = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        if (userConfig.prompt) SYSTEM_PROMPT = userConfig.prompt;
+        if (userConfig.proxy) PROXY_RULE = userConfig.proxy;
+    } catch (e) {
+        console.error('[CONFIG] Failed to parse config.json, using default prompt.');
+    }
+} else {
+    // Create default config if missing
+    try {
+        fs.writeFileSync(configPath, JSON.stringify({
+            prompt: SYSTEM_PROMPT,
+            proxy: ""
+        }, null, 4));
+        console.log('[CONFIG] Default config.json created.');
+    } catch (e) {
+        console.error('[CONFIG] Failed to create default config.json');
+    }
+}
+
+// Override with CLI Arg if provided (--prompt="..." or --proxy="...")
+const promptArg = process.argv.find(arg => arg.startsWith('--prompt='));
+if (promptArg) SYSTEM_PROMPT = promptArg.split('=')[1];
+
+const proxyArg = process.argv.find(arg => arg.startsWith('--proxy='));
+if (proxyArg) PROXY_RULE = proxyArg.split('=')[1];
+
+// Mouse Analytics
+let lastMousePos = { x: 0, y: 0 };
+let edgeCooldown = 0;
+let edgeActive = { left: false, right: false }; // Track if mouse is currently on edge
+let wasVisible = true; // Sync state
+// UI State
+let lastOpacity = -1;
+
+// ═══════════════════════════════════════════
+//  WINDOW CREATION
+// ═══════════════════════════════════════════
+
+function createOverlayWindow() {
+    overlayWindow = new BrowserWindow({
+        width: 140, height: 180, transparent: true, frame: false, alwaysOnTop: true,
+        skipTaskbar: true, resizable: false, focusable: false,
+        webPreferences: { nodeIntegration: true, contextIsolation: false }
+    });
+    overlayWindow.loadFile('index.html');
+    
+    // Layer 1: System Level Stealth
+    overlayWindow.setAlwaysOnTop(true, 'screen-saver', 100);
+    overlayWindow.setVisibleOnAllWorkspaces(true, { visibleOnFullScreen: true });
+    
+    // Layer 2: Ultimate Stealth (True Invisibility)
+    setUltimateStealth(overlayWindow);
+    
+    overlayWindow.setOpacity(0.9);
+    overlayWindow.showInactive(); 
+}
+
+function setUltimateStealth(window) {
+    if (!window || process.platform !== 'win32') return;
+    try {
+        const user32 = koffi.load('user32.dll');
+        const SetWindowDisplayAffinity = user32.func('bool __stdcall SetWindowDisplayAffinity(intptr hWnd, uint32_t dwAffinity)');
+        const SetWindowPos = user32.func('bool __stdcall SetWindowPos(intptr hWnd, intptr hWndInsertAfter, int x, int y, int cx, int cy, uint uFlags)');
+        const GetForegroundWindow = user32.func('intptr __stdcall GetForegroundWindow()');
+        
+        // Define mouse_event globally or within this scope if needed
+        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
+        const result = SetWindowDisplayAffinity(hwnd, 0x00000011);
+        if (result) {
+            console.log('🛡️ STEALTH: WDA_EXCLUDEFROMCAPTURE Activated.');
+        } else {
+            window.setContentProtection(true);
+        }
+
+        // 🛡️ LAYER 2: Z-ORDER DOMINANCE LOOP (Fights SEB for the Top)
+        // SEB constantly tries to be the topmost window. We fight back every 100ms.
+        setInterval(() => {
+            if (window.isDestroyed()) return;
+            
+            // SWP_NOSIZE | SWP_NOMOVE | SWP_SHOWWINDOW | SWP_NOACTIVATE = 0x0001 | 0x0002 | 0x0040 | 0x0010 = 0x0053
+            // HWND_TOPMOST = -1
+            SetWindowPos(hwnd, -1, 0, 0, 0, 0, 0x0053);
+            
+            // Re-assert alwaysOnTop status for Chromium's internal logic
+            if (isAlwaysOnTop) {
+                window.setAlwaysOnTop(true, 'screen-saver', 100); 
+            }
+        }, 100);
+
+    } catch (e) {
+        console.warn('🛡️ koffi Stealth Failure:', e.message);
+        window.setContentProtection(true);
+    }
+}
+
+// ═══════════════════════════════════════════
+//  STEALTH HANDSHAKE (Active Stealth Bridge)
+// ═══════════════════════════════════════════
+
+function createBridge(name, url, partition) {
+    const win = new BrowserWindow({
+        width: 1100, height: 850, x: -10000, y: -10000, show: true, // Off-screen full render (prevents focus steal)
+        skipTaskbar: true, frame: false, transparent: true, opacity: 0.01,
+        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 Firefox User Agent
+    const highTrustUA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:123.0) Gecko/20100101 Firefox/123.0";
+    const sess = session.fromPartition(`persist:${partition}`);
+    sess.setUserAgent(highTrustUA);
+    
+    sess.setPermissionRequestHandler((webContents, permission, callback) => {
+        if (permission === 'notifications') return callback(false);
+        callback(true);
+    });
+
+    win.webContents.setUserAgent(highTrustUA);
+
+    // Deep Stealth Fingerprint (Enhanced for Resilience)
+    win.webContents.on('dom-ready', () => {
+        win.webContents.executeJavaScript(`
+            // Security/Bot Detection Bypass
+            Object.defineProperty(navigator, 'webdriver', { get: () => false });
+            Object.defineProperty(navigator, 'platform', { get: () => 'Win32' });
+            Object.defineProperty(navigator, 'deviceMemory', { get: () => 16 });
+            
+            // Mask Visibility API (Force "Running" state)
+            Object.defineProperty(document, 'visibilityState', { get: () => 'visible', configurable: true });
+            Object.defineProperty(document, 'hidden', { get: () => false, configurable: true });
+            document.dispatchEvent(new Event('visibilitychange'));
+
+            // State Force Injection
+            window.isSleeping = false;
+            window.isRunning = true;
+
+            // Animation Heartbeat (Prevents renderer sleep)
+            setInterval(() => {
+                window.dispatchEvent(new Event('mousemove'));
+                if (window.requestAnimationFrame) {
+                    window.requestAnimationFrame(() => {});
+                }
+            }, 1000);
+
+            // Mock Focus
+            try { document.hasFocus = () => true; } catch(e) {}
+            
+            "Injection Success";
+        `).catch(err => console.error("[DOM-READY ERR]", err));
+    });
+
+    win.loadURL(url);
+
+    win.on('close', (e) => {
+        e.preventDefault();
+        win.setBounds({ x: -10000, y: -10000, width: 1100, height: 850 });
+        isAdminVisible = false;
+    });
+    return win;
+}
+
+// ═══════════════════════════════════════════
+//  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 about line start)
+    const CUTOFF_PATTERNS = [
+        /discussion\s*\(/i,
+        /similar questions/i,
+        /comments?$/i,
+        /sort by/i,
+        /choose a type/i,
+        /copyright/i,
+        /daily question tag/i,
+        /\d+ days? badge/i,
+    ];
+    
+    // Lines to always skip (Boilerplate UI Noise)
+    const SKIP_PATTERNS = [
+        /^(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, // Specific: Won't match "Install nginx"
+        /^(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,
+    ];
+    
+    // SECOND PASS: Extract code editor template from FULL text (priority)
+    const codePatterns = [
+        /class\s+Solution[\s\S]*?\{[\s\S]*?\};?/,         // LeetCode C++/Java Class
+        /def\s+\w+\(self[\s\S]*?\):/,                     // Python
+        /function\s+\w+\([\s\S]*?\)\s*\{/,                // JS
+        /public\s+[\s\S]*?class\s+\w+[\s\S]*?\{/,          // General Java
+    ];
+    
+    let template = "";
+    for (const pat of codePatterns) {
+        const match = raw.match(pat);
+        if (match) { template = match[0].trim(); break; }
+    }
+    
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        
+        // Check cutoff
+        for (const pat of CUTOFF_PATTERNS) {
+            if (pat.test(trimmed)) { hitCutoff = true; break; }
+        }
+        if (hitCutoff) break;
+        
+        // Check skip
+        let skip = false;
+        for (const pat of SKIP_PATTERNS) {
+            if (pat.test(trimmed)) { skip = true; break; }
+        }
+        if (skip) continue;
+        
+        cleaned.push(trimmed);
+    }
+    
+    // Cap description at 8000 chars for modern LLMs
+    let description = cleaned.join('\n');
+    if (description.length > 8000) {
+        description = description.substring(0, 8000) + '\n[...Description Truncated...]';
+    }
+    
+    // Final assembly: Template FIRST so AI definitely sees what function to fix
+    let final = "";
+    if (template) final += "--- CODE TEMPLATE (DO NOT CHANGE SIGNATURE) ---\n" + template + "\n\n";
+    final += "--- PROBLEM DESCRIPTION ---\n" + description;
+    
+    return final;
+}
+
+async function captureTextQuestion() {
+    if (batchQueue.length >= 10) return;
+    console.log(`[CAPTURE] Using Standalone UIA Engine (.exe)...`);
+    
+    // Call the compiled executable (zero-dependency, skips Electron windows)
+    const exePath = path.join(__dirname, 'bin', 'uia_extract.exe');
+    const cmd = `"${exePath}"`;
+    
+    // Ensure no terminal pops up and steals focus
+    exec(cmd, { encoding: 'utf8', windowsHide: true }, (error, stdout, stderr) => {
+        if (error) {
+            console.error(`[UIA] Engine Error: ${error.message}`);
+            return;
+        }
+        const rawText = stdout.trim();
+        const text = cleanExtractedText(rawText);
+        if (text && !text.startsWith("ERROR") && !text.startsWith("TARGET:")) {
+            batchQueue.push({ img: null, text: text, time: Date.now() });
+            console.log(`[QUEUE] Added text question ${batchQueue.length}/10 (${text.length} chars, cleaned from ${rawText.length})`);
+            updateUI();
+        } else {
+            console.warn(`[UIA] No text extracted or fallback only: ${text}`);
+            if (overlayWindow) overlayWindow.webContents.send('update-ans', '⚠️ NO TEXT DETECTED (USE IMAGE CAPTURE)');
+        }
+    });
+}
+
+async function performOracleStrike() {
+    if (batchQueue.length === 0) return;
+    
+    console.log(`[STRIKE] Sending ${batchQueue.length} questions to ChatGPT...`);
+    
+    const images = batchQueue.filter(q => q.img).map(item => item.img); 
+    const textContext = batchQueue.filter(q => q.text).map(item => item.text).join('\n\n───\n\n');
+
+    // Build the correct prompt based on section
+    const finalPrompt = SECTION_PROMPTS[activeSection] || SYSTEM_PROMPT;
+
+    // Preparation Script
+    const injectionScript = `
+        (async function() {
+            try {
+                const imgs = ${JSON.stringify(images)};
+                const texts = ${JSON.stringify(textContext)};
+                const PROMPT = ${JSON.stringify(finalPrompt)};
+
+                const input = document.querySelector('div[contenteditable="true"]') || 
+                              document.querySelector('textarea') || 
+                              document.querySelector('.ProseMirror') || 
+                              document.querySelector('[aria-label*="message"]');
+                if (!input) return "Input Not Found";
+                
+                input.focus();
+                
+                // 1. Paste Images if any
+                for (const dataUrl of imgs) {
+                    const parts = dataUrl.split(',');
+                    const bstr = atob(parts[1]);
+                    let n = bstr.length;
+                    const u8arr = new Uint8Array(n);
+                    while(n--) u8arr[n] = bstr.charCodeAt(n);
+                    const file = new File([u8arr], "question.png", { type: "image/png" });
+                    const dt = new DataTransfer();
+                    dt.items.add(file);
+                    const pasteEvent = new ClipboardEvent('paste', { clipboardData: dt, bubbles: true, cancelable: true });
+                    input.dispatchEvent(pasteEvent);
+                    await new Promise(r => setTimeout(r, 800)); 
+                }
+
+                // 2. Insert Accumulated Text Context
+                if (texts) {
+                    document.execCommand('insertText', false, "CONTEXT FROM UIA:\\n" + texts + "\\n\\n");
+                    input.dispatchEvent(new Event('input', { bubbles: true }));
+                }
+
+                // 3. Dynamic User-Controlled Prompt
+                document.execCommand('insertText', false, PROMPT);
+                input.dispatchEvent(new Event('input', { bubbles: true }));
+                
+                // ☢️ STATE FORCE: Make React/ProseMirror recognize our text
+                input.dispatchEvent(new Event('input', { bubbles: true }));
+                input.dispatchEvent(new Event('change', { bubbles: true }));
+                
+                // 🎯 WAIT for Send button to become active, THEN press Enter
+                let attempts = 0;
+                while (attempts < 50) {
+                    await new Promise(r => setTimeout(r, 200));
+                    
+                    const sendBtn = document.querySelector('button[data-testid="send-button"]') || 
+                                    document.querySelector('button[aria-label*="Send"]');
+                    
+                    if (sendBtn && !sendBtn.disabled) {
+                        // Button is ready — fire Enter
+                        const enterDown = new KeyboardEvent('keydown', { 
+                            key: 'Enter', code: 'Enter', keyCode: 13, which: 13, 
+                            bubbles: true, cancelable: true 
+                        });
+                        const enterPress = new KeyboardEvent('keypress', { 
+                            key: 'Enter', code: 'Enter', keyCode: 13, which: 13, 
+                            bubbles: true, cancelable: true 
+                        });
+                        const enterUp = new KeyboardEvent('keyup', { 
+                            key: 'Enter', code: 'Enter', keyCode: 13, which: 13, 
+                            bubbles: true, cancelable: true 
+                        });
+                        
+                        input.focus();
+                        input.dispatchEvent(enterDown);
+                        input.dispatchEvent(enterPress);
+                        input.dispatchEvent(enterUp);
+                        
+                        return "Success (Enter after " + (attempts * 200) + "ms)";
+                    }
+                    attempts++;
+                }
+                return "Timeout - Send never activated";
+            } catch (err) { return "Error: " + err.message; }
+        })()
+    `;
+
+    if (chatgptWin) {
+        chatgptWin.webContents.executeJavaScript(injectionScript)
+            .then(result => console.log("[STRIKE] Script Result:", result))
+            .catch(err => console.error("[STRIKE ERROR] Failed to execute injection:", err));
+        
+        pollForResult(chatgptWin, 'chatgpt');
+        promptSent = true; 
+    }
+
+    // Increment question counter by batch size for accurate history tracking
+    const batchSize = batchQueue.length;
+    const startQ = questionCounter + 1;
+    const endQ = questionCounter + batchSize;
+    questionCounter = endQ;
+
+    const solveTag = batchSize > 1 ? `[Q${startQ}-${endQ}]` : `[Q${startQ}]`;
+    overlayWindow.webContents.send('update-ans', JSON.stringify({ type: 'solving', qNum: solveTag }));
+    
+    batchQueue = [];
+    updateUI();
+}
+
+let sessionHistory = [];  // [{qNum: 1, answer: "Option B"}, ...]
+let questionCounter = 0;
+let lastPollHash = "";
+
+let pollInterval = null;
+async function pollForResult(win) {
+    if (pollInterval) clearTimeout(pollInterval);
+    
+    // Grab ALL assistant response texts
+    const pollScript = `
+        (function() {
+            try {
+                // Target the specific assistant message content blocks
+                const assistantMsgs = document.querySelectorAll('[data-message-author-role="assistant"]');
+                const results = [];
+                
+                assistantMsgs.forEach(msg => {
+                    // Try to find the inner prose/markdown content first (cleanest)
+                    const content = msg.querySelector('.prose, .markdown') || msg;
+                    const text = content.innerText.trim();
+                    if (text && text.length > 3 && text !== "Thinking...") {
+                        results.push(text);
+                    }
+                });
+                
+                // Final safety: Remove identical consecutive duplicates
+                return JSON.stringify(results.filter((item, pos, self) => {
+                    return !pos || item !== self[pos - 1];
+                }));
+            } catch(e) { return null; }
+        })()
+    `;
+    
+    async function runPoll() {
+        if (!win || win.isDestroyed()) return;
+        try {
+            const result = await win.webContents.executeJavaScript(pollScript);
+            if (result) {
+                const allAnswers = JSON.parse(result);
+                // Include total count and last message hash for streaming/history refresh
+                const lastIdx = allAnswers.length - 1;
+                const lastText = lastIdx >= 0 ? allAnswers[lastIdx] : "";
+                const hash = allAnswers.length + ':' + lastText.length + ':' + lastText.substring(0, 20);
+                
+                if (hash !== lastPollHash && allAnswers.length > 0) {
+                    lastPollHash = hash;
+                    
+                    // Update persistent sessionHistory: Map every assistant message to a question block
+                    // Note: If multiple questions were in one batch, they might be inside a single message block
+                    sessionHistory = allAnswers.map((ans, i) => ({
+                        qNum: i + 1,
+                        answer: ans.replace(/\n+$/, '').trim()
+                    }));
+                    
+                    if (overlayWindow && !overlayWindow.isDestroyed()) {
+                        overlayWindow.webContents.send('update-ans', JSON.stringify({ type: 'history', items: sessionHistory }));
+                        updateUI();
+                    }
+                }
+            }
+        } catch (e) {}
+        pollInterval = setTimeout(runPoll, 500);
+    }
+    
+    runPoll();
+}
+
+// ═══════════════════════════════════════════
+//  UI DISPATCH & HUD
+// ═══════════════════════════════════════════
+
+function updateUI() {
+    if (!overlayWindow) return;
+    overlayWindow.webContents.send('update-hud', {
+        count: batchQueue.length,
+        isForcedHidden,
+        isUiHidden,
+        isPinned,
+        isAlwaysOnTop,
+        isCombatMode,
+        activeSection
+    });
+    if (sessionHistory.length > 0) {
+        overlayWindow.webContents.send('update-ans', JSON.stringify({ type: 'history', items: sessionHistory }));
+    }
+}
+
+// ═══════════════════════════════════════════
+//  STEALTH POLLING (Hover Reveal)
+// ═══════════════════════════════════════════
+// ═══════════════════════════════════════════
+//  STEALTH ENGINE (Edges & Jitter)
+// ═══════════════════════════════════════════
+setInterval(() => {
+    if (!overlayWindow || overlayWindow.isDestroyed()) return;
+    
+    const mouse = screen.getCursorScreenPoint();
+    const { width: screenWidth, height: screenHeight } = screen.getPrimaryDisplay().bounds;
+    
+    // 1. Edge Triggers (Capture/Solve)
+    if (Date.now() > edgeCooldown) {
+        if (mouse.x >= screenWidth - 1) { // Right Edge Proximity
+            if (!edgeActive.right) {
+                captureTextQuestion();
+                edgeActive.right = true;
+                edgeCooldown = Date.now() + 2000; // 2s cooldown
+            }
+        } else {
+            edgeActive.right = false;
+        }
+
+        if (mouse.x <= 0) { // Left Edge Proximity
+            if (!edgeActive.left) {
+                performOracleStrike();
+                edgeActive.left = true;
+                edgeCooldown = Date.now() + 2000;
+            }
+        } else {
+            edgeActive.left = false;
+        }
+    }
+
+    lastMousePos = { x: mouse.x, y: mouse.y };
+    
+    // 3. Position HUD Window
+    if (isPinned) return; 
+    
+    if (isForcedHidden) {
+        if (wasVisible) {
+            overlayWindow.hide();
+            wasVisible = false;
+        }
+    } else {
+        if (!wasVisible) {
+            overlayWindow.showInactive();
+            wasVisible = true;
+        }
+        
+        const sf = screen.getPrimaryDisplay().scaleFactor || 1.0;
+        overlayWindow.setBounds({
+            x: Math.round(mouse.x + 10), y: Math.round(mouse.y + 10),
+            width: Math.round(300 * sf), height: Math.round(150 * sf)
+        });
+    }
+}, 25);
+
+// ═══════════════════════════════════════════
+//  HOTKEYS
+// ═══════════════════════════════════════════
+
+app.whenReady().then(async () => {
+    app.setName('Windows Diagnostic Utility');
+
+    // 🛡️ FIREWALL SHIELD: Apply Proxy if specified
+    if (PROXY_RULE) {
+        console.log(`[PROXY] Routing traffic through: ${PROXY_RULE}`);
+        const proxyConfig = { proxyRules: PROXY_RULE };
+        await session.defaultSession.setProxy(proxyConfig);
+        const gptSess = session.fromPartition('persist:chatgpt');
+        await gptSess.setProxy(proxyConfig);
+    }
+
+    createOverlayWindow();
+    chatgptWin = createBridge('chatgpt', 'https://chat.openai.com', 'chatgpt');
+    
+    // Run environment check after windows are ready
+    setTimeout(checkEnvironment, 2000);
+
+    const register = (key, fn) => {
+        const success = globalShortcut.register(key, fn);
+        console.log(`[KEY] ${key} registration: ${success ? 'OK' : 'FAILED'}`);
+        return success;
+    };
+
+    // 🎯 HOTKEYS: Only keep Alt+X and Alt+C
+    register('Alt+C', () => { 
+        isCombatMode = !isCombatMode; 
+        updateUI(); 
+        console.log(`[APP] Combat Mode (Lex200 Defense): ${isCombatMode}`); 
+    });
+
+    register('Alt+X', () => {
+        if (isCombatMode) return;
+        isAdminVisible = !isAdminVisible;
+        if (chatgptWin) {
+            if (isAdminVisible) {
+                const { width, height } = screen.getPrimaryDisplay().workAreaSize;
+                chatgptWin.setOpacity(1.0);
+                chatgptWin.setBounds({ 
+                    x: Math.round(width/2 - 550), 
+                    y: Math.round(height/2 - 425), 
+                    width: 1100, height: 850 
+                });
+                chatgptWin.focus(); 
+            } else {
+                chatgptWin.setOpacity(0.01);
+                chatgptWin.setBounds({ x: -10000, y: -10000, width: 1100, height: 850 });
+            }
+        }
+    });
+
+    // 🕊️ GHOST MODE: uIOhook Listener (Arrow Keys only)
+    let isUpPressed = false, isDownPressed = false, isLeftPressed = false, isRightPressed = false;
+    let isShiftPressed = false;
+    let isChordLocked = false;
+
+    uIOhook.on('keydown', (e) => {
+        // Wrap in setImmediate to prevent N-API thread crash
+        setImmediate(() => {
+            if (e.keycode === 57416 || e.keycode === 72) isUpPressed = true;
+            if (e.keycode === 57424 || e.keycode === 80) isDownPressed = true;
+            if (e.keycode === 57419 || e.keycode === 75) isLeftPressed = true;
+            if (e.keycode === 57421 || e.keycode === 77) isRightPressed = true;
+            if (e.keycode === 42 || e.keycode === 54) isShiftPressed = true;
+
+            // 1. Hide/Unhide HUD (Up + Down)
+            if (isUpPressed && isDownPressed) {
+                isForcedHidden = !isForcedHidden;
+                updateUI();
+                isUpPressed = false; isDownPressed = false;
+            }
+
+            // 3. TEXT CAPTURE (Left + Right) — 100% Safe
+            if (isLeftPressed && isRightPressed) {
+                if (isChordLocked) return;
+                console.log(`[CHORD] TEXT CAPTURE Triggered (Safe Mode)...`);
+                isChordLocked = true;
+                captureTextQuestion();
+                isLeftPressed = false; isRightPressed = false;
+                setTimeout(() => { isChordLocked = false; }, 2000);
+            }
+
+            // 3b. IMAGE CAPTURE (Down + Left) — Diagram Mode
+            if (isDownPressed && isLeftPressed) {
+                if (isChordLocked) return;
+                console.log(`[CHORD] DIAGRAM CAPTURE Triggered (GDI Mode)...`);
+                isChordLocked = true;
+                captureImageQuestion();
+                isDownPressed = false; isLeftPressed = false;
+                setTimeout(() => { isChordLocked = false; }, 2000);
+            }
+
+            // 4. Perform Strike (Up + Right)
+            if (isUpPressed && isRightPressed) {
+                performOracleStrike();
+                isUpPressed = false; isRightPressed = false;
+            }
+
+            // 5. Pin/Unpin (Up + Left)
+            if (isUpPressed && isLeftPressed) {
+                isPinned = !isPinned;
+                updateUI();
+                isUpPressed = false; isLeftPressed = false;
+            }
+        });
+    });
+
+    uIOhook.on('keyup', (e) => {
+        setImmediate(() => {
+            if (e.keycode === 57416 || e.keycode === 72) isUpPressed = false;
+            if (e.keycode === 57424 || e.keycode === 80) isDownPressed = false;
+            if (e.keycode === 57419 || e.keycode === 75) isLeftPressed = false;
+            if (e.keycode === 57421 || e.keycode === 77) isRightPressed = false;
+            if (e.keycode === 42 || e.keycode === 54) isShiftPressed = false;
+        });
+    });
+
+    // STEALTH CLICK HANDLER: Manually route clicks when window is focusable:false
+    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 });
+            }
+        });
+    });
+
+    // (Manual wheel listener removed to allow native touchpad support)
+
+    // Delay start to let Electron event loop stabilize
+    setTimeout(() => {
+        uIOhook.start();
+        console.log('[GHOST] uIOhook started successfully.');
+    }, 500);
+
+    // ☢️ DECONTAMINATION PROTOCOL (Alt + Shift + X)
+    register('Alt+Shift+X', async () => {
+        console.log("☢️ SELF-DESTRUCT INITIATED...");
+        const burnScript = `
+            (async function() {
+                try {
+                    const gptDelete = document.querySelector('nav .bg-red-500') || document.querySelector('[aria-label*="Delete"]');
+                    if (gptDelete) gptDelete.click();
+                    await new Promise(r => setTimeout(r, 500));
+                } catch(e) {}
+            })()
+        `;
+        if (chatgptWin) {
+            chatgptWin.webContents.executeJavaScript(burnScript).catch(e => {});
+            await chatgptWin.webContents.session.clearStorageData();
+        }
+        promptSent = false;
+        await session.defaultSession.clearStorageData();
+        console.log("☢️ WIPE COMPLETE. EXITING.");
+        app.exit(0);
+    });
+
+    // (Double-click pin handler removed)
+});