repomix-output.txt

This file is a merged representation of the entire codebase, combined into a single document by Repomix.

================================================================
File Summary
================================================================

Purpose:
--------
This file contains a packed representation of the entire repository's contents.
It is designed to be easily consumable by AI systems for analysis, code review,
or other automated processes.

File Format:
------------
The content is organized as follows:
1. This summary section
2. Repository information
3. Directory structure
4. Repository files (if enabled)
5. Multiple file entries, each consisting of:
  a. A separator line (================)
  b. The file path (File: path/to/file)
  c. Another separator line
  d. The full contents of the file
  e. A blank line

Usage Guidelines:
-----------------
- This file should be treated as read-only. Any changes should be made to the
  original repository files, not this packed version.
- When processing this file, use the file path to distinguish
  between different files in the repository.
- Be aware that this file may contain sensitive information. Handle it with
  the same level of security as you would the original repository.

Notes:
------
- Some files may have been excluded based on .gitignore rules and Repomix's configuration
- Binary files are not included in this packed representation. Please refer to the Repository Structure section for a complete list of file paths, including binary files
- Files matching patterns in .gitignore are excluded
- Files matching default ignore patterns are excluded
- Files are sorted by Git change count (files with more changes are at the bottom)


================================================================
Directory Structure
================================================================
.env.example
.gitignore
assets/chrome.ico
assets/README.md
BUILD_INSTRUCTIONS.md
notes.md
package.json
README.md
scripts/fetch-gemini-models.js
SETUP-VOSK.md
src/bootstrap/environment.js
src/config.js
src/main-process/features/assistant/gemini-runtime.js
src/main-process/features/assistant/ipc.js
src/main-process/features/assistant/screenshot-manager.js
src/main-process/features/settings/ipc.js
src/main-process/features/window/window-constants.js
src/main-process/features/window/window-controller.js
src/main-process/shared/safe-send.js
src/main-process/start-application.js
src/main-process/startup-logging.js
src/main.js
src/services/ai/gemini-service.js
src/services/ai/prompts.js
src/services/assembly-ai/ipc.js
src/services/assembly-ai/service.js
src/services/assembly-ai/stt-history.js
src/services/state/app-state.js
src/windows/assistant/pcm-capture-worklet.js
src/windows/assistant/preload.js
src/windows/assistant/preload/actions.js
src/windows/assistant/preload/create-electron-api.js
src/windows/assistant/preload/helpers.js
src/windows/assistant/preload/listeners.js
src/windows/assistant/renderer-globals.d.ts
src/windows/assistant/renderer.html
src/windows/assistant/renderer.js
src/windows/assistant/renderer/features/ai-context/context-bundle.js
src/windows/assistant/renderer/features/ai-context/message-store.js
src/windows/assistant/renderer/features/ai-context/message-types.js
src/windows/assistant/renderer/features/ai-context/toggle-ui.js
src/windows/assistant/renderer/features/assembly-ai/audio-pipeline.js
src/windows/assistant/renderer/features/assembly-ai/source-state.js
src/windows/assistant/renderer/features/assembly-ai/transcript-buffer.js
src/windows/assistant/renderer/features/chat/chat-ui-manager.js
src/windows/assistant/renderer/features/layout/window-adjustments.js
src/windows/assistant/renderer/features/listeners/event-listeners.js
src/windows/assistant/renderer/features/listeners/ipc-listeners.js
src/windows/assistant/renderer/features/settings/settings-panel-manager.js
src/windows/assistant/renderer/features/settings/shortcut-manager.js
src/windows/assistant/renderer/features/transcription/transcription-manager.js
src/windows/assistant/styles.css
src/windows/assistant/window.js
src/windows/legacy/renderer-webspeech-broken.js
src/windows/legacy/renderer-whisper-backup.js
src/windows/legacy/whisper-worker.js

================================================================
Files
================================================================

================
File: assets/README.md
================
# Assets Folder - Chrome Icons Required

This folder should contain Chrome icon files for building the disguised executable.

## Required Files:

1. **chrome.ico** (Windows) - 256x256 or higher
2. **chrome.icns** (macOS) - For Mac builds
3. **chrome.png** (Linux) - 512x512 for Linux builds

## How to Get Chrome Icons:

### Method 1: Extract from Chrome Installation

**Windows:**
1. Navigate to: `C:\Program Files\Google\Chrome\Application\`
2. Find `chrome.exe`
3. Right-click → Properties → Icons tab
4. Use a tool like [ResourceHacker](http://www.angusj.com/resourcehacker/) to extract
5. Save as `chrome.ico` in this folder

### Method 2: Download from Icon Sites

**Recommended Sites:**
- https://icon-icons.com/icon/chrome/194617
- https://www.iconfinder.com/icons/386254/chrome_icon
- https://icons8.com/icons/set/chrome

**Download Requirements:**
- **Windows**: ICO format, 256x256 pixels minimum
- **macOS**: ICNS format (if building for Mac)
- **Linux**: PNG format, 512x512 pixels

### Method 3: Use Online Converter

If you have a Chrome PNG:
1. Go to: https://convertio.co/png-ico/
2. Upload Chrome PNG (high resolution)
3. Convert to ICO (256x256)
4. Download and save as `chrome.ico`

## File Placement:

After obtaining the icons, your folder should look like:
```
d:\Open-Cluely\assets\
  ├── chrome.ico     ← Windows icon (REQUIRED for building)
  ├── chrome.icns    ← macOS icon (optional)
  ├── chrome.png     ← Linux icon (optional)
  └── README.md      ← This file
```

## Verification:

Before building, verify:
- [ ] `chrome.ico` exists in this folder
- [ ] Icon is 256x256 or higher resolution
- [ ] Icon looks like the official Chrome logo

## Quick Build Test:

After adding icons, test the build:
```bash
npm run build
```

If successful, you should see:
- `dist/GoogleChrome.exe` with Chrome icon
- Icon visible in File Explorer
- Icon shows in Task Manager

## Troubleshooting:

**Icon doesn't show:**
- Make sure filename is exactly `chrome.ico`
- Check file is in ICO format (not renamed PNG)
- Resolution must be 256x256 or higher
- Try rebuilding with `--clean` flag

**Can't find Chrome icon:**
- Check `C:\Program Files\Google\Chrome\Application\chrome.exe`
- Use ResourceHacker to extract icon from chrome.exe
- Or download from icon sites listed above

---

**Note:** This is for educational purposes and authorized use only.

================
File: scripts/fetch-gemini-models.js
================
// ============================================================================
// SCRIPT: fetch-gemini-models.js
// ============================================================================
// Fetches all supported Google Gemini models from the API and shows which
// ones support generateContent (usable for chat/AI).
//
// Usage:
//   node scripts/fetch-gemini-models.js
//
// Reads GEMINI_API_KEY from .env (same as the app). Supports comma-separated
// keys — uses the first valid one found.
// ============================================================================

const https = require('https');
const path = require('path');

// Load .env from project root (same as app infrastructure)
require('dotenv').config({ path: path.join(__dirname, '..', '.env') });

const { getGeminiModels } = require('../src/config');

// ============================================================================
// API key resolution (mirrors the app's multi-key support)
// ============================================================================

function resolveApiKey() {
  const raw = String(process.env.GEMINI_API_KEY || '').trim();
  if (!raw) {
    return null;
  }
  // Support comma-separated keys — use the first non-empty one
  const keys = raw.split(',').map((k) => k.trim()).filter(Boolean);
  return keys[0] || null;
}

// ============================================================================
// HTTP helpers
// ============================================================================

function httpsGet(url) {
  return new Promise((resolve, reject) => {
    https.get(url, (res) => {
      const chunks = [];
      res.on('data', (chunk) => chunks.push(chunk));
      res.on('end', () => {
        const body = Buffer.concat(chunks).toString();
        if (res.statusCode >= 400) {
          let parsed;
          try { parsed = JSON.parse(body); } catch { parsed = { message: body }; }
          const msg = parsed?.error?.message || parsed?.message || body;
          reject(new Error(`HTTP ${res.statusCode}: ${msg}`));
        } else {
          try {
            resolve(JSON.parse(body));
          } catch {
            reject(new Error('Failed to parse response as JSON'));
          }
        }
      });
      res.on('error', reject);
    }).on('error', reject);
  });
}

// ============================================================================
// Fetch models from both v1 and v1beta endpoints
// ============================================================================

async function fetchModels(apiKey, apiVersion) {
  const url = `https://generativelanguage.googleapis.com/${apiVersion}/models?key=${apiKey}`;
  try {
    const data = await httpsGet(url);
    return (data.models || []);
  } catch (error) {
    console.warn(`  [${apiVersion}] ${error.message}`);
    return [];
  }
}

// ============================================================================
// Display helpers
// ============================================================================

function formatModel(model, configuredModels) {
  const name = model.name || '';               // e.g. "models/gemini-1.5-flash"
  const displayName = model.displayName || name;
  const shortName = name.replace(/^models\//, '');
  const methods = (model.supportedGenerationMethods || []);
  const supportsGenerate = methods.includes('generateContent');
  const isConfigured = configuredModels.includes(shortName);

  const tags = [];
  if (supportsGenerate) tags.push('generateContent');
  if (isConfigured) tags.push('IN CONFIG');

  return { shortName, displayName, supportsGenerate, isConfigured, tags, methods };
}

// ============================================================================
// Main
// ============================================================================

async function main() {
  console.log('=== Gemini Model Fetcher ===\n');

  const apiKey = resolveApiKey();
  if (!apiKey) {
    console.error('ERROR: GEMINI_API_KEY not set in .env');
    console.error('  Add your key to .env: GEMINI_API_KEY=your_key_here');
    process.exit(1);
  }
  console.log(`API key loaded from .env (${apiKey.slice(0, 8)}...)\n`);

  const configuredModels = getGeminiModels();
  console.log('Models currently in src/config.js:');
  configuredModels.forEach((m) => console.log(`  - ${m}`));
  console.log();

  // Fetch from both API versions to get the widest coverage
  console.log('Fetching models from Google Generative AI API...');
  const [v1Models, v1betaModels] = await Promise.all([
    fetchModels(apiKey, 'v1'),
    fetchModels(apiKey, 'v1beta')
  ]);

  // Deduplicate by model name
  const seen = new Set();
  const allModels = [...v1Models, ...v1betaModels].filter((m) => {
    if (seen.has(m.name)) return false;
    seen.add(m.name);
    return true;
  });

  if (allModels.length === 0) {
    console.error('No models returned. Check your API key and internet connection.');
    process.exit(1);
  }

  const formatted = allModels.map((m) => formatModel(m, configuredModels));

  // Split into generateContent-capable vs others
  const generateModels = formatted.filter((m) => m.supportsGenerate);
  const otherModels = formatted.filter((m) => !m.supportsGenerate);

  // ---- generateContent-capable models ----
  console.log(`\n${'─'.repeat(60)}`);
  console.log(`Models supporting generateContent (${generateModels.length} found):`);
  console.log('─'.repeat(60));

  for (const m of generateModels) {
    const configured = m.isConfigured ? ' ✓ IN CONFIG' : '';
    console.log(`  ${m.shortName}${configured}`);
    if (m.displayName && m.displayName !== m.shortName) {
      console.log(`    Display name: ${m.displayName}`);
    }
  }

  // ---- other models ----
  if (otherModels.length > 0) {
    console.log(`\n${'─'.repeat(60)}`);
    console.log(`Other models (no generateContent support, ${otherModels.length} found):`);
    console.log('─'.repeat(60));
    for (const m of otherModels) {
      const methods = m.methods.join(', ') || 'none';
      console.log(`  ${m.shortName}  [${methods}]`);
    }
  }

  // ---- config validation ----
  console.log(`\n${'─'.repeat(60)}`);
  console.log('Config validation:');
  console.log('─'.repeat(60));
  const generateModelNames = generateModels.map((m) => m.shortName);
  for (const name of configuredModels) {
    const valid = generateModelNames.includes(name);
    const status = valid ? '  OK' : '  NOT FOUND / UNSUPPORTED';
    console.log(`  ${name}${status}`);
  }

  console.log(`\nTotal models: ${allModels.length} (${generateModels.length} support generateContent)\n`);
}

main().catch((err) => {
  console.error('Fatal error:', err.message);
  process.exit(1);
});

================
File: SETUP-VOSK.md
================
# Vosk Setup Guide

This guide provides detailed instructions for setting up Vosk speech recognition in Open-Cluely.

## Prerequisites

- Python 3.8 or newer
- pip (Python package installer)
- A working microphone
- At least 2GB of free disk space (for the model)

## Installation Steps

### 1. Install Python Dependencies

```bash
# Install Vosk
pip install vosk

# Install sounddevice for audio capture
pip install sounddevice

# Install requests (used for model download)
pip install requests
```

### 2. Model Download

When you first run Open-Cluely, it will automatically download the Vosk model (approximately 1.8GB). However, if you want to download it manually:

1. Create a models directory in your application folder
2. Download the model from [Vosk's model repository](https://alphacephei.com/vosk/models)
3. Extract the model files into the models directory

The default model used is `vosk-model-small-en-us-0.15`, which provides a good balance between accuracy and performance.

## Troubleshooting

### Common Issues

#### 1. No Microphone Access

**Symptoms:**
- No transcription appears
- Error messages about audio device

**Solutions:**
- Check if your microphone is properly connected
- Verify microphone permissions in your OS settings
- Try selecting a different audio input device

#### 2. Model Download Fails

**Symptoms:**
- Error during first launch
- Missing model files

**Solutions:**
- Check your internet connection
- Manually download the model (see Manual Model Installation below)
- Verify you have enough disk space

#### 3. Performance Issues

**Symptoms:**
- Delayed transcription
- High CPU usage

**Solutions:**
- Close other CPU-intensive applications
- Consider using a smaller model
- Ensure your Python installation matches your system architecture (32/64 bit)

### Manual Model Installation

If the automatic model download fails, you can install it manually:

1. Create a directory: `models`
2. Download the model from: https://alphacephei.com/vosk/models
3. Select `vosk-model-small-en-us-0.15` (recommended)
4. Extract the downloaded archive into the models directory
5. Verify the path structure matches: `models/vosk-model-small-en-us-0.15/`

## Advanced Configuration

### Selecting Different Models

Vosk offers various models with different sizes and languages. You can change the model by:

1. Downloading a different model from [Vosk Models](https://alphacephei.com/vosk/models)
2. Extracting it to the models directory
3. Updating the model path in the application settings

Available model types:
- Small models (~50MB) - Fast but less accurate
- Medium models (~1.8GB) - Good balance (recommended)
- Large models (~4GB) - Most accurate but slower

### Audio Device Selection

By default, the system's default microphone is used. To use a different audio device:

1. List available devices:
```python
import sounddevice as sd
print(sd.query_devices())
```

2. Note the device index you want to use
3. Update the device settings in your configuration

## System-Specific Notes

### Windows
- Ensure Microsoft Visual C++ Redistributable is installed
- Use Python 3.8+ 64-bit version
- Check Windows Security for microphone permissions

### macOS
- Grant microphone permissions in System Preferences
- Install Python through Homebrew for best compatibility

### Linux
- Install PortAudio development package:
  ```bash
  # Ubuntu/Debian
  sudo apt-get install portaudio19-dev
  
  # Fedora
  sudo dnf install portaudio-devel
  ```
- Ensure your user has audio device permissions

## Additional Resources

- [Vosk API Documentation](https://alphacephei.com/vosk/api)
- [Vosk Models Repository](https://alphacephei.com/vosk/models)
- [sounddevice Documentation](https://python-sounddevice.readthedocs.io/)

## Support

If you encounter any issues not covered in this guide:
1. Check the [GitHub Issues](https://github.com/yourusername/open-cluely/issues)
2. Create a new issue with:
   - Your system information
   - Error messages
   - Steps to reproduce the problem

================
File: src/main-process/shared/safe-send.js
================
function createSafeSender(getMainWindow) {
  return function sendToRenderer(channel, data) {
    const mainWindow = typeof getMainWindow === 'function' ? getMainWindow() : null;
    if (!mainWindow || mainWindow.isDestroyed()) return false;

    const contents = mainWindow.webContents;
    if (!contents || contents.isDestroyed()) return false;

    if (typeof contents.isCrashed === 'function' && contents.isCrashed()) {
      return false;
    }

    const frame = contents.mainFrame;
    if (frame && typeof frame.isDestroyed === 'function' && frame.isDestroyed()) {
      return false;
    }

    try {
      contents.send(channel, data);
      return true;
    } catch (error) {
      console.error(`Failed to send renderer event "${channel}":`, error.message);
      return false;
    }
  };
}

module.exports = {
  createSafeSender
};

================
File: src/services/assembly-ai/ipc.js
================
function registerAssemblyAiIpc({ ipcMain, assemblyAiService }) {
  ipcMain.handle('start-voice-recognition', (_event, { source } = {}) => {
    const resolvedSource = source === 'system' ? 'system' : 'mic';
    console.log(`IPC: start-voice-recognition [${resolvedSource}]`);
    assemblyAiService.emitSttDebug({
      source: resolvedSource,
      event: 'ipc-start',
      message: 'Renderer requested source start'
    });

    return assemblyAiService.startAssemblyAiStream(resolvedSource);
  });

  ipcMain.on('audio-chunk', (_event, payload = {}) => {
    assemblyAiService.handleAudioChunk(payload);
  });

  ipcMain.handle('stop-voice-recognition', (_event, { source } = {}) => {
    console.log(`IPC: stop-voice-recognition [${source}]`);
    return assemblyAiService.stopVoiceRecognition({ source });
  });

  ipcMain.handle('get-desktop-sources', async () => {
    return assemblyAiService.getDesktopSources();
  });

  ipcMain.handle('transcribe-audio', async (_event, base64Audio) => {
    console.log('IPC: transcribe-audio called, size:', base64Audio?.length || 0);
    return assemblyAiService.transcribeAudio(base64Audio);
  });
}

module.exports = {
  registerAssemblyAiIpc
};

================
File: src/services/assembly-ai/stt-history.js
================
function normalizeSttSource(source) {
  return source === 'system' ? 'system' : 'mic';
}

function normalizeTranscriptForMerge(text) {
  return String(text || '')
    .toLowerCase()
    .replace(/[^a-z0-9\s]/g, ' ')
    .replace(/\s+/g, ' ')
    .trim();
}

function mergeTranscriptText(existingText, incomingText) {
  const current = String(existingText || '').trim();
  const incoming = String(incomingText || '').trim();

  if (!current) return incoming;
  if (!incoming) return current;

  const currentNorm = normalizeTranscriptForMerge(current);
  const incomingNorm = normalizeTranscriptForMerge(incoming);

  if (!incomingNorm) return current;
  if (!currentNorm) return incoming;

  if (currentNorm === incomingNorm) {
    return incoming.length >= current.length ? incoming : current;
  }

  if (incomingNorm.includes(currentNorm)) {
    return incoming;
  }

  if (currentNorm.includes(incomingNorm)) {
    return current;
  }

  const currentWords = current.split(/\s+/);
  const incomingWords = incoming.split(/\s+/);
  const maxOverlap = Math.min(12, currentWords.length, incomingWords.length);
  let overlap = 0;

  for (let size = maxOverlap; size > 0; size -= 1) {
    const currentTail = currentWords.slice(-size).join(' ').toLowerCase();
    const incomingHead = incomingWords.slice(0, size).join(' ').toLowerCase();
    if (currentTail === incomingHead) {
      overlap = size;
      break;
    }
  }

  if (overlap > 0) {
    const remainder = incomingWords.slice(overlap).join(' ');
    if (!remainder) return current;
    return `${current} ${remainder}`.replace(/\s+/g, ' ').trim();
  }

  return `${current} ${incoming}`.replace(/\s+/g, ' ').trim();
}

function createSttHistoryManager({
  getGeminiService,
  emitSttDebug,
  mergeWindowMs = 2400
}) {
  const sttHistoryBuffers = {
    mic: { text: '', segments: 0, timer: null },
    system: { text: '', segments: 0, timer: null }
  };

  function clearSttHistoryTimer(source) {
    const resolvedSource = normalizeSttSource(source);
    const timer = sttHistoryBuffers[resolvedSource].timer;
    if (timer) {
      clearTimeout(timer);
      sttHistoryBuffers[resolvedSource].timer = null;
    }
  }

  function resetSttHistoryBuffer(source) {
    const resolvedSource = normalizeSttSource(source);
    clearSttHistoryTimer(resolvedSource);
    sttHistoryBuffers[resolvedSource].text = '';
    sttHistoryBuffers[resolvedSource].segments = 0;
  }

  function flushSttHistoryBuffer(source, reason = 'pause-timeout') {
    const resolvedSource = normalizeSttSource(source);
    const buffer = sttHistoryBuffers[resolvedSource];
    const finalText = String(buffer.text || '').trim();
    const segmentCount = buffer.segments;

    clearSttHistoryTimer(resolvedSource);
    buffer.text = '';
    buffer.segments = 0;

    const geminiService = getGeminiService();
    if (!finalText || !geminiService) {
      return;
    }

    try {
      const label = resolvedSource === 'system' ? 'Host' : 'You';
      geminiService.addToHistory('user', `${label}: ${finalText}`);
      emitSttDebug({
        source: resolvedSource,
        event: 'history-flush',
        message: 'Merged transcript added to Gemini history',
        meta: {
          reason,
          chars: finalText.length,
          segments: segmentCount
        }
      });
    } catch (error) {
      emitSttDebug({
        source: resolvedSource,
        level: 'error',
        event: 'history-flush-failed',
        message: error?.message || 'Failed to add merged transcript to history'
      });
    }
  }

  function flushAllSttHistoryBuffers(reason = 'flush-all') {
    flushSttHistoryBuffer('mic', reason);
    flushSttHistoryBuffer('system', reason);
  }

  function queueSttHistorySegment(source, transcriptText) {
    const resolvedSource = normalizeSttSource(source);
    const buffer = sttHistoryBuffers[resolvedSource];

    buffer.text = mergeTranscriptText(buffer.text, transcriptText);
    buffer.segments += 1;

    emitSttDebug({
      source: resolvedSource,
      event: 'history-buffer',
      message: 'Buffered final transcript segment',
      meta: {
        segments: buffer.segments,
        chars: buffer.text.length
      }
    });

    clearSttHistoryTimer(resolvedSource);

    buffer.timer = setTimeout(() => {
      flushSttHistoryBuffer(resolvedSource, 'pause-timeout');
    }, mergeWindowMs);
  }

  function dispose() {
    resetSttHistoryBuffer('mic');
    resetSttHistoryBuffer('system');
  }

  return {
    flushAllSttHistoryBuffers,
    flushSttHistoryBuffer,
    queueSttHistorySegment,
    resetSttHistoryBuffer,
    dispose
  };
}

module.exports = {
  createSttHistoryManager,
  normalizeSttSource
};

================
File: src/windows/assistant/pcm-capture-worklet.js
================
class PcmCaptureProcessor extends AudioWorkletProcessor {
  constructor() {
    super();
    this.chunkSize = 2048;
    this.buffer = new Float32Array(this.chunkSize * 4);
    this.writeOffset = 0;
  }

  process(inputs) {
    const input = inputs[0];
    if (!input || input.length === 0) {
      return true;
    }

    const channelData = input[0];
    if (!channelData || channelData.length === 0) {
      return true;
    }

    this.pushSamples(channelData);
    return true;
  }

  pushSamples(channelData) {
    let readOffset = 0;
    while (readOffset < channelData.length) {
      const freeSpace = this.buffer.length - this.writeOffset;
      const toCopy = Math.min(freeSpace, channelData.length - readOffset);
      this.buffer.set(channelData.subarray(readOffset, readOffset + toCopy), this.writeOffset);
      this.writeOffset += toCopy;
      readOffset += toCopy;

      while (this.writeOffset >= this.chunkSize) {
        const chunk = this.buffer.slice(0, this.chunkSize);
        this.port.postMessage(chunk);

        const remaining = this.writeOffset - this.chunkSize;
        if (remaining > 0) {
          this.buffer.copyWithin(0, this.chunkSize, this.writeOffset);
        }
        this.writeOffset = remaining;
      }
    }
  }
}

registerProcessor('pcm-capture-processor', PcmCaptureProcessor);

================
File: src/windows/assistant/preload/create-electron-api.js
================
const { createInvokeActions } = require('./actions');
const { createEventActions } = require('./listeners');

function createElectronApi(ipcRenderer) {
  const invokeActions = createInvokeActions(ipcRenderer);
  const eventActions = createEventActions(ipcRenderer);

  return {
    ...invokeActions,
    ...eventActions,
    log: (message) => {
      console.log('PreloadAPI log:', message);
    },
    isAvailable: () => true
  };
}

module.exports = {
  createElectronApi
};

================
File: src/windows/assistant/preload/helpers.js
================
function invokeWithFallback(ipcRenderer, { channel, label, fallback, transformArgs }) {
  return (...args) => {
    const callArgs = typeof transformArgs === 'function' ? transformArgs(args) : args;

    console.log(`PreloadAPI: ${label} called`);

    return ipcRenderer.invoke(channel, ...callArgs).catch((error) => {
      console.error(`PreloadAPI: ${label} error:`, error);
      return typeof fallback === 'function' ? fallback(error) : fallback;
    });
  };
}

function createEventListener(ipcRenderer, { channel, label }) {
  return (callback) => {
    const handler = (_event, payload) => {
      try {
        callback(payload);
      } catch (error) {
        console.error(`PreloadAPI: ${label} callback error:`, error);
      }
    };

    ipcRenderer.on(channel, handler);

    return () => {
      console.log(`PreloadAPI: removing ${label} listener`);
      ipcRenderer.removeListener(channel, handler);
    };
  };
}

module.exports = {
  createEventListener,
  invokeWithFallback
};

================
File: src/windows/assistant/renderer-globals.d.ts
================
export {};

declare global {
  interface Window {
    electronAPI: any;
  }
}

================
File: src/windows/assistant/renderer/features/ai-context/context-bundle.js
================
import {
  contextLineForMessage,
  isScreenshotMessageType,
  isSystemMessageType,
  isTranscriptMessageType,
  summaryLineForMessage
} from './message-types.js';

export function buildFilteredAiContextBundle({
  messages,
  isMessageIncludedForAi,
  charBudget,
  emitTruncationLog = true,
  onTruncationLog
}) {
  const candidates = messages
    .filter(isMessageIncludedForAi)
    .map((message) => ({
      message,
      contextLine: contextLineForMessage(message),
      summaryLine: summaryLineForMessage(message)
    }))
    .filter((entry) => entry.contextLine.length > 0);

  const selectedReversed = [];
  let currentChars = 0;
  let dropped = 0;

  for (let index = candidates.length - 1; index >= 0; index -= 1) {
    const entry = candidates[index];
    const nextCost = entry.contextLine.length + 1;

    if (currentChars + nextCost > charBudget) {
      dropped += 1;
      continue;
    }

    selectedReversed.push(entry);
    currentChars += nextCost;
  }

  const selected = selectedReversed.reverse();

  if (emitTruncationLog && dropped > 0 && typeof onTruncationLog === 'function') {
    onTruncationLog(dropped, charBudget);
  }

  const transcriptContext = selected
    .filter((entry) => isTranscriptMessageType(entry.message.type))
    .map((entry) => entry.contextLine)
    .join('\n');

  const sessionSummary = selected
    .filter((entry) => !isSystemMessageType(entry.message.type))
    .map((entry) => entry.summaryLine)
    .filter((line) => line.length > 0)
    .slice(-16)
    .join('\n');

  const enabledScreenshotIds = Array.from(
    new Set(
      selected
        .filter((entry) => isScreenshotMessageType(entry.message.type))
        .map((entry) => entry.message.screenshotId)
        .filter((value) => typeof value === 'string' && value.trim().length > 0)
    )
  );

  return {
    contextString: selected.map((entry) => entry.contextLine).join('\n'),
    transcriptContext,
    sessionSummary,
    enabledScreenshotIds,
    droppedMessages: dropped,
    selectedMessages: selected.length,
    charBudget
  };
}

================
File: src/windows/assistant/renderer/features/ai-context/message-store.js
================
import {
  canToggleAiForMessageType,
  defaultIncludeInAiForMessageType,
  isSystemMessageType
} from './message-types.js';

export function createMessageStore() {
  let messages = [];
  let sequence = 0;

  function nextId() {
    sequence += 1;
    return `msg-${sequence}`;
  }

  function createRecord(type, content, options = {}) {
    return {
      id: options.id || nextId(),
      type,
      content,
      timestamp: options.timestamp || new Date(),
      canToggleAi: typeof options.canToggleAi === 'boolean'
        ? options.canToggleAi
        : canToggleAiForMessageType(type),
      includeInAi: typeof options.includeInAi === 'boolean'
        ? options.includeInAi
        : defaultIncludeInAiForMessageType(type),
      screenshotId: typeof options.screenshotId === 'string' ? options.screenshotId : null
    };
  }

  function add(type, content, options = {}) {
    const record = createRecord(type, content, options);
    messages.push(record);
    return record;
  }

  function clear() {
    messages = [];
    sequence = 0;
  }

  function findById(messageId) {
    return messages.find((message) => message.id === messageId);
  }

  function getMessages() {
    return messages.slice();
  }

  function toggleInclusion(messageId) {
    const message = findById(messageId);
    if (!message || !message.canToggleAi) {
      return null;
    }

    message.includeInAi = !message.includeInAi;
    return message;
  }

  function isIncludedForAi(message) {
    if (!message || isSystemMessageType(message.type)) {
      return false;
    }

    if (message.canToggleAi) {
      return !!message.includeInAi;
    }

    return message.includeInAi !== false;
  }

  return {
    add,
    clear,
    findById,
    getMessages,
    isIncludedForAi,
    toggleInclusion
  };
}

================
File: src/windows/assistant/renderer/features/assembly-ai/audio-pipeline.js
================
import { normalizeSource } from './source-state.js';

const TARGET_SAMPLE_RATE = 16000;
const TARGET_FRAME_MS = 100;
const MIN_FRAME_MS = 50;
const TARGET_FRAME_SAMPLES = Math.round((TARGET_SAMPLE_RATE * TARGET_FRAME_MS) / 1000);
const MIN_FRAME_SAMPLES = Math.round((TARGET_SAMPLE_RATE * MIN_FRAME_MS) / 1000);
const WORKLET_MODULE_PATH = 'pcm-capture-worklet.js';

export function createAudioPipeline({ sendAudioChunk, addMonitorLog }) {
  const workletLoadedContexts = new WeakSet();
  const sourceSampleQueues = {
    mic: { chunks: [], length: 0 },
    system: { chunks: [], length: 0 }
  };
  const audioChunkCounters = { mic: 0, system: 0 };

  function convertToPCM16(float32Data) {
    const int16Data = new Int16Array(float32Data.length);
    for (let index = 0; index < float32Data.length; index += 1) {
      const sample = Math.max(-1, Math.min(1, float32Data[index]));
      int16Data[index] = sample < 0 ? sample * 0x8000 : sample * 0x7fff;
    }
    return int16Data;
  }

  function downsampleFloat32Buffer(input, inputSampleRate, outputSampleRate = TARGET_SAMPLE_RATE) {
    if (inputSampleRate <= 0 || outputSampleRate <= 0 || input.length === 0) {
      return input;
    }

    if (inputSampleRate === outputSampleRate) {
      return input;
    }

    const sampleRateRatio = inputSampleRate / outputSampleRate;
    const newLength = Math.max(1, Math.round(input.length / sampleRateRatio));
    const result = new Float32Array(newLength);
    let offsetResult = 0;
    let offsetInput = 0;

    while (offsetResult < result.length) {
      const nextOffsetInput = Math.min(input.length, Math.round((offsetResult + 1) * sampleRateRatio));
      let accum = 0;
      let count = 0;

      for (let index = offsetInput; index < nextOffsetInput; index += 1) {
        accum += input[index];
        count += 1;
      }

      result[offsetResult] = count > 0 ? accum / count : 0;
      offsetResult += 1;
      offsetInput = nextOffsetInput;
    }

    return result;
  }

  async function ensureWorkletModule(context) {
    if (workletLoadedContexts.has(context)) {
      return;
    }

    await context.audioWorklet.addModule(WORKLET_MODULE_PATH);
    workletLoadedContexts.add(context);
  }

  function isLikelyCameraTrack(trackLabel) {
    const label = String(trackLabel || '').toLowerCase();
    return label.includes('camera') || label.includes('webcam');
  }

  async function getSystemAudioStream(sourceId) {
    const mandatoryConstraints = {
      audio: {
        mandatory: {
          chromeMediaSource: 'desktop',
          chromeMediaSourceId: sourceId
        }
      },
      video: {
        mandatory: {
          chromeMediaSource: 'desktop',
          chromeMediaSourceId: sourceId
        }
      }
    };

    const flatConstraints = {
      audio: { chromeMediaSource: 'desktop', chromeMediaSourceId: sourceId },
      video: { chromeMediaSource: 'desktop', chromeMediaSourceId: sourceId }
    };

    try {
      return await navigator.mediaDevices.getUserMedia(mandatoryConstraints);
    } catch (_mandatoryError) {
      addMonitorLog(
        'info',
        'desktop-constraints-fallback',
        'Mandatory desktop constraints failed; trying flat syntax',
        'system'
      );
      return navigator.mediaDevices.getUserMedia(flatConstraints);
    }
  }

  function resetSourceSampleQueue(source) {
    const resolvedSource = normalizeSource(source);
    sourceSampleQueues[resolvedSource] = { chunks: [], length: 0 };
  }

  function appendSourceSamples(source, samples) {
    if (!samples || samples.length === 0) {
      return;
    }

    const resolvedSource = normalizeSource(source);
    sourceSampleQueues[resolvedSource].chunks.push(samples);
    sourceSampleQueues[resolvedSource].length += samples.length;
  }

  function pullSourceSamples(source, count) {
    const resolvedSource = normalizeSource(source);
    const queue = sourceSampleQueues[resolvedSource];
    const output = new Float32Array(count);
    let written = 0;

    while (written < count && queue.chunks.length > 0) {
      const first = queue.chunks[0];
      const take = Math.min(first.length, count - written);
      output.set(first.subarray(0, take), written);
      written += take;

      if (take === first.length) {
        queue.chunks.shift();
      } else {
        queue.chunks[0] = first.subarray(take);
      }

      queue.length -= take;
    }

    if (written === count) {
      return output;
    }

    return output.subarray(0, written);
  }

  function sendPcmFrame(source, floatSamples) {
    if (!floatSamples || floatSamples.length < MIN_FRAME_SAMPLES) {
      return;
    }

    const resolvedSource = normalizeSource(source);
    const pcm = convertToPCM16(floatSamples);
    sendAudioChunk(resolvedSource, pcm.buffer);
    audioChunkCounters[resolvedSource] += 1;

    if (audioChunkCounters[resolvedSource] % 50 === 0) {
      addMonitorLog('info', 'chunk-heartbeat', `Chunks sent: ${audioChunkCounters[resolvedSource]}`, resolvedSource, {
        chunks: audioChunkCounters[resolvedSource],
        frameSamples: floatSamples.length
      });
    }
  }

  function drainSourceSampleQueue(source, { flushPartial = false } = {}) {
    const resolvedSource = normalizeSource(source);
    const queue = sourceSampleQueues[resolvedSource];

    while (queue.length >= TARGET_FRAME_SAMPLES) {
      const frame = pullSourceSamples(resolvedSource, TARGET_FRAME_SAMPLES);
      sendPcmFrame(resolvedSource, frame);
    }

    if (flushPartial && queue.length >= MIN_FRAME_SAMPLES) {
      const tailFrame = pullSourceSamples(resolvedSource, queue.length);
      sendPcmFrame(resolvedSource, tailFrame);
    }
  }

  async function buildAudioProcessor(context, stream, source, activeCheck) {
    await ensureWorkletModule(context);

    const src = context.createMediaStreamSource(stream);
    const node = new AudioWorkletNode(context, 'pcm-capture-processor', {
      numberOfInputs: 1,
      numberOfOutputs: 1,
      outputChannelCount: [1]
    });

    const silentGain = context.createGain();
    silentGain.gain.value = 0;

    node.port.onmessage = (event) => {
      if (!activeCheck()) {
        return;
      }

      try {
        const chunk = event.data instanceof Float32Array ? event.data : new Float32Array(event.data || []);
        const normalizedChunk = downsampleFloat32Buffer(chunk, context.sampleRate, TARGET_SAMPLE_RATE);
        appendSourceSamples(source, normalizedChunk);
        drainSourceSampleQueue(source);
      } catch (error) {
        addMonitorLog('error', 'audio-process-failed', error.message || 'Audio processing failed', source);
      }
    };

    src.connect(node);
    node.connect(silentGain);
    silentGain.connect(context.destination);

    return {
      disconnect: () => {
        try {
          node.port.onmessage = null;
        } catch (_) {
          // no-op
        }
        try {
          src.disconnect();
        } catch (_) {
          // no-op
        }
        try {
          node.disconnect();
        } catch (_) {
          // no-op
        }
        try {
          silentGain.disconnect();
        } catch (_) {
          // no-op
        }
      }
    };
  }

  function stopAudioResources(context, stream, processor) {
    try {
      processor?.disconnect();
    } catch (_) {
      // no-op
    }

    try {
      context?.close();
    } catch (_) {
      // no-op
    }

    stream?.getTracks().forEach((track) => track.stop());
  }

  function resetChunkCounter(source) {
    audioChunkCounters[normalizeSource(source)] = 0;
  }

  return {
    buildAudioProcessor,
    drainSourceSampleQueue,
    getSystemAudioStream,
    isLikelyCameraTrack,
    resetChunkCounter,
    resetSourceSampleQueue,
    stopAudioResources
  };
}

================
File: src/windows/assistant/renderer/features/assembly-ai/source-state.js
================
export function normalizeSource(source) {
  return source === 'system' ? 'system' : 'mic';
}

export function sourceLabel(source) {
  return source === 'system' ? 'Host' : 'Mic';
}

export function createTranscriptionSourceState() {
  const selectedSources = {
    system: true,
    mic: false
  };

  const sourceStatuses = {
    system: 'off',
    mic: 'off'
  };

  const activeSources = {
    system: false,
    mic: false
  };

  function setSourceSelected(source, enabled) {
    selectedSources[normalizeSource(source)] = !!enabled;
  }

  function isSourceSelected(source) {
    return !!selectedSources[normalizeSource(source)];
  }

  function getSelectedSources() {
    return { ...selectedSources };
  }

  function setSourceStatus(source, status) {
    const resolvedSource = normalizeSource(source);
    const allowedStatuses = new Set(['off', 'connecting', 'listening', 'error']);
    sourceStatuses[resolvedSource] = allowedStatuses.has(status) ? status : 'off';
  }

  function getSourceStatus(source) {
    return sourceStatuses[normalizeSource(source)];
  }

  function getSourceStatuses() {
    return { ...sourceStatuses };
  }

  function setSourceActive(source, active) {
    activeSources[normalizeSource(source)] = !!active;
  }

  function isSourceActive(source) {
    return !!activeSources[normalizeSource(source)];
  }

  function isAnySourceActive() {
    return activeSources.system || activeSources.mic;
  }

  function isAnySourceConnecting() {
    return sourceStatuses.system === 'connecting' || sourceStatuses.mic === 'connecting';
  }

  return {
    selectedSources,
    sourceStatuses,
    getSelectedSources,
    getSourceStatus,
    getSourceStatuses,
    isAnySourceActive,
    isAnySourceConnecting,
    isSourceActive,
    isSourceSelected,
    setSourceActive,
    setSourceSelected,
    setSourceStatus
  };
}

================
File: src/windows/assistant/renderer/features/assembly-ai/transcript-buffer.js
================
import { normalizeSource } from './source-state.js';

function normalizeTranscriptForMerge(text) {
  return String(text || '')
    .toLowerCase()
    .replace(/[^a-z0-9\s]/g, ' ')
    .replace(/\s+/g, ' ')
    .trim();
}

function mergeTranscriptText(existingText, incomingText) {
  const current = String(existingText || '').trim();
  const incoming = String(incomingText || '').trim();

  if (!current) return incoming;
  if (!incoming) return current;

  const currentNorm = normalizeTranscriptForMerge(current);
  const incomingNorm = normalizeTranscriptForMerge(incoming);

  if (!incomingNorm) return current;
  if (!currentNorm) return incoming;

  if (currentNorm === incomingNorm) {
    return incoming.length >= current.length ? incoming : current;
  }

  if (incomingNorm.includes(currentNorm)) {
    return incoming;
  }

  if (currentNorm.includes(incomingNorm)) {
    return current;
  }

  const currentWords = current.split(/\s+/);
  const incomingWords = incoming.split(/\s+/);
  const maxOverlap = Math.min(12, currentWords.length, incomingWords.length);
  let overlap = 0;

  for (let size = maxOverlap; size > 0; size -= 1) {
    const currentTail = currentWords.slice(-size).join(' ').toLowerCase();
    const incomingHead = incomingWords.slice(0, size).join(' ').toLowerCase();
    if (currentTail === incomingHead) {
      overlap = size;
      break;
    }
  }

  if (overlap > 0) {
    const remainder = incomingWords.slice(overlap).join(' ');
    if (!remainder) return current;
    return `${current} ${remainder}`.replace(/\s+/g, ' ').trim();
  }

  return `${current} ${incoming}`.replace(/\s+/g, ' ').trim();
}

export function createTranscriptBufferManager({
  onFlush,
  onBuffer,
  mergeWindowMs = 2400
}) {
  const buffers = {
    mic: { text: '', segments: 0, timer: null },
    system: { text: '', segments: 0, timer: null }
  };

  function clearFinalTranscriptTimer(source) {
    const resolvedSource = normalizeSource(source);
    const timer = buffers[resolvedSource].timer;

    if (timer) {
      clearTimeout(timer);
      buffers[resolvedSource].timer = null;
    }
  }

  function resetFinalTranscriptBuffer(source) {
    const resolvedSource = normalizeSource(source);
    clearFinalTranscriptTimer(resolvedSource);
    buffers[resolvedSource].text = '';
    buffers[resolvedSource].segments = 0;
  }

  function flushFinalTranscript(source, reason = 'pause-timeout') {
    const resolvedSource = normalizeSource(source);
    const buffer = buffers[resolvedSource];
    const text = String(buffer.text || '').trim();
    const segments = buffer.segments;

    clearFinalTranscriptTimer(resolvedSource);
    buffer.text = '';
    buffer.segments = 0;

    if (!text) {
      return;
    }

    onFlush({ source: resolvedSource, text, reason, segments });
  }

  function queueFinalTranscript(source, text) {
    const resolvedSource = normalizeSource(source);
    const buffer = buffers[resolvedSource];

    buffer.text = mergeTranscriptText(buffer.text, text);
    buffer.segments += 1;

    if (typeof onBuffer === 'function') {
      onBuffer({
        source: resolvedSource,
        text: buffer.text,
        segments: buffer.segments
      });
    }

    clearFinalTranscriptTimer(resolvedSource);
    buffer.timer = setTimeout(() => {
      flushFinalTranscript(resolvedSource, 'pause-timeout');
    }, mergeWindowMs);
  }

  function flushAllFinalTranscripts(reason = 'flush-all') {
    flushFinalTranscript('mic', reason);
    flushFinalTranscript('system', reason);
  }

  return {
    flushAllFinalTranscripts,
    flushFinalTranscript,
    queueFinalTranscript,
    resetFinalTranscriptBuffer
  };
}

================
File: src/windows/assistant/renderer/features/layout/window-adjustments.js
================
export function createWindowAdjustmentManager({
    windowResizeHandles,
    chatContainer,
    minWindowWidth,
    minWindowHeight,
    onViewportResize
}) {
    let activeWindowResize = null;
    let pendingWindowBounds = null;
    let windowResizeFrame = null;

    function setupWindowAdjustments() {
        setupWindowResizeHandles();
        enforceChatFillLayout();
        window.addEventListener('resize', () => {
            enforceChatFillLayout();
            onViewportResize?.();
        });
    }

    function enforceChatFillLayout() {
        if (!chatContainer) {
            return;
        }

        // Ensure stale manual-resize inline styles never pin chat height.
        chatContainer.style.removeProperty('height');
    }

    function setupWindowResizeHandles() {
        if (!window.electronAPI || !windowResizeHandles.length) {
            return;
        }

        windowResizeHandles.forEach((handle) => {
            handle.addEventListener('pointerdown', startWindowResize);
        });
    }

    async function startWindowResize(event) {
        if (!window.electronAPI?.getWindowBounds || !window.electronAPI?.setWindowBounds) {
            return;
        }

        event.preventDefault();
        event.stopPropagation();

        const handleElement = event.currentTarget;
        if (!handleElement) {
            return;
        }

        const direction = handleElement.dataset.resizeHandle;
        const pointerId = event.pointerId;
        const startScreenX = event.screenX;
        const startScreenY = event.screenY;
        const startBounds = await window.electronAPI.getWindowBounds();
        if (!startBounds || startBounds.error) {
            console.error('Failed to get initial window bounds:', startBounds?.error);
            return;
        }

        activeWindowResize = {
            direction,
            pointerId,
            startScreenX,
            startScreenY,
            startBounds,
            handleElement
        };

        document.body.classList.add('window-resizing');
        handleElement.setPointerCapture?.(pointerId);

        document.addEventListener('pointermove', onWindowResizeMove);
        document.addEventListener('pointerup', stopWindowResize);
        document.addEventListener('pointercancel', stopWindowResize);
    }

    function onWindowResizeMove(event) {
        if (!activeWindowResize || event.pointerId !== activeWindowResize.pointerId) {
            return;
        }

        event.preventDefault();

        const deltaX = event.screenX - activeWindowResize.startScreenX;
        const deltaY = event.screenY - activeWindowResize.startScreenY;
        const nextBounds = calculateWindowResizeBounds(
            activeWindowResize.startBounds,
            activeWindowResize.direction,
            deltaX,
            deltaY
        );

        scheduleWindowResize(nextBounds);
    }

    function calculateWindowResizeBounds(startBounds, direction, deltaX, deltaY) {
        let { x, y, width, height } = startBounds;

        if (direction.includes('e')) {
            width = Math.max(minWindowWidth, startBounds.width + deltaX);
        }

        if (direction.includes('s')) {
            height = Math.max(minWindowHeight, startBounds.height + deltaY);
        }

        if (direction.includes('w')) {
            const nextWidth = Math.max(minWindowWidth, startBounds.width - deltaX);
            x = startBounds.x + (startBounds.width - nextWidth);
            width = nextWidth;
        }

        if (direction.includes('n')) {
            const nextHeight = Math.max(minWindowHeight, startBounds.height - deltaY);
            y = startBounds.y + (startBounds.height - nextHeight);
            height = nextHeight;
        }

        return {
            x: Math.round(x),
            y: Math.round(y),
            width: Math.round(width),
            height: Math.round(height)
        };
    }

    function scheduleWindowResize(bounds) {
        pendingWindowBounds = bounds;
        if (windowResizeFrame) {
            return;
        }

        windowResizeFrame = window.requestAnimationFrame(async () => {
            windowResizeFrame = null;
            const nextBounds = pendingWindowBounds;
            pendingWindowBounds = null;

            if (!nextBounds) {
                return;
            }

            const result = await window.electronAPI.setWindowBounds(nextBounds);
            if (result && result.error) {
                console.error('Failed to set window bounds:', result.error);
            }
        });
    }

    function stopWindowResize(event) {
        if (!activeWindowResize) {
            return;
        }

        if (event.pointerId && event.pointerId !== activeWindowResize.pointerId) {
            return;
        }

        activeWindowResize.handleElement?.releasePointerCapture?.(activeWindowResize.pointerId);
        activeWindowResize = null;
        pendingWindowBounds = null;

        if (windowResizeFrame) {
            window.cancelAnimationFrame(windowResizeFrame);
            windowResizeFrame = null;
        }

        document.body.classList.remove('window-resizing');
        document.removeEventListener('pointermove', onWindowResizeMove);
        document.removeEventListener('pointerup', stopWindowResize);
        document.removeEventListener('pointercancel', stopWindowResize);
    }

    return {
        setupWindowAdjustments
    };
}

================
File: src/windows/assistant/renderer/features/transcription/transcription-manager.js
================
const MAX_MONITOR_LOG_ENTRIES = 80;

export function createTranscriptionManager({
    transcriptionSourceState,
    normalizeSourceRule,
    sourceLabelRule,
    audioPipeline,
    transcriptBufferManager,
    chatMessagesElement,
    transcriptionToggle,
    sourceSystemToggle,
    sourceMicToggle,
    monitorMasterState,
    monitorStatusSystem,
    monitorStatusMic,
    monitorLiveSystem,
    monitorLiveMic,
    monitorLogList,
    addChatMessage,
    showFeedback
}) {
    let micAudioContext = null;
    let micMediaStream = null;
    let micScriptProcessor = null;
    let isMicActive = false;

    let systemAudioContext = null;
    let systemMediaStream = null;
    let systemScriptProcessor = null;
    let isSystemActive = false;

    let micPartialText = '';
    let micPartialDiv = null;
    let systemPartialText = '';
    let systemPartialDiv = null;

    const selectedSources = transcriptionSourceState.selectedSources;
    const sourceStatuses = transcriptionSourceState.sourceStatuses;
    const monitorLogEntries = [];
    const monitorLastText = {
        system: 'No transcript yet',
        mic: 'No transcript yet'
    };

    function normalizeSource(source) {
        return normalizeSourceRule(source);
    }

    function sourceLabel(source) {
        return sourceLabelRule(normalizeSource(source));
    }

    function isSourceActive(source) {
        return source === 'system' ? isSystemActive : isMicActive;
    }

    function setMicActive(active) {
        isMicActive = !!active;
        transcriptionSourceState.setSourceActive('mic', isMicActive);
    }

    function setSystemActive(active) {
        isSystemActive = !!active;
        transcriptionSourceState.setSourceActive('system', isSystemActive);
    }

    function isAnyTranscriptionActive() {
        return isSystemActive || isMicActive;
    }

    function isAnySourceConnecting() {
        return transcriptionSourceState.isAnySourceConnecting();
    }

    function setSourceStatus(source, status, liveText) {
        const resolvedSource = normalizeSource(source);
        transcriptionSourceState.setSourceStatus(resolvedSource, status);

        if (typeof liveText === 'string' && liveText.trim().length > 0) {
            monitorLastText[resolvedSource] = liveText.trim();
        }

        renderMonitorState();
    }

    function updateTranscriptionUI() {
        const anyActive = isAnyTranscriptionActive();
        const anyConnecting = !anyActive && isAnySourceConnecting();

        if (transcriptionToggle) {
            transcriptionToggle.classList.toggle('active', anyActive);
            transcriptionToggle.classList.toggle('listening', anyActive);
            transcriptionToggle.classList.toggle('connecting', anyConnecting);
        }

        if (sourceSystemToggle) {
            sourceSystemToggle.classList.toggle('selected', selectedSources.system);
            sourceSystemToggle.classList.toggle('running', isSystemActive);
        }

        if (sourceMicToggle) {
            sourceMicToggle.classList.toggle('selected', selectedSources.mic);
            sourceMicToggle.classList.toggle('running', isMicActive);
        }
    }

    function renderMonitorState() {
        updateTranscriptionUI();

        const statusMap = {
            off: 'Off',
            connecting: 'Connecting',
            listening: 'Listening',
            error: 'Error'
        };

        if (monitorStatusSystem) {
            monitorStatusSystem.className = `monitor-status-badge ${sourceStatuses.system}`;
            monitorStatusSystem.textContent = statusMap[sourceStatuses.system] || 'Off';
        }

        if (monitorStatusMic) {
            monitorStatusMic.className = `monitor-status-badge ${sourceStatuses.mic}`;
            monitorStatusMic.textContent = statusMap[sourceStatuses.mic] || 'Off';
        }

        if (monitorLiveSystem) {
            monitorLiveSystem.textContent = monitorLastText.system || 'No transcript yet';
        }

        if (monitorLiveMic) {
            monitorLiveMic.textContent = monitorLastText.mic || 'No transcript yet';
        }

        if (monitorMasterState) {
            monitorMasterState.classList.remove('active', 'connecting');
            if (isAnyTranscriptionActive()) {
                monitorMasterState.textContent = 'Running';
                monitorMasterState.classList.add('active');
            } else if (isAnySourceConnecting()) {
                monitorMasterState.textContent = 'Connecting';
                monitorMasterState.classList.add('connecting');
            } else {
                monitorMasterState.textContent = 'Idle';
            }
        }
    }

    function formatMonitorTime(timestamp = Date.now()) {
        return new Date(timestamp).toLocaleTimeString('en-US', {
            hour: '2-digit',
            minute: '2-digit',
            second: '2-digit'
        });
    }

    function safeJson(value) {
        try {
            return JSON.stringify(value);
        } catch (_) {
            return '';
        }
    }

    function addMonitorLog(level, event, message, source = null, meta = null, timestamp = Date.now()) {
        const entry = {
            level: level || 'info',
            event: event || 'event',
            message: message || '',
            source: source ? normalizeSource(source) : null,
            meta,
            timestamp
        };

        monitorLogEntries.push(entry);
        if (monitorLogEntries.length > MAX_MONITOR_LOG_ENTRIES) {
            monitorLogEntries.shift();
        }

        if (!monitorLogList) {
            return;
        }

        monitorLogList.innerHTML = '';
        const entriesToRender = [...monitorLogEntries].reverse();
        for (const item of entriesToRender) {
            const row = document.createElement('div');
            row.className = `monitor-log-entry ${item.level === 'error' ? 'error' : ''}`.trim();

            const sourcePrefix = item.source ? `${sourceLabel(item.source)} ` : '';
            const metaText = item.meta ? ` ${safeJson(item.meta)}` : '';
            row.textContent = `${formatMonitorTime(item.timestamp)} ${sourcePrefix}${item.event}: ${item.message}${metaText}`;
            monitorLogList.appendChild(row);
        }
    }

    function resetFinalTranscriptBuffer(source) {
        transcriptBufferManager.resetFinalTranscriptBuffer(source);
    }

    function flushFinalTranscript(source, reason = 'pause-timeout') {
        transcriptBufferManager.flushFinalTranscript(source, reason);
    }

    function queueFinalTranscript(source, text) {
        transcriptBufferManager.queueFinalTranscript(source, text);
    }

    function flushAllFinalTranscripts(reason = 'flush-all') {
        transcriptBufferManager.flushAllFinalTranscripts(reason);
    }

    function setSourceSelected(source, enabled) {
        const resolvedSource = normalizeSource(source);
        transcriptionSourceState.setSourceSelected(resolvedSource, enabled);
        addMonitorLog('info', 'source-toggle', `${sourceLabel(resolvedSource)} ${enabled ? 'enabled' : 'disabled'}`, resolvedSource);
        updateTranscriptionUI();

        if (isAnyTranscriptionActive() || sourceStatuses[resolvedSource] === 'connecting') {
            ensureSourceRunning(resolvedSource, !!enabled).catch((error) => {
                console.error(`Failed to apply live source toggle for ${resolvedSource}:`, error);
                addMonitorLog('error', 'source-toggle-failed', error.message, resolvedSource);
            });
        }
    }

    async function ensureSourceRunning(source, shouldRun) {
        const resolvedSource = normalizeSource(source);
        if (shouldRun) {
            if (resolvedSource === 'system') {
                await startSystemAudioRecording();
            } else {
                await startMicRecording();
            }
        } else if (resolvedSource === 'system') {
            await stopSystemAudioRecording();
        } else {
            await stopMicRecording();
        }
    }

    async function startSelectedSources() {
        if (!selectedSources.system && !selectedSources.mic) {
            const message = 'Select at least one source (Host or Mic) before starting transcription.';
            showFeedback(message, 'error');
            addMonitorLog('error', 'start-blocked', message);
            return;
        }

        addMonitorLog('info', 'master-start', 'Starting selected transcription sources');

        if (selectedSources.system) {
            await ensureSourceRunning('system', true);
        }

        if (selectedSources.mic) {
            await ensureSourceRunning('mic', true);
        }
    }

    async function stopAllSources() {
        addMonitorLog('info', 'master-stop', 'Stopping all active transcription sources');
        if (isSystemActive || sourceStatuses.system === 'connecting') {
            await stopSystemAudioRecording();
        }
        if (isMicActive || sourceStatuses.mic === 'connecting') {
            await stopMicRecording();
        }
    }

    async function toggleMasterTranscription() {
        if (isAnyTranscriptionActive() || isAnySourceConnecting()) {
            await stopAllSources();
        } else {
            await startSelectedSources();
        }
        updateTranscriptionUI();
    }

    function isLikelyCameraTrack(trackLabel) {
        return audioPipeline.isLikelyCameraTrack(trackLabel);
    }

    async function getSystemAudioStream(sourceId) {
        return audioPipeline.getSystemAudioStream(sourceId);
    }

    function resetSourceSampleQueue(source) {
        audioPipeline.resetSourceSampleQueue(source);
    }

    function drainSourceSampleQueue(source, { flushPartial = false } = {}) {
        audioPipeline.drainSourceSampleQueue(source, { flushPartial });
    }

    async function buildAudioProcessor(context, stream, source, activeCheck) {
        return audioPipeline.buildAudioProcessor(context, stream, source, activeCheck);
    }

    function stopAudioResources(ctx, stream, processor) {
        audioPipeline.stopAudioResources(ctx, stream, processor);
    }

    async function startMicRecording() {
        if (isMicActive || sourceStatuses.mic === 'connecting') return;
        setSourceStatus('mic', 'connecting', 'Connecting to mic...');
        addMonitorLog('info', 'start-request', 'Starting mic source', 'mic');
        resetFinalTranscriptBuffer('mic');

        try {
            const result = await window.electronAPI.startVoiceRecognition('mic');
            if (result && result.error) throw new Error(result.error);

            micMediaStream = await navigator.mediaDevices.getUserMedia({
                audio: { channelCount: 1, echoCancellation: true, noiseSuppression: true }
            });
            micAudioContext = new AudioContext();
            await micAudioContext.resume();
            resetSourceSampleQueue('mic');
            micScriptProcessor = await buildAudioProcessor(micAudioContext, micMediaStream, 'mic', () => isMicActive);

            setMicActive(true);
            addChatMessage('system', 'Mic listening...');
            showFeedback('Mic on', 'success');
            addMonitorLog('info', 'source-active', 'Mic source active', 'mic');
        } catch (error) {
            console.error('Failed to start mic:', error);
            showFeedback(`Mic failed: ${error.message}`, 'error');
            addMonitorLog('error', 'source-failed', error.message, 'mic');
            stopAudioResources(micAudioContext, micMediaStream, micScriptProcessor);
            micAudioContext = null;
            micMediaStream = null;
            micScriptProcessor = null;
            setMicActive(false);
            resetSourceSampleQueue('mic');
            setSourceStatus('mic', 'error', `Mic error: ${error.message}`);
            try {
                await window.electronAPI.stopVoiceRecognition('mic');
            } catch (_) {}
        }

        updateTranscriptionUI();
    }

    async function stopMicRecording() {
        if (!isMicActive && sourceStatuses.mic !== 'connecting') return;
        drainSourceSampleQueue('mic', { flushPartial: true });
        flushFinalTranscript('mic', 'stop-request');
        stopAudioResources(micAudioContext, micMediaStream, micScriptProcessor);
        micAudioContext = null;
        micMediaStream = null;
        micScriptProcessor = null;
        if (micPartialDiv) {
            micPartialDiv.remove();
            micPartialDiv = null;
        }
        micPartialText = '';
        try {
            await window.electronAPI.stopVoiceRecognition('mic');
        } catch (error) {
            addMonitorLog('error', 'stop-failed', error.message || 'Failed to stop mic source', 'mic');
        }
        setMicActive(false);
        resetSourceSampleQueue('mic');
        audioPipeline.resetChunkCounter('mic');
        setSourceStatus('mic', 'off', 'Mic stopped');
        addMonitorLog('info', 'source-stopped', 'Mic source stopped', 'mic');
        showFeedback('Mic off', 'info');
    }

    async function startSystemAudioRecording() {
        if (isSystemActive || sourceStatuses.system === 'connecting') return;
        setSourceStatus('system', 'connecting', 'Connecting to host audio...');
        addMonitorLog('info', 'start-request', 'Starting host audio source', 'system');
        resetFinalTranscriptBuffer('system');

        try {
            const sources = await window.electronAPI.getDesktopSources();
            if (!sources || sources.length === 0) throw new Error('No desktop sources found');
            const sourceId = sources[0].id;
            addMonitorLog('info', 'desktop-source', `Using desktop source: ${sources[0].name || sourceId}`, 'system');

            const result = await window.electronAPI.startVoiceRecognition('system');
            if (result && result.error) throw new Error(result.error);

            systemMediaStream = await getSystemAudioStream(sourceId);

            const videoTrack = systemMediaStream.getVideoTracks()[0];
            if (videoTrack && isLikelyCameraTrack(videoTrack.label)) {
                throw new Error(`Desktop capture fell back to camera source (${videoTrack.label || 'unknown'}).`);
            }

            systemMediaStream.getVideoTracks().forEach((track) => track.stop());

            systemAudioContext = new AudioContext();
            await systemAudioContext.resume();
            resetSourceSampleQueue('system');
            systemScriptProcessor = await buildAudioProcessor(systemAudioContext, systemMediaStream, 'system', () => isSystemActive);

            setSystemActive(true);
            addChatMessage('system', 'Listening to host audio...');
            showFeedback('System audio on', 'success');
            addMonitorLog('info', 'source-active', 'Host source active', 'system');
        } catch (error) {
            console.error('Failed to start system audio:', error);
            showFeedback(`System audio failed: ${error.message}`, 'error');
            addMonitorLog('error', 'source-failed', error.message, 'system');
            stopAudioResources(systemAudioContext, systemMediaStream, systemScriptProcessor);
            systemAudioContext = null;
            systemMediaStream = null;
            systemScriptProcessor = null;
            setSystemActive(false);
            resetSourceSampleQueue('system');
            setSourceStatus('system', 'error', `Host error: ${error.message}`);
            try {
                await window.electronAPI.stopVoiceRecognition('system');
            } catch (_) {}
        }

        updateTranscriptionUI();
    }

    async function stopSystemAudioRecording() {
        if (!isSystemActive && sourceStatuses.system !== 'connecting') return;
        drainSourceSampleQueue('system', { flushPartial: true });
        flushFinalTranscript('system', 'stop-request');
        stopAudioResources(systemAudioContext, systemMediaStream, systemScriptProcessor);
        systemAudioContext = null;
        systemMediaStream = null;
        systemScriptProcessor = null;
        if (systemPartialDiv) {
            systemPartialDiv.remove();
            systemPartialDiv = null;
        }
        systemPartialText = '';
        try {
            await window.electronAPI.stopVoiceRecognition('system');
        } catch (error) {
            addMonitorLog('error', 'stop-failed', error.message || 'Failed to stop host source', 'system');
        }
        setSystemActive(false);
        resetSourceSampleQueue('system');
        audioPipeline.resetChunkCounter('system');
        setSourceStatus('system', 'off', 'Host source stopped');
        addMonitorLog('info', 'source-stopped', 'Host source stopped', 'system');
        showFeedback('System audio off', 'info');
    }

    function createPartialDiv(icon) {
        const div = document.createElement('div');
        div.className = 'chat-message voice-message partial';
        const ts = new Date().toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit' });
        div.innerHTML = `
        <div class="message-header">
            <span class="message-icon">${icon}</span>
            <span class="message-time">${ts}</span>
            <span class="partial-indicator">Live</span>
        </div>
        <div class="message-content partial-text"></div>
    `;
        return div;
    }

    function handleVoskPartial(data) {
        const source = normalizeSource(data?.source);
        const text = data?.text;
        if (!text || text.trim().length === 0) return;
        if (!isSourceActive(source)) return;

        const trimmed = text.trim();
        const icon = source === 'system' ? '\u{1F50A}' : '\u{1F3A4}';
        monitorLastText[source] = `Live: ${trimmed}`;
        renderMonitorState();

        if (source === 'mic') {
            micPartialText = trimmed;
            if (!micPartialDiv) {
                micPartialDiv = createPartialDiv(icon);
                chatMessagesElement.appendChild(micPartialDiv);
            }
            micPartialDiv.querySelector('.message-content').textContent = trimmed;
        } else {
            systemPartialText = trimmed;
            if (!systemPartialDiv) {
                systemPartialDiv = createPartialDiv(icon);
                chatMessagesElement.appendChild(systemPartialDiv);
            }
            systemPartialDiv.querySelector('.message-content').textContent = trimmed;
        }
        chatMessagesElement.scrollTop = chatMessagesElement.scrollHeight;
    }

    function handleVoskFinal(data) {
        const source = normalizeSource(data?.source);
        const text = data?.text;
        if (!text || text.trim().length === 0) return;

        const finalText = text.trim();
        monitorLastText[source] = `Final: ${finalText}`;
        renderMonitorState();
        addMonitorLog('info', 'final', 'Final transcript received', source, {
            chars: finalText.length
        });

        if (source === 'mic') {
            if (micPartialDiv) {
                micPartialDiv.remove();
                micPartialDiv = null;
            }
            micPartialText = '';
        } else {
            if (systemPartialDiv) {
                systemPartialDiv.remove();
                systemPartialDiv = null;
            }
            systemPartialText = '';
        }
        queueFinalTranscript(source, finalText);
    }

    function handleVoskStatus(data) {
        const source = normalizeSource(data?.source);
        const status = data?.status;
        const message = data?.message || '';
        console.log(`STT status [${source}]:`, status, message);

        if (status === 'loading') {
            setSourceStatus(source, 'connecting', `Connecting (${sourceLabel(source)})...`);
            showFeedback(`Connecting (${sourceLabel(source)})...`, 'info');
            addMonitorLog('info', 'status-loading', message || 'Connection requested', source);
        } else if (status === 'listening') {
            setSourceStatus(source, 'listening', `Listening (${sourceLabel(source)})...`);
            showFeedback(`Listening (${sourceLabel(source)})...`, 'success');
            addMonitorLog('info', 'status-listening', message || 'Source listening', source);
        } else if (status === 'stopped') {
            setSourceStatus(source, 'off', `${sourceLabel(source)} stopped`);
            showFeedback(`Stopped (${sourceLabel(source)})`, 'info');
            addMonitorLog('info', 'status-stopped', message || 'Source stopped', source);
        }
    }

    function handleVoskError(data) {
        const source = normalizeSource(data?.source);
        const error = data?.error || 'Unknown transcription error';
        console.error(`STT error [${source}]:`, error);
        showFeedback(`Error (${sourceLabel(source)}): ${error}`, 'error');
        addChatMessage('system', `Transcription error (${sourceLabel(source)}): ${error}`);
        addMonitorLog('error', 'status-error', error, source);
        flushFinalTranscript(source, 'status-error');

        if (source === 'system') {
            stopAudioResources(systemAudioContext, systemMediaStream, systemScriptProcessor);
            systemAudioContext = null;
            systemMediaStream = null;
            systemScriptProcessor = null;
            if (systemPartialDiv) {
                systemPartialDiv.remove();
                systemPartialDiv = null;
            }
            systemPartialText = '';
            setSystemActive(false);
            resetSourceSampleQueue('system');
            resetFinalTranscriptBuffer('system');
        } else {
            stopAudioResources(micAudioContext, micMediaStream, micScriptProcessor);
            micAudioContext = null;
            micMediaStream = null;
            micScriptProcessor = null;
            if (micPartialDiv) {
                micPartialDiv.remove();
                micPartialDiv = null;
            }
            micPartialText = '';
            setMicActive(false);
            resetSourceSampleQueue('mic');
            resetFinalTranscriptBuffer('mic');
        }

        setSourceStatus(source, 'error', `Error: ${error}`);
        updateTranscriptionUI();
    }

    function handleVoskStopped(data) {
        const source = normalizeSource(data?.source);
        console.log(`STT stopped [${source}]`);
        flushFinalTranscript(source, 'stopped-event');
        if (source === 'system') {
            stopAudioResources(systemAudioContext, systemMediaStream, systemScriptProcessor);
            systemAudioContext = null;
            systemMediaStream = null;
            systemScriptProcessor = null;
            if (systemPartialDiv) {
                systemPartialDiv.remove();
                systemPartialDiv = null;
            }
            systemPartialText = '';
            setSystemActive(false);
            resetSourceSampleQueue('system');
            resetFinalTranscriptBuffer('system');
        } else {
            stopAudioResources(micAudioContext, micMediaStream, micScriptProcessor);
            micAudioContext = null;
            micMediaStream = null;
            micScriptProcessor = null;
            if (micPartialDiv) {
                micPartialDiv.remove();
                micPartialDiv = null;
            }
            micPartialText = '';
            setMicActive(false);
            resetSourceSampleQueue('mic');
            resetFinalTranscriptBuffer('mic');
        }
        setSourceStatus(source, 'off', `${sourceLabel(source)} stopped`);
        addMonitorLog('info', 'stopped-event', 'Stop acknowledged by backend', source);
    }

    return {
        selectedSources,
        sourceStatuses,
        normalizeSource,
        sourceLabel,
        addMonitorLog,
        updateTranscriptionUI,
        renderMonitorState,
        setSourceSelected,
        toggleMasterTranscription,
        flushAllFinalTranscripts,
        handleVoskPartial,
        handleVoskFinal,
        handleVoskStatus,
        handleVoskError,
        handleVoskStopped
    };
}

================
File: src/windows/legacy/renderer-webspeech-broken.js
================
// Renderer with Web Speech API (Instant - No Model Loading!)

let screenshotsCount = 0;
let isAnalyzing = false;
let stealthModeActive = false;
let stealthHideTimeout = null;
let isRecording = false;
let chatMessagesArray = [];

// Web Speech API - Instant recognition!
let recognition = null;
let isRecognitionReady = false;

// DOM elements
const statusText = document.getElementById('status-text');
const screenshotCount = document.getElementById('screenshot-count');
const resultsPanel = document.getElementById('results-panel');
const resultText = document.getElementById('result-text');
const loadingOverlay = document.getElementById('loading-overlay');
const emergencyOverlay = document.getElementById('emergency-overlay');
const chatContainer = document.getElementById('chat-container');
const chatMessagesElement = document.getElementById('chat-messages');
const voiceToggle = document.getElementById('voice-toggle');

const screenshotBtn = document.getElementById('screenshot-btn');
const analyzeBtn = document.getElementById('analyze-btn');
const clearBtn = document.getElementById('clear-btn');
const hideBtn = document.getElementById('hide-btn');
const copyBtn = document.getElementById('copy-btn');
const closeResultsBtn = document.getElementById('close-results');

// New Cluely-style buttons
const suggestBtn = document.getElementById('suggest-btn');
const notesBtn = document.getElementById('notes-btn');
const insightsBtn = document.getElementById('insights-btn');

// Timer
let startTime = Date.now();
let timerInterval;

// Initialize
async function init() {
    console.log('Initializing renderer with Web Speech API...');

    // Check if electronAPI is available
    if (typeof window.electronAPI !== 'undefined') {
        console.log('electronAPI is available');
    } else {
        console.error('electronAPI not available');
        showFeedback('electronAPI not available', 'error');
    }

    initializeWebSpeech();
    setupEventListeners();
    setupIpcListeners();
    updateUI();
    startTimer();
    stealthModeActive = false;

    document.body.style.visibility = 'visible';
    document.body.style.display = 'block';
    const app = document.getElementById('app');
    if (app) {
        app.style.visibility = 'visible';
        app.style.display = 'block';
    }

    console.log('Renderer initialized successfully with Web Speech API');
}

// Initialize Web Speech API (instant!)
function initializeWebSpeech() {
    try {
        // Check for browser support
        const SpeechRecognition = window.SpeechRecognition || window.webkitSpeechRecognition;

        if (!SpeechRecognition) {
            console.error('Web Speech API not supported in this browser');
            showFeedback('Speech recognition not supported', 'error');
            return;
        }

        console.log('Initializing Web Speech API...');
        recognition = new SpeechRecognition();

        // Configuration
        recognition.continuous = true;           // Keep listening
        recognition.interimResults = true;       // Get partial results
        recognition.lang = 'en-US';             // Language
        recognition.maxAlternatives = 1;         // Only get best result

        // Event handlers
        recognition.onstart = () => {
            console.log('Speech recognition started');
            isRecognitionReady = true;
            isRecording = true;
            updateVoiceUI();
            showFeedback('Listening...', 'success');
        };

        recognition.onresult = (event) => {
            console.log('Speech recognition result');

            // Get the latest result
            const lastResultIndex = event.results.length - 1;
            const result = event.results[lastResultIndex];
            const transcript = result[0].transcript.trim();

            console.log('Transcript:', transcript, 'Final:', result.isFinal);

            // Only add final results to chat
            if (result.isFinal && transcript.length > 0) {
                // Filter out noise
                if (!isNoise(transcript)) {
                    addChatMessage('voice', transcript);
                    showFeedback('Voice captured', 'success');

                    // Add to Gemini conversation history
                    if (window.electronAPI && window.electronAPI.addVoiceTranscript) {
                        window.electronAPI.addVoiceTranscript(transcript).catch(err => {
                            console.error('Failed to add transcript to history:', err);
                        });
                    }
                } else {
                    console.log('Filtered out noise:', transcript);
                }
            }
        };

        recognition.onerror = (event) => {
            console.error('Speech recognition error:', event.error);

            // Handle different error types
            let errorMessage = 'Speech recognition error';
            switch (event.error) {
                case 'no-speech':
                    errorMessage = 'No speech detected';
                    break;
                case 'audio-capture':
                    errorMessage = 'No microphone found';
                    break;
                case 'not-allowed':
                    errorMessage = 'Microphone permission denied';
                    break;
                case 'network':
                    errorMessage = 'Network error';
                    break;
                case 'aborted':
                    // Don't show error for intentional stops
                    return;
                default:
                    errorMessage = `Error: ${event.error}`;
            }

            showFeedback(errorMessage, 'error');

            // Auto-restart on some errors
            if (isRecording && (event.error === 'no-speech' || event.error === 'network')) {
                console.log('Auto-restarting recognition...');
                setTimeout(() => {
                    if (isRecording) {
                        try {
                            recognition.start();
                        } catch (e) {
                            console.error('Failed to restart:', e);
                        }
                    }
                }, 1000);
            }
        };

        recognition.onend = () => {
            console.log('Speech recognition ended');

            // Auto-restart if we're still supposed to be recording
            if (isRecording) {
                console.log('Auto-restarting recognition...');
                try {
                    recognition.start();
                } catch (error) {
                    console.error('Failed to restart recognition:', error);
                    isRecording = false;
                    updateVoiceUI();
                }
            } else {
                updateVoiceUI();
            }
        };

        isRecognitionReady = true;
        console.log('Web Speech API initialized successfully - INSTANT!');
        showFeedback('Speech recognition ready - No loading needed!', 'success');

    } catch (error) {
        console.error('Failed to initialize Web Speech API:', error);
        showFeedback('Failed to initialize speech recognition', 'error');
    }
}

// Start voice recognition
async function startVoiceRecognition() {
    if (!recognition || !isRecognitionReady) {
        showFeedback('Speech recognition not available', 'error');
        return;
    }

    if (isRecording) {
        console.log('Already recording');
        return;
    }

    try {
        console.log('Starting voice recognition...');
        isRecording = true;
        recognition.start();
        updateVoiceUI();
        addChatMessage('system', 'Voice recording started...');
    } catch (error) {
        console.error('Failed to start recognition:', error);
        showFeedback('Failed to start recording', 'error');
        isRecording = false;
        updateVoiceUI();
    }
}

// Stop voice recognition
function stopVoiceRecognition() {
    if (!recognition || !isRecording) {
        return;
    }

    console.log('Stopping voice recognition...');
    isRecording = false;

    try {
        recognition.stop();
    } catch (error) {
        console.error('Error stopping recognition:', error);
    }

    updateVoiceUI();
    addChatMessage('system', 'Voice recording stopped');
    showFeedback('Recording stopped', 'info');
}

// Toggle voice recognition
async function toggleVoiceRecognition() {
    if (isRecording) {
        stopVoiceRecognition();
        voiceToggle.classList.remove('active');
    } else {
        await startVoiceRecognition();
        if (isRecording) {
            voiceToggle.classList.add('active');
        }
    }
}

// Update voice UI
function updateVoiceUI() {
    if (!voiceToggle) return;

    if (isRecording) {
        voiceToggle.classList.add('active', 'listening');
    } else {
        voiceToggle.classList.remove('active', 'listening');
    }
}

// Filter noise (simple version)
function isNoise(text) {
    const cleanText = text.trim().toLowerCase();

    // Very short or empty
    if (cleanText.length < 2) return true;

    // Only punctuation or symbols
    if (/^[^\w\s]*$/.test(cleanText)) return true;

    // Common filler words alone
    const fillerWords = ['uh', 'um', 'er', 'ah', 'oh', 'hmm'];
    if (fillerWords.includes(cleanText)) return true;

    return false;
}

// Screenshot functions
async function takeStealthScreenshot() {
    try {
        showFeedback('Taking screenshot...', 'info');
        await window.electronAPI.takeStealthScreenshot();
    } catch (error) {
        console.error('Screenshot error:', error);
        showFeedback('Screenshot failed', 'error');
    }
}

async function analyzeScreenshots() {
    if (screenshotsCount === 0) {
        showFeedback('No screenshots to analyze', 'error');
        return;
    }

    try {
        setAnalyzing(true);
        showLoadingOverlay();

        // Get conversation context
        const context = chatMessagesArray
            .map(msg => `${msg.type}: ${msg.content}`)
            .join('\n\n');

        await window.electronAPI.analyzeStealthWithContext(context);
    } catch (error) {
        console.error('Analysis error:', error);
        showFeedback('Analysis failed', 'error');
        setAnalyzing(false);
        hideLoadingOverlay();
    }
}

async function clearStealthData() {
    try {
        await window.electronAPI.clearStealth();
        screenshotsCount = 0;
        chatMessagesArray = [];
        chatMessagesElement.innerHTML = '';
        updateUI();
        showFeedback('Cleared', 'success');
    } catch (error) {
        console.error('Clear error:', error);
        showFeedback('Clear failed', 'error');
    }
}

async function emergencyHide() {
    try {
        await window.electronAPI.emergencyHide();
        showEmergencyOverlay();
    } catch (error) {
        console.error('Emergency hide error:', error);
    }
}

// NEW CLUELY-STYLE FEATURES

async function getResponseSuggestions() {
    if (!window.electronAPI || !window.electronAPI.suggestResponse) {
        showFeedback('Feature not available', 'error');
        return;
    }

    try {
        showFeedback('Generating suggestions...', 'info');

        const recentMessages = chatMessagesArray
            .slice(-5)
            .map(m => `${m.type}: ${m.content}`)
            .join('\n');

        const context = recentMessages || 'Current meeting conversation';

        const result = await window.electronAPI.suggestResponse(context);

        if (result.success && result.suggestions) {
            addChatMessage('ai-response', `💡 **What should I say?**\n\n${result.suggestions}`);
            showFeedback('Suggestions generated', 'success');
        } else {
            throw new Error(result.error || 'Failed to generate suggestions');
        }
    } catch (error) {
        console.error('Error getting suggestions:', error);
        showFeedback('Failed to generate suggestions', 'error');
        addChatMessage('system', `Error: ${error.message}`);
    }
}

async function generateMeetingNotes() {
    if (!window.electronAPI || !window.electronAPI.generateMeetingNotes) {
        showFeedback('Feature not available', 'error');
        return;
    }

    try {
        showFeedback('Generating meeting notes...', 'info');
        setAnalyzing(true);

        const result = await window.electronAPI.generateMeetingNotes();

        setAnalyzing(false);

        if (result.success && result.notes) {
            addChatMessage('ai-response', `📝 **Meeting Notes**\n\n${result.notes}`);
            showFeedback('Meeting notes generated', 'success');
        } else {
            throw new Error(result.error || 'Failed to generate notes');
        }
    } catch (error) {
        console.error('Error generating notes:', error);
        setAnalyzing(false);
        showFeedback('Failed to generate notes', 'error');
        addChatMessage('system', `Error: ${error.message}`);
    }
}

async function getConversationInsights() {
    if (!window.electronAPI || !window.electronAPI.getConversationInsights) {
        showFeedback('Feature not available', 'error');
        return;
    }

    try {
        showFeedback('Analyzing conversation...', 'info');
        setAnalyzing(true);

        const result = await window.electronAPI.getConversationInsights();

        setAnalyzing(false);

        if (result.success && result.insights) {
            addChatMessage('ai-response', `📊 **Conversation Insights**\n\n${result.insights}`);
            showFeedback('Insights generated', 'success');
        } else {
            throw new Error(result.error || 'Failed to get insights');
        }
    } catch (error) {
        console.error('Error getting insights:', error);
        setAnalyzing(false);
        showFeedback('Failed to get insights', 'error');
        addChatMessage('system', `Error: ${error.message}`);
    }
}

// UI Helper functions
function setAnalyzing(analyzing) {
    isAnalyzing = analyzing;
    updateUI();
}

function updateUI() {
    if (screenshotCount) {
        screenshotCount.textContent = screenshotsCount;
    }

    if (analyzeBtn) {
        analyzeBtn.disabled = isAnalyzing || screenshotsCount === 0;
    }
}

function showFeedback(message, type = 'info') {
    console.log(`Feedback (${type}):`, message);

    if (statusText) {
        statusText.textContent = message;
        statusText.className = `status-text ${type} show`;
        statusText.style.display = 'block';

        setTimeout(() => {
            statusText.classList.remove('show');
            setTimeout(() => {
                statusText.style.display = 'none';
            }, 300);
        }, 3000);
    }
}

function showLoadingOverlay() {
    if (loadingOverlay) {
        loadingOverlay.classList.remove('hidden');
    }
}

function hideLoadingOverlay() {
    if (loadingOverlay) {
        loadingOverlay.classList.add('hidden');
    }
}

function showEmergencyOverlay() {
    if (emergencyOverlay) {
        emergencyOverlay.classList.remove('hidden');
        setTimeout(() => {
            emergencyOverlay.classList.add('hidden');
        }, 2000);
    }
}

function hideResults() {
    if (resultsPanel) {
        resultsPanel.classList.add('hidden');
    }
}

async function copyToClipboard() {
    const lastAiMessage = chatMessagesArray
        .slice()
        .reverse()
        .find(msg => msg.type === 'ai-response');

    if (!lastAiMessage) {
        showFeedback('No AI response to copy', 'error');
        return;
    }

    try {
        await navigator.clipboard.writeText(lastAiMessage.content);
        showFeedback('Copied to clipboard', 'success');
    } catch (error) {
        console.error('Copy error:', error);
        showFeedback('Copy failed', 'error');
    }
}

// Chat message management
function formatResponse(text) {
    // Basic markdown formatting
    let formatted = text
        .replace(/```(\w+)?\n([\s\S]*?)```/g, '<pre><code>$2</code></pre>')
        .replace(/\*\*(.*?)\*\*/g, '<strong>$1</strong>')
        .replace(/\*(.*?)\*/g, '<em>$1</em>')
        .replace(/\n/g, '<br>');

    return formatted;
}

function addChatMessage(type, content) {
    if (!chatMessagesElement) return;

    const messageDiv = document.createElement('div');
    messageDiv.className = `chat-message ${type}-message`;

    const timestamp = new Date().toLocaleTimeString('en-US', {
        hour: '2-digit',
        minute: '2-digit'
    });

    let messageContent = '';

    switch (type) {
        case 'voice':
            messageContent = `<div class="message-header"><span class="message-icon">🎤</span><span class="message-time">${timestamp}</span></div><div class="message-content">${content}</div>`;
            break;

        case 'screenshot':
            messageContent = `<div class="message-header"><span class="message-icon">📸</span><span class="message-time">${timestamp}</span></div><div class="message-content">${content}</div>`;
            break;

        case 'ai-response':
            messageContent = `<div class="message-header"><span class="message-icon">🤖</span><span class="message-time">${timestamp}</span></div><div class="message-content ai-response">${formatResponse(content)}</div>`;
            break;

        case 'system':
            messageContent = `<div class="message-header"><span class="message-icon">ℹ️</span><span class="message-time">${timestamp}</span></div><div class="message-content system-message">${content}</div>`;
            break;
    }

    messageDiv.innerHTML = messageContent;
    chatMessagesElement.appendChild(messageDiv);

    chatMessagesElement.scrollTop = chatMessagesElement.scrollHeight;

    chatMessagesArray.push({
        type,
        content,
        timestamp: new Date()
    });
}

// Timer
function startTimer() {
    const timerElement = document.querySelector('.timer');
    if (!timerElement) return;

    timerInterval = setInterval(() => {
        const elapsed = Math.floor((Date.now() - startTime) / 1000);
        const minutes = Math.floor(elapsed / 60).toString().padStart(2, '0');
        const seconds = (elapsed % 60).toString().padStart(2, '0');
        timerElement.textContent = `${minutes}:${seconds}`;
    }, 1000);
}

// Event listeners
function setupEventListeners() {
    if (screenshotBtn) screenshotBtn.addEventListener('click', takeStealthScreenshot);
    if (analyzeBtn) analyzeBtn.addEventListener('click', analyzeScreenshots);
    if (clearBtn) clearBtn.addEventListener('click', clearStealthData);
    if (hideBtn) hideBtn.addEventListener('click', emergencyHide);
    if (copyBtn) copyBtn.addEventListener('click', copyToClipboard);
    if (closeResultsBtn) closeResultsBtn.addEventListener('click', hideResults);
    if (voiceToggle) voiceToggle.addEventListener('click', toggleVoiceRecognition);

    // New feature buttons
    if (suggestBtn) suggestBtn.addEventListener('click', getResponseSuggestions);
    if (notesBtn) notesBtn.addEventListener('click', generateMeetingNotes);
    if (insightsBtn) insightsBtn.addEventListener('click', getConversationInsights);

    // Keyboard shortcuts
    document.addEventListener('keydown', (e) => {
        if (e.ctrlKey && e.altKey && e.shiftKey) {
            switch (e.key.toLowerCase()) {
                case 'h':
                    e.preventDefault();
                    if (window.electronAPI) window.electronAPI.toggleStealth();
                    break;
                case 's':
                    e.preventDefault();
                    takeStealthScreenshot();
                    break;
                case 'a':
                    e.preventDefault();
                    analyzeScreenshots();
                    break;
                case 'x':
                    e.preventDefault();
                    emergencyHide();
                    break;
                case 'v':
                    e.preventDefault();
                    toggleVoiceRecognition();
                    break;
            }
        }
    });

    document.addEventListener('contextmenu', e => e.preventDefault());
    document.addEventListener('selectstart', e => e.preventDefault());
    document.addEventListener('dragstart', e => e.preventDefault());
}

// IPC listeners
function setupIpcListeners() {
    if (!window.electronAPI) {
        console.error('electronAPI not available');
        return;
    }

    window.electronAPI.onScreenshotTakenStealth((count) => {
        screenshotsCount = count;
        updateUI();
        addChatMessage('screenshot', 'Screenshot captured');
        showFeedback('Screenshot captured', 'success');
    });

    window.electronAPI.onAnalysisStart(() => {
        setAnalyzing(true);
        showLoadingOverlay();
        addChatMessage('system', 'Analyzing screenshots and context...');
    });

    window.electronAPI.onAnalysisResult((data) => {
        setAnalyzing(false);
        hideLoadingOverlay();

        if (data.error) {
            addChatMessage('system', `Error: ${data.error}`);
            showFeedback('Analysis failed', 'error');
        } else {
            addChatMessage('ai-response', data.text);
            showFeedback('Analysis complete', 'success');
        }
    });

    window.electronAPI.onSetStealthMode((enabled) => {
        stealthModeActive = enabled;
        showFeedback(enabled ? 'Stealth mode ON' : 'Stealth mode OFF', 'info');
    });

    window.electronAPI.onEmergencyClear(() => {
        showEmergencyOverlay();
    });

    window.electronAPI.onError((message) => {
        showFeedback(message, 'error');
    });
}

// Initialize on load
if (document.readyState === 'loading') {
    document.addEventListener('DOMContentLoaded', init);
} else {
    init();
}

================
File: src/windows/legacy/renderer-whisper-backup.js
================
// Fixed renderer.js with proper Whisper Worker implementation

let screenshotsCount = 0;
let isAnalyzing = false;
let stealthModeActive = false;
let stealthHideTimeout = null;
let isRecording = false;
let mediaRecorder = null;
let audioStream = null;
let recordingChunks = [];
let chatMessagesArray = [];
let isModelLoading = false;
let audioContext = null;

// Whisper worker
let worker = null;
let isWorkerReady = false;

// DOM elements
const statusText = document.getElementById('status-text');
const screenshotCount = document.getElementById('screenshot-count');
const resultsPanel = document.getElementById('results-panel');
const resultText = document.getElementById('result-text');
const loadingOverlay = document.getElementById('loading-overlay');
const emergencyOverlay = document.getElementById('emergency-overlay');
const chatContainer = document.getElementById('chat-container');
const chatMessagesElement = document.getElementById('chat-messages');
const voiceToggle = document.getElementById('voice-toggle');

const screenshotBtn = document.getElementById('screenshot-btn');
const analyzeBtn = document.getElementById('analyze-btn');
const clearBtn = document.getElementById('clear-btn');
const hideBtn = document.getElementById('hide-btn');
const copyBtn = document.getElementById('copy-btn');
const closeResultsBtn = document.getElementById('close-results');

// New Cluely-style buttons
const suggestBtn = document.getElementById('suggest-btn');
const notesBtn = document.getElementById('notes-btn');
const insightsBtn = document.getElementById('insights-btn');

// Timer
let startTime = Date.now();
let timerInterval;

// Whisper configuration
const WHISPER_CONFIG = {
    model: 'Xenova/whisper-tiny', // Use base whisper-tiny (works better)
    multilingual: false,
    quantized: true,
    subtask: 'transcribe',
    language: 'en' // Changed from 'english' to 'en'
};


// Initialize
async function init() {
    console.log('Initializing renderer...');
    
    // Create a single AudioContext
    try {
        audioContext = new (window.AudioContext || window.webkitAudioContext)({
            sampleRate: 16000
        });
        console.log('AudioContext created successfully');
    } catch (error) {
        console.error('Failed to create AudioContext:', error);
        showFeedback('Audio processing disabled', 'error');
    }
    
    // Check if electronAPI is available
    if (typeof window.electronAPI !== 'undefined') {
        console.log('electronAPI is available');
    } else {
        console.error('electronAPI not available');
        showFeedback('electronAPI not available', 'error');
    }
    
    await initializeWhisperWorker();
    setupEventListeners();
    setupIpcListeners();
    updateUI();
    startTimer();
    stealthModeActive = false;
    
    document.body.style.visibility = 'visible';
    document.body.style.display = 'block';
    const app = document.getElementById('app');
    if (app) {
        app.style.visibility = 'visible';
        app.style.display = 'block';
    }
    
    console.log('Renderer initialized successfully');
}

async function initializeWhisperWorker() {
    try {
        console.log('Initializing Whisper Web Worker...');
        
        // Since you have the bundled version in dist/, use that
        // Use relative path from the renderer.html location
        worker = new Worker('./dist/whisper-worker.bundle.js', { type: 'module' });
        
        worker.addEventListener('message', handleWorkerMessage);
        worker.addEventListener('error', (error) => {
            console.error('Worker error:', error);
            showFeedback('Speech recognition worker failed', 'error');
        });
        
        console.log('Whisper worker created successfully');
        return true;
        
    } catch (error) {
        console.error('Failed to initialize Whisper worker:', error);
        showFeedback('Failed to initialize speech recognition', 'error');
        
        // Fallback: try the unbundled version
        try {
            console.log('Trying fallback worker path...');
            worker = new Worker('./whisper-worker.js', { type: 'module' });
            
            worker.addEventListener('message', handleWorkerMessage);
            worker.addEventListener('error', (error) => {
                console.error('Fallback worker error:', error);
                showFeedback('Speech recognition worker failed', 'error');
            });
            
            console.log('Fallback whisper worker created successfully');
            return true;
            
        } catch (fallbackError) {
            console.error('Fallback worker also failed:', fallbackError);
            return false;
        }
    }
}   

// Handle worker messages
function handleWorkerMessage(event) {
    const message = event.data;
    
    console.log('Worker message:', JSON.stringify(message, null, 2));
    
    switch (message.status) {
        case "progress":
            const percent = Math.round((message.progress || 0) * 100);
            showFeedback(`Loading model: ${percent}%`, 'info');
            break;
            
        case "update":
            // Handle interim results but don't add to chat yet
            if (message.data && message.data[0]) {
                const interimText = message.data[0].trim();
                console.log('Interim transcription:', interimText);
                
                // Only show meaningful interim results
                if (interimText.length > 3 && !isNoise(interimText)) {
                    // You could display this as interim feedback
                    // showFeedback(`Hearing: "${interimText}"`, 'info');
                }
            }
            break;
            
        case "complete":
            if (message.data && message.data[0]) {
                const transcribedText = message.data[0].trim();
                console.log('Final transcription result:', transcribedText);

                // More strict filtering for final results
                if (transcribedText.length > 3 && !isNoise(transcribedText) && !isRepeatedPattern(transcribedText)) {
                    addChatMessage('voice', transcribedText);
                    showFeedback('Voice captured', 'success');

                    // Add to Gemini conversation history
                    if (window.electronAPI && window.electronAPI.addVoiceTranscript) {
                        window.electronAPI.addVoiceTranscript(transcribedText).catch(err => {
                            console.error('Failed to add transcript to history:', err);
                        });
                    }
                } else {
                    console.log('Filtered out noise/invalid transcription:', transcribedText);
                }
            }
            break;
            
        case "initiate":
            isModelLoading = true;
            showFeedback('Loading speech recognition model...', 'info');
            break;
            
        case "ready":
            isModelLoading = false;
            isWorkerReady = true;
            showFeedback('Speech recognition ready', 'success');
            break;
            
        case "error":
            console.error('Worker error:', message.data);
            showFeedback('Speech recognition error', 'error');
            isModelLoading = false;
            break;
    }
    
    updateUI();
}


// Setup audio recording
// Alternative microphone access approach
async function setupVoiceRecording() {
  try {
    console.log('Setting up voice recording...');
    
    // Check if getUserMedia is available
    if (!navigator.mediaDevices || !navigator.mediaDevices.getUserMedia) {
      throw new Error('getUserMedia not supported');
    }
    
    // Request permissions first
    const devices = await navigator.mediaDevices.enumerateDevices();
    const audioDevices = devices.filter(device => device.kind === 'audioinput');
    console.log('Available audio devices:', audioDevices.length);
    
    if (audioDevices.length === 0) {
      throw new Error('No microphone devices found');
    }
    
    // Try different constraint configurations
    const constraints = [
      // Simple constraint
      { audio: true },
      // Detailed constraint
      {
        audio: {
          echoCancellation: true,
          noiseSuppression: true,
          autoGainControl: true,
          sampleRate: 16000,
          channelCount: 1
        }
      },
      // Minimal constraint
      {
        audio: {
          sampleRate: 16000
        }
      }
    ];
    
    let stream = null;
    let lastError = null;
    
    for (const constraint of constraints) {
      try {
        console.log('Trying constraint:', constraint);
        stream = await navigator.mediaDevices.getUserMedia(constraint);
        console.log('Microphone access granted with constraint:', constraint);
        break;
      } catch (error) {
        console.warn('Failed with constraint:', constraint, error);
        lastError = error;
      }
    }
    
    if (!stream) {
      throw lastError || new Error('All microphone access attempts failed');
    }
    
    audioStream = stream;
    return true;
    
} catch (error) {
  console.error('Microphone access error details:');
  console.error('Error name:', error.name);
  console.error('Error message:', error.message);
  console.error('Error constraint:', error.constraint);
  console.error('Full error:', error);
  
  let userMessage = 'Microphone access denied';
  
  switch (error.name) {
    case 'NotAllowedError':
      userMessage = 'Microphone permission denied. Check browser/system settings.';
      break;
    case 'NotFoundError':
      userMessage = 'No microphone found. Please connect a microphone.';
      break;
    case 'NotReadableError':
      userMessage = 'Microphone is being used by another application.';
      break;
    case 'OverconstrainedError':
      userMessage = 'Microphone constraints not supported. Trying simpler settings...';
      break;
    case 'SecurityError':
      userMessage = 'Microphone access blocked due to security policy.';
      break;
    default:
      userMessage = `Microphone error: ${error.message}`;
  }
  
  showFeedback(userMessage, 'error');
  return false;
}
}

// Start recording
async function startAutoRecording() {
    if (isRecording || !isWorkerReady) {
        console.log('Cannot start recording:', { isRecording, isWorkerReady });
        return;
    }
    
    if (!audioStream) {
        const success = await setupVoiceRecording();
        if (!success) return;
    }
    
    try {
        isRecording = true;
        updateVoiceUI();
        
        console.log('Starting recording...');
        startChunkedRecording();
        
        addChatMessage('system', 'Voice recording started...');
        showFeedback('Recording started', 'success');
        
    } catch (error) {
        console.error('Failed to start recording:', error);
        showFeedback('Recording failed', 'error');
        isRecording = false;
        updateVoiceUI();
    }
}

// Stop recording
function stopAutoRecording() {
    if (!isRecording) return;
    
    console.log('Stopping recording...');
    
    isRecording = false;
    
    if (mediaRecorder && mediaRecorder.state !== 'inactive') {
        mediaRecorder.stop();
    }
    
    updateVoiceUI();
    addChatMessage('system', 'Voice recording stopped');
    showFeedback('Recording stopped', 'info');
}

// Start chunked recording
function startChunkedRecording() {
    const chunkDuration = 3000; // 3 seconds for better audio quality
    const silenceTimeout = 100;  // Minimal gap between chunks
    
    function recordChunk() {
        if (!isRecording) return;
        
        recordingChunks = [];
        
        try {
            // Better MediaRecorder configuration
            const options = {
                mimeType: 'audio/webm;codecs=opus',
                bitsPerSecond: 32000 // Higher bitrate for better quality
            };
            
            // Fallback for different browsers
            if (!MediaRecorder.isTypeSupported(options.mimeType)) {
                options.mimeType = 'audio/webm';
            }
            
            mediaRecorder = new MediaRecorder(audioStream, options);
            
            mediaRecorder.ondataavailable = (event) => {
                if (event.data.size > 500) { // Only process substantial chunks
                    recordingChunks.push(event.data);
                    console.log('Audio chunk received, size:', event.data.size);
                }
            };
            
            mediaRecorder.onstop = async () => {
                console.log('MediaRecorder stopped, chunks:', recordingChunks.length);
                
                if (recordingChunks.length > 0 && isRecording) {
                    await processAudioChunk();
                }
                
                if (isRecording) {
                    setTimeout(recordChunk, silenceTimeout);
                }
            };
            
            mediaRecorder.onerror = (event) => {
                console.error('MediaRecorder error:', event.error);
                if (isRecording) {
                    setTimeout(recordChunk, 1000); // Retry after error
                }
            };
            
            mediaRecorder.start();
            console.log('MediaRecorder started');
            
            setTimeout(() => {
                if (mediaRecorder && mediaRecorder.state === 'recording') {
                    console.log('Stopping MediaRecorder after', chunkDuration, 'ms');
                    mediaRecorder.stop();
                }
            }, chunkDuration);
            
        } catch (error) {
            console.error('Error in recordChunk:', error);
            if (isRecording) {
                setTimeout(recordChunk, 1000); // Retry after 1 second
            }
        }
    }
    
    recordChunk();
}


// Process audio chunk
async function processAudioChunk() {
    if (!worker || !isWorkerReady || recordingChunks.length === 0) return;
    try {
        console.log('Processing audio chunk...');
        const audioBlob = new Blob(recordingChunks, { type: 'audio/webm' }); // Or 'audio/webm;codecs=opus'
        // Check if audio is substantial enough to process
        if (audioBlob.size < 2000) { // Less than 2KB, likely silence
            console.log('Audio chunk too small, skipping. Size:', audioBlob.size);
            return;
        }
        // Call the NEW convertBlobToAudioBuffer function (renderer-based)
        const audioBuffer = await convertBlobToAudioBuffer(audioBlob);
        if (!audioBuffer || audioBuffer.length === 0) {
            console.warn('No audio data to process after conversion');
            return;
        }
        // Enhanced audio quality checks (using the Float32Array from renderer)
        const maxAmplitude = Math.max(...audioBuffer.map(Math.abs));
        const rms = Math.sqrt(audioBuffer.reduce((sum, val) => sum + val * val, 0) / audioBuffer.length);
        console.log(`Audio quality - Length: ${audioBuffer.length}, Max: ${maxAmplitude.toFixed(4)}, RMS: ${rms.toFixed(4)}`);

        // More strict thresholds
        const minAmplitude = 0.005; // Minimum peak amplitude
        const minRMS = 0.001;       // Minimum RMS energy
        if (maxAmplitude < minAmplitude || rms < minRMS) {
            console.log(`Audio too quiet - Max: ${maxAmplitude.toFixed(4)} < ${minAmplitude}, RMS: ${rms.toFixed(4)} < ${minRMS}`);
            return;
        }
        // Check for minimum duration (at least 0.5 seconds at 16kHz)
        const minSamples = 8000; // 0.5 seconds at 16kHz
        if (audioBuffer.length < minSamples) {
            console.log(`Audio too short: ${audioBuffer.length} samples < ${minSamples} required`);
            return;
        }
        console.log('Sending quality audio to Whisper worker');
        // Send the 16kHz Float32Array directly to the worker
        worker.postMessage({
            audio: audioBuffer, // This is now the Float32Array from renderer
            model: WHISPER_CONFIG.model,
            multilingual: WHISPER_CONFIG.multilingual,
            quantized: WHISPER_CONFIG.quantized,
            subtask: WHISPER_CONFIG.subtask,
            language: WHISPER_CONFIG.language
        });
    } catch (error) {
        console.error('Error processing audio:', error);
    }
}

// Convert audio blob to format for Whisper
async function convertBlobToAudioBuffer(blob) {
    try {
        console.log('Converting blob to audio buffer. Size:', blob.size);
        if (blob.size === 0) {
            console.warn('Empty audio blob');
            return null;
        }

        // Decode the audio blob using the AudioContext created in init()
        const arrayBuffer = await blob.arrayBuffer();
        // Ensure audioContext is available and resume if suspended
        if (!audioContext) {
            console.error('AudioContext is not available');
            return null;
        }
        if (audioContext.state === 'suspended') {
            await audioContext.resume();
        }

        const audioBuffer = await audioContext.decodeAudioData(arrayBuffer);

        // Get the first channel (mono)
        const rawData = audioBuffer.getChannelData(0);
        const sampleRate = audioBuffer.sampleRate;

        console.log(`Decoded audio: ${rawData.length} samples, ${sampleRate} Hz`);

        // Whisper expects 16kHz. Resample if necessary using a simple averaging method.
        const targetSampleRate = 16000;
        if (sampleRate !== targetSampleRate) {
            console.log(`Resampling from ${sampleRate} Hz to ${targetSampleRate} Hz`);
            const resampledData = resampleAudio(rawData, sampleRate, targetSampleRate);
            console.log(`Resampled data length: ${resampledData.length}`);
            return resampledData; // Return the Float32Array at 16kHz
        }

        // If already 16kHz, return the raw data directly
        console.log(`Audio already at target sample rate ${targetSampleRate} Hz`);
        return rawData; // rawData is already a Float32Array

    } catch (error) {
        console.error('Error decoding audio blob:', error);
        return null;
    }
}

function resampleAudio(buffer, fromRate, toRate) {
    if (fromRate === toRate) {
        return buffer;
    }
    const sampleRateRatio = fromRate / toRate;
    const newLength = Math.round(buffer.length / sampleRateRatio);
    const result = new Float32Array(newLength);
    let offsetResult = 0;
    let offsetBuffer = 0;

    while (offsetResult < result.length) {
        const nextOffsetBuffer = Math.round((offsetResult + 1) * sampleRateRatio);
        let accum = 0;
        let count = 0;
        for (let i = offsetBuffer; i < nextOffsetBuffer && i < buffer.length; i++) {
            accum += buffer[i];
            count++;
        }
        result[offsetResult] = accum / count;
        offsetResult++;
        offsetBuffer = nextOffsetBuffer;
    }
    return result;
}

// Filter noise
function isNoise(text) {
    const cleanText = text.trim().toLowerCase();
    
    // Filter out noise patterns
    const noisePatterns = [
        /^[^\w\s]*$/,                    // Only punctuation
        /^[!@#$%^&*()_+\-=\[\]{}|;':".,<>?\/`~]*$/, // Only symbols
        /^(uh|um|er|ah|oh|hmm)+$/i,      // Filler words
        /^[.!?]+$/,                      // Only punctuation
        /^silence$/i,                    // Literal "silence"
        /^background/i,                  // Background noise
        /^[!]{2,}$/,                     // Multiple exclamation marks (your issue!)
        /^[\s]*$/,                       // Only whitespace
        /^[a-z]$/i,                      // Single characters
        /^[0-9]+$/,                      // Only numbers
        /^[.,;:!?]+$/,                   // Only punctuation
        /^music$/i,                      // Music detection
        /^noise$/i,                      // Noise detection
    ];
    
    // Check length - very short transcriptions are usually noise
    if (cleanText.length < 3) {
        return true;
    }
    
    // Check against patterns
    return noisePatterns.some(pattern => pattern.test(cleanText));
}

function isRepeatedPattern(text) {
    // Check for repeated single characters
    if (/^(.)\1{3,}$/.test(text)) {
        return true;
    }
    
    // Check for repeated short patterns
    if (text.length > 6) {
        for (let len = 1; len <= 3; len++) {
            const pattern = text.substring(0, len);
            const repeated = pattern.repeat(Math.floor(text.length / len));
            if (text.startsWith(repeated) && repeated.length >= text.length * 0.8) {
                return true;
            }
        }
    }
    
    return false;
}

// Toggle voice recognition
async function toggleVoiceRecognition() {
    if (isRecording) {
        stopAutoRecording();
        voiceToggle.classList.remove('active');
    } else {
        await startAutoRecording();
        if (isRecording) {
            voiceToggle.classList.add('active');
        }
    }
}

// Update voice UI
function updateVoiceUI() {
    if (!voiceToggle) return;
    
    if (isRecording) {
        voiceToggle.classList.add('listening');
        voiceToggle.title = 'Stop recording';
    } else {
        voiceToggle.classList.remove('listening');
        
        if (!isWorkerReady) {
            voiceToggle.title = 'Loading speech recognition...';
            voiceToggle.disabled = true;
        } else {
            voiceToggle.title = 'Start recording';
            voiceToggle.disabled = false;
        }
    }
}

// Add chat message
function addChatMessage(type, content) {
    if (!chatMessagesElement) return;
    
    const messageDiv = document.createElement('div');
    messageDiv.className = `chat-message ${type}`;
    
    const timestamp = new Date().toLocaleTimeString([], { 
        hour: '2-digit', 
        minute: '2-digit' 
    });
    
    let messageContent = '';
    
    switch (type) {
        case 'voice':
            messageContent = `<div class="message-header"><span class="message-icon">🎤</span><span class="message-time">${timestamp}</span></div><div class="message-content">${content}</div>`;
            break;
            
        case 'screenshot':
            messageContent = `<div class="message-header"><span class="message-icon">📸</span><span class="message-time">${timestamp}</span></div><div class="message-content">Screenshot captured</div>`;
            break;
            
        case 'ai-response':
            messageContent = `<div class="message-header"><span class="message-icon">🤖</span><span class="message-time">${timestamp}</span></div><div class="message-content ai-response">${formatResponse(content)}</div>`;
            break;
            
        case 'system':
            messageContent = `<div class="message-header"><span class="message-icon">ℹ️</span><span class="message-time">${timestamp}</span></div><div class="message-content system-message">${content}</div>`;
            break;
    }
    
    messageDiv.innerHTML = messageContent;
    chatMessagesElement.appendChild(messageDiv);
    
    chatMessagesElement.scrollTop = chatMessagesElement.scrollHeight;
    
    chatMessagesArray.push({
        type,
        content,
        timestamp: new Date()
    });
}

// Start timer
function startTimer() {
    const timerElement = document.querySelector('.timer');
    if (!timerElement) return;

    timerInterval = setInterval(() => {
        const elapsed = Math.floor((Date.now() - startTime) / 1000);
        const minutes = Math.floor(elapsed / 60).toString().padStart(2, '0');
        const seconds = (elapsed % 60).toString().padStart(2, '0');
        timerElement.textContent = `${minutes}:${seconds}`;
    }, 1000);
}

// NEW CLUELY-STYLE FEATURES

// "What should I say?" feature
async function getResponseSuggestions() {
    if (!window.electronAPI || !window.electronAPI.suggestResponse) {
        showFeedback('Feature not available', 'error');
        return;
    }

    try {
        showFeedback('Generating suggestions...', 'info');

        // Get recent context from chat messages
        const recentMessages = chatMessagesArray
            .slice(-5)
            .map(m => `${m.type}: ${m.content}`)
            .join('\n');

        const context = recentMessages || 'Current meeting conversation';

        const result = await window.electronAPI.suggestResponse(context);

        if (result.success && result.suggestions) {
            addChatMessage('ai-response', `💡 **What should I say?**\n\n${result.suggestions}`);
            showFeedback('Suggestions generated', 'success');
        } else {
            throw new Error(result.error || 'Failed to generate suggestions');
        }
    } catch (error) {
        console.error('Error getting suggestions:', error);
        showFeedback('Failed to generate suggestions', 'error');
        addChatMessage('system', `Error: ${error.message}`);
    }
}

// Generate meeting notes
async function generateMeetingNotes() {
    if (!window.electronAPI || !window.electronAPI.generateMeetingNotes) {
        showFeedback('Feature not available', 'error');
        return;
    }

    try {
        showFeedback('Generating meeting notes...', 'info');
        setAnalyzing(true);

        const result = await window.electronAPI.generateMeetingNotes();

        setAnalyzing(false);

        if (result.success && result.notes) {
            addChatMessage('ai-response', `📝 **Meeting Notes**\n\n${result.notes}`);
            showFeedback('Meeting notes generated', 'success');
        } else {
            throw new Error(result.error || 'Failed to generate notes');
        }
    } catch (error) {
        console.error('Error generating notes:', error);
        setAnalyzing(false);
        showFeedback('Failed to generate notes', 'error');
        addChatMessage('system', `Error: ${error.message}`);
    }
}

// Get conversation insights
async function getConversationInsights() {
    if (!window.electronAPI || !window.electronAPI.getConversationInsights) {
        showFeedback('Feature not available', 'error');
        return;
    }

    try {
        showFeedback('Analyzing conversation...', 'info');
        setAnalyzing(true);

        const result = await window.electronAPI.getConversationInsights();

        setAnalyzing(false);

        if (result.success && result.insights) {
            addChatMessage('ai-response', `📊 **Conversation Insights**\n\n${result.insights}`);
            showFeedback('Insights generated', 'success');
        } else {
            throw new Error(result.error || 'Failed to get insights');
        }
    } catch (error) {
        console.error('Error getting insights:', error);
        setAnalyzing(false);
        showFeedback('Failed to get insights', 'error');
        addChatMessage('system', `Error: ${error.message}`);
    }
}

// Setup event listeners
function setupEventListeners() {
    if (screenshotBtn) screenshotBtn.addEventListener('click', takeStealthScreenshot);
    if (analyzeBtn) analyzeBtn.addEventListener('click', analyzeScreenshots);
    if (clearBtn) clearBtn.addEventListener('click', clearStealthData);
    if (hideBtn) hideBtn.addEventListener('click', emergencyHide);
    if (copyBtn) copyBtn.addEventListener('click', copyToClipboard);
    if (closeResultsBtn) closeResultsBtn.addEventListener('click', hideResults);
    if (voiceToggle) voiceToggle.addEventListener('click', toggleVoiceRecognition);

    // New Cluely-style feature buttons
    if (suggestBtn) suggestBtn.addEventListener('click', getResponseSuggestions);
    if (notesBtn) notesBtn.addEventListener('click', generateMeetingNotes);
    if (insightsBtn) insightsBtn.addEventListener('click', getConversationInsights);

    document.addEventListener('keydown', (e) => {
        if (e.ctrlKey && e.altKey && e.shiftKey) {
            switch (e.key.toLowerCase()) {
                case 'h':
                    e.preventDefault();
                    if (window.electronAPI) window.electronAPI.toggleStealth();
                    break;
                case 's':
                    e.preventDefault();
                    takeStealthScreenshot();
                    break;
                case 'a':
                    e.preventDefault();
                    analyzeScreenshots();
                    break;
                case 'x':
                    e.preventDefault();
                    emergencyHide();
                    break;
                case 'v':
                    e.preventDefault();
                    toggleVoiceRecognition();
                    break;
            }
        }
    });

    document.addEventListener('contextmenu', e => e.preventDefault());
    document.addEventListener('selectstart', e => e.preventDefault());
    document.addEventListener('dragstart', e => e.preventDefault());
}

// Setup IPC listeners
function setupIpcListeners() {
    if (!window.electronAPI) {
        console.error('electronAPI not available');
        return;
    }

    window.electronAPI.onScreenshotTakenStealth((count) => {
        screenshotsCount = count;
        updateUI();
        addChatMessage('screenshot', 'Screenshot captured');
        showFeedback('Screenshot captured', 'success');
    });

    window.electronAPI.onAnalysisStart(() => {
        setAnalyzing(true);
        showLoadingOverlay();
        addChatMessage('system', 'Analyzing screenshots and context...');
    });

    window.electronAPI.onAnalysisResult((data) => {
        setAnalyzing(false);
        hideLoadingOverlay();
        
        if (data.error) {
            addChatMessage('system', `Error: ${data.error}`);
            showFeedback(data.error, 'error');
        } else {
            addChatMessage('ai-response', data.text);
            showFeedback('Analysis complete', 'success');
        }
    });

    window.electronAPI.onSetStealthMode((enabled) => {
        setStealthMode(enabled);
    });

    window.electronAPI.onEmergencyClear(() => {
        hideResults();
        clearStealthData();
        emergencyHide();
    });

    window.electronAPI.onError((message) => {
        addChatMessage('system', `Error: ${message}`);
        showFeedback(message, 'error');
    });
}

// Take screenshot
async function takeStealthScreenshot() {
    if (!window.electronAPI) {
        showFeedback('electronAPI not available', 'error');
        return;
    }

    try {
        screenshotBtn.disabled = true;
        await window.electronAPI.takeStealthScreenshot();
    } catch (error) {
        console.error('Screenshot error:', error);
        showFeedback('Screenshot failed', 'error');
        addChatMessage('system', 'Screenshot failed');
    } finally {
        screenshotBtn.disabled = false;
    }
}

// Analyze screenshots
async function analyzeScreenshots() {
    if (screenshotsCount === 0) {
        showFeedback('No screenshots to analyze', 'error');
        return;
    }

    if (!window.electronAPI) {
        showFeedback('electronAPI not available', 'error');
        return;
    }

    try {
        const recentMessages = chatMessagesArray.slice(-10).filter(msg => 
            msg.type === 'voice' || msg.type === 'ai-response'
        );
        
        const context = recentMessages.map(msg => 
            `${msg.type === 'voice' ? 'User' : 'AI'}: ${msg.content}`
        ).join('\n');
        
        await window.electronAPI.analyzeStealthWithContext(context);
    } catch (error) {
        console.error('Analysis error:', error);
        showFeedback('Analysis failed', 'error');
        addChatMessage('system', 'Analysis failed');
    }
}

// Clear data
async function clearStealthData() {
    if (!window.electronAPI) return;

    try {
        clearBtn.disabled = true;
        const result = await window.electronAPI.clearStealth();
        
        if (result.success) {
            screenshotsCount = 0;
            chatMessagesElement.innerHTML = '';
            chatMessagesArray.length = 0;
            hideResults();
            updateUI();
            addChatMessage('system', 'Data cleared');
            showFeedback('Data cleared', 'info');
        }
    } catch (error) {
        console.error('Clear error:', error);
        showFeedback('Clear failed', 'error');
    } finally {
        clearBtn.disabled = false;
    }
}

// Emergency hide
function emergencyHide() {
    if (emergencyOverlay) {
        emergencyOverlay.classList.remove('hidden');
    }
    
    if (isRecording) {
        stopAutoRecording();
        voiceToggle.classList.remove('active');
    }
    
    if (resultText) {
        resultText.textContent = '';
    }
    
    setTimeout(() => {
        if (emergencyOverlay) {
            emergencyOverlay.classList.add('hidden');
        }
    }, 2000);
}

// Utility functions
function hideResults() {
    if (resultsPanel) {
        resultsPanel.classList.add('hidden');
    }
    if (resultText) {
        resultText.innerHTML = '';
    }
}

function formatResponse(text) {
    let formatted = text;
    formatted = formatted.replace(/```(\w+)?\n([\s\S]*?)```/g, '<div class="code-block"><code>$2</code></div>');
    formatted = formatted.replace(/`([^`]+)`/g, '<code>$1</code>');
    formatted = formatted.replace(/\*\*(.*?)\*\*/g, '<strong>$1</strong>');
    formatted = formatted.replace(/• (.*?)(?=\n|$)/g, '<div>• $1</div>');
    formatted = formatted.replace(/\n/g, '<br>');
    return formatted;
}

async function copyToClipboard() {
    if (!chatMessagesElement || chatMessagesElement.children.length === 0) {
        showFeedback('No content to copy', 'error');
        return;
    }

    try {
        const lastAiMessage = Array.from(chatMessagesElement.children)
            .reverse()
            .find(msg => msg.classList.contains('ai-response'));
        
        if (lastAiMessage) {
            const text = lastAiMessage.querySelector('.message-content').textContent;
            await navigator.clipboard.writeText(text);
            showFeedback('Copied to clipboard', 'success');
        } else {
            showFeedback('No AI response to copy', 'error');
        }
    } catch (error) {
        console.error('Copy error:', error);
        showFeedback('Copy failed', 'error');
    }
}

function updateUI() {
    if (screenshotCount) {
        screenshotCount.textContent = screenshotsCount;
    }
    
    if (analyzeBtn) {
        analyzeBtn.disabled = screenshotsCount === 0 || isAnalyzing;
    }
    if (clearBtn) {
        clearBtn.disabled = screenshotsCount === 0 && chatMessagesElement.children.length === 0;
    }
    
    updateVoiceUI();
}

function setAnalyzing(analyzing) {
    isAnalyzing = analyzing;
    updateUI();
}

function setStealthMode(enabled) {
    if (stealthHideTimeout) {
        clearTimeout(stealthHideTimeout);
        stealthHideTimeout = null;
    }

    stealthModeActive = enabled;
    
    if (enabled) {
        document.body.classList.add('stealth-mode');
        if (isRecording) {
            stopAutoRecording();
            voiceToggle.classList.remove('active');
        }
    } else {
        document.body.classList.remove('stealth-mode');
    }
}

function showLoadingOverlay() {
    if (loadingOverlay) {
        loadingOverlay.classList.remove('hidden');
    }
}

function hideLoadingOverlay() {
    if (loadingOverlay) {
        loadingOverlay.classList.add('hidden');
    }
}

function showFeedback(message, type) {
    type = type || 'info';
    
    if (!statusText) {
        console.log('Status feedback:', message, type);
        return;
    }
    
    statusText.style.display = 'block';
    statusText.style.opacity = '1';
    statusText.textContent = message;
    statusText.className = `status-text status-${type} show`;
    
    setTimeout(() => {
        statusText.style.opacity = '0';
        setTimeout(() => {
            statusText.style.display = 'none';
            statusText.className = 'status-text';
        }, 300);
    }, 3000);
}

// Initialize when DOM is ready
document.addEventListener('DOMContentLoaded', async () => {
    console.log('DOM loaded, initializing...');
    await init();
    
    stealthModeActive = false;
    
    setTimeout(() => {
        addChatMessage('system', 'AI Meeting Assistant with Whisper speech recognition ready. Click the microphone to start recording.');
    }, 1000);
});

// Cleanup
window.addEventListener('beforeunload', () => {
    if (timerInterval) {
        clearInterval(timerInterval);
    }
    if (stealthHideTimeout) {
        clearTimeout(stealthHideTimeout);
    }
    if (isRecording) {
        stopAutoRecording();
    }
    if (audioStream) {
        audioStream.getTracks().forEach(track => track.stop());
    }
    if (worker) {
        worker.terminate();
    }
    if (audioContext && audioContext.state !== 'closed') {
        audioContext.close();
    }
});

================
File: src/windows/legacy/whisper-worker.js
================
/* eslint-disable camelcase */
// REPLACE your entire whisper-worker.js with this exact working version
import { pipeline, env } from "@xenova/transformers";

// Disable local models
env.allowLocalModels = false;

// Define model factories
// Ensures only one model is created of each type
class PipelineFactory {
    static task = null;
    static model = null;
    static quantized = null;
    static instance = null;

    constructor(tokenizer, model, quantized) {
        this.tokenizer = tokenizer;
        this.model = model;
        this.quantized = quantized;
    }

    static async getInstance(progress_callback = null) {
        if (this.instance === null) {
            this.instance = pipeline(this.task, this.model, {
                quantized: this.quantized,
                progress_callback,
                // For medium models, we need to load the `no_attentions` revision to avoid running out of memory
                revision: this.model.includes("/whisper-medium") ? "no_attentions" : "main"
            });
        }
        return this.instance;
    }
}

self.addEventListener("message", async (event) => {
    const message = event.data;

    // Do transcription work
    let transcript = await transcribe(
        message.audio,
        message.model,
        message.multilingual,
        message.quantized,
        message.subtask,
        message.language,
    );
    if (transcript === null) return;

    // Send the result back to the main thread
    self.postMessage({
        status: "complete",
        task: "automatic-speech-recognition",
        data: transcript,
    });
});

class AutomaticSpeechRecognitionPipelineFactory extends PipelineFactory {
    static task = "automatic-speech-recognition";
    static model = null;
    static quantized = null;
}

const transcribe = async (
    audio,
    model,
    multilingual,
    quantized,
    subtask,
    language,
) => {
    const isDistilWhisper = model.startsWith("distil-whisper/");

    let modelName = model;
    if (!isDistilWhisper && !multilingual) {
        modelName += ".en"
    }

    const p = AutomaticSpeechRecognitionPipelineFactory;
    if (p.model !== modelName || p.quantized !== quantized) {
        // Invalidate model if different
        p.model = modelName;
        p.quantized = quantized;

        if (p.instance !== null) {
            (await p.getInstance()).dispose();
            p.instance = null;
        }
    }

    // Load transcriber model
    let transcriber = await p.getInstance((data) => {
        self.postMessage(data);
    });

    const time_precision =
        transcriber.processor.feature_extractor.config.chunk_length /
        transcriber.model.config.max_source_positions;

    // Storage for chunks to be processed. Initialise with an empty chunk.
    let chunks_to_process = [
        {
            tokens: [],
            finalised: false,
        },
    ];

    function chunk_callback(chunk) {
        let last = chunks_to_process[chunks_to_process.length - 1];

        // Overwrite last chunk with new info
        Object.assign(last, chunk);
        last.finalised = true;

        // Create an empty chunk after, if it not the last chunk
        if (!chunk.is_last) {
            chunks_to_process.push({
                tokens: [],
                finalised: false,
            });
        }
    }

    // Inject custom callback function to handle merging of chunks
    function callback_function(item) {
        let last = chunks_to_process[chunks_to_process.length - 1];

        // Update tokens of last chunk
        last.tokens = [...item[0].output_token_ids];

        // Merge text chunks
        let data = transcriber.tokenizer._decode_asr(chunks_to_process, {
            time_precision: time_precision,
            return_timestamps: true,
            force_full_sequences: false,
        });

        self.postMessage({
            status: "update",
            task: "automatic-speech-recognition",
            data: data,
        });
    }

    // Actually run transcription
    let output = await transcriber(audio, {
        // Greedy
        top_k: 0,
        do_sample: false,

        // Sliding window
        chunk_length_s: isDistilWhisper ? 20 : 30,
        stride_length_s: isDistilWhisper ? 3 : 5,

        // Language and task
        language: language,
        task: subtask,

        // Return timestamps
        return_timestamps: true,
        force_full_sequences: false,

        // Callback functions
        callback_function: callback_function, // after each generation step
        chunk_callback: chunk_callback, // after each chunk is processed
    }).catch((error) => {
        self.postMessage({
            status: "error",
            task: "automatic-speech-recognition",
            data: error,
        });
        return null;
    });

    return output;
};

================
File: notes.md
================
# Open-Cluely Codebase Structure (Updated)

This is the current architecture and file-ownership map for the repository.
It is based on the actual code in `src/` after the renderer modular refactor.

## 1) Runtime Architecture

1. **Main process boot**
   - `src/main.js` calls `startApplication()` in `src/main-process/start-application.js`.
2. **Environment + state**
   - `.env` is loaded/sanitized via `src/bootstrap/environment.js`.
   - persisted UI/runtime choices are loaded from `cache/app-state.json` via `src/services/state/app-state.js`.
3. **Main-process composition**
   - `start-application.js` wires:
     - window controller
     - screenshot manager
     - Gemini runtime
     - AssemblyAI streaming service
     - all IPC handlers
4. **Preload bridge**
   - `src/windows/assistant/preload.js` exposes `window.electronAPI` through `contextBridge`.
   - API is modularized in `src/windows/assistant/preload/*`.
5. **Renderer UI**
   - `src/windows/assistant/renderer.html` + `styles.css` define UI.
   - `src/windows/assistant/renderer.js` orchestrates feature managers under `src/windows/assistant/renderer/features/*`.

## 2) Top-Level Files And Folders

- `package.json`: scripts, dependencies, and `electron-builder` configuration.
- `.env` / `.env.example`: runtime secrets and defaults contract.
- `README.md`: setup, usage, and high-level docs.
- `BUILD_INSTRUCTIONS.md`: build/package walkthrough.
- `SETUP-VOSK.md`: legacy STT setup notes (project now uses AssemblyAI modules in active flow).
- `notes.md`: this architecture map.
- `src/`: all application source.
- `assets/`: icons and packaging assets.
- `cache/`: generated persisted state in development (`app-state.json`).
- `.stealth_screenshots/`: generated screenshots in development.
- `dist/`: packaged output.

## 3) `src/` Detailed File Ownership

### `src/main.js`
- Thin entrypoint. Starts app by calling `startApplication()` and exits on fatal startup failure.

### `src/config.js`
- Central source of truth for:
  - Gemini model list
  - AssemblyAI speech model list
  - programming-language list
  - global shortcut definitions
- Exposes getters/resolvers and shortcut lookup helpers.

### `src/bootstrap/environment.js`
- Handles env file path resolution (dev vs packaged).
- Loads `.env` with `dotenv`.
- Normalizes values (booleans, ints, key arrays).
- Validates required keys (`GEMINI_API_KEY`, `ASSEMBLY_AI_API_KEY`).
- Persists settings back to `.env` through `saveApplicationEnvironment`.

### `src/main-process/`

#### `src/main-process/start-application.js`
- Main composition root for Electron app lifecycle.
- Initializes and wires:
  - window controller
  - screenshot manager
  - Gemini runtime
  - AssemblyAI service
  - assistant/settings/assembly IPC registrations
- Loads persisted app state and restores model/language/opacity/key-index.
- Registers global shortcuts and lifecycle hooks (`whenReady`, `activate`, `will-quit`).

#### `src/main-process/startup-logging.js`
- Logs startup config values (keys presence, selected defaults, lists).

#### `src/main-process/shared/safe-send.js`
- Safe wrapper for `webContents.send` to avoid sending to destroyed/crashed renderer.

#### `src/main-process/features/window/window-constants.js`
- Window defaults and constraints:
  - default/min width/height
  - opacity bounds and default
  - stealth opacity delta

#### `src/main-process/features/window/window-controller.js`
- Owns BrowserWindow runtime behavior:
  - create/destroy/get window
  - opacity application + stealth mode toggle
  - emergency hide behavior
  - guarded recovery/reload handlers
  - set/get bounds with work-area clamping
  - global shortcut registration and movement shortcuts

#### `src/main-process/features/assistant/gemini-runtime.js`
- Runtime controller around `GeminiService`:
  - model/language/key configuration
  - active-key index tracking and persistence callback
  - key rotation/failover logic on quota/auth errors
  - wrapper for executing operations with automatic key fallback

#### `src/main-process/features/assistant/screenshot-manager.js`
- Screenshot lifecycle:
  - stealth capture with temporary low-opacity window
  - screenshot directory management
  - screenshot retention cap cleanup
  - conversion to Gemini multimodal image parts
  - clear/cleanup helpers

#### `src/main-process/features/assistant/ipc.js`
- Assistant and AI-related IPC handlers:
  - screenshot analysis
  - Ask AI with transcript + optional screenshots
  - suggestions/notes/insights/email/QA helpers
  - clear conversation/history
  - close app
- Maps raw Gemini/runtime errors into user-facing messages.

#### `src/main-process/features/settings/ipc.js`
- Settings IPC handlers:
  - `get-settings` returns current keys, models, languages, shortcuts, opacity
  - `save-settings` persists `.env` + `app-state.json`, reapplies runtime config

### `src/services/`

#### `src/services/ai/gemini-service.js`
- Core Gemini service wrapper:
  - model init/re-init
  - request queue + rate limiting + retry/backoff
  - quota/auth error detection helpers
  - conversation history storage
  - feature methods (`analyzeScreenshots`, `askAiWithSessionContext`, notes/insights/etc.)

#### `src/services/ai/prompts.js`
- Prompt builder library for all Gemini tasks:
  - screenshot analysis
  - ask-ai session mode
  - suggestions
  - meeting notes
  - follow-up email
  - direct question answering
  - conversation insights
- Applies programming-language preference policy and language-specific guidance.

#### `src/services/assembly-ai/service.js`
- AssemblyAI streaming backend:
  - per-source WS connect/start/stop
  - partial/final transcript events to renderer
  - audio chunk intake and heartbeat/drop debug
  - source state resets and cleanup
  - non-streaming transcription endpoint flow (`upload` -> `transcript` -> polling)

#### `src/services/assembly-ai/stt-history.js`
- Merges and buffers final STT segments per source.
- Flushes merged transcripts into Gemini history on pause/stop/termination.
- Handles overlap-aware transcript merge to reduce duplicate fragments.

#### `src/services/assembly-ai/ipc.js`
- IPC adapter for AssemblyAI service:
  - start/stop voice recognition
  - audio chunk forwarding
  - desktop source listing
  - offline transcription call

#### `src/services/state/app-state.js`
- Persisted app-state read/write/sanitize for `cache/app-state.json`.
- Stores key index, selected models/language, and window opacity level.

### `src/windows/assistant/`

#### `src/windows/assistant/window.js`
- BrowserWindow creation/config for transparent overlay window.
- Permission handlers for media/microphone.
- Content protection setup (`setContentProtection`).
- Initial visibility behavior (`launchHidden` aware).

#### `src/windows/assistant/preload.js`
- Exposes `window.electronAPI` through `contextBridge`.
- Uses `createElectronApi` factory from `preload/create-electron-api.js`.

#### `src/windows/assistant/preload/create-electron-api.js`
- Composes invoke and event API modules into one renderer-facing object.

#### `src/windows/assistant/preload/actions.js`
- All `ipcRenderer.invoke` wrappers used by renderer.
- Includes fallbacks and consistent logging through helper factory.

#### `src/windows/assistant/preload/listeners.js`
- Renderer event subscription wrappers for all push events from main process.

#### `src/windows/assistant/preload/helpers.js`
- Utility factories:
  - `invokeWithFallback`
  - `createEventListener`

#### `src/windows/assistant/renderer.html`
- Main UI layout:
  - top controls and action buttons
  - transcription monitor
  - AI chat area + composer
  - settings panel
  - close confirmation modal
  - loading/emergency overlays
  - resize handles

#### `src/windows/assistant/styles.css`
- Full visual system for overlay UI:
  - glass theme variables
  - chat/transcription/settings styling
  - dark theme support
  - resize-handle and interaction styling
  - responsive layout behavior

#### `src/windows/assistant/renderer-globals.d.ts`
- Global renderer typing for `window.electronAPI`.

#### `src/windows/assistant/pcm-capture-worklet.js`
- AudioWorklet processor that batches PCM float samples and posts chunks to main thread.

#### `src/windows/assistant/renderer.js`
- Renderer composition root.
- Instantiates managers and wires dependencies:
  - message store/context bundle
  - chat UI manager
  - window adjustment manager
  - shortcut manager
  - settings panel manager
  - transcription manager
  - listener modules
- Owns high-level UI actions and feature flows:
  - Ask AI / Screen AI
  - suggestions/notes/insights
  - theme switching
  - feedback/loading overlays
  - close confirmation

### `src/windows/assistant/renderer/features/ai-context/`

#### `message-types.js`
- Message-type classification and context/summary line formatting rules.

#### `message-store.js`
- In-memory chat message records:
  - add/clear/find
  - toggle `includeInAi`
  - inclusion rules for AI context

#### `context-bundle.js`
- Builds token-budgeted AI context bundle from included messages.
- Produces:
  - `contextString`
  - `transcriptContext`
  - `sessionSummary`
  - enabled screenshot IDs

#### `toggle-ui.js`
- Applies include/exclude toggle state to rendered chat message DOM.

### `src/windows/assistant/renderer/features/chat/`

#### `chat-ui-manager.js`
- Chat rendering and local UX behavior:
  - message card rendering
  - AI formatting for markdown-like blocks
  - auto-scroll behavior
  - composer auto-resize
  - manual context message submission

### `src/windows/assistant/renderer/features/layout/`

#### `window-adjustments.js`
- Renderer-side window resize handle behavior.
- Uses `electronAPI.getWindowBounds/setWindowBounds` and pointer events.
- Enforces chat fill layout after viewport changes.

### `src/windows/assistant/renderer/features/listeners/`

#### `event-listeners.js`
- All DOM/event wiring in one place:
  - button clicks
  - chat input handlers
  - keyboard shortcuts
  - context-menu/select/drag suppression

#### `ipc-listeners.js`
- All renderer IPC subscriptions:
  - screenshot/analysis/status events
  - STT status/partial/final/error/stopped events
  - global shortcut events
  - STT debug event relay to monitor log
  - global renderer error/unhandled rejection logging

### `src/windows/assistant/renderer/features/settings/`

#### `shortcut-manager.js`
- Parses accelerator strings and evaluates keyboard events against shortcut ids.
- Renders read-only shortcut list in settings panel.

#### `settings-panel-manager.js`
- Settings panel behavior:
  - load and populate fields/options from `getSettings`
  - opacity label handling
  - save/apply settings via `saveSettings`

### `src/windows/assistant/renderer/features/transcription/`

#### `transcription-manager.js`
- Renderer-side transcription orchestration:
  - source toggles and status state
  - monitor UI updates and monitor logs
  - mic/system start/stop lifecycle
  - partial/final transcript handling
  - buffering/flush integration

### `src/windows/assistant/renderer/features/assembly-ai/`

#### `source-state.js`
- Shared source selection/status/active state model for renderer.

#### `audio-pipeline.js`
- WebAudio capture and processing pipeline:
  - desktop/mic stream handling
  - downsampling to 16 kHz
  - frame batching and PCM16 conversion
  - chunk emission via `sendAudioChunk`

#### `transcript-buffer.js`
- Final transcript merge/buffer/flush logic in renderer before chat commit.

### `src/windows/legacy/`

#### `whisper-worker.js`
- Legacy Whisper worker implementation (not in active production flow).

#### `renderer-whisper-backup.js`
- Legacy backup renderer for old Whisper-based approach.

#### `renderer-webspeech-broken.js`
- Legacy experimental Web Speech renderer (deprecated/broken path).

## 4) Quick Boundaries (What Goes Where)

- **`src/main-process/**`**: Electron main-process orchestration and IPC registration.
- **`src/services/**`**: reusable domain logic (AI, STT, state persistence).
- **`src/windows/assistant/preload/**`**: secure IPC bridge exposed to renderer.
- **`src/windows/assistant/renderer/features/**`**: renderer feature modules only.
- **`src/windows/legacy/**`**: reference-only old experiments.

## 5) Practical Guidance For New Changes

- Add new renderer behavior under `renderer/features/*` and keep `renderer.js` as composition/orchestration.
- Add new invoke/listener APIs under `windows/assistant/preload/*` and register matching IPC in main process.
- Keep configurable lists/defaults/shortcuts in `src/config.js`.
- When adding env fields, update together:
  - `src/bootstrap/environment.js`
  - `.env.example`
  - `README.md`

================
File: src/main-process/features/assistant/screenshot-manager.js
================
const fs = require('fs');
const path = require('path');
const screenshot = require('screenshot-desktop');

function createScreenshotManager({ app, getMainWindow, getAppEnvironment, sendToRenderer }) {
  let screenshots = [];
  let screenshotSequence = 0;
  let screenshotInProgress = false;

  function nextScreenshotId() {
    screenshotSequence += 1;
    return `ss-${Date.now()}-${screenshotSequence}`;
  }

  function normalizeScreenshotEntry(entry) {
    if (!entry) return null;

    if (typeof entry === 'string') {
      return {
        id: null,
        path: entry,
        timestamp: null
      };
    }

    if (typeof entry.path === 'string') {
      return {
        id: typeof entry.id === 'string' ? entry.id : null,
        path: entry.path,
        timestamp: typeof entry.timestamp === 'string' ? entry.timestamp : null
      };
    }

    return null;
  }

  function getScreenshotsDir() {
    return app.isPackaged
      ? path.join(app.getPath('userData'), '.stealth_screenshots')
      : path.join(__dirname, '..', '..', '..', '..', '.stealth_screenshots');
  }

  function ensureScreenshotsDir() {
    const screenshotsDir = getScreenshotsDir();
    if (!fs.existsSync(screenshotsDir)) {
      fs.mkdirSync(screenshotsDir, { recursive: true });
    }
    return screenshotsDir;
  }

  function cleanupScreenshotFile(entry) {
    const normalizedEntry = normalizeScreenshotEntry(entry);
    if (normalizedEntry && fs.existsSync(normalizedEntry.path)) {
      fs.unlinkSync(normalizedEntry.path);
    }
  }

  async function takeStealthScreenshot() {
    if (screenshotInProgress) {
      console.log('Screenshot already in progress, skipping');
      return null;
    }

    const mainWindow = getMainWindow();
    const appEnvironment = getAppEnvironment();

    if (!mainWindow || mainWindow.isDestroyed()) {
      throw new Error('Main window not available');
    }

    screenshotInProgress = true;
    try {
      console.log('Taking stealth screenshot...');
      const currentOpacity = mainWindow.getOpacity();
      const screenshotDelay = appEnvironment?.screenshotDelay || 300;

      mainWindow.setOpacity(0.01);
      await new Promise((resolve) => setTimeout(resolve, screenshotDelay));

      const screenshotsDir = ensureScreenshotsDir();
      const screenshotPath = path.join(screenshotsDir, `stealth-${Date.now()}.png`);

      await screenshot({ filename: screenshotPath });

      const screenshotEntry = {
        id: nextScreenshotId(),
        path: screenshotPath,
        timestamp: new Date().toISOString()
      };

      screenshots.push(screenshotEntry);
      if (screenshots.length > appEnvironment.maxScreenshots) {
        cleanupScreenshotFile(screenshots.shift());
      }

      mainWindow.setOpacity(currentOpacity);

      console.log(`Screenshot saved: ${screenshotPath}`);
      console.log(`Total screenshots: ${screenshots.length}`);

      sendToRenderer('screenshot-taken-stealth', {
        count: screenshots.length,
        screenshotId: screenshotEntry.id,
        timestamp: screenshotEntry.timestamp
      });

      return screenshotPath;
    } catch (error) {
      try {
        mainWindow.setOpacity(1.0);
      } catch (_) {
        // no-op
      }
      console.error('Stealth screenshot error:', error);
      throw error;
    } finally {
      screenshotInProgress = false;
    }
  }

  async function buildImagePartsFromScreenshots({ strict = true, includeIds = null } = {}) {
    const includeIdSet = Array.isArray(includeIds)
      ? new Set(includeIds.filter((id) => typeof id === 'string' && id.trim().length > 0))
      : null;

    const usableEntries = [];

    for (const entry of screenshots) {
      const normalizedEntry = normalizeScreenshotEntry(entry);
      if (!normalizedEntry) continue;

      if (includeIdSet && (!normalizedEntry.id || !includeIdSet.has(normalizedEntry.id))) {
        continue;
      }

      if (fs.existsSync(normalizedEntry.path)) {
        usableEntries.push(normalizedEntry);
        continue;
      }

      console.error(`Screenshot file not found: ${normalizedEntry.path}`);
      if (strict) {
        throw new Error(`Screenshot file not found: ${normalizedEntry.path}`);
      }
    }

    const imageParts = usableEntries.map((entry) => {
      const imageData = fs.readFileSync(entry.path);
      return {
        inlineData: {
          data: imageData.toString('base64'),
          mimeType: 'image/png'
        }
      };
    });

    return {
      imageParts,
      entries: usableEntries
    };
  }

  function clearStealth() {
    screenshots.forEach((entry) => {
      cleanupScreenshotFile(entry);
    });

    screenshots = [];
    screenshotSequence = 0;

    console.log('All screenshots and context cleared');
    return { success: true };
  }

  function cleanupTransientResources() {
    screenshots.forEach((entry) => {
      cleanupScreenshotFile(entry);
    });

    screenshots = [];
    screenshotSequence = 0;
  }

  function getScreenshotsCount() {
    return screenshots.length;
  }

  function hasScreenshots() {
    return screenshots.length > 0;
  }

  return {
    buildImagePartsFromScreenshots,
    cleanupTransientResources,
    clearStealth,
    getScreenshotsCount,
    hasScreenshots,
    takeStealthScreenshot
  };
}

module.exports = {
  createScreenshotManager
};

================
File: src/services/assembly-ai/service.js
================
const https = require('https');
const {
  createSttHistoryManager,
  normalizeSttSource
} = require('./stt-history');

const ASSEMBLY_AI_SAMPLE_RATE = 16000;

function createAssemblyAiService({
  WebSocket,
  desktopCapturer,
  getAssemblyApiKey,
  getSpeechModel,
  getGeminiService,
  sendToRenderer
}) {
  let assemblyWsMic = null;
  let assemblyWsSystem = null;
  let isStreamingMic = false;
  let isStreamingSystem = false;

  const sttChunkCounters = { mic: 0, system: 0 };
  const sttDroppedChunkCounters = { mic: 0, system: 0 };

  function emitSttDebug({ source = null, level = 'info', event = 'event', message = '', meta = null } = {}) {
    const payload = {
      ts: new Date().toISOString(),
      source: source === 'mic' || source === 'system' ? source : null,
      level,
      event,
      message,
      meta
    };

    sendToRenderer('stt-debug', payload);
  }

  const sttHistoryManager = createSttHistoryManager({
    getGeminiService,
    emitSttDebug,
    mergeWindowMs: 2400
  });

  function cleanupAssemblyWs(ws) {
    if (!ws) return;
    try {
      if (ws.readyState === WebSocket.OPEN) {
        ws.send(JSON.stringify({ type: 'Terminate' }));
      }
      ws.terminate();
    } catch (error) {
      console.error('Error cleaning up AssemblyAI WebSocket:', error);
    }
  }

  function resetSourceState(source) {
    const resolvedSource = normalizeSttSource(source);
    sttChunkCounters[resolvedSource] = 0;
    sttDroppedChunkCounters[resolvedSource] = 0;
    sttHistoryManager.resetSttHistoryBuffer(resolvedSource);

    if (resolvedSource === 'mic') {
      isStreamingMic = false;
      assemblyWsMic = null;
    } else {
      isStreamingSystem = false;
      assemblyWsSystem = null;
    }
  }

  function cleanupTransientResources() {
    sttHistoryManager.flushAllSttHistoryBuffers('cleanup');
    cleanupAssemblyWs(assemblyWsMic);
    cleanupAssemblyWs(assemblyWsSystem);

    assemblyWsMic = null;
    assemblyWsSystem = null;
    isStreamingMic = false;
    isStreamingSystem = false;

    sttChunkCounters.mic = 0;
    sttChunkCounters.system = 0;
    sttDroppedChunkCounters.mic = 0;
    sttDroppedChunkCounters.system = 0;

    sttHistoryManager.resetSttHistoryBuffer('mic');
    sttHistoryManager.resetSttHistoryBuffer('system');
  }

  function isSourceStreaming(source) {
    return source === 'system' ? isStreamingSystem : isStreamingMic;
  }

  function getSourceSocket(source) {
    return source === 'system' ? assemblyWsSystem : assemblyWsMic;
  }

  function setSourceSocket(source, socket) {
    if (source === 'system') {
      assemblyWsSystem = socket;
    } else {
      assemblyWsMic = socket;
    }
  }

  function setSourceStreaming(source, active) {
    if (source === 'system') {
      isStreamingSystem = active;
    } else {
      isStreamingMic = active;
    }
  }

  function startAssemblyAiStream(source) {
    const resolvedSource = normalizeSttSource(source);
    const apiKey = getAssemblyApiKey();

    if (!apiKey) {
      console.error('AssemblyAI API key not configured in app settings');
      emitSttDebug({
        source: resolvedSource,
        level: 'error',
        event: 'missing-api-key',
        message: 'AssemblyAI API key not configured in Settings'
      });
      sendToRenderer('vosk-error', {
        source: resolvedSource,
        error: 'AssemblyAI API key not configured. Add it in Settings.'
      });
      return { success: false, error: 'AssemblyAI API key not configured. Add it in Settings.' };
    }

    if (isSourceStreaming(resolvedSource)) {
      emitSttDebug({
        source: resolvedSource,
        event: 'start-skipped',
        message: 'Start requested while source is already streaming'
      });
      return {
        success: true,
        message: resolvedSource === 'system' ? 'System audio already streaming' : 'Mic already streaming'
      };
    }

    try {
      const queryParams = new URLSearchParams({
        sample_rate: String(ASSEMBLY_AI_SAMPLE_RATE),
        format_turns: 'true',
        speech_model: getSpeechModel()
      });

      const wsUrl = `wss://streaming.assemblyai.com/v3/ws?${queryParams.toString()}`;

      console.log(`Connecting to AssemblyAI for source: ${resolvedSource}`);
      emitSttDebug({
        source: resolvedSource,
        event: 'start-request',
        message: 'Opening AssemblyAI WebSocket',
        meta: { speechModel: getSpeechModel() }
      });

      sttChunkCounters[resolvedSource] = 0;
      sttDroppedChunkCounters[resolvedSource] = 0;
      sttHistoryManager.resetSttHistoryBuffer(resolvedSource);

      sendToRenderer('vosk-status', {
        source: resolvedSource,
        status: 'loading',
        message: `Connecting (${resolvedSource})...`
      });

      const ws = new WebSocket(wsUrl, {
        headers: { Authorization: apiKey }
      });

      setSourceSocket(resolvedSource, ws);

      ws.on('open', () => {
        console.log(`AssemblyAI WebSocket connected [${resolvedSource}]`);
        setSourceStreaming(resolvedSource, true);
        emitSttDebug({
          source: resolvedSource,
          event: 'ws-open',
          message: 'AssemblyAI WebSocket connected'
        });
      });

      ws.on('message', (rawMessage) => {
        try {
          const msg = JSON.parse(rawMessage.toString());

          switch (msg.type) {
            case 'Begin':
              console.log(`AssemblyAI session started [${resolvedSource}]:`, msg.id);
              emitSttDebug({
                source: resolvedSource,
                event: 'session-begin',
                message: 'AssemblyAI session started',
                meta: { id: msg.id }
              });
              sendToRenderer('vosk-status', {
                source: resolvedSource,
                status: 'listening',
                message: `Listening (${resolvedSource === 'system' ? 'Host' : 'You'})...`
              });
              break;

            case 'Turn':
              if (msg.transcript) {
                if (msg.end_of_turn) {
                  console.log(`AssemblyAI final [${resolvedSource}]:`, msg.transcript);
                  emitSttDebug({
                    source: resolvedSource,
                    event: 'turn-final',
                    message: 'Final transcript received',
                    meta: { chars: msg.transcript.length }
                  });
                  sendToRenderer('vosk-final', {
                    source: resolvedSource,
                    text: msg.transcript
                  });
                  sttHistoryManager.queueSttHistorySegment(resolvedSource, msg.transcript);
                } else {
                  sendToRenderer('vosk-partial', {
                    source: resolvedSource,
                    text: msg.transcript
                  });
                }
              }
              break;

            case 'Termination':
              console.log(
                `AssemblyAI terminated [${resolvedSource}]. Duration:`,
                msg.audio_duration_seconds,
                's'
              );
              emitSttDebug({
                source: resolvedSource,
                event: 'termination',
                message: 'AssemblyAI stream terminated',
                meta: { durationSeconds: msg.audio_duration_seconds }
              });
              sttHistoryManager.flushSttHistoryBuffer(resolvedSource, 'termination');
              resetSourceState(resolvedSource);
              sendToRenderer('vosk-stopped', { source: resolvedSource });
              break;

            default:
              console.log(`AssemblyAI message [${resolvedSource}]:`, msg.type);
          }
        } catch (parseError) {
          console.error(`Failed to parse AssemblyAI message [${resolvedSource}]:`, parseError);
          emitSttDebug({
            source: resolvedSource,
            level: 'error',
            event: 'parse-error',
            message: parseError.message
          });
        }
      });

      ws.on('error', (error) => {
        console.error(`AssemblyAI WebSocket error [${resolvedSource}]:`, error.message);
        emitSttDebug({
          source: resolvedSource,
          level: 'error',
          event: 'ws-error',
          message: error.message
        });
        sttHistoryManager.flushSttHistoryBuffer(resolvedSource, 'ws-error');
        sendToRenderer('vosk-error', {
          source: resolvedSource,
          error: `Connection error (${resolvedSource}): ${error.message}`
        });
        resetSourceState(resolvedSource);
      });

      ws.on('close', (code, reason) => {
        console.log(`AssemblyAI WebSocket closed [${resolvedSource}]:`, code, reason?.toString());
        emitSttDebug({
          source: resolvedSource,
          event: 'ws-close',
          message: 'AssemblyAI WebSocket closed',
          meta: { code, reason: reason?.toString() || '' }
        });

        if (isSourceStreaming(resolvedSource)) {
          sttHistoryManager.flushSttHistoryBuffer(resolvedSource, 'ws-close');
          resetSourceState(resolvedSource);
          sendToRenderer('vosk-stopped', { source: resolvedSource });
        }
      });

      return { success: true };
    } catch (error) {
      console.error(`Error starting AssemblyAI stream [${resolvedSource}]:`, error.message);
      emitSttDebug({
        source: resolvedSource,
        level: 'error',
        event: 'start-failed',
        message: error.message
      });
      setSourceStreaming(resolvedSource, false);
      return { success: false, error: error.message };
    }
  }

  function handleAudioChunk({ source, data }) {
    const resolvedSource = normalizeSttSource(source);
    const ws = getSourceSocket(resolvedSource);

    if (ws && ws.readyState === WebSocket.OPEN) {
      ws.send(Buffer.from(data));
      sttChunkCounters[resolvedSource] += 1;

      if (sttChunkCounters[resolvedSource] % 50 === 0) {
        emitSttDebug({
          source: resolvedSource,
          event: 'chunk-heartbeat',
          message: 'Streaming audio chunks',
          meta: {
            chunks: sttChunkCounters[resolvedSource],
            dropped: sttDroppedChunkCounters[resolvedSource]
          }
        });
      }
      return;
    }

    sttDroppedChunkCounters[resolvedSource] += 1;
    if (sttDroppedChunkCounters[resolvedSource] % 25 === 0) {
      emitSttDebug({
        source: resolvedSource,
        level: 'error',
        event: 'chunk-dropped',
        message: 'Audio chunk dropped because WebSocket is not open',
        meta: {
          dropped: sttDroppedChunkCounters[resolvedSource],
          readyState: ws ? ws.readyState : 'no-ws'
        }
      });
    }
  }

  function stopVoiceRecognition({ source } = {}) {
    emitSttDebug({
      source: source === 'system' || source === 'mic' ? source : null,
      event: 'ipc-stop',
      message: `Stop requested for ${source || 'default'}`
    });

    const stopSource = (src) => {
      const resolvedSource = normalizeSttSource(src);
      const ws = getSourceSocket(resolvedSource);

      if (!ws) {
        sttHistoryManager.flushSttHistoryBuffer(resolvedSource, 'stop-noop');
        emitSttDebug({
          source: resolvedSource,
          event: 'stop-noop',
          message: 'Stop requested but no active socket found'
        });
        sttChunkCounters[resolvedSource] = 0;
        sttDroppedChunkCounters[resolvedSource] = 0;
        return;
      }

      try {
        if (ws.readyState === WebSocket.OPEN) {
          ws.send(JSON.stringify({ type: 'Terminate' }));
        }
      } catch (error) {
        console.error(`Error stopping [${resolvedSource}]:`, error.message);
        emitSttDebug({
          source: resolvedSource,
          level: 'error',
          event: 'stop-error',
          message: error.message
        });
      }

      sttHistoryManager.flushSttHistoryBuffer(resolvedSource, 'stop-request');
      sendToRenderer('vosk-status', {
        source: resolvedSource,
        status: 'stopped',
        message: 'Stopped'
      });

      setSourceStreaming(resolvedSource, false);
      sttChunkCounters[resolvedSource] = 0;
      sttDroppedChunkCounters[resolvedSource] = 0;

      emitSttDebug({
        source: resolvedSource,
        event: 'stop-issued',
        message: 'Terminate frame sent to AssemblyAI'
      });
    };

    if (source === 'all') {
      stopSource('mic');
      stopSource('system');
    } else {
      stopSource(source === 'system' ? 'system' : 'mic');
    }

    return { success: true };
  }

  async function getDesktopSources() {
    try {
      const sources = await desktopCapturer.getSources({ types: ['screen'] });
      return sources.map((source) => ({ id: source.id, name: source.name }));
    } catch (error) {
      console.error('Error getting desktop sources:', error.message);
      return [];
    }
  }

  async function transcribeAudio(base64Audio) {
    const apiKey = getAssemblyApiKey();

    if (!apiKey) {
      return { success: false, error: 'AssemblyAI API key not configured. Add it in Settings.' };
    }

    try {
      const audioBuffer = Buffer.from(base64Audio, 'base64');

      const uploadUrl = await new Promise((resolve, reject) => {
        const request = https.request({
          hostname: 'api.assemblyai.com',
          path: '/v2/upload',
          method: 'POST',
          headers: {
            Authorization: apiKey,
            'Content-Type': 'application/octet-stream',
            'Content-Length': audioBuffer.length
          }
        }, (response) => {
          let data = '';
          response.on('data', (chunk) => {
            data += chunk;
          });
          response.on('end', () => {
            try {
              const result = JSON.parse(data);
              if (result.upload_url) {
                resolve(result.upload_url);
              } else {
                reject(new Error(result.error || 'Upload failed'));
              }
            } catch (_error) {
              reject(new Error('Failed to parse upload response'));
            }
          });
        });

        request.on('error', reject);
        request.write(audioBuffer);
        request.end();
      });

      const transcriptId = await new Promise((resolve, reject) => {
        const body = JSON.stringify({ audio_url: uploadUrl, language_code: 'en' });

        const request = https.request({
          hostname: 'api.assemblyai.com',
          path: '/v2/transcript',
          method: 'POST',
          headers: {
            Authorization: apiKey,
            'Content-Type': 'application/json'
          }
        }, (response) => {
          let data = '';
          response.on('data', (chunk) => {
            data += chunk;
          });
          response.on('end', () => {
            try {
              const result = JSON.parse(data);
              if (result.id) {
                resolve(result.id);
              } else {
                reject(new Error(result.error || 'Transcript creation failed'));
              }
            } catch (_error) {
              reject(new Error('Failed to parse transcript response'));
            }
          });
        });

        request.on('error', reject);
        request.write(body);
        request.end();
      });

      const pollTranscript = () => new Promise((resolve, reject) => {
        const request = https.request({
          hostname: 'api.assemblyai.com',
          path: `/v2/transcript/${transcriptId}`,
          method: 'GET',
          headers: { Authorization: apiKey }
        }, (response) => {
          let data = '';
          response.on('data', (chunk) => {
            data += chunk;
          });
          response.on('end', () => {
            try {
              resolve(JSON.parse(data));
            } catch (_error) {
              reject(new Error('Failed to parse poll response'));
            }
          });
        });

        request.on('error', reject);
        request.end();
      });

      let transcript;
      while (true) {
        transcript = await pollTranscript();
        if (transcript.status === 'completed') break;
        if (transcript.status === 'error') {
          throw new Error(transcript.error || 'Transcription failed');
        }
        await new Promise((resolve) => setTimeout(resolve, 1000));
      }

      const geminiService = getGeminiService();
      if (transcript.text && geminiService) {
        geminiService.addToHistory('user', transcript.text.trim());
      }

      return { success: true, transcript: transcript.text || '' };
    } catch (error) {
      console.error('Error in transcribe-audio:', error.message);
      return { success: false, error: error.message };
    }
  }

  function dispose() {
    cleanupTransientResources();
    sttHistoryManager.dispose();
  }

  function resetSttHistoryBuffers() {
    sttHistoryManager.resetSttHistoryBuffer('mic');
    sttHistoryManager.resetSttHistoryBuffer('system');
  }

  return {
    dispose,
    emitSttDebug,
    flushAllSttHistoryBuffers: sttHistoryManager.flushAllSttHistoryBuffers,
    getDesktopSources,
    handleAudioChunk,
    resetSttHistoryBuffers,
    startAssemblyAiStream,
    stopVoiceRecognition,
    transcribeAudio
  };
}

module.exports = {
  createAssemblyAiService
};

================
File: src/windows/assistant/preload/listeners.js
================
const { createEventListener } = require('./helpers');

function createEventActions(ipcRenderer) {
  const onScreenshotTakenStealth = createEventListener(ipcRenderer, {
    channel: 'screenshot-taken-stealth',
    label: 'onScreenshotTakenStealth'
  });

  const onAnalysisStart = createEventListener(ipcRenderer, {
    channel: 'analysis-start',
    label: 'onAnalysisStart'
  });

  const onAnalysisResult = createEventListener(ipcRenderer, {
    channel: 'analysis-result',
    label: 'onAnalysisResult'
  });

  const onSetStealthMode = createEventListener(ipcRenderer, {
    channel: 'set-stealth-mode',
    label: 'onSetStealthMode'
  });

  const onEmergencyClear = createEventListener(ipcRenderer, {
    channel: 'emergency-clear',
    label: 'onEmergencyClear'
  });

  const onError = createEventListener(ipcRenderer, {
    channel: 'error',
    label: 'onError'
  });

  const onVoiceTranscript = createEventListener(ipcRenderer, {
    channel: 'voice-transcript',
    label: 'onVoiceTranscript'
  });

  const onVoiceError = createEventListener(ipcRenderer, {
    channel: 'voice-error',
    label: 'onVoiceError'
  });

  const onVoskStatus = createEventListener(ipcRenderer, {
    channel: 'vosk-status',
    label: 'onVoskStatus'
  });

  const onVoskPartial = createEventListener(ipcRenderer, {
    channel: 'vosk-partial',
    label: 'onVoskPartial'
  });

  const onVoskFinal = createEventListener(ipcRenderer, {
    channel: 'vosk-final',
    label: 'onVoskFinal'
  });

  const onVoskError = createEventListener(ipcRenderer, {
    channel: 'vosk-error',
    label: 'onVoskError'
  });

  const onVoskStopped = createEventListener(ipcRenderer, {
    channel: 'vosk-stopped',
    label: 'onVoskStopped'
  });

  const onToggleVoiceRecognition = createEventListener(ipcRenderer, {
    channel: 'toggle-voice-recognition',
    label: 'onToggleVoiceRecognition'
  });

  const onTriggerAskAi = createEventListener(ipcRenderer, {
    channel: 'trigger-ask-ai',
    label: 'onTriggerAskAi'
  });

  const onAiStreamStart = createEventListener(ipcRenderer, {
    channel: 'ai-stream-start',
    label: 'onAiStreamStart'
  });

  const onAiStreamChunk = createEventListener(ipcRenderer, {
    channel: 'ai-stream-chunk',
    label: 'onAiStreamChunk'
  });

  const onAiStreamEnd = createEventListener(ipcRenderer, {
    channel: 'ai-stream-end',
    label: 'onAiStreamEnd'
  });

  const rawOnSttDebug = createEventListener(ipcRenderer, {
    channel: 'stt-debug',
    label: 'onSttDebug'
  });

  return {
    onScreenshotTakenStealth,
    onAnalysisStart,
    onAnalysisResult,
    onSetStealthMode,
    onEmergencyClear,
    onError,
    onVoiceTranscript,
    onVoiceError,
    onVoskStatus,
    onVoskPartial,
    onVoskFinal,
    onVoskError,
    onVoskStopped,
    onAiStreamStart,
    onAiStreamChunk,
    onAiStreamEnd,
    onToggleVoiceRecognition,
    onTriggerAskAi,
    onSttDebug: (callback) => rawOnSttDebug((data) => callback(data || {}))
  };
}

module.exports = {
  createEventActions
};

================
File: src/windows/assistant/renderer/features/ai-context/message-types.js
================
export function isTranscriptMessageType(type) {
  return type === 'voice' || type === 'voice-mic' || type === 'voice-system';
}

export function isScreenshotMessageType(type) {
  return type === 'screenshot';
}

export function isSystemMessageType(type) {
  return type === 'system';
}

export function isAiResponseMessageType(type) {
  return type === 'ai-response';
}

export function canToggleAiForMessageType(type) {
  return isTranscriptMessageType(type) || isScreenshotMessageType(type) || isAiResponseMessageType(type);
}

export function defaultIncludeInAiForMessageType(type) {
  if (isSystemMessageType(type)) {
    return false;
  }
  return true;
}

export function contextLineForMessage(message) {
  const content = String(message?.content || '').trim();
  if (!content) return '';

  if (message.type === 'voice-system') return `Host: ${content}`;
  if (message.type === 'voice' || message.type === 'voice-mic') return `You: ${content}`;
  if (message.type === 'screenshot') {
    return message.screenshotId
      ? `Screenshot(${message.screenshotId}): ${content}`
      : `Screenshot: ${content}`;
  }
  if (message.type === 'ai-response') return `AI: ${content}`;
  return '';
}

export function summaryLineForMessage(message) {
  const content = String(message?.content || '').trim().replace(/\s+/g, ' ');
  if (!content) return '';

  if (message.type === 'voice-system') return `Host said: ${content}`;
  if (message.type === 'voice' || message.type === 'voice-mic') return `You said: ${content}`;
  if (message.type === 'screenshot') return `Screenshot: ${content}`;
  if (message.type === 'ai-response') return `AI response: ${content}`;
  return '';
}

================
File: src/windows/assistant/renderer/features/settings/settings-panel-manager.js
================
function clamp(value, min, max) {
    return Math.min(Math.max(value, min), max);
}

export function createSettingsPanelManager({
    settingsPanel,
    settingGeminiKey,
    toggleGeminiKeyVisibilityBtn,
    settingGeminiModel,
    settingProgrammingLanguage,
    settingAssemblyKey,
    toggleAssemblyKeyVisibilityBtn,
    settingAssemblyModel,
    settingWindowOpacity,
    settingWindowOpacityValue,
    applySettingsShortcutConfig,
    showFeedback,
    onSettingsSaved
}) {
    function normalizeWindowOpacityLevel(value) {
        const parsedValue = Number.parseInt(String(value ?? ''), 10);

        if (!Number.isFinite(parsedValue)) {
            return 10;
        }

        return clamp(parsedValue, 1, 10);
    }

    function updateWindowOpacityValueLabel(value) {
        if (!settingWindowOpacityValue) {
            return;
        }

        const opacityLevel = normalizeWindowOpacityLevel(value);
        settingWindowOpacityValue.textContent = `${opacityLevel}/10`;
    }

    function setApiKeyFieldVisibility(inputElement, toggleButton, providerName, visible) {
        if (!inputElement || !toggleButton) {
            return;
        }

        const shouldShow = Boolean(visible);
        inputElement.type = shouldShow ? 'text' : 'password';
        toggleButton.textContent = shouldShow ? 'Hide' : 'Show';
        toggleButton.setAttribute('aria-pressed', shouldShow ? 'true' : 'false');
        toggleButton.setAttribute(
            'aria-label',
            `${shouldShow ? 'Hide' : 'Show'} ${providerName} API key`
        );
    }

    function bindApiKeyVisibilityToggle(inputElement, toggleButton, providerName) {
        if (!inputElement || !toggleButton) {
            return;
        }

        setApiKeyFieldVisibility(inputElement, toggleButton, providerName, false);
        toggleButton.addEventListener('click', () => {
            const nextVisible = inputElement.type !== 'text';
            setApiKeyFieldVisibility(inputElement, toggleButton, providerName, nextVisible);
        });
    }

    function populateGeminiModelOptions(models, selectedModel) {
        if (!settingGeminiModel) {
            return;
        }

        settingGeminiModel.innerHTML = '';

        const configuredModels = Array.isArray(models) ? models : [];
        if (configuredModels.length === 0) {
            throw new Error('Gemini models are not configured.');
        }

        configuredModels.forEach((modelName) => {
            const option = document.createElement('option');
            option.value = modelName;
            option.textContent = modelName;
            settingGeminiModel.appendChild(option);
        });

        settingGeminiModel.value = configuredModels.includes(selectedModel)
            ? selectedModel
            : configuredModels[0];
    }

    function populateProgrammingLanguageOptions(languages, selectedLanguage) {
        if (!settingProgrammingLanguage) {
            return;
        }

        settingProgrammingLanguage.innerHTML = '';

        const configuredLanguages = Array.isArray(languages) ? languages : [];
        if (configuredLanguages.length === 0) {
            throw new Error('Programming languages are not configured.');
        }

        configuredLanguages.forEach((languageName) => {
            const option = document.createElement('option');
            option.value = languageName;
            option.textContent = languageName;
            settingProgrammingLanguage.appendChild(option);
        });

        settingProgrammingLanguage.value = configuredLanguages.includes(selectedLanguage)
            ? selectedLanguage
            : configuredLanguages[0];
    }

    function populateAssemblyAiSpeechModelOptions(models, selectedModel) {
        if (!settingAssemblyModel) {
            return;
        }

        settingAssemblyModel.innerHTML = '';

        const configuredModels = Array.isArray(models) ? models : [];
        if (configuredModels.length === 0) {
            throw new Error('AssemblyAI speech models are not configured.');
        }

        configuredModels.forEach((modelName) => {
            const option = document.createElement('option');
            option.value = modelName;
            option.textContent = modelName;
            settingAssemblyModel.appendChild(option);
        });

        settingAssemblyModel.value = configuredModels.includes(selectedModel)
            ? selectedModel
            : configuredModels[0];
    }

    async function openSettings() {
        if (!settingsPanel) {
            return;
        }

        try {
            const settings = await window.electronAPI.getSettings();
            if (settings && !settings.error) {
                applySettingsShortcutConfig?.(settings);
                if (settingGeminiKey) settingGeminiKey.value = settings.geminiApiKey || '';
                populateGeminiModelOptions(settings.geminiModels, settings.geminiModel || settings.defaultGeminiModel);
                populateProgrammingLanguageOptions(
                    settings.programmingLanguages,
                    settings.programmingLanguage || settings.defaultProgrammingLanguage
                );
                if (settingAssemblyKey) settingAssemblyKey.value = settings.assemblyAiApiKey || '';
                populateAssemblyAiSpeechModelOptions(
                    settings.assemblyAiSpeechModels,
                    settings.assemblyAiSpeechModel || settings.defaultAssemblyAiSpeechModel
                );
                if (settingWindowOpacity) {
                    settingWindowOpacity.value = normalizeWindowOpacityLevel(settings.windowOpacityLevel);
                }
                updateWindowOpacityValueLabel(settings.windowOpacityLevel);
            }
        } catch (error) {
            console.error('Failed to load settings:', error);
        }

        setApiKeyFieldVisibility(settingGeminiKey, toggleGeminiKeyVisibilityBtn, 'Gemini', false);
        setApiKeyFieldVisibility(settingAssemblyKey, toggleAssemblyKeyVisibilityBtn, 'AssemblyAI', false);

        settingsPanel.classList.remove('hidden');
    }

    function closeSettings() {
        if (settingsPanel) {
            settingsPanel.classList.add('hidden');
        }

        setApiKeyFieldVisibility(settingGeminiKey, toggleGeminiKeyVisibilityBtn, 'Gemini', false);
        setApiKeyFieldVisibility(settingAssemblyKey, toggleAssemblyKeyVisibilityBtn, 'AssemblyAI', false);
    }

    async function saveSettings() {
        try {
            if (!settingGeminiModel || settingGeminiModel.options.length === 0) {
                throw new Error('Gemini models are not configured.');
            }

            if (!settingProgrammingLanguage || settingProgrammingLanguage.options.length === 0) {
                throw new Error('Programming languages are not configured.');
            }

            if (!settingAssemblyModel || settingAssemblyModel.options.length === 0) {
                throw new Error('AssemblyAI speech models are not configured.');
            }

            const settings = {
                geminiApiKey: settingGeminiKey ? settingGeminiKey.value.trim() : '',
                assemblyAiApiKey: settingAssemblyKey ? settingAssemblyKey.value.trim() : '',
                geminiModel: settingGeminiModel.value,
                programmingLanguage: settingProgrammingLanguage.value,
                assemblyAiSpeechModel: settingAssemblyModel.value,
                windowOpacityLevel: normalizeWindowOpacityLevel(settingWindowOpacity?.value)
            };

            const result = await window.electronAPI.saveSettings(settings);

            if (result.success) {
                showFeedback?.('Settings saved. Latest API keys and AI settings are active now; voice model applies next session.', 'success');
                onSettingsSaved?.(settings);
                closeSettings();
                return { success: true, settings };
            } else {
                showFeedback?.(`Failed to save: ${result.error}`, 'error');
                return { success: false, error: result.error || 'Failed to save settings' };
            }
        } catch (error) {
            console.error('Failed to save settings:', error);
            showFeedback?.('Failed to save settings', 'error');
            return { success: false, error: error.message || 'Failed to save settings' };
        }
    }

    bindApiKeyVisibilityToggle(settingGeminiKey, toggleGeminiKeyVisibilityBtn, 'Gemini');
    bindApiKeyVisibilityToggle(settingAssemblyKey, toggleAssemblyKeyVisibilityBtn, 'AssemblyAI');

    return {
        normalizeWindowOpacityLevel,
        updateWindowOpacityValueLabel,
        openSettings,
        closeSettings,
        saveSettings
    };
}

================
File: BUILD_INSTRUCTIONS.md
================
# Build Instructions - Chrome Disguised Executable

This guide will help you build the app as a disguised Chrome executable.

## Prerequisites

1. **Node.js and npm** installed
2. **All dependencies** installed (`npm install`)
3. **Chrome icon files** (see below)

## Step 1: Check Existing Icons

This repo already includes the Windows icon at `assets/chrome.ico`, so you can build the Windows portable `.exe` without downloading anything else first.

You only need additional icon files if:

- you want to replace the current Windows icon, or
- you plan to build for macOS or Linux and need `chrome.icns` / `chrome.png`

If you need to add or replace icons, use one of the following options:

### Option A: Extract from Chrome Installation
1. Navigate to: `C:\Program Files\Google\Chrome\Application\`
2. Find `chrome.exe`
3. Use a tool like ResourceHacker or IconsExtract to extract the icon
4. Save as `chrome.ico`

### Option B: Download Chrome Icon
1. Go to: https://icon-icons.com/icon/chrome/194617
2. Download in these formats:
   - **Windows**: `chrome.ico` (256x256 or higher)
   - **macOS**: `chrome.icns`
   - **Linux**: `chrome.png` (512x512)

### Step 2: Place Icons in Assets Folder

Current state in this repo:

- `assets/chrome.ico` already exists
- `assets/chrome.icns` is optional unless building for macOS
- `assets/chrome.png` is optional unless building for Linux

Copy the icon files to the `assets/` folder:
```
d:\Open-Cluely\assets\
  ├── chrome.ico   (Windows)
  ├── chrome.icns  (macOS)
  └── chrome.png   (Linux)
```

## Step 3: Build the Application

### For Windows (Portable EXE):
```bash
npm run build:win
```

This will create: `dist/GoogleChrome.exe`

For this repo, this is the recommended build and does not require any extra icon download because `assets/chrome.ico` is already present.

### Build Options:

**Portable (recommended for stealth):**
```bash
npm run build:win
```
- Creates: `dist/GoogleChrome.exe`
- No installation required
- Can be run from any location
- No registry entries

**NSIS Installer (for permanent installation):**
```bash
npm run build -- --win nsis
```
- Creates: `dist/Google Chrome (2) Setup.exe`
- Installs to Program Files
- Adds to Start Menu

## Step 4: Configure Environment

Before building, make sure your `.env` file is configured:

```env
GEMINI_API_KEY=your_api_key_here
```

The `.env` file will be automatically included in the build.

## Step 5: Run the Built Application

### Portable Version:
1. Navigate to `dist/`
2. Run `GoogleChrome.exe`
3. The app will run with Chrome icon and name

### Running in Background:
The app is configured to:
- Run with Chrome icon
- Show as "Google Chrome (2)" in Task Manager
- Be published by "Google LLC" (in properties)
- Use portable mode (no installation)
- Support hidden launch mode via `START_HIDDEN=true` or `--start-hidden`

## Build Configuration Details

The app is configured with:

- **Product Name**: Google Chrome (2)
- **Executable Name**: GoogleChrome.exe
- **App ID**: com.google.chrome
- **Publisher**: Google LLC
- **Icon**: Chrome logo
- **Target**: Portable (no installer)

## Stealth Features

✅ Chrome icon in taskbar
✅ "Google Chrome (2)" in Task Manager
✅ Google LLC as publisher
✅ Portable (no installation traces)
✅ Runs in background
✅ Transparent overlay

## Testing the Build

After building:

1. **Check the file**:
   - Name: `GoogleChrome.exe`
   - Icon: Chrome logo
   - Location: `dist/GoogleChrome.exe`

2. **Run it**:
   ```bash
   cd dist
   ./GoogleChrome.exe
   ```

3. **Verify in Task Manager**:
   - Press `Ctrl + Shift + Esc`
   - Look for "Google Chrome (2)"
   - Should have Chrome icon

## Advanced: Custom Build Options

### Change the disguise name:
Edit `package.json`:
```json
"productName": "Your Custom Name"
```

### Change the output filename:
```json
"portable": {
  "artifactName": "YourName.exe"
}
```

### Add auto-start on Windows login:
Add this to your code in `main.js`:
```javascript
const { app } = require('electron');

app.setLoginItemSettings({
  openAtLogin: true,
  path: process.execPath
});
```

## Troubleshooting

### Icon not showing:
- Make sure `assets/chrome.ico` exists
- Icon must be 256x256 or higher
- Try rebuilding: `npm run build -- --win portable`

### Build fails:
- Run: `npm install electron-builder --save-dev`
- Clear cache: `npm run build -- --win portable --clean`

### .env file missing in build:
- Check `extraResources` in package.json
- Make sure `.env` file exists in root directory

## Security Notes

⚠️ **Important**: This tool is for educational purposes and authorized use only (interviews, meetings with consent).

- Use responsibly
- Obtain consent when required
- Follow local laws and regulations
- Do not use for malicious purposes

## File Locations After Build

```
d:\Open-Cluely\
├── dist/
│   ├── GoogleChrome.exe          ← Your built app
│   ├── win-unpacked/             ← Unpacked files (can delete)
│   └── builder-debug.yml         ← Build logs
├── assets/
│   └── chrome.ico                ← Chrome icon
├── src/                          ← Source code
└── package.json                  ← Build config
```

## Distribution

To share the app:
1. Copy `GoogleChrome.exe` from `dist/` folder
2. Make sure `.env` with GEMINI_API_KEY is in the same directory
3. Run the executable

## Updating

To rebuild after changes:
```bash
npm run build:win
```

This will overwrite the previous build in `dist/`.

---

**Version:** 1.0.0

================
File: src/main-process/features/assistant/gemini-runtime.js
================
const GeminiService = require('../../../services/ai/gemini-service');
const {
  resolveGeminiModel,
  resolveProgrammingLanguage,
  getGeminiModels,
  getDefaultGeminiModel,
  getProgrammingLanguages,
  getDefaultProgrammingLanguage
} = require('../../../config');

const GEMINI_ALL_KEYS_UNAVAILABLE_ERROR_CODE = 'GEMINI_ALL_KEYS_UNAVAILABLE';

function normalizeGeminiApiKeys(keys) {
  const sourceValues = Array.isArray(keys)
    ? keys
    : String(keys ?? '').split(',');
  const seen = new Set();
  const nextKeys = [];

  for (const rawValue of sourceValues) {
    const key = String(rawValue || '').trim();
    if (!key || seen.has(key)) {
      continue;
    }

    seen.add(key);
    nextKeys.push(key);
  }

  return nextKeys;
}

function createGeminiRuntime() {
  let geminiService = null;
  let activeGeminiModel = getDefaultGeminiModel();
  let activeProgrammingLanguage = getDefaultProgrammingLanguage();
  let geminiApiKeys = [];
  let activeApiKeyIndex = 0;
  let activeKeyIndexChangeHandler = null;

  function notifyActiveKeyIndexChanged(index) {
    if (typeof activeKeyIndexChangeHandler !== 'function') {
      return;
    }

    try {
      activeKeyIndexChangeHandler(index);
    } catch (error) {
      console.error('Failed to persist active Gemini API key index:', error);
    }
  }

  function normalizeKeyIndex(index) {
    if (geminiApiKeys.length === 0) {
      return 0;
    }

    const parsedIndex = Number.parseInt(String(index ?? ''), 10);
    const safeIndex = Number.isFinite(parsedIndex) ? parsedIndex : 0;
    const maxIndex = geminiApiKeys.length - 1;

    return Math.min(Math.max(safeIndex, 0), maxIndex);
  }

  function setActiveApiKeyIndex(index, options = {}) {
    const nextIndex = normalizeKeyIndex(index);
    const shouldNotify = options.notify !== false;
    const changed = nextIndex !== activeApiKeyIndex;
    activeApiKeyIndex = nextIndex;

    if (changed && shouldNotify) {
      notifyActiveKeyIndexChanged(activeApiKeyIndex);
    }

    return activeApiKeyIndex;
  }

  function getActiveApiKey() {
    if (geminiApiKeys.length === 0) {
      return '';
    }

    return geminiApiKeys[activeApiKeyIndex] || '';
  }

  function hasApiKeys() {
    return geminiApiKeys.length > 0;
  }

  function initializeGeminiService(
    apiKey = getActiveApiKey(),
    modelName = activeGeminiModel,
    programmingLanguage = activeProgrammingLanguage
  ) {
    activeGeminiModel = resolveGeminiModel(modelName);
    activeProgrammingLanguage = resolveProgrammingLanguage(programmingLanguage);

    try {
      if (!apiKey) {
        console.error('Gemini API key not configured in app settings');
        geminiService = null;
        return null;
      }

      console.log(
        'Initializing Gemini AI Service with model and language:',
        activeGeminiModel,
        activeProgrammingLanguage
      );

      if (geminiService) {
        geminiService.updateConfiguration({
          apiKey,
          modelName: activeGeminiModel,
          programmingLanguage: activeProgrammingLanguage
        });
      } else {
        geminiService = new GeminiService(apiKey, {
          modelName: activeGeminiModel,
          programmingLanguage: activeProgrammingLanguage
        });
      }

      console.log('Gemini AI Service initialized successfully');
      return geminiService;
    } catch (error) {
      geminiService = null;
      console.error('Failed to initialize Gemini AI Service:', error);
      return null;
    }
  }

  function setKeys(apiKeys, preferredIndex = 0) {
    geminiApiKeys = normalizeGeminiApiKeys(apiKeys);

    if (!hasApiKeys()) {
      setActiveApiKeyIndex(0);
      geminiService = null;
      return {
        geminiApiKeys: [],
        activeApiKeyIndex: 0,
        activeApiKey: ''
      };
    }

    setActiveApiKeyIndex(preferredIndex);

    return {
      geminiApiKeys: [...geminiApiKeys],
      activeApiKeyIndex,
      activeApiKey: getActiveApiKey()
    };
  }

  function getApiKeys() {
    return [...geminiApiKeys];
  }

  function switchToNextKey() {
    if (!hasApiKeys()) {
      return {
        switched: false,
        activeApiKeyIndex,
        activeApiKey: ''
      };
    }

    if (geminiApiKeys.length === 1) {
      return {
        switched: false,
        activeApiKeyIndex,
        activeApiKey: getActiveApiKey()
      };
    }

    const previousIndex = activeApiKeyIndex;
    const nextIndex = (activeApiKeyIndex + 1) % geminiApiKeys.length;
    setActiveApiKeyIndex(nextIndex);

    if (nextIndex === previousIndex) {
      return {
        switched: false,
        activeApiKeyIndex,
        activeApiKey: getActiveApiKey()
      };
    }

    initializeGeminiService(getActiveApiKey(), activeGeminiModel, activeProgrammingLanguage);

    return {
      switched: true,
      activeApiKeyIndex,
      activeApiKey: getActiveApiKey()
    };
  }

  function isSwitchEligibleError(error) {
    if (!error) {
      return false;
    }

    if (geminiService?.isQuotaExhaustedError?.(error)) {
      return true;
    }

    if (geminiService?.isAuthenticationError?.(error)) {
      return true;
    }

    const message = String(error?.message || '').toLowerCase();
    return (
      message.includes('quota exceeded') ||
      message.includes('api key not valid') ||
      message.includes('invalid api key') ||
      message.includes('permission denied') ||
      message.includes('401') ||
      message.includes('403') ||
      message.includes('unauthorized') ||
      message.includes('forbidden')
    );
  }

  function createAllKeysUnavailableError(cause) {
    const allKeysUnavailableError = new Error(
      'All configured Gemini API keys are currently unavailable due to quota or authentication errors.'
    );

    allKeysUnavailableError.code = GEMINI_ALL_KEYS_UNAVAILABLE_ERROR_CODE;
    allKeysUnavailableError.isAllKeysUnavailable = true;
    if (cause) {
      allKeysUnavailableError.cause = cause;
    }

    return allKeysUnavailableError;
  }

  function isAllKeysUnavailableError(error) {
    return Boolean(
      error && (
        error.code === GEMINI_ALL_KEYS_UNAVAILABLE_ERROR_CODE ||
        error.isAllKeysUnavailable === true
      )
    );
  }

  async function executeWithKeyFailover(operation) {
    if (typeof operation !== 'function') {
      throw new Error('Gemini failover operation must be a function.');
    }

    if (!hasApiKeys()) {
      throw new Error('No Gemini API key configured. Add it in Settings.');
    }

    const totalKeys = geminiApiKeys.length;
    const startIndex = activeApiKeyIndex;
    let attemptedKeys = 0;
    let lastSwitchEligibleError = null;

    while (attemptedKeys < totalKeys) {
      const activeApiKey = getActiveApiKey();
      if (!activeApiKey) {
        break;
      }

      if (!geminiService || geminiService.apiKey !== activeApiKey) {
        initializeGeminiService(activeApiKey, activeGeminiModel, activeProgrammingLanguage);
      }

      try {
        return await operation(geminiService, {
          activeApiKeyIndex,
          activeApiKey,
          attempt: attemptedKeys + 1,
          totalKeys
        });
      } catch (error) {
        if (!isSwitchEligibleError(error)) {
          throw error;
        }

        lastSwitchEligibleError = error;
        attemptedKeys += 1;

        if (attemptedKeys >= totalKeys) {
          if (activeApiKeyIndex !== startIndex) {
            setActiveApiKeyIndex(startIndex);
            initializeGeminiService(getActiveApiKey(), activeGeminiModel, activeProgrammingLanguage);
          }

          throw createAllKeysUnavailableError(lastSwitchEligibleError);
        }

        switchToNextKey();
      }
    }

    throw createAllKeysUnavailableError(lastSwitchEligibleError);
  }

  function getService() {
    return geminiService;
  }

  function getActiveGeminiModel() {
    return activeGeminiModel;
  }

  function getActiveProgrammingLanguage() {
    return activeProgrammingLanguage;
  }

  function setActiveGeminiModel(modelName) {
    activeGeminiModel = resolveGeminiModel(modelName);
    return activeGeminiModel;
  }

  function setActiveProgrammingLanguage(language) {
    activeProgrammingLanguage = resolveProgrammingLanguage(language);
    return activeProgrammingLanguage;
  }

  function setActiveKeyIndexChangeHandler(handler) {
    activeKeyIndexChangeHandler = typeof handler === 'function' ? handler : null;
  }

  return {
    initializeGeminiService,
    setKeys,
    getApiKeys,
    hasApiKeys,
    getActiveApiKey,
    getActiveApiKeyIndex: () => activeApiKeyIndex,
    switchToNextKey,
    executeWithKeyFailover,
    isAllKeysUnavailableError,
    setActiveKeyIndexChangeHandler,
    getService,
    getGeminiModels,
    getDefaultGeminiModel,
    getActiveGeminiModel,
    setActiveGeminiModel,
    getProgrammingLanguages,
    getDefaultProgrammingLanguage,
    getActiveProgrammingLanguage,
    setActiveProgrammingLanguage
  };
}

module.exports = {
  GEMINI_ALL_KEYS_UNAVAILABLE_ERROR_CODE,
  createGeminiRuntime
};

================
File: src/main-process/features/window/window-constants.js
================
const WINDOW_DEFAULT_WIDTH = 900;
const WINDOW_DEFAULT_HEIGHT = 400;
const WINDOW_MIN_WIDTH = 600;
const WINDOW_MIN_HEIGHT = 380;
const WINDOW_OPACITY_LEVEL_MIN = 1;
const WINDOW_OPACITY_LEVEL_MAX = 10;
const DEFAULT_WINDOW_OPACITY_LEVEL = 10;
const STEALTH_WINDOW_OPACITY = 0.02;

module.exports = {
  WINDOW_DEFAULT_WIDTH,
  WINDOW_DEFAULT_HEIGHT,
  WINDOW_MIN_WIDTH,
  WINDOW_MIN_HEIGHT,
  WINDOW_OPACITY_LEVEL_MIN,
  WINDOW_OPACITY_LEVEL_MAX,
  DEFAULT_WINDOW_OPACITY_LEVEL,
  STEALTH_WINDOW_OPACITY
};

================
File: src/main-process/startup-logging.js
================
function logStartupConfiguration({
  appEnvironment,
  appState,
  geminiModels,
  defaultGeminiModel,
  assemblyAiSpeechModels,
  defaultAssemblyAiSpeechModel,
  programmingLanguages,
  defaultProgrammingLanguage
}) {
  const geminiApiKey = typeof appState?.geminiApiKey === 'string' ? appState.geminiApiKey : '';
  const assemblyAiApiKey = typeof appState?.assemblyAiApiKey === 'string' ? appState.assemblyAiApiKey : '';
  const geminiApiKeyCount = geminiApiKey
    ? geminiApiKey
      .split(',')
      .map((value) => value.trim())
      .filter(Boolean)
      .length
    : 0;

  console.log('Loaded .env from:', appEnvironment.envPath);
  console.log('Startup configuration:');
  console.log(`  GEMINI_API_KEY (UI state): ${geminiApiKey ? 'present' : 'missing'}`);
  console.log(`  GEMINI_API_KEYS configured (UI state): ${geminiApiKeyCount}`);
  console.log(`  ASSEMBLY_AI_API_KEY (UI state): ${assemblyAiApiKey ? 'present' : 'missing'}`);
  console.log(`  HIDE_FROM_SCREEN_CAPTURE: ${appEnvironment.hideFromScreenCapture}`);
  console.log(`  MAX_SCREENSHOTS: ${appEnvironment.maxScreenshots}`);
  console.log(`  SCREENSHOT_DELAY: ${appEnvironment.screenshotDelay}`);
  console.log(`  NODE_ENV: ${appEnvironment.nodeEnv}`);
  console.log(`  NODE_OPTIONS: ${appEnvironment.nodeOptions}`);
  console.log(`  Default Gemini model: ${defaultGeminiModel}`);
  console.log(`  Gemini models: ${geminiModels.join(', ')}`);
  console.log(`  Default AssemblyAI speech model: ${defaultAssemblyAiSpeechModel}`);
  console.log(`  AssemblyAI speech models: ${assemblyAiSpeechModels.join(', ')}`);
  console.log(`  Default programming language: ${defaultProgrammingLanguage}`);
  console.log(`  Programming languages: ${programmingLanguages.join(', ')}`);
}

module.exports = {
  logStartupConfiguration
};

================
File: src/windows/assistant/preload/actions.js
================
const { invokeWithFallback } = require('./helpers');

function createInvokeActions(ipcRenderer) {
  return {
    toggleStealth: invokeWithFallback(ipcRenderer, {
      channel: 'toggle-stealth',
      label: 'toggleStealth',
      fallback: (error) => ({ error: error.message })
    }),

    emergencyHide: invokeWithFallback(ipcRenderer, {
      channel: 'emergency-hide',
      label: 'emergencyHide',
      fallback: (error) => ({ error: error.message })
    }),

    takeStealthScreenshot: invokeWithFallback(ipcRenderer, {
      channel: 'take-stealth-screenshot',
      label: 'takeStealthScreenshot',
      fallback: (error) => ({ error: error.message })
    }),

    analyzeStealth: invokeWithFallback(ipcRenderer, {
      channel: 'analyze-stealth',
      label: 'analyzeStealth',
      fallback: (error) => ({ error: error.message })
    }),

    analyzeStealthWithContext: invokeWithFallback(ipcRenderer, {
      channel: 'analyze-stealth-with-context',
      label: 'analyzeStealthWithContext',
      fallback: (error) => ({ error: error.message })
    }),

    askAiWithSessionContext: invokeWithFallback(ipcRenderer, {
      channel: 'ask-ai-with-session-context',
      label: 'askAiWithSessionContext',
      fallback: (error) => ({ success: false, error: error.message })
    }),

    clearStealth: invokeWithFallback(ipcRenderer, {
      channel: 'clear-stealth',
      label: 'clearStealth',
      fallback: (error) => ({ error: error.message })
    }),

    getScreenshotsCount: invokeWithFallback(ipcRenderer, {
      channel: 'get-screenshots-count',
      label: 'getScreenshotsCount',
      fallback: () => 0
    }),

    getWindowBounds: invokeWithFallback(ipcRenderer, {
      channel: 'get-window-bounds',
      label: 'getWindowBounds',
      fallback: (error) => ({ error: error.message })
    }),

    setWindowBounds: invokeWithFallback(ipcRenderer, {
      channel: 'set-window-bounds',
      label: 'setWindowBounds',
      fallback: (error) => ({ error: error.message })
    }),

    setWindowSizePreset: invokeWithFallback(ipcRenderer, {
      channel: 'set-window-size-preset',
      label: 'setWindowSizePreset',
      transformArgs: (args) => [{ preset: args[0] }],
      fallback: (error) => ({ error: error.message })
    }),

    startVoiceRecognition: invokeWithFallback(ipcRenderer, {
      channel: 'start-voice-recognition',
      label: 'startVoiceRecognition',
      transformArgs: (args) => [{ source: args[0] }],
      fallback: (error) => ({ error: error.message })
    }),

    stopVoiceRecognition: invokeWithFallback(ipcRenderer, {
      channel: 'stop-voice-recognition',
      label: 'stopVoiceRecognition',
      transformArgs: (args) => [{ source: args[0] }],
      fallback: (error) => ({ error: error.message })
    }),

    sendAudioChunk: (source, audioData) => {
      ipcRenderer.send('audio-chunk', { source, data: audioData });
    },

    getDesktopSources: invokeWithFallback(ipcRenderer, {
      channel: 'get-desktop-sources',
      label: 'getDesktopSources',
      fallback: () => []
    }),

    transcribeAudio: invokeWithFallback(ipcRenderer, {
      channel: 'transcribe-audio',
      label: 'transcribeAudio',
      fallback: (error) => ({ success: false, error: error.message })
    }),

    addVoiceTranscript: invokeWithFallback(ipcRenderer, {
      channel: 'add-voice-transcript',
      label: 'addVoiceTranscript',
      fallback: (error) => ({ error: error.message })
    }),

    suggestResponse: invokeWithFallback(ipcRenderer, {
      channel: 'suggest-response',
      label: 'suggestResponse',
      fallback: (error) => ({ error: error.message })
    }),

    generateMeetingNotes: invokeWithFallback(ipcRenderer, {
      channel: 'generate-meeting-notes',
      label: 'generateMeetingNotes',
      fallback: (error) => ({ error: error.message })
    }),

    generateFollowUpEmail: invokeWithFallback(ipcRenderer, {
      channel: 'generate-follow-up-email',
      label: 'generateFollowUpEmail',
      fallback: (error) => ({ error: error.message })
    }),

    answerQuestion: invokeWithFallback(ipcRenderer, {
      channel: 'answer-question',
      label: 'answerQuestion',
      fallback: (error) => ({ error: error.message })
    }),

    getConversationInsights: invokeWithFallback(ipcRenderer, {
      channel: 'get-conversation-insights',
      label: 'getConversationInsights',
      fallback: (error) => ({ error: error.message })
    }),

    clearConversationHistory: invokeWithFallback(ipcRenderer, {
      channel: 'clear-conversation-history',
      label: 'clearConversationHistory',
      fallback: (error) => ({ error: error.message })
    }),

    getConversationHistory: invokeWithFallback(ipcRenderer, {
      channel: 'get-conversation-history',
      label: 'getConversationHistory',
      fallback: (error) => ({ error: error.message })
    }),

    getSettings: invokeWithFallback(ipcRenderer, {
      channel: 'get-settings',
      label: 'getSettings',
      fallback: (error) => ({ error: error.message })
    }),

    saveSettings: invokeWithFallback(ipcRenderer, {
      channel: 'save-settings',
      label: 'saveSettings',
      fallback: (error) => ({ success: false, error: error.message })
    }),

    setThemePreference: invokeWithFallback(ipcRenderer, {
      channel: 'set-theme-preference',
      label: 'setThemePreference',
      transformArgs: (args) => [{ theme: args[0] }],
      fallback: (error) => ({ success: false, error: error.message })
    }),

    closeApp: invokeWithFallback(ipcRenderer, {
      channel: 'close-app',
      label: 'closeApp',
      fallback: (error) => ({ error: error.message })
    })
  };
}

module.exports = {
  createInvokeActions
};

================
File: src/windows/assistant/renderer/features/ai-context/toggle-ui.js
================
export function updateMessageAiToggleUi(chatMessagesElement, message) {
  if (!message || !message.id || !chatMessagesElement) {
    return;
  }

  const container = chatMessagesElement.querySelector(`.chat-message[data-message-id="${message.id}"]`);
  if (!container) {
    return;
  }

  container.classList.toggle('ai-excluded', message.canToggleAi && !message.includeInAi);
  container.classList.toggle('ai-included', message.canToggleAi && !!message.includeInAi);

  const toggle = container.querySelector('.ai-include-toggle');
  if (toggle) {
    toggle.classList.toggle('included', !!message.includeInAi);
    toggle.classList.toggle('excluded', !message.includeInAi);
    toggle.textContent = message.includeInAi ? '-' : '+';
    toggle.setAttribute('aria-pressed', message.includeInAi ? 'true' : 'false');
  }
}

================
File: src/windows/assistant/renderer/features/listeners/event-listeners.js
================
export function setupEventListeners({
    windowApi,
    screenshotBtn,
    analyzeBtn,
    screenAiBtn,
    clearBtn,
    hideBtn,
    chatManualSend,
    chatManualInput,
    closeResultsBtn,
    transcriptionToggle,
    sourceSystemToggle,
    sourceMicToggle,
    closeAppBtn,
    cancelCloseBtn,
    confirmCloseBtn,
    closeConfirmationDialog,
    chatMessagesElement,
    suggestBtn,
    notesBtn,
    insightsBtn,
    themeToggleBtn,
    settingsBtn,
    closeSettingsBtn,
    saveSettingsBtn,
    settingWindowOpacity,
    selectedSources,
    isCloseConfirmationOpen,
    isShortcutPressed,
    updateWindowOpacityValueLabel,
    takeStealthScreenshot,
    askAiWithSessionContext,
    analyzeScreenshotsOnly,
    clearStealthData,
    emergencyHide,
    copyChatMessageById,
    submitManualContextMessage,
    autoResizeManualInput,
    updateManualComposerState,
    hideResults,
    toggleMasterTranscription,
    addMonitorLog,
    setSourceSelected,
    openCloseConfirmation,
    closeCloseConfirmation,
    closeApplication,
    toggleChatMessageInclusion,
    getResponseSuggestions,
    generateMeetingNotes,
    getConversationInsights,
    toggleThemeMode,
    openSettings,
    closeSettings,
    saveSettings
}) {
    if (screenshotBtn) screenshotBtn.addEventListener('click', takeStealthScreenshot);
    if (analyzeBtn) analyzeBtn.addEventListener('click', askAiWithSessionContext);
    if (screenAiBtn) screenAiBtn.addEventListener('click', analyzeScreenshotsOnly);
    if (clearBtn) clearBtn.addEventListener('click', clearStealthData);
    if (hideBtn) hideBtn.addEventListener('click', emergencyHide);
    if (chatManualSend) chatManualSend.addEventListener('click', submitManualContextMessage);

    if (chatManualInput) {
        chatManualInput.addEventListener('input', () => {
            autoResizeManualInput();
            updateManualComposerState();
        });

        chatManualInput.addEventListener('keydown', (event) => {
            if (event.isComposing) {
                return;
            }

            if (event.key === 'Enter' && !event.shiftKey) {
                event.preventDefault();
                submitManualContextMessage();
            }
        });

        autoResizeManualInput();
        updateManualComposerState();
    }

    if (closeResultsBtn) closeResultsBtn.addEventListener('click', hideResults);

    if (transcriptionToggle) {
        transcriptionToggle.addEventListener('click', () => {
            toggleMasterTranscription().catch((error) => {
                console.error('Failed to toggle transcription:', error);
                addMonitorLog('error', 'master-toggle-failed', error.message);
            });
        });
    }

    if (sourceSystemToggle) {
        sourceSystemToggle.addEventListener('click', () => {
            setSourceSelected('system', !selectedSources.system);
        });
    }

    if (sourceMicToggle) {
        sourceMicToggle.addEventListener('click', () => {
            setSourceSelected('mic', !selectedSources.mic);
        });
    }

    if (closeAppBtn) closeAppBtn.addEventListener('click', openCloseConfirmation);
    if (cancelCloseBtn) cancelCloseBtn.addEventListener('click', closeCloseConfirmation);
    if (confirmCloseBtn) confirmCloseBtn.addEventListener('click', closeApplication);

    if (closeConfirmationDialog) {
        closeConfirmationDialog.addEventListener('click', (event) => {
            if (event.target === closeConfirmationDialog) {
                closeCloseConfirmation();
            }
        });
    }

    if (chatMessagesElement) {
        chatMessagesElement.addEventListener('click', (event) => {
            const copyButton = event.target?.closest?.('.message-copy-btn');
            if (copyButton) {
                event.preventDefault();
                const messageId = copyButton.dataset.messageId;
                if (!messageId) return;
                copyChatMessageById(messageId);
                return;
            }

            const toggleButton = event.target?.closest?.('.ai-include-toggle');
            if (!toggleButton) return;
            event.preventDefault();
            const messageId = toggleButton.dataset.messageId;
            if (!messageId) return;
            toggleChatMessageInclusion(messageId);
        });
    }

    if (suggestBtn) suggestBtn.addEventListener('click', getResponseSuggestions);
    if (notesBtn) notesBtn.addEventListener('click', generateMeetingNotes);
    if (insightsBtn) insightsBtn.addEventListener('click', getConversationInsights);
    if (themeToggleBtn) themeToggleBtn.addEventListener('click', toggleThemeMode);

    if (settingsBtn) settingsBtn.addEventListener('click', openSettings);
    if (closeSettingsBtn) closeSettingsBtn.addEventListener('click', closeSettings);
    if (saveSettingsBtn) saveSettingsBtn.addEventListener('click', saveSettings);

    if (settingWindowOpacity) {
        settingWindowOpacity.addEventListener('input', (event) => {
            const value = event?.target?.value;
            if (typeof value !== 'undefined') {
                updateWindowOpacityValueLabel(value);
            }
        });
    }

    document.addEventListener('keydown', (event) => {
        if (isCloseConfirmationOpen?.()) {
            if (event.key === 'Escape') {
                event.preventDefault();
                closeCloseConfirmation();
                return;
            }

            if (event.key === 'Enter') {
                event.preventDefault();
                closeApplication();
                return;
            }
        }

        if (isShortcutPressed?.(event, 'toggleStealth')) {
            event.preventDefault();
            windowApi?.toggleStealth?.();
            return;
        }

        if (isShortcutPressed?.(event, 'takeScreenshot')) {
            event.preventDefault();
            takeStealthScreenshot();
            return;
        }

        if (isShortcutPressed?.(event, 'askAi')) {
            event.preventDefault();
            addMonitorLog('info', 'shortcut-local', 'Local Ask AI shortcut captured; awaiting global Ask AI event');
            return;
        }

        if (isShortcutPressed?.(event, 'screenAi')) {
            event.preventDefault();
            if (screenAiBtn?.disabled) {
                return;
            }
            analyzeScreenshotsOnly().catch((error) => {
                console.error('Local Screen AI shortcut failed:', error);
                addMonitorLog('error', 'shortcut-screen-ai-failed', error.message);
            });
            return;
        }

        if (isShortcutPressed?.(event, 'suggest')) {
            event.preventDefault();
            if (suggestBtn?.disabled) {
                return;
            }
            getResponseSuggestions().catch((error) => {
                console.error('Local Suggest shortcut failed:', error);
                addMonitorLog('error', 'shortcut-suggest-failed', error.message);
            });
            return;
        }

        if (isShortcutPressed?.(event, 'notes')) {
            event.preventDefault();
            if (notesBtn?.disabled) {
                return;
            }
            generateMeetingNotes().catch((error) => {
                console.error('Local Notes shortcut failed:', error);
                addMonitorLog('error', 'shortcut-notes-failed', error.message);
            });
            return;
        }

        if (isShortcutPressed?.(event, 'insights')) {
            event.preventDefault();
            if (insightsBtn?.disabled) {
                return;
            }
            getConversationInsights().catch((error) => {
                console.error('Local Insights shortcut failed:', error);
                addMonitorLog('error', 'shortcut-insights-failed', error.message);
            });
            return;
        }

        if (isShortcutPressed?.(event, 'clearChat')) {
            event.preventDefault();
            clearStealthData().catch((error) => {
                console.error('Local Clear Chat shortcut failed:', error);
                addMonitorLog('error', 'shortcut-clear-chat-failed', error.message);
            });
            return;
        }

        if (isShortcutPressed?.(event, 'emergencyHide')) {
            event.preventDefault();
            emergencyHide();
            return;
        }

        if (isShortcutPressed?.(event, 'toggleTranscription')) {
            event.preventDefault();
            addMonitorLog('info', 'shortcut-local', 'Local transcription shortcut captured; awaiting global shortcut event');
        }
    });

    document.addEventListener('contextmenu', (event) => event.preventDefault());
    document.addEventListener('selectstart', (event) => event.preventDefault());
    document.addEventListener('dragstart', (event) => event.preventDefault());
}

================
File: src/bootstrap/environment.js
================
const fs = require('fs');
const path = require('path');
const dotenv = require('dotenv');

const OPTIONAL_ENV_DEFAULTS = Object.freeze({
  HIDE_FROM_SCREEN_CAPTURE: 'true',
  START_HIDDEN: 'false',
  MAX_SCREENSHOTS: '50',
  SCREENSHOT_DELAY: '300',
  NODE_ENV: 'production',
  NODE_OPTIONS: '--max-old-space-size=4096'
});

function normalizeGeminiApiKeys(value) {
  const sourceValues = Array.isArray(value)
    ? value
    : String(value ?? '').split(',');
  const seen = new Set();
  const keys = [];

  for (const rawValue of sourceValues) {
    const key = String(rawValue || '').trim();
    if (!key || seen.has(key)) {
      continue;
    }

    seen.add(key);
    keys.push(key);
  }

  return keys;
}

function getEnvPath(app) {
  return app.isPackaged
    ? path.join(process.resourcesPath, '.env')
    : path.join(__dirname, '..', '..', '.env');
}

function parseBoolean(value, defaultValue) {
  if (value == null || value === '') {
    return defaultValue;
  }

  const normalized = String(value).trim().toLowerCase();

  if (['1', 'true', 'yes', 'on'].includes(normalized)) {
    return true;
  }

  if (['0', 'false', 'no', 'off'].includes(normalized)) {
    return false;
  }

  return defaultValue;
}

function parsePositiveInteger(value, defaultValue) {
  const parsedValue = Number.parseInt(String(value ?? ''), 10);
  return Number.isFinite(parsedValue) && parsedValue > 0 ? parsedValue : defaultValue;
}

function normalizeApplicationEnvironment(source = {}) {
  const geminiApiKeys = normalizeGeminiApiKeys(
    source.geminiApiKey ?? source.geminiApiKeys
  );

  return {
    geminiApiKey: geminiApiKeys.join(','),
    geminiApiKeys,
    assemblyAiApiKey: String(source.assemblyAiApiKey || '').trim(),
    hideFromScreenCapture: parseBoolean(
      source.HIDE_FROM_SCREEN_CAPTURE ?? source.hideFromScreenCapture,
      parseBoolean(OPTIONAL_ENV_DEFAULTS.HIDE_FROM_SCREEN_CAPTURE, true)
    ),
    startHidden: parseBoolean(
      source.START_HIDDEN ?? source.startHidden,
      parseBoolean(OPTIONAL_ENV_DEFAULTS.START_HIDDEN, false)
    ),
    maxScreenshots: parsePositiveInteger(
      source.MAX_SCREENSHOTS ?? source.maxScreenshots,
      parsePositiveInteger(OPTIONAL_ENV_DEFAULTS.MAX_SCREENSHOTS, 50)
    ),
    screenshotDelay: parsePositiveInteger(
      source.SCREENSHOT_DELAY ?? source.screenshotDelay,
      parsePositiveInteger(OPTIONAL_ENV_DEFAULTS.SCREENSHOT_DELAY, 300)
    ),
    nodeEnv: String(source.NODE_ENV || source.nodeEnv || OPTIONAL_ENV_DEFAULTS.NODE_ENV).trim() || OPTIONAL_ENV_DEFAULTS.NODE_ENV,
    nodeOptions: String(source.NODE_OPTIONS || source.nodeOptions || OPTIONAL_ENV_DEFAULTS.NODE_OPTIONS).trim() || OPTIONAL_ENV_DEFAULTS.NODE_OPTIONS
  };
}

function syncProcessEnvironment(environment) {
  process.env.GEMINI_API_KEY = environment.geminiApiKey;
  process.env.ASSEMBLY_AI_API_KEY = environment.assemblyAiApiKey;
  process.env.HIDE_FROM_SCREEN_CAPTURE = String(environment.hideFromScreenCapture);
  process.env.START_HIDDEN = String(environment.startHidden);
  process.env.MAX_SCREENSHOTS = String(environment.maxScreenshots);
  process.env.SCREENSHOT_DELAY = String(environment.screenshotDelay);
  process.env.NODE_ENV = environment.nodeEnv;
  process.env.NODE_OPTIONS = environment.nodeOptions;
}

function validateRequiredEnvironment(environment, envPath) {
  void environment;
  void envPath;
}

function loadApplicationEnvironment(app) {
  const envPath = getEnvPath(app);
  dotenv.config({ path: envPath });

  const environment = normalizeApplicationEnvironment(process.env);
  syncProcessEnvironment(environment);
  validateRequiredEnvironment(environment, envPath);

  return {
    envPath,
    ...environment
  };
}

function buildEnvironmentFileContent(environment) {
  return [
    '# API keys are managed in the in-app Settings UI and stored in app state.',
    '# Do not place API keys in this file.',
    '',
    '# Optional capture behavior',
    '# true = hide this app from screen sharing/screen capture',
    '# false = allow this app to appear in screen sharing/screen capture',
    `HIDE_FROM_SCREEN_CAPTURE=${environment.hideFromScreenCapture}`,
    '',
    '# Optional startup mode',
    '# true = start the window hidden (background mode)',
    '# false = show the window on startup',
    `START_HIDDEN=${environment.startHidden}`,
    '',
    '# Optional screenshot settings',
    `MAX_SCREENSHOTS=${environment.maxScreenshots}`,
    `SCREENSHOT_DELAY=${environment.screenshotDelay}`,
    '',
    '# Optional runtime settings',
    `NODE_ENV=${environment.nodeEnv}`,
    `NODE_OPTIONS=${environment.nodeOptions}`,
    ''
  ].join('\n');
}

function saveApplicationEnvironment(app, values = {}) {
  const envPath = getEnvPath(app);
  const environment = normalizeApplicationEnvironment(values);
  syncProcessEnvironment(environment);
  fs.writeFileSync(envPath, buildEnvironmentFileContent(environment), 'utf8');

  return {
    envPath,
    ...environment
  };
}

module.exports = {
  OPTIONAL_ENV_DEFAULTS,
  buildEnvironmentFileContent,
  getEnvPath,
  loadApplicationEnvironment,
  normalizeGeminiApiKeys,
  normalizeApplicationEnvironment,
  saveApplicationEnvironment
};

================
File: src/windows/assistant/renderer/features/listeners/ipc-listeners.js
================
export function setupIpcListeners({
    windowApi,
    setScreenshotsCount,
    updateUi,
    addChatMessage,
    setAnalyzing,
    showLoadingOverlay,
    hideLoadingOverlay,
    showFeedback,
    showEmergencyOverlay,
    transcriptionManager,
    toggleMasterTranscription,
    askAiWithSessionContext,
    isAskAiShortcutEnabled,
    addMonitorLog,
    getActiveScreenAiStream,
    clearActiveScreenAiStream
}) {
    if (!windowApi) {
        console.error('electronAPI not available');
        return;
    }

    windowApi.onScreenshotTakenStealth((count) => {
        const payload = typeof count === 'object' && count !== null ? count : { count };
        setScreenshotsCount(Number(payload.count || 0));
        updateUi();
        addChatMessage('screenshot', 'Screenshot captured', {
            screenshotId: typeof payload.screenshotId === 'string' ? payload.screenshotId : null
        });
        showFeedback('Screenshot captured', 'success');
    });

    windowApi.onAnalysisStart(() => {
        setAnalyzing(true);
        showLoadingOverlay();
        const stream = typeof getActiveScreenAiStream === 'function' ? getActiveScreenAiStream() : null;
        if (!stream) {
            addChatMessage('system', 'Analyzing screenshots...');
        }
    });

    windowApi.onAnalysisResult((data) => {
        setAnalyzing(false);
        hideLoadingOverlay();

        const stream = typeof getActiveScreenAiStream === 'function' ? getActiveScreenAiStream() : null;
        console.log('[onAnalysisResult] stream active:', !!stream, 'has error:', !!data.error);
        if (data.error) {
            addChatMessage('system', `Error: ${data.error}`);
            showFeedback('Analysis failed', 'error');
        } else if (stream) {
            stream.finalize(data.text);
            showFeedback('Analysis complete', 'success');
        } else {
            console.log('[onAnalysisResult] No active stream - creating new message');
            addChatMessage('ai-response', data.text);
            showFeedback('Analysis complete', 'success');
        }

        // Clean up the screen AI stream after processing the result
        if (typeof clearActiveScreenAiStream === 'function') {
            clearActiveScreenAiStream();
        }
    });

    windowApi.onSetStealthMode((enabled) => {
        showFeedback(enabled ? 'Stealth mode ON' : 'Stealth mode OFF', 'info');
    });

    windowApi.onEmergencyClear(() => {
        showEmergencyOverlay();
    });

    windowApi.onError((message) => {
        showFeedback(message, 'error');
    });

    windowApi.onVoskStatus((data) => {
        transcriptionManager.handleVoskStatus(data);
    });

    windowApi.onVoskPartial((data) => {
        transcriptionManager.handleVoskPartial(data);
    });

    windowApi.onVoskFinal((data) => {
        transcriptionManager.handleVoskFinal(data);
    });

    windowApi.onVoskError((data) => {
        transcriptionManager.handleVoskError(data);
    });

    windowApi.onVoskStopped((data) => {
        transcriptionManager.handleVoskStopped(data);
    });

    if (windowApi.onToggleVoiceRecognition) {
        windowApi.onToggleVoiceRecognition(() => {
            addMonitorLog('info', 'shortcut-event', 'Global shortcut toggled transcription');
            toggleMasterTranscription().catch((error) => {
                console.error('Global shortcut toggle failed:', error);
                addMonitorLog('error', 'shortcut-toggle-failed', error.message);
            });
        });
    }

    if (windowApi.onTriggerAskAi) {
        windowApi.onTriggerAskAi(() => {
            if (typeof isAskAiShortcutEnabled === 'function' && !isAskAiShortcutEnabled()) {
                addMonitorLog('info', 'shortcut-ask-ai-blocked', 'Global Ask AI shortcut ignored because Ask AI is disabled');
                return;
            }

            addMonitorLog('info', 'shortcut-event', 'Global Ask AI shortcut triggered');
            askAiWithSessionContext().catch((error) => {
                console.error('Global Ask AI trigger failed:', error);
                addMonitorLog('error', 'shortcut-ask-ai-failed', error.message);
            });
        });
    }

    if (windowApi.onSttDebug) {
        windowApi.onSttDebug((data) => {
            const source = data?.source ? transcriptionManager.normalizeSource(data.source) : null;
            addMonitorLog(
                data?.level || 'info',
                data?.event || 'stt-debug',
                data?.message || '',
                source,
                data?.meta || null,
                data?.ts || Date.now()
            );
        });
    }

    window.addEventListener('error', (event) => {
        addMonitorLog('error', 'renderer-error', event?.message || 'Renderer error');
    });

    window.addEventListener('unhandledrejection', (event) => {
        const reason = event?.reason;
        const message = typeof reason === 'string'
            ? reason
            : reason?.message || 'Unhandled promise rejection';
        addMonitorLog('error', 'renderer-rejection', message);
    });
}

================
File: src/windows/assistant/renderer/features/settings/shortcut-manager.js
================
function normalizeShortcutToken(token) {
    const normalized = String(token || '').trim().toLowerCase();
    const aliasMap = {
        left: 'arrowleft',
        right: 'arrowright',
        up: 'arrowup',
        down: 'arrowdown',
        escape: 'escape',
        esc: 'escape',
        enter: 'enter',
        return: 'enter',
        plus: '+',
        space: ' '
    };

    if (Object.prototype.hasOwnProperty.call(aliasMap, normalized)) {
        return aliasMap[normalized];
    }

    return normalized;
}

function parseAcceleratorBinding(accelerator) {
    if (typeof accelerator !== 'string' || accelerator.trim().length === 0) {
        return null;
    }

    const tokens = accelerator
        .split('+')
        .map((token) => token.trim())
        .filter(Boolean);

    if (tokens.length === 0) {
        return null;
    }

    const binding = {
        ctrl: false,
        meta: false,
        ctrlOrMeta: false,
        alt: false,
        shift: false,
        key: ''
    };

    tokens.forEach((token) => {
        const normalized = String(token).toLowerCase();
        switch (normalized) {
            case 'commandorcontrol':
                binding.ctrlOrMeta = true;
                break;
            case 'ctrl':
            case 'control':
                binding.ctrl = true;
                break;
            case 'command':
            case 'cmd':
            case 'meta':
            case 'super':
                binding.meta = true;
                break;
            case 'alt':
            case 'option':
                binding.alt = true;
                break;
            case 'shift':
                binding.shift = true;
                break;
            default:
                binding.key = normalizeShortcutToken(normalized);
                break;
        }
    });

    if (!binding.key) {
        return null;
    }

    return binding;
}

function normalizeKeyboardShortcutDefinition(shortcut) {
    if (!shortcut || typeof shortcut !== 'object') {
        return null;
    }

    const id = typeof shortcut.id === 'string' ? shortcut.id.trim() : '';
    const accelerator = typeof shortcut.accelerator === 'string' ? shortcut.accelerator.trim() : '';
    if (!id || !accelerator) {
        return null;
    }

    const buttonLabel = typeof shortcut.buttonLabel === 'string' && shortcut.buttonLabel.trim()
        ? shortcut.buttonLabel.trim()
        : id;
    const description = typeof shortcut.description === 'string' ? shortcut.description.trim() : '';

    return {
        id,
        accelerator,
        buttonLabel,
        description
    };
}

function formatShortcutTokenForDisplay(token) {
    const normalized = String(token || '').trim().toLowerCase();
    const displayMap = {
        commandorcontrol: navigator.platform.toLowerCase().includes('mac') ? 'Cmd' : 'Ctrl',
        command: 'Cmd',
        cmd: 'Cmd',
        control: 'Ctrl',
        ctrl: 'Ctrl',
        alt: navigator.platform.toLowerCase().includes('mac') ? 'Option' : 'Alt',
        option: 'Option',
        shift: 'Shift',
        left: 'Left',
        right: 'Right',
        up: 'Up',
        down: 'Down'
    };

    if (Object.prototype.hasOwnProperty.call(displayMap, normalized)) {
        return displayMap[normalized];
    }

    if (normalized.length === 1) {
        return normalized.toUpperCase();
    }

    return token;
}

function formatShortcutForDisplay(accelerator) {
    return String(accelerator || '')
        .split('+')
        .map((token) => token.trim())
        .filter(Boolean)
        .map((token) => formatShortcutTokenForDisplay(token))
        .join('+');
}

const shortcutIconById = {
    toggleTranscription: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M3 10v4"/><path d="M7 7v10"/><path d="M11 4v16"/><path d="M15 7v10"/><path d="M19 10v4"/></svg>',
    takeScreenshot: '<svg viewBox="0 0 24 24" fill="currentColor"><path d="M9 2 7.17 4H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2h-3.17L15 2H9zm3 15c-2.76 0-5-2.24-5-5s2.24-5 5-5 5 2.24 5 5-2.24 5-5 5z"/></svg>',
    askAi: '<svg viewBox="0 0 24 24" fill="currentColor"><path d="M12 2a8 8 0 0 0-8 8v2a4 4 0 0 0 4 4h1v3l3-3h3a8 8 0 0 0 8-8 8 8 0 0 0-8-8zm-1 6h2v2h-2V8zm0 3h2v5h-2v-5z"/></svg>',
    screenAi: '<svg viewBox="0 0 24 24" fill="currentColor"><path d="M4 5h16a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2h-6v2h3v1H7v-1h3v-2H4a2 2 0 0 1-2-2V7a2 2 0 0 1 2-2zm0 2v10h16V7H4z"/></svg>',
    suggest: '<svg viewBox="0 0 24 24" fill="currentColor"><path d="M9 21h6v-1H9v1zm3-19a7 7 0 0 0-4 12.74V17a1 1 0 0 0 1 1h6a1 1 0 0 0 1-1v-2.26A7 7 0 0 0 12 2zm2 11.6V16h-4v-2.4A5 5 0 1 1 14 13.6z"/></svg>',
    notes: '<svg viewBox="0 0 24 24" fill="currentColor"><path d="M6 2h9l5 5v15a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2zm8 1v5h5"/><path d="M8 13h8v1H8zm0 3h8v1H8zm0-6h5v1H8z"/></svg>',
    insights: '<svg viewBox="0 0 24 24" fill="currentColor"><path d="M4 20h16v1H3V4h1v16z"/><path d="M7 16h2v-5H7v5zm4 0h2V8h-2v8zm4 0h2v-3h-2v3z"/></svg>',
    clearChat: '<svg viewBox="0 0 24 24" fill="currentColor"><path d="M6 19c0 1.1.9 2 2 2h8c1.1 0 2-.9 2-2V7H6v12zM19 4h-3.5l-1-1h-5l-1 1H5v2h14V4z"/></svg>',
    emergencyHide: '<svg viewBox="0 0 24 24" fill="currentColor"><path d="M18.3 5.71a1 1 0 0 0-1.41 0L12 10.59 7.11 5.7a1 1 0 1 0-1.42 1.42L10.59 12l-4.9 4.89a1 1 0 0 0 1.42 1.42L12 13.41l4.89 4.9a1 1 0 0 0 1.42-1.42L13.41 12l4.9-4.89a1 1 0 0 0 0-1.4Z"/></svg>',
    toggleStealth: '<svg viewBox="0 0 24 24" fill="currentColor"><path d="M12 4a8 8 0 1 0 0 16V4z"/></svg>',
    moveWindowLeft: '<svg viewBox="0 0 24 24" fill="currentColor"><path d="M14 7l-5 5 5 5V7z"/></svg>',
    moveWindowRight: '<svg viewBox="0 0 24 24" fill="currentColor"><path d="M10 7l5 5-5 5V7z"/></svg>',
    moveWindowUp: '<svg viewBox="0 0 24 24" fill="currentColor"><path d="M7 14l5-5 5 5H7z"/></svg>',
    moveWindowDown: '<svg viewBox="0 0 24 24" fill="currentColor"><path d="M7 10l5 5 5-5H7z"/></svg>',
    windowSizePreset1: '<svg viewBox="0 0 24 24" fill="currentColor"><rect x="6" y="8" width="12" height="8" rx="1.5"/></svg>',
    windowSizePreset2: '<svg viewBox="0 0 24 24" fill="currentColor"><rect x="5" y="7" width="14" height="10" rx="1.5"/></svg>',
    windowSizePreset3: '<svg viewBox="0 0 24 24" fill="currentColor"><rect x="4" y="6" width="16" height="12" rx="1.5"/></svg>',
    windowSizePreset4: '<svg viewBox="0 0 24 24" fill="currentColor"><rect x="3" y="5" width="18" height="14" rx="1.5"/></svg>'
};

function getShortcutIconMarkup(shortcutId) {
    return shortcutIconById[shortcutId] || '<svg viewBox="0 0 24 24" fill="currentColor"><circle cx="12" cy="12" r="4"/></svg>';
}

export function createShortcutManager({ settingsShortcutsList }) {
    let configuredKeyboardShortcuts = [];
    const shortcutBindingsById = new Map();

    function renderKeyboardShortcutsInSettings() {
        if (!settingsShortcutsList) {
            return;
        }

        settingsShortcutsList.innerHTML = '';

        if (!configuredKeyboardShortcuts.length) {
            const emptyState = document.createElement('div');
            emptyState.className = 'settings-shortcuts-empty';
            emptyState.textContent = 'No shortcuts configured.';
            settingsShortcutsList.appendChild(emptyState);
            return;
        }

        configuredKeyboardShortcuts.forEach((shortcut) => {
            const row = document.createElement('div');
            row.className = 'settings-shortcut-row';

            const shortcutMeta = document.createElement('div');
            shortcutMeta.className = 'settings-shortcut-meta';

            const icon = document.createElement('span');
            icon.className = 'settings-shortcut-icon';
            icon.innerHTML = getShortcutIconMarkup(shortcut.id);

            const buttonLabel = document.createElement('span');
            buttonLabel.className = 'settings-shortcut-button';
            buttonLabel.textContent = shortcut.buttonLabel;
            if (shortcut.description) {
                buttonLabel.title = shortcut.description;
            }
            const shortcutText = document.createElement('div');
            shortcutText.className = 'settings-shortcut-text';
            shortcutText.appendChild(buttonLabel);

            if (shortcut.description) {
                const description = document.createElement('span');
                description.className = 'settings-shortcut-description';
                description.textContent = shortcut.description;
                shortcutText.appendChild(description);
            }

            const shortcutValue = document.createElement('span');
            shortcutValue.className = 'settings-shortcut-key';
            shortcutValue.textContent = formatShortcutForDisplay(shortcut.accelerator);

            shortcutMeta.appendChild(icon);
            shortcutMeta.appendChild(shortcutText);
            row.appendChild(shortcutMeta);
            row.appendChild(shortcutValue);
            settingsShortcutsList.appendChild(row);
        });
    }

    function setConfiguredKeyboardShortcuts(shortcuts) {
        const normalizedShortcuts = Array.isArray(shortcuts)
            ? shortcuts
                .map((shortcut) => normalizeKeyboardShortcutDefinition(shortcut))
                .filter(Boolean)
            : [];

        configuredKeyboardShortcuts = normalizedShortcuts;
        shortcutBindingsById.clear();

        normalizedShortcuts.forEach((shortcut) => {
            const parsedBinding = parseAcceleratorBinding(shortcut.accelerator);
            if (parsedBinding) {
                shortcutBindingsById.set(shortcut.id, parsedBinding);
            }
        });

        renderKeyboardShortcutsInSettings();
    }

    function getShortcutBinding(shortcutId) {
        return shortcutBindingsById.get(shortcutId) || null;
    }

    function isShortcutPressed(event, shortcutId) {
        const binding = getShortcutBinding(shortcutId);
        if (!binding) {
            return false;
        }

        const eventKey = normalizeShortcutToken(event.key);
        if (eventKey !== binding.key) {
            return false;
        }

        if (binding.ctrlOrMeta) {
            if (!event.ctrlKey && !event.metaKey) {
                return false;
            }
        } else if (event.ctrlKey !== binding.ctrl || event.metaKey !== binding.meta) {
            return false;
        }

        return event.altKey === binding.alt && event.shiftKey === binding.shift;
    }

    function applySettingsShortcutConfig(settings) {
        if (!settings || settings.error) {
            return;
        }

        setConfiguredKeyboardShortcuts(settings.keyboardShortcuts);
    }

    return {
        applySettingsShortcutConfig,
        isShortcutPressed
    };
}

================
File: src/windows/assistant/window.js
================
const path = require('path');
const { BrowserWindow } = require('electron');

function createAssistantWindow({
  app,
  screen,
  defaultWidth,
  defaultHeight,
  minWidth,
  minHeight,
  hideFromScreenCapture,
  initialOpacity,
  launchHidden,
  nodeEnv
}) {
  console.log('Creating assistant window...');
  const { width, height } = screen.getPrimaryDisplay().workAreaSize;
  const x = Math.floor((width - defaultWidth) / 2);
  const y = 40;
  const windowOpacity = Number.isFinite(initialOpacity) ? initialOpacity : 1;

  console.log(`Window position: ${x}, ${y}, size: ${defaultWidth}x${defaultHeight}`);

  const mainWindow = new BrowserWindow({
    width: defaultWidth,
    height: defaultHeight,
    minWidth,
    minHeight,
    maxWidth: width,
    maxHeight: height,
    x,
    y,
    webPreferences: {
      nodeIntegration: false,
      contextIsolation: true,
      preload: path.join(__dirname, 'preload.js'),
      backgroundThrottling: false,
      offscreen: false,
      webSecurity: false,
      allowRunningInsecureContent: true,
      experimentalFeatures: false,
      enableRemoteModule: false,
      sandbox: false
    },
    frame: false,
    transparent: true,
    alwaysOnTop: true,
    skipTaskbar: true,
    resizable: true,
    minimizable: false,
    maximizable: false,
    closable: false,
    focusable: true,
    show: false,
    opacity: windowOpacity,
    type: 'toolbar',
    acceptFirstMouse: false,
    disableAutoHideCursor: true,
    enableLargerThanScreen: false,
    hasShadow: false,
    thickFrame: false,
    titleBarStyle: 'hidden',
    backgroundColor: '#00000000'
  });

  const htmlPath = path.join(__dirname, 'renderer.html');
  console.log('Loading HTML from:', htmlPath);
  mainWindow.loadFile(htmlPath);

  mainWindow.webContents.session.setPermissionRequestHandler((webContents, permission, callback) => {
    console.log('Permission requested:', permission);
    if (permission === 'microphone' || permission === 'media') {
      console.log('Granting microphone permission');
      callback(true);
    } else {
      console.log('Denying permission:', permission);
      callback(false);
    }
  });

  mainWindow.webContents.session.setPermissionCheckHandler((webContents, permission, requestingOrigin) => {
    console.log('Permission check:', permission, requestingOrigin);
    return permission === 'microphone' || permission === 'media';
  });

  mainWindow.webContents.session.protocol.registerFileProtocol('file', (request, callback) => {
    const pathname = decodeURI(request.url.replace('file:///', ''));
    callback(pathname);
  });

  if (process.platform === 'darwin') {
    mainWindow.setVisibleOnAllWorkspaces(true, {
      visibleOnFullScreen: true,
      skipTransformProcessType: true
    });
    mainWindow.setAlwaysOnTop(true, 'pop-up-menu', 1);
    app.dock.hide();
    mainWindow.setHiddenInMissionControl(true);
  } else if (process.platform === 'win32') {
    console.log('Applying Windows stealth settings');
    mainWindow.setSkipTaskbar(true);
    mainWindow.setAlwaysOnTop(true, 'pop-up-menu');
    mainWindow.setAppDetails({
      appId: 'SystemProcess',
      appIconPath: '',
      relaunchCommand: '',
      relaunchDisplayName: ''
    });
  }

  mainWindow.setContentProtection(hideFromScreenCapture);
  console.log(
    `Content protection ${hideFromScreenCapture ? 'enabled' : 'disabled'} (HIDE_FROM_SCREEN_CAPTURE=${hideFromScreenCapture})`
  );

  mainWindow.setIgnoreMouseEvents(false);

  mainWindow.webContents.on('dom-ready', () => {
    console.log('DOM is ready');
  });

  mainWindow.webContents.on('did-finish-load', () => {
    console.log('HTML finished loading');

    mainWindow.webContents.executeJavaScript(`
      console.log('Content check...');
      console.log('Document title:', document.title);
      console.log('Body exists:', !!document.body);
      console.log('App element exists:', !!document.getElementById('app'));
      console.log('Glass container exists:', !!document.querySelector('.glass-container'));

      document.body.style.background = 'transparent';

      if (document.body) {
        document.body.style.visibility = 'visible';
        document.body.style.display = 'block';
        console.log('Body made visible');
      }

      const app = document.getElementById('app');
      if (app) {
        app.style.visibility = 'visible';
        app.style.display = 'flex';
        console.log('App container made visible');
      }

      'Content visibility check complete';
    `).then((result) => {
      console.log('JavaScript result:', result);
      if (launchHidden) {
        console.log('Window initialized in hidden launch mode');
        return;
      }

      mainWindow.showInactive();
      console.log('Window shown in inactive mode with transparent background');
    }).catch((error) => {
      console.log('JavaScript execution failed:', error);
      if (!launchHidden) {
        mainWindow.showInactive();
      }
    });
  });

  mainWindow.webContents.on('did-fail-load', (event, errorCode, errorDescription) => {
    console.error('Failed to load:', errorCode, errorDescription);
  });

  mainWindow.webContents.on('console-message', (event, level, message) => {
    console.log(`Renderer console.${level}: ${message}`);
  });

  if (nodeEnv === 'development') {
    mainWindow.webContents.openDevTools();
  }

  return mainWindow;
}

module.exports = {
  createAssistantWindow
};

================
File: src/main-process/features/assistant/ipc.js
================
function registerAssistantIpc({
  ipcMain,
  screenshotManager,
  windowController,
  geminiRuntime,
  assemblyAiService,
  sendToRenderer,
  quitApplication
}) {
  let chatContext = [];

  function getAllKeysUnavailableMessage() {
    return 'All configured Gemini API keys are currently unavailable (quota exhausted or invalid). Please wait and try again later.';
  }

  function mapGeminiErrorMessage(error, fallbackPrefix = 'Request failed') {
    const message = String(error?.message || '');
    const normalizedMessage = message.toLowerCase();

    if (geminiRuntime.isAllKeysUnavailableError?.(error)) {
      return getAllKeysUnavailableMessage();
    }

    if (normalizedMessage.includes('no api key configured')) {
      return 'No Gemini API key configured. Add it in Settings.';
    }

    if (
      normalizedMessage.includes('api key not valid') ||
      normalizedMessage.includes('invalid api key') ||
      normalizedMessage.includes('api_key_invalid') ||
      normalizedMessage.includes('permission denied') ||
      normalizedMessage.includes('permission_denied') ||
      normalizedMessage.includes('unauthorized') ||
      normalizedMessage.includes('forbidden') ||
      normalizedMessage.includes('401') ||
      normalizedMessage.includes('403')
    ) {
      return 'Invalid Gemini API key. Please check the key values in Settings.';
    }

    if (
      normalizedMessage.includes('quota') ||
      normalizedMessage.includes('daily request limit') ||
      normalizedMessage.includes('exceeded your current quota')
    ) {
      return 'API quota exceeded. Please try again later.';
    }

    if (normalizedMessage.includes('network') || normalizedMessage.includes('fetch')) {
      return 'Network error. Please check your internet connection.';
    }

    if (normalizedMessage.includes('model')) {
      return 'AI model error. Please try a different model.';
    }

    return message ? `${fallbackPrefix}: ${message}` : fallbackPrefix;
  }

  async function analyzeForMeetingWithContext(contextInput = '') {
    const payload = typeof contextInput === 'object' && contextInput !== null
      ? contextInput
      : { contextString: String(contextInput || '') };

    const contextString = typeof payload.contextString === 'string' ? payload.contextString : '';
    const enabledScreenshotIds = Array.isArray(payload.enabledScreenshotIds) ? payload.enabledScreenshotIds : null;

    console.log('Starting context-aware analysis...');
    console.log('Context length:', contextString.length);
    console.log('API Keys configured:', geminiRuntime.getApiKeys().length);
    console.log('Model initialized:', !!(geminiRuntime.getService() && geminiRuntime.getService().model));
    console.log('Programming language preference:', geminiRuntime.getActiveProgrammingLanguage());
    console.log('Screenshots count:', screenshotManager.getScreenshotsCount());

    if (!geminiRuntime.hasApiKeys()) {
      sendToRenderer('analysis-result', {
        error: 'No Gemini API key configured. Add it in Settings.'
      });
      return;
    }

    if (!screenshotManager.hasScreenshots()) {
      sendToRenderer('analysis-result', {
        error: 'No screenshots to analyze. Take a screenshot first.'
      });
      return;
    }

    try {
      sendToRenderer('analysis-start');

      const { imageParts } = await screenshotManager.buildImagePartsFromScreenshots({
        strict: true,
        includeIds: enabledScreenshotIds
      });

      if (imageParts.length === 0) {
        sendToRenderer('analysis-result', {
          error: 'No enabled screenshots selected for analysis.'
        });
        return;
      }

      const onChunk = ({ text, index }) => {
        sendToRenderer('ai-stream-chunk', { actionId: 'screenAi', text, index });
      };
      sendToRenderer('ai-stream-start', { actionId: 'screenAi' });

      const text = await geminiRuntime.executeWithKeyFailover((geminiService) => {
        if (!geminiService || !geminiService.model) {
          throw new Error('AI model not initialized. Please check your API key.');
        }

        return geminiService.analyzeScreenshots(
          imageParts,
          '',
          { contextStringOverride: contextString, onChunk }
        );
      });

      chatContext.push({
        type: 'analysis',
        content: text,
        timestamp: new Date().toISOString(),
        screenshotCount: imageParts.length
      });

      sendToRenderer('ai-stream-end', { actionId: 'screenAi' });
      sendToRenderer('analysis-result', { text });
    } catch (error) {
      console.error('Analysis error details:', error);

      sendToRenderer('ai-stream-end', { actionId: 'screenAi' });
      sendToRenderer('analysis-result', {
        error: mapGeminiErrorMessage(error, 'Analysis failed')
      });
    }
  }

  async function analyzeForMeeting() {
    await analyzeForMeetingWithContext();
  }

  ipcMain.handle('get-screenshots-count', () => {
    return screenshotManager.getScreenshotsCount();
  });

  ipcMain.handle('get-window-bounds', () => {
    return windowController.getWindowBounds();
  });

  ipcMain.handle('set-window-bounds', (_event, nextBounds) => {
    return windowController.setWindowBounds(nextBounds);
  });

  ipcMain.handle('set-window-size-preset', (_event, payload = {}) => {
    const preset = typeof payload === 'number' ? payload : payload?.preset;
    return windowController.setWindowSizePreset(preset);
  });

  ipcMain.handle('toggle-stealth', () => {
    return windowController.toggleStealthMode();
  });

  ipcMain.handle('emergency-hide', () => {
    return windowController.emergencyHide();
  });

  ipcMain.handle('take-stealth-screenshot', async () => {
    return screenshotManager.takeStealthScreenshot();
  });

  ipcMain.handle('analyze-stealth', async () => {
    return analyzeForMeeting();
  });

  ipcMain.handle('analyze-stealth-with-context', async (_event, context) => {
    return analyzeForMeetingWithContext(context);
  });

  ipcMain.handle('ask-ai-with-session-context', async (_event, payload = {}) => {
    const mode = payload?.mode === 'best-next-answer' ? 'best-next-answer' : 'best-next-answer';

    try {
      assemblyAiService.flushAllSttHistoryBuffers('pre-ask-ai');

      if (!geminiRuntime.hasApiKeys()) {
        throw new Error('No Gemini API key configured. Add it in Settings.');
      }

      const transcriptContext = typeof payload?.transcriptContext === 'string'
        ? payload.transcriptContext.trim()
        : '';
      const sessionSummary = typeof payload?.sessionSummary === 'string'
        ? payload.sessionSummary.trim()
        : '';
      const contextString = typeof payload?.contextString === 'string'
        ? payload.contextString.trim()
        : '';
      const enabledScreenshotIds = Array.isArray(payload?.enabledScreenshotIds)
        ? payload.enabledScreenshotIds.filter((id) => typeof id === 'string' && id.trim().length > 0)
        : null;

      if (!transcriptContext && !contextString && !screenshotManager.hasScreenshots()) {
        return {
          success: false,
          error: 'No transcript or screenshots available yet. Start transcription or capture a screenshot first.',
          mode,
          usedScreenshots: false
        };
      }

      const onChunk = ({ text, index }) => {
        sendToRenderer('ai-stream-chunk', { actionId: 'askAi', text, index });
      };
      sendToRenderer('ai-stream-start', { actionId: 'askAi' });

      let usedScreenshots = false;
      let usedScreenshotCount = 0;
      let text = '';

      if (screenshotManager.hasScreenshots()) {
        const { imageParts } = await screenshotManager.buildImagePartsFromScreenshots({
          strict: false,
          includeIds: enabledScreenshotIds
        });

        if (imageParts.length > 0) {
          usedScreenshots = true;
          usedScreenshotCount = imageParts.length;
          text = await geminiRuntime.executeWithKeyFailover((geminiService) => {
            if (!geminiService || !geminiService.model) {
              throw new Error('AI model not initialized. Please check your API key.');
            }

            return geminiService.askAiWithSessionContextAndScreenshots(imageParts, {
              contextString,
              transcriptContext,
              sessionSummary,
              screenshotCount: imageParts.length,
              mode,
              onChunk
            });
          });
        }
      }

      if (!text) {
        text = await geminiRuntime.executeWithKeyFailover((geminiService) => {
          if (!geminiService || !geminiService.model) {
            throw new Error('AI model not initialized. Please check your API key.');
          }

          return geminiService.askAiWithSessionContext({
            contextString,
            transcriptContext,
            sessionSummary,
            screenshotCount: usedScreenshots ? usedScreenshotCount : 0,
            mode,
            onChunk
          });
        });
      }

      chatContext.push({
        type: 'ask-ai',
        content: text,
        timestamp: new Date().toISOString(),
        screenshotCount: usedScreenshots ? usedScreenshotCount : 0
      });

      sendToRenderer('ai-stream-end', { actionId: 'askAi' });
      return { success: true, text, mode, usedScreenshots };
    } catch (error) {
      console.error('Error in ask-ai-with-session-context:', error);
      sendToRenderer('ai-stream-end', { actionId: 'askAi' });
      return {
        success: false,
        error: mapGeminiErrorMessage(error, 'Ask AI failed'),
        mode,
        usedScreenshots: false
      };
    }
  });

  ipcMain.handle('clear-stealth', () => {
    chatContext = [];
    return screenshotManager.clearStealth();
  });

  ipcMain.handle('close-app', () => {
    setTimeout(() => {
      quitApplication();
    }, 0);

    return { success: true };
  });

  ipcMain.handle('add-voice-transcript', async (_event, transcript) => {
    const geminiService = geminiRuntime.getService();
    if (geminiService) {
      geminiService.addToHistory('user', transcript);
    }

    return { success: true };
  });

  ipcMain.handle('suggest-response', async (_event, context) => {
    try {
      assemblyAiService.flushAllSttHistoryBuffers('pre-suggest');
      if (!geminiRuntime.hasApiKeys()) {
        throw new Error('No Gemini API key configured. Add it in Settings.');
      }

      const payload = typeof context === 'object' && context !== null
        ? context
        : { context };
      const contextPrompt = typeof payload.context === 'string'
        ? payload.context
        : 'Current meeting conversation';
      const contextStringOverride = typeof payload.contextString === 'string'
        ? payload.contextString
        : '';

      const onChunk = ({ text, index }) => {
        sendToRenderer('ai-stream-chunk', { actionId: 'suggest', text, index });
      };
      sendToRenderer('ai-stream-start', { actionId: 'suggest' });

      const suggestions = await geminiRuntime.executeWithKeyFailover((geminiService) => {
        if (!geminiService || !geminiService.model) {
          throw new Error('Gemini service not initialized');
        }

        return geminiService.suggestResponse(contextPrompt, {
          contextString: contextStringOverride,
          onChunk
        });
      });

      sendToRenderer('ai-stream-end', { actionId: 'suggest' });
      return { success: true, suggestions };
    } catch (error) {
      console.error('Error generating suggestions:', error);
      sendToRenderer('ai-stream-end', { actionId: 'suggest' });
      return { success: false, error: mapGeminiErrorMessage(error, 'Failed to generate suggestions') };
    }
  });

  ipcMain.handle('generate-meeting-notes', async (_event, payload = {}) => {
    try {
      assemblyAiService.flushAllSttHistoryBuffers('pre-notes');
      if (!geminiRuntime.hasApiKeys()) {
        throw new Error('No Gemini API key configured. Add it in Settings.');
      }

      const contextStringOverride = typeof payload?.contextString === 'string'
        ? payload.contextString
        : '';

      const onChunk = ({ text, index }) => {
        sendToRenderer('ai-stream-chunk', { actionId: 'notes', text, index });
      };
      sendToRenderer('ai-stream-start', { actionId: 'notes' });

      const notes = await geminiRuntime.executeWithKeyFailover((geminiService) => {
        if (!geminiService || !geminiService.model) {
          throw new Error('Gemini service not initialized');
        }

        return geminiService.generateMeetingNotes({
          contextString: contextStringOverride,
          onChunk
        });
      });

      sendToRenderer('ai-stream-end', { actionId: 'notes' });
      return { success: true, notes };
    } catch (error) {
      console.error('Error generating meeting notes:', error);
      sendToRenderer('ai-stream-end', { actionId: 'notes' });
      return { success: false, error: mapGeminiErrorMessage(error, 'Failed to generate meeting notes') };
    }
  });

  ipcMain.handle('generate-follow-up-email', async () => {
    try {
      assemblyAiService.flushAllSttHistoryBuffers('pre-followup');
      if (!geminiRuntime.hasApiKeys()) {
        throw new Error('No Gemini API key configured. Add it in Settings.');
      }

      const email = await geminiRuntime.executeWithKeyFailover((geminiService) => {
        if (!geminiService || !geminiService.model) {
          throw new Error('Gemini service not initialized');
        }

        return geminiService.generateFollowUpEmail();
      });

      return { success: true, email };
    } catch (error) {
      console.error('Error generating email:', error);
      return { success: false, error: mapGeminiErrorMessage(error, 'Failed to generate follow-up email') };
    }
  });

  ipcMain.handle('answer-question', async (_event, question) => {
    try {
      assemblyAiService.flushAllSttHistoryBuffers('pre-answer');
      if (!geminiRuntime.hasApiKeys()) {
        throw new Error('No Gemini API key configured. Add it in Settings.');
      }

      const answer = await geminiRuntime.executeWithKeyFailover((geminiService) => {
        if (!geminiService || !geminiService.model) {
          throw new Error('Gemini service not initialized');
        }

        return geminiService.answerQuestion(question);
      });

      return { success: true, answer };
    } catch (error) {
      console.error('Error answering question:', error);
      return { success: false, error: mapGeminiErrorMessage(error, 'Failed to answer question') };
    }
  });

  ipcMain.handle('get-conversation-insights', async (_event, payload = {}) => {
    try {
      assemblyAiService.flushAllSttHistoryBuffers('pre-insights');
      if (!geminiRuntime.hasApiKeys()) {
        throw new Error('No Gemini API key configured. Add it in Settings.');
      }

      const contextStringOverride = typeof payload?.contextString === 'string'
        ? payload.contextString
        : '';

      const onChunk = ({ text, index }) => {
        sendToRenderer('ai-stream-chunk', { actionId: 'insights', text, index });
      };
      sendToRenderer('ai-stream-start', { actionId: 'insights' });

      const insights = await geminiRuntime.executeWithKeyFailover((geminiService) => {
        if (!geminiService || !geminiService.model) {
          throw new Error('Gemini service not initialized');
        }

        return geminiService.getConversationInsights({
          contextString: contextStringOverride,
          onChunk
        });
      });

      sendToRenderer('ai-stream-end', { actionId: 'insights' });
      return { success: true, insights };
    } catch (error) {
      console.error('Error getting insights:', error);
      sendToRenderer('ai-stream-end', { actionId: 'insights' });
      return { success: false, error: mapGeminiErrorMessage(error, 'Failed to get conversation insights') };
    }
  });

  ipcMain.handle('clear-conversation-history', async () => {
    const geminiService = geminiRuntime.getService();

    try {
      assemblyAiService.resetSttHistoryBuffers();
      if (geminiService) {
        geminiService.clearHistory();
      }

      chatContext = [];
      return { success: true };
    } catch (error) {
      console.error('Error clearing history:', error);
      return { success: false, error: error.message };
    }
  });

  ipcMain.handle('get-conversation-history', async () => {
    const geminiService = geminiRuntime.getService();

    try {
      if (!geminiService) {
        return { success: true, history: [] };
      }

      return { success: true, history: geminiService.conversationHistory };
    } catch (error) {
      console.error('Error getting history:', error);
      return { success: false, error: error.message };
    }
  });
}

module.exports = {
  registerAssistantIpc
};

================
File: src/main-process/features/window/window-controller.js
================
const {
  WINDOW_DEFAULT_WIDTH,
  WINDOW_DEFAULT_HEIGHT,
  WINDOW_MIN_WIDTH,
  WINDOW_MIN_HEIGHT,
  WINDOW_OPACITY_LEVEL_MIN,
  WINDOW_OPACITY_LEVEL_MAX,
  DEFAULT_WINDOW_OPACITY_LEVEL,
  STEALTH_WINDOW_OPACITY
} = require('./window-constants');
const { getKeyboardShortcutAccelerator } = require('../../../config');

function createWindowController({
  app,
  screen,
  globalShortcut,
  createAssistantWindow,
  getAppEnvironment,
  emitSttDebug,
  sendToRenderer,
  onTakeStealthScreenshot
}) {
  let mainWindow = null;
  let isVisible = true;
  let autoHideTimer = null;
  let isRecoveryReloadInProgress = false;
  let lastRecoveryReloadAt = 0;
  let activeWindowOpacityLevel = DEFAULT_WINDOW_OPACITY_LEVEL;

  const RECOVERY_RELOAD_COOLDOWN_MS = 5000;

  function clamp(value, min, max) {
    return Math.min(Math.max(value, min), max);
  }

  function clampWindowOpacityLevel(level) {
    const parsedLevel = Number.parseInt(String(level ?? ''), 10);

    if (!Number.isFinite(parsedLevel)) {
      return DEFAULT_WINDOW_OPACITY_LEVEL;
    }

    return clamp(parsedLevel, WINDOW_OPACITY_LEVEL_MIN, WINDOW_OPACITY_LEVEL_MAX);
  }

  function setWindowOpacityLevel(level) {
    activeWindowOpacityLevel = clampWindowOpacityLevel(level);
    applyWindowOpacity();
    return activeWindowOpacityLevel;
  }

  function getWindowOpacityLevel() {
    return activeWindowOpacityLevel;
  }

  function getWindowOpacityFromLevel(level) {
    return clampWindowOpacityLevel(level) / 10;
  }

  function getVisibleWindowOpacity() {
    return getWindowOpacityFromLevel(activeWindowOpacityLevel);
  }

  function getStealthWindowOpacity() {
    return Math.min(getVisibleWindowOpacity(), STEALTH_WINDOW_OPACITY);
  }

  function getCurrentWindowOpacity() {
    return isVisible ? getVisibleWindowOpacity() : getStealthWindowOpacity();
  }

  function applyWindowOpacity() {
    if (!mainWindow || mainWindow.isDestroyed()) {
      return;
    }

    mainWindow.setOpacity(getCurrentWindowOpacity());
  }

  function recoverMainWindowVisibility(reason, { reload = false } = {}) {
    if (!mainWindow || mainWindow.isDestroyed()) {
      return;
    }

    console.warn(`Window recovery triggered: ${reason}`);
    if (typeof emitSttDebug === 'function') {
      emitSttDebug({
        level: 'error',
        event: 'window-recovery',
        message: reason
      });
    }

    try {
      if (autoHideTimer) {
        clearTimeout(autoHideTimer);
        autoHideTimer = null;
      }

      isVisible = true;
      mainWindow.setOpacity(getVisibleWindowOpacity());
      if (!mainWindow.isVisible()) {
        mainWindow.show();
      }
      sendToRenderer('set-stealth-mode', false);
    } catch (error) {
      console.error('Window visibility recovery failed:', error);
    }

    if (!reload || !mainWindow.webContents || mainWindow.webContents.isDestroyed()) {
      return;
    }

    const now = Date.now();
    if (isRecoveryReloadInProgress || now - lastRecoveryReloadAt < RECOVERY_RELOAD_COOLDOWN_MS) {
      return;
    }

    isRecoveryReloadInProgress = true;
    lastRecoveryReloadAt = now;
    try {
      mainWindow.webContents.reload();
      if (typeof emitSttDebug === 'function') {
        emitSttDebug({
          event: 'window-reload',
          message: 'Triggered guarded renderer reload'
        });
      }
    } catch (error) {
      console.error('Window recovery reload failed:', error);
      isRecoveryReloadInProgress = false;
      return;
    }

    setTimeout(() => {
      isRecoveryReloadInProgress = false;
    }, 1500);
  }

  function attachWindowRecoveryHandlers() {
    if (!mainWindow || mainWindow.isDestroyed()) {
      return;
    }

    mainWindow.on('unresponsive', () => {
      console.error('Main window became unresponsive');
      recoverMainWindowVisibility('window-unresponsive', { reload: true });
    });

    const contents = mainWindow.webContents;
    if (!contents || contents.isDestroyed()) {
      return;
    }

    contents.on('render-process-gone', (_event, details) => {
      console.error('Renderer process gone:', details);
      recoverMainWindowVisibility('render-process-gone', { reload: true });
    });

    contents.on('unresponsive', () => {
      console.error('WebContents became unresponsive');
      recoverMainWindowVisibility('webcontents-unresponsive', { reload: true });
    });

    contents.on('did-fail-load', (_event, errorCode, errorDescription, validatedURL, isMainFrame) => {
      console.error('WebContents did-fail-load:', {
        errorCode,
        errorDescription,
        validatedURL,
        isMainFrame
      });
      recoverMainWindowVisibility('did-fail-load', { reload: !!isMainFrame });
    });

    contents.on('did-finish-load', () => {
      isRecoveryReloadInProgress = false;
    });
  }

  function createWindow({ launchHidden = false } = {}) {
    const appEnvironment = getAppEnvironment();
    mainWindow = createAssistantWindow({
      app,
      screen,
      defaultWidth: WINDOW_DEFAULT_WIDTH,
      defaultHeight: WINDOW_DEFAULT_HEIGHT,
      minWidth: WINDOW_MIN_WIDTH,
      minHeight: WINDOW_MIN_HEIGHT,
      hideFromScreenCapture: appEnvironment.hideFromScreenCapture,
      initialOpacity: launchHidden ? getStealthWindowOpacity() : getVisibleWindowOpacity(),
      launchHidden,
      nodeEnv: appEnvironment.nodeEnv
    });

    attachWindowRecoveryHandlers();
    isVisible = !launchHidden;
    return mainWindow;
  }

  function getMainWindow() {
    return mainWindow;
  }

  function getSafeWindowBounds(nextBounds = {}) {
    const currentBounds = mainWindow ? mainWindow.getBounds() : {
      x: 0,
      y: 0,
      width: WINDOW_DEFAULT_WIDTH,
      height: WINDOW_DEFAULT_HEIGHT
    };

    const rawBounds = {
      x: Number.isFinite(nextBounds.x) ? Math.round(nextBounds.x) : currentBounds.x,
      y: Number.isFinite(nextBounds.y) ? Math.round(nextBounds.y) : currentBounds.y,
      width: Number.isFinite(nextBounds.width) ? Math.round(nextBounds.width) : currentBounds.width,
      height: Number.isFinite(nextBounds.height) ? Math.round(nextBounds.height) : currentBounds.height
    };

    const display = screen.getDisplayMatching(rawBounds);
    const workArea = display && display.workArea ? display.workArea : screen.getPrimaryDisplay().workArea;

    const width = clamp(rawBounds.width, WINDOW_MIN_WIDTH, workArea.width);
    const height = clamp(rawBounds.height, WINDOW_MIN_HEIGHT, workArea.height);
    const x = clamp(rawBounds.x, workArea.x, workArea.x + workArea.width - width);
    const y = clamp(rawBounds.y, workArea.y, workArea.y + workArea.height - height);

    return { x, y, width, height };
  }

  function setWindowBounds(nextBounds) {
    if (!mainWindow || mainWindow.isDestroyed()) {
      return { error: 'Main window not available' };
    }

    const safeBounds = getSafeWindowBounds(nextBounds);
    mainWindow.setBounds(safeBounds, false);
    return mainWindow.getBounds();
  }

  function getWindowBounds() {
    if (!mainWindow || mainWindow.isDestroyed()) {
      return { error: 'Main window not available' };
    }

    return mainWindow.getBounds();
  }

  function toggleStealthMode() {
    if (autoHideTimer) {
      clearTimeout(autoHideTimer);
      autoHideTimer = null;
    }

    if (!mainWindow || mainWindow.isDestroyed()) {
      return;
    }

    const stealthModeEnabled = isVisible;
    isVisible = !stealthModeEnabled;
    if (isVisible && !mainWindow.isVisible()) {
      mainWindow.showInactive();
    }
    applyWindowOpacity();
    sendToRenderer('set-stealth-mode', stealthModeEnabled);
  }

  function emergencyHide() {
    if (autoHideTimer) {
      clearTimeout(autoHideTimer);
      autoHideTimer = null;
    }

    if (!mainWindow || mainWindow.isDestroyed()) {
      return;
    }

    mainWindow.setOpacity(0.01);
    sendToRenderer('emergency-clear');

    autoHideTimer = setTimeout(() => {
      if (mainWindow && !mainWindow.isDestroyed()) {
        isVisible = true;
        applyWindowOpacity();
        sendToRenderer('set-stealth-mode', false);
      }
      autoHideTimer = null;
    }, 2000);
  }

  function moveToPosition(position) {
    if (!mainWindow || mainWindow.isDestroyed()) {
      return;
    }

    const { width, height } = screen.getPrimaryDisplay().workAreaSize;
    const windowBounds = mainWindow.getBounds();

    let x;
    let y;

    switch (position) {
      case 'left':
        x = 20;
        y = windowBounds.y;
        break;
      case 'right':
        x = width - windowBounds.width - 20;
        y = windowBounds.y;
        break;
      case 'top':
        x = Math.floor((width - windowBounds.width) / 2);
        y = 40;
        break;
      case 'bottom':
        x = Math.floor((width - windowBounds.width) / 2);
        y = height - windowBounds.height - 40;
        break;
      default:
        return;
    }

    mainWindow.setPosition(x, y);
  }

  function clampWindowSizePreset(preset) {
    const parsedPreset = Number.parseInt(String(preset ?? ''), 10);
    if (!Number.isFinite(parsedPreset)) {
      return 1;
    }

    return clamp(parsedPreset, 1, 4);
  }

  function getWindowSizeScaleForPreset(preset) {
    const clampedPreset = clampWindowSizePreset(preset);
    return 1 + ((clampedPreset - 1) * 0.25);
  }

  function setWindowSizePreset(preset) {
    if (!mainWindow || mainWindow.isDestroyed()) {
      return { error: 'Main window not available' };
    }

    const clampedPreset = clampWindowSizePreset(preset);
    const scale = getWindowSizeScaleForPreset(clampedPreset);
    const currentBounds = mainWindow.getBounds();

    const width = Math.round(WINDOW_MIN_WIDTH * scale);
    const height = Math.round(WINDOW_MIN_HEIGHT * scale);

    const centerX = currentBounds.x + Math.round(currentBounds.width / 2);
    const centerY = currentBounds.y + Math.round(currentBounds.height / 2);

    const nextBounds = getSafeWindowBounds({
      x: centerX - Math.round(width / 2),
      y: centerY - Math.round(height / 2),
      width,
      height
    });

    mainWindow.setBounds(nextBounds, false);
    return {
      ...mainWindow.getBounds(),
      preset: clampedPreset
    };
  }

  function registerShortcuts() {
    const registerShortcut = (shortcutId, handler) => {
      const accelerator = getKeyboardShortcutAccelerator(shortcutId);
      const isRegistered = globalShortcut.register(accelerator, handler);
      if (!isRegistered) {
        console.warn(`Failed to register shortcut "${shortcutId}" (${accelerator})`);
      }
    };

    registerShortcut('toggleStealth', () => {
      toggleStealthMode();
    });

    registerShortcut('takeScreenshot', async () => {
      if (typeof onTakeStealthScreenshot === 'function') {
        await onTakeStealthScreenshot();
      }
    });

    registerShortcut('askAi', async () => {
      if (typeof emitSttDebug === 'function') {
        emitSttDebug({
          event: 'shortcut-ask-ai',
          message: 'Global Ask AI shortcut triggered'
        });
      }
      sendToRenderer('trigger-ask-ai');
    });

    registerShortcut('emergencyHide', () => {
      emergencyHide();
    });

    registerShortcut('toggleTranscription', () => {
      if (typeof emitSttDebug === 'function') {
        emitSttDebug({
          event: 'shortcut-toggle',
          message: 'Global transcription shortcut triggered'
        });
      }
      sendToRenderer('toggle-voice-recognition');
    });

    registerShortcut('moveWindowLeft', () => {
      moveToPosition('left');
    });

    registerShortcut('moveWindowRight', () => {
      moveToPosition('right');
    });

    registerShortcut('moveWindowUp', () => {
      moveToPosition('top');
    });

    registerShortcut('moveWindowDown', () => {
      moveToPosition('bottom');
    });

    registerShortcut('windowSizePreset1', () => {
      setWindowSizePreset(1);
    });

    registerShortcut('windowSizePreset2', () => {
      setWindowSizePreset(2);
    });

    registerShortcut('windowSizePreset3', () => {
      setWindowSizePreset(3);
    });

    registerShortcut('windowSizePreset4', () => {
      setWindowSizePreset(4);
    });
  }

  function unregisterShortcuts() {
    globalShortcut.unregisterAll();
  }

  function destroyWindow() {
    if (autoHideTimer) {
      clearTimeout(autoHideTimer);
      autoHideTimer = null;
    }

    if (!mainWindow || mainWindow.isDestroyed()) {
      return;
    }

    mainWindow.setClosable(true);
    mainWindow.destroy();
    mainWindow = null;
  }

  function hasWindow() {
    return !!mainWindow && !mainWindow.isDestroyed();
  }

  function markVisible() {
    isVisible = true;
    if (mainWindow && !mainWindow.isDestroyed() && !mainWindow.isVisible()) {
      mainWindow.showInactive();
    }
    applyWindowOpacity();
  }

  return {
    applyWindowOpacity,
    clampWindowOpacityLevel,
    createWindow,
    destroyWindow,
    emergencyHide,
    getMainWindow,
    getWindowBounds,
    getWindowOpacityLevel,
    hasWindow,
    markVisible,
    registerShortcuts,
    setWindowSizePreset,
    setWindowBounds,
    setWindowOpacityLevel,
    toggleStealthMode,
    unregisterShortcuts
  };
}

module.exports = {
  createWindowController
};

================
File: src/services/ai/prompts.js
================
const {
  getProgrammingLanguages,
  resolveProgrammingLanguage
} = require('../../config');

function buildContextBlock(label, content) {
  const normalizedContent = typeof content === 'string' ? content.trim() : '';
  return normalizedContent ? `${label}:\n${normalizedContent}\n\n` : '';
}

function getCodeFenceLanguage(programmingLanguage) {
  const resolvedLanguage = resolveProgrammingLanguage(programmingLanguage);

  switch (resolvedLanguage) {
    case 'C++':
      return 'cpp';
    case 'C#':
      return 'csharp';
    case 'JavaScript':
      return 'javascript';
    case 'TypeScript':
      return 'typescript';
    default:
      return resolvedLanguage.toLowerCase();
  }
}

function buildProgrammingLanguagePreference(programmingLanguage) {
  const resolvedLanguage = resolveProgrammingLanguage(programmingLanguage);
  const configuredLanguages = getProgrammingLanguages().join(', ');

  return `
=== PROGRAMMING LANGUAGE PREFERENCE ===
- Selected default programming language: ${resolvedLanguage}
- Use ${resolvedLanguage} for code solutions and code examples unless a higher-priority signal requires another language.
- Language precedence:
  1. Explicit user request
  2. Language clearly implied by the screenshot, codebase, or platform
  3. Selected default programming language (${resolvedLanguage})
- Keep all code, libraries, syntax, idioms, and complexity discussion aligned with the final language you choose.
- Configured language options in this app: ${configuredLanguages}
`.trim();
}

function buildLanguageBestPractices(programmingLanguage) {
  const resolvedLanguage = resolveProgrammingLanguage(programmingLanguage);

  switch (resolvedLanguage) {
    case 'Python':
      return 'Use idiomatic Python, prefer standard-library data structures, import required modules, and pay attention to stdin/stdout performance when the problem is input-heavy.';
    case 'Java':
      return 'Use modern Java style, choose the right collection classes, include required imports, and use BufferedReader/StringBuilder when input or output volume is large.';
    case 'JavaScript':
      return 'Use modern JavaScript syntax, keep runtime assumptions explicit, and choose built-in structures like Map, Set, and arrays appropriately.';
    case 'TypeScript':
      return 'Use modern TypeScript with clear types, keep runtime behavior valid JavaScript, and prefer typed collections and interfaces when they improve clarity.';
    case 'C++':
      return 'Use modern C++ with STL containers and algorithms, include the necessary headers, and avoid undefined behavior or needless manual memory management.';
    case 'Go':
      return 'Use idiomatic Go, keep functions and data structures simple, handle errors when relevant, and use buffered I/O for competitive-style input.';
    case 'Rust':
      return 'Use idiomatic Rust, keep ownership and borrowing valid, prefer standard-library collections, and make the code compile cleanly without placeholder gaps.';
    case 'C#':
      return 'Use idiomatic C#, prefer generic collections and clear method structure, and include the required namespaces for compilation.';
    case 'Kotlin':
      return 'Use idiomatic Kotlin, prefer null-safe constructs and standard-library collections, and keep the solution concise but complete.';
    default:
      return 'Follow the best practices, syntax, standard library, and performance expectations of the final programming language you choose.';
  }
}

// ─── ASK AI ──────────────────────────────────────────────────────────────────
// Uses transcript, screenshots, and chat history together.
// Goal: understand the full context across multiple messages and screenshots,
// correct for STT noise, identify what is actually being asked, and answer it.
function buildAskAiSessionPrompt({
  contextString = '',
  transcriptContext = '',
  sessionSummary = '',
  screenshotCount = 0,
  programmingLanguage
} = {}) {
  const resolvedLanguage = resolveProgrammingLanguage(programmingLanguage);
  const codeFenceLanguage = getCodeFenceLanguage(resolvedLanguage);

  return `
You are Invisibrain, an expert AI assistant for technical interviews, coding sessions, meetings, and problem-solving.

${buildProgrammingLanguagePreference(resolvedLanguage)}

=== WHAT YOU HAVE ===
- Transcript: live speech-to-text capture of the conversation (may contain recognition errors)
- Screenshots attached: ${screenshotCount}
- Conversation history: ${contextString ? 'yes' : 'none'}
${sessionSummary ? '- Session summary: available' : ''}

=== STEP 1 — SYNTHESIZE ALL CONTEXT ===
Read every input source together before forming a response:
1. Treat ALL transcript messages as a single conversation thread — not isolated messages. Piece together what is being asked across the full thread.
2. If screenshots are attached, treat them as the primary visual context. They show exactly what the user is looking at.
3. Use conversation history to understand prior exchanges and avoid repeating what was already answered.
4. Use the session summary (if available) to fill in context gaps.

=== STEP 2 — CORRECT FOR STT ERRORS AND IDENTIFY THE REAL QUESTION ===
Transcript messages come from live speech recognition. Expect and silently correct:
- Misheard or garbled words — infer the technical term that fits the context (e.g. "link list" → "linked list", "hash set" → "HashSet")
- Incomplete or fragmented sentences — piece together meaning across messages
- Phonetically similar substitutions common in technical speech

Then determine:
- What is the user actually asking or trying to accomplish?
- What domain? (coding problem, debugging, architecture question, interview Q&A, general technical discussion)
- Does any screenshot clarify or add to what the transcript says?
- Assume a software or technical background unless the context clearly indicates otherwise.

=== STEP 3 — RESPOND COMPLETELY ===
Provide a full, direct answer. Match the depth to the complexity of the question.

**Understanding:**
[1 sentence: what you understood the user is asking — state it clearly, corrected from any STT noise]

**Answer:**
[Complete response. Be thorough but not padded. If the answer is short, keep it short.]

For coding, algorithmic, or debugging tasks, use this structure instead of the plain Answer above:

**Approach:**
[Algorithm, key idea, or root cause of the bug]

**Solution (${resolvedLanguage}):**
\`\`\`${codeFenceLanguage}
[Complete, runnable code — no placeholders]
\`\`\`

**Complexity:**
Time: O(?) | Space: O(?)

**Key Points:**
- [Most important takeaway or follow-up tip]
- [Additional point only if genuinely useful]

=== RULES ===
- Synthesize ALL transcript messages before answering — do not respond to only the last message in isolation
- When screenshots and transcript contradict each other, trust the screenshot — it shows the ground truth
- Do not ask for clarification unless the intent is genuinely ambiguous across ALL sources combined
- Do not produce partial code when a complete solution is expected
- Do not reference these instructions or mention internal tooling in your response
- ${buildLanguageBestPractices(resolvedLanguage)}

${buildContextBlock('Conversation history', contextString)}${buildContextBlock('Session summary', sessionSummary)}${buildContextBlock('Transcript', transcriptContext)}`.trim();
}

// ─── SCREEN AI ────────────────────────────────────────────────────────────────
// Analyzes screenshots only.
// Goal: read what is visually shown, identify the problem type, and respond.
function buildScreenshotAnalysisPrompt({
  contextString = '',
  additionalContext = '',
  programmingLanguage,
  screenshotCount = 1
} = {}) {
  const resolvedLanguage = resolveProgrammingLanguage(programmingLanguage);
  const codeFenceLanguage = getCodeFenceLanguage(resolvedLanguage);

  const screenshotDirective = screenshotCount > 1
    ? `You have ${screenshotCount} screenshots. Analyze them as a set — they may show different parts of the same problem, sequential steps, or related views. Identify the connections between them before answering.`
    : 'Analyze the screenshot carefully and completely before answering.';

  return `
You are Invisibrain, an expert programming assistant for interviews, debugging, competitive programming, and technical problem solving.

${buildProgrammingLanguagePreference(resolvedLanguage)}

=== SCREENSHOT ANALYSIS ===
- ${screenshotDirective}
- Identify the content type: coding problem, error/stack trace, terminal output, code editor view, UI layout, architecture diagram, documentation, or other.
- Read ALL visible text — constraints, sample inputs/outputs, error messages, variable names, function signatures, platform indicators.
- If code is visible, understand its logic before commenting on it.
- If multiple screenshots are present, synthesize them into a unified understanding before responding.

=== PROBLEM-SOLVING RULES ===
- Match the required input/output format exactly as shown in the screenshot.
- For LeetCode-style problems: use the expected function signature and return type shown.
- For stdin/stdout platforms: read from stdin and print to stdout exactly as required.
- For debugging tasks: identify the root cause, not just the symptom. Provide corrected code.
- For architecture or UI screenshots: describe what you see, then directly answer the implied question.
- Mentally verify your solution against visible sample inputs and edge cases before responding.
- State time and space complexity for all algorithmic solutions.
- Prefer the simplest correct solution that satisfies the visible constraints.
- ${buildLanguageBestPractices(resolvedLanguage)}

=== RESPONSE FORMAT ===
For coding, algorithmic, or debugging tasks:

**Understanding:**
[What the screenshot shows and what is being asked]

**Approach:**
[Key algorithm, pattern, or fix]

**Complexity:**
Time: O(?) | Space: O(?)

**Solution (${resolvedLanguage}):**
\`\`\`${codeFenceLanguage}
[Complete, runnable code — no placeholders or stubs]
\`\`\`

**Explanation:**
[Include only when it adds meaningful value beyond what the code already communicates]

For non-coding screenshots (UI, architecture, documentation, general technical):

**What I see:**
[Brief, accurate description of the screenshot content]

**Answer:**
[Direct response to the question implied by the screenshot]

**Key Points:**
- [Point 1]
- [Point 2]

=== FINAL CHECK BEFORE RESPONDING ===
- Verify all syntax, imports, and platform-specific I/O conventions are correct.
- Confirm the language choice follows the precedence rules above.
- Do not produce partial code when a complete solution is expected.
- If you switch away from ${resolvedLanguage}, explicitly state the language used and why.

${buildContextBlock('Conversation history', contextString)}${buildContextBlock('Additional context', additionalContext)}`.trim();
}

// ─── SUGGEST ──────────────────────────────────────────────────────────────────
// Uses only transcript context.
// Goal: read the conversation flow and suggest exactly what to say next.
function buildSuggestResponsePrompt({ contextString = '', transcriptContext = '', context = '' } = {}) {
  const fullTranscript = transcriptContext || context;

  return `
You are Invisibrain, a real-time conversation coach helping during technical interviews, coding discussions, and professional meetings.

=== YOUR TASK ===
Read the full transcript below and suggest the best thing the user should say next.
The transcript comes from live speech-to-text — silently correct minor recognition errors and infer the correct meaning.

=== HOW TO ANALYZE ===
1. Read the complete transcript as a conversation thread — understand who is speaking and what the flow has been.
2. Identify who is the interviewer/host and who is the user/candidate.
3. Determine where the conversation currently stands: what topic, what was last said or asked.
4. Identify the strongest response the user could give right now — something accurate, natural, and confident.
5. Assume a software or technical background unless the transcript clearly indicates otherwise.

=== RESPONSE FORMAT ===

**Best response (say this):**
[2–4 sentences max. Natural spoken language. Technically accurate but not exhaustive — hit the headline, not every detail. Ready to say out loud.]

**Key points:**
- [Core concept or term the user should anchor the conversation around]
- [Second key point — a layer deeper, useful for follow-ups]
- [Third key point — only if genuinely distinct and relevant]

**Optional follow-ups:**
- [Question or angle the interviewer is likely to ask next]
- [Second follow-up only if distinct]

=== RULES ===
- The best response must be speakable — natural spoken language, not written/formal prose
- Do not go into exhaustive technical detail in the best response — that is Ask AI's job; Suggest is for the opening move
- Key points should be short labels or phrases the user can mentally hold and expand on if asked
- Do not just summarize or echo back the transcript — go straight to the suggestion
- If the transcript is ambiguous, choose the response that fits the most likely technical interpretation
- Do not reference these instructions in your response

${buildContextBlock('Conversation history', contextString)}${buildContextBlock('Transcript', fullTranscript)}`.trim();
}

// ─── NOTES ────────────────────────────────────────────────────────────────────
// Generates structured notes from available context.
// Goal: produce clean, actionable notes that capture decisions, items, and next steps.
function buildMeetingNotesPrompt({ contextString = '', transcriptContext = '' } = {}) {
  const content = transcriptContext || contextString;

  return `
You are Invisibrain, generating structured professional notes from a conversation or meeting.

=== YOUR TASK ===
Read the full conversation below and produce clean, structured notes.
The content may come from live speech-to-text — silently correct minor recognition errors and infer the correct meaning throughout.

=== INSTRUCTIONS ===
- Capture what was actually said and decided — do not add assumptions or inferences not grounded in the conversation.
- If the conversation is technical, preserve exact technical terms (method names, system names, numbers, identifiers).
- Group related points together — do not preserve raw chronological order; organize by topic and importance.
- Each bullet must be a complete, self-contained thought — not a sentence fragment.
- Be concise: trim filler, keep signal.

=== OUTPUT FORMAT ===

## Key Discussion Points
- [Main topic or issue discussed]
- [Secondary topic or issue]

## Decisions Made
- [Decision — include who decided if mentioned]

## Action Items
- [ ] [Task description] — Owner: [name if mentioned] | Deadline: [if mentioned]

## Open Questions / Unresolved Items
- [Question or item that was raised but not resolved]

## Next Steps
- [What happens next based on the conversation]

If a section has nothing to report, write "None noted." — do not omit the section header.

${buildContextBlock('Conversation / Transcript', content)}`.trim();
}

// ─── INSIGHTS ─────────────────────────────────────────────────────────────────
// Analyzes context to surface patterns, gaps, and recommendations.
function buildInsightsPrompt({ contextString = '', transcriptContext = '' } = {}) {
  const content = transcriptContext || contextString;

  return `
You are Invisibrain, analyzing a conversation to extract actionable insights.

=== YOUR TASK ===
Read the conversation below and provide a sharp, useful analysis.
Focus on patterns, gaps, and opportunities — not a summary of what was said.
The content may come from live speech-to-text — silently correct minor recognition errors throughout.

=== OUTPUT FORMAT ===

## Key Themes
- [Main recurring topic, concern, or focus area]
- [Secondary theme, if present]

## Technical Patterns Observed
- [Code quality signal, architectural choice, or technical behavior noted]
- [Performance, security, scalability, or design observation — only if present in the conversation]

## Strengths
- [What was handled well or demonstrated competence]

## Gaps & Risks
- [What was unclear, missing, incorrect, or potentially problematic]

## Recommendations
- [Specific, actionable suggestion based on what was observed]
- [Second recommendation — only if distinct and warranted]

Keep every bullet concrete and specific. Avoid vague observations like "communication could be improved" — say what specifically should improve and how.
If a section genuinely has nothing to report, write "None identified." — do not omit the section header.

${buildContextBlock('Conversation / Transcript', content)}`.trim();
}

// ─── LEGACY / UTILITY ─────────────────────────────────────────────────────────

function buildFollowUpEmailPrompt({ contextString = '' } = {}) {
  return `
Generate a professional follow-up email based on this conversation:

${contextString}

Include:
- Brief summary
- Key points discussed
- Action items
- Professional closing
`.trim();
}

function buildAnswerQuestionPrompt({
  contextString = '',
  question = '',
  programmingLanguage
} = {}) {
  const resolvedLanguage = resolveProgrammingLanguage(programmingLanguage);
  const codeFenceLanguage = getCodeFenceLanguage(resolvedLanguage);

  return `
You are Invisibrain, an expert technical assistant.

${buildProgrammingLanguagePreference(resolvedLanguage)}

${buildContextBlock('Previous conversation', contextString)}Question: ${question}

Provide a clear, concise answer. If code is useful, default to ${resolvedLanguage} unless the question explicitly requires another language.

Example code format when needed:
\`\`\`${codeFenceLanguage}
[Code example]
\`\`\`
`.trim();
}

module.exports = {
  buildAnswerQuestionPrompt,
  buildFollowUpEmailPrompt,
  buildInsightsPrompt,
  buildMeetingNotesPrompt,
  buildAskAiSessionPrompt,
  buildScreenshotAnalysisPrompt,
  buildSuggestResponsePrompt
};

================
File: src/windows/assistant/preload.js
================
const { contextBridge, ipcRenderer } = require('electron');
const { createElectronApi } = require('./preload/create-electron-api');

console.log('Preload script loading...');

try {
  contextBridge.exposeInMainWorld('electronAPI', createElectronApi(ipcRenderer));
  console.log('PreloadAPI: electronAPI exposed successfully');
} catch (error) {
  console.error('PreloadAPI: Failed to expose electronAPI:', error);
}

process.on('uncaughtException', (error) => {
  console.error('PreloadAPI: Uncaught exception:', error);
});

process.on('unhandledRejection', (reason, promise) => {
  console.error('PreloadAPI: Unhandled rejection at:', promise, 'reason:', reason);
});

console.log('PreloadAPI: Preload script loaded successfully');

================
File: src/windows/assistant/renderer/features/chat/chat-ui-manager.js
================
export function createChatUiManager({
    chatContainer,
    chatMessagesElement,
    chatComposer,
    chatManualInput,
    chatManualSend,
    messageStore,
    maxChatInputHeight,
    escapeHtml,
    updateUi,
    onMessagesChanged,
    showFeedback,
    addMonitorLog
}) {
    function formatResponse(text) {
        return String(text || '')
            .replace(/```(\w+)?\n([\s\S]*?)```/g, '<pre><code>$2</code></pre>')
            .replace(/\*\*(.*?)\*\*/g, '<strong>$1</strong>')
            .replace(/\*(.*?)\*/g, '<em>$1</em>')
            .replace(/\n/g, '<br>');
    }

    function isChatNearBottom(threshold = 28) {
        if (!chatMessagesElement) {
            return true;
        }

        const distanceFromBottom =
            chatMessagesElement.scrollHeight - chatMessagesElement.clientHeight - chatMessagesElement.scrollTop;
        return distanceFromBottom <= threshold;
    }

    function addChatMessage(type, content, options = {}) {
        if (!chatMessagesElement) {
            return null;
        }

        const shouldAutoScroll = isChatNearBottom();

        const timestampDate = new Date();
        const record = messageStore.add(type, content, {
            id: options.id,
            timestamp: timestampDate,
            canToggleAi: options.canToggleAi,
            includeInAi: options.includeInAi,
            screenshotId: options.screenshotId
        });

        const messageDiv = document.createElement('div');
        messageDiv.className = `chat-message ${type}-message`;
        messageDiv.dataset.messageId = record.id;
        if (record.canToggleAi) {
            messageDiv.classList.add('ai-toggleable');
            messageDiv.classList.add(record.includeInAi ? 'ai-included' : 'ai-excluded');
        }

        const timestamp = timestampDate.toLocaleTimeString('en-US', {
            hour: '2-digit',
            minute: '2-digit'
        });

        let icon = '\u2139\uFE0F';
        let label = '';
        let contentClass = 'message-content';
        let safeContent = escapeHtml(content);

        switch (type) {
            case 'voice':
            case 'voice-mic':
                icon = '\u{1F3A4}';
                label = 'You';
                break;

            case 'voice-system':
                icon = '\u{1F50A}';
                label = 'Host';
                break;

            case 'screenshot':
                icon = '\u{1F4F8}';
                break;

            case 'ai-response':
                icon = '\u{1F916}';
                contentClass = 'message-content ai-response';
                safeContent = formatResponse(content);
                break;

            case 'system':
                icon = '\u2139\uFE0F';
                contentClass = 'message-content system-message';
                break;
        }

        const labelHtml = label ? `<span class="message-label">${label}</span>` : '';
        const toggleHtml = record.canToggleAi
            ? `<button class="ai-include-toggle ${record.includeInAi ? 'included' : 'excluded'}" data-message-id="${record.id}" type="button" aria-label="Toggle AI context" aria-pressed="${record.includeInAi ? 'true' : 'false'}">${record.includeInAi ? '-' : '+'}</button>`
            : '';
        const copyHtml = `<button class="message-copy-btn" data-message-id="${record.id}" type="button" aria-label="Copy message"><svg width="11" height="11" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true"><path d="M16 1H4c-1.1 0-2 .9-2 2v14h2V3h12V1zm3 4H8c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h11c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2zm0 16H8V7h11v14z"/></svg></button>`;
        const messageActionsHtml = `<span class="message-actions">${toggleHtml}${copyHtml}</span>`;
        const exclusionHtml = record.canToggleAi
            ? '<div class="ai-excluded-note">Excluded from AI context</div>'
            : '';

        const messageContent = `
        <div class="message-header">
            <span class="message-icon">${icon}</span>
            ${labelHtml}
            ${messageActionsHtml}
            <span class="message-time">${timestamp}</span>
        </div>
        <div class="${contentClass}">${exclusionHtml}${safeContent}</div>
    `;

        messageDiv.innerHTML = messageContent;
        chatMessagesElement.appendChild(messageDiv);

        if (shouldAutoScroll) {
            chatMessagesElement.scrollTop = chatMessagesElement.scrollHeight;
        }

        onMessagesChanged?.(messageStore.getMessages());
        updateUi?.();

        return record;
    }

    function updateChatComposerHeight() {
        if (!chatContainer || !chatComposer) {
            return;
        }

        // Remove the variable first so the min-height constraint is cleared,
        // allowing getBoundingClientRect to return the natural content height
        // instead of being held at the previous (potentially stale) large value.
        chatContainer.style.removeProperty('--chat-composer-height');
        const composerHeight = Math.max(0, Math.round(chatComposer.getBoundingClientRect().height));
        if (composerHeight > 0) {
            chatContainer.style.setProperty('--chat-composer-height', `${composerHeight}px`);
        }
    }

    function autoResizeManualInput() {
        if (!chatManualInput) {
            return;
        }

        chatManualInput.style.height = 'auto';
        const nextHeight = Math.min(chatManualInput.scrollHeight, maxChatInputHeight);
        chatManualInput.style.height = `${Math.max(24, nextHeight)}px`;
        chatManualInput.style.overflowY = chatManualInput.scrollHeight > maxChatInputHeight ? 'auto' : 'hidden';
        updateChatComposerHeight();
    }

    function updateManualComposerState() {
        if (!chatManualInput || !chatManualSend) {
            return;
        }

        chatManualSend.disabled = String(chatManualInput.value || '').trim().length === 0;
    }

    function updateChatMessageContent(messageId, newContent) {
        const record = messageStore.findById(messageId);
        if (record) {
            record.content = newContent;
        }

        if (!chatMessagesElement) return;

        const messageEl = chatMessagesElement.querySelector(`[data-message-id="${messageId}"]`);
        if (!messageEl) return;

        const contentEl = messageEl.querySelector('.message-content');
        if (!contentEl) return;

        const shouldAutoScroll = isChatNearBottom();
        contentEl.innerHTML = formatResponse(newContent);

        if (shouldAutoScroll) {
            chatMessagesElement.scrollTop = chatMessagesElement.scrollHeight;
        }
    }

    function submitManualContextMessage() {
        if (!chatManualInput) {
            return;
        }

        const text = String(chatManualInput.value || '').trim();
        if (!text) {
            showFeedback?.('Type a message first', 'error');
            return;
        }

        addChatMessage('voice-mic', text);
        addMonitorLog?.('info', 'manual-context-added', 'Manual context message added', 'mic', {
            chars: text.length
        });
        showFeedback?.('Manual context added', 'success');

        chatManualInput.value = '';
        autoResizeManualInput();
        updateManualComposerState();
        chatManualInput.focus();
    }

    return {
        addChatMessage,
        updateChatMessageContent,
        autoResizeManualInput,
        submitManualContextMessage,
        updateManualComposerState
    };
}

================
File: .env.example
================
# API keys are managed in the in-app Settings UI and stored in app state.
# Do not place API keys in this file.

# Optional capture behavior
# true = hide this app from screen sharing/screen capture
# false = allow this app to appear in screen sharing/screen capture
HIDE_FROM_SCREEN_CAPTURE=true

# Optional startup mode
# true = start in background mode (window hidden at launch)
# false = show window on startup
START_HIDDEN=false

# Optional screenshot settings
MAX_SCREENSHOTS=50
SCREENSHOT_DELAY=1000

# Optional runtime settings
NODE_ENV=production
NODE_OPTIONS=--max-old-space-size=4096

================
File: src/main-process/features/settings/ipc.js
================
function registerSettingsIpc({
  ipcMain,
  app,
  getAppEnvironment,
  setAppEnvironment,
  getAppState,
  setAppState,
  getAppStatePath,
  saveApplicationEnvironment,
  saveAppState,
  geminiRuntime,
  windowController,
  getAssemblyAiSpeechModel,
  setAssemblyAiSpeechModel,
  keyboardShortcuts,
  assemblyAiSpeechModels,
  defaultAssemblyAiSpeechModel
}) {
  ipcMain.handle('get-settings', () => {
    const appEnvironment = getAppEnvironment();
    const appState = getAppState();
    const geminiApiKey = typeof appState?.geminiApiKey === 'string' ? appState.geminiApiKey : '';
    const assemblyAiApiKey = typeof appState?.assemblyAiApiKey === 'string' ? appState.assemblyAiApiKey : '';

    return {
      geminiApiKey,
      assemblyAiApiKey,
      hasGeminiApiKeys: geminiApiKey.split(',').map((value) => value.trim()).filter(Boolean).length > 0,
      hasAssemblyAiApiKey: assemblyAiApiKey.length > 0,
      geminiModel: geminiRuntime.getActiveGeminiModel(),
      geminiModels: geminiRuntime.getGeminiModels(),
      defaultGeminiModel: geminiRuntime.getDefaultGeminiModel(),
      programmingLanguage: geminiRuntime.getActiveProgrammingLanguage(),
      programmingLanguages: geminiRuntime.getProgrammingLanguages(),
      defaultProgrammingLanguage: geminiRuntime.getDefaultProgrammingLanguage(),
      assemblyAiSpeechModels,
      defaultAssemblyAiSpeechModel,
      assemblyAiSpeechModel: getAssemblyAiSpeechModel(),
      keyboardShortcuts,
      hideFromScreenCapture: appEnvironment.hideFromScreenCapture,
      startHidden: appEnvironment.startHidden,
      windowOpacityLevel: windowController.getWindowOpacityLevel(),
      themePreference: appState?.themePreference === 'dark' || appState?.themePreference === 'light'
        ? appState.themePreference
        : null
    };
  });

  ipcMain.handle('set-theme-preference', (_event, payload = {}) => {
    try {
      const requestedTheme = typeof payload === 'string'
        ? payload
        : payload?.theme;
      const normalizedTheme = String(requestedTheme || '').trim().toLowerCase();
      const themePreference = normalizedTheme === 'dark' ? 'dark' : 'light';

      const updatedAppState = saveAppState(app, { themePreference });
      setAppState(updatedAppState);

      return { success: true, themePreference };
    } catch (error) {
      console.error('Error saving theme preference:', error);
      return { success: false, error: error.message };
    }
  });

  ipcMain.handle('save-settings', async (_event, settings = {}) => {
    console.log('IPC: save-settings called');

    try {
      const appEnvironment = getAppEnvironment();
      const nextGeminiApiKey = String(settings.geminiApiKey || '').trim();
      const nextAssemblyAiApiKey = String(settings.assemblyAiApiKey || '').trim();
      const nextGeminiModel = geminiRuntime.setActiveGeminiModel(settings.geminiModel);
      const nextAssemblyModel = setAssemblyAiSpeechModel(settings.assemblyAiSpeechModel);
      const nextProgrammingLanguage = geminiRuntime.setActiveProgrammingLanguage(settings.programmingLanguage);
      const nextWindowOpacityLevel = windowController.setWindowOpacityLevel(settings.windowOpacityLevel);

      const updatedEnvironment = saveApplicationEnvironment(app, {
        hideFromScreenCapture: appEnvironment.hideFromScreenCapture,
        startHidden: appEnvironment.startHidden,
        maxScreenshots: appEnvironment.maxScreenshots,
        screenshotDelay: appEnvironment.screenshotDelay,
        nodeEnv: appEnvironment.nodeEnv,
        nodeOptions: appEnvironment.nodeOptions
      });

      const keyState = geminiRuntime.setKeys(nextGeminiApiKey, 0);
      const updatedAppState = saveAppState(app, {
        geminiApiKey: nextGeminiApiKey,
        assemblyAiApiKey: nextAssemblyAiApiKey,
        geminiApiKeyIndex: keyState.activeApiKeyIndex,
        geminiModel: nextGeminiModel,
        assemblyAiSpeechModel: nextAssemblyModel,
        programmingLanguage: nextProgrammingLanguage,
        windowOpacityLevel: nextWindowOpacityLevel
      });

      setAppEnvironment(updatedEnvironment);
      setAppState(updatedAppState);

      console.log('Saved app state to:', getAppStatePath(app));
      console.log('Settings saved to:', updatedEnvironment.envPath);
      console.log('Applied programming language:', nextProgrammingLanguage);
      console.log(`Applied window opacity level: ${nextWindowOpacityLevel}/10`);
      console.log(`Applied Gemini API key index: ${keyState.activeApiKeyIndex + 1}/${keyState.geminiApiKeys.length}`);

      geminiRuntime.initializeGeminiService(
        keyState.activeApiKey,
        nextGeminiModel,
        nextProgrammingLanguage
      );

      return { success: true };
    } catch (error) {
      console.error('Error saving settings:', error);
      return { success: false, error: error.message };
    }
  });
}

module.exports = {
  registerSettingsIpc
};

================
File: src/main-process/start-application.js
================
const {
  app,
  dialog,
  desktopCapturer,
  globalShortcut,
  ipcMain,
  screen
} = require('electron');
const WebSocket = require('ws');

const {
  loadApplicationEnvironment,
  normalizeGeminiApiKeys,
  saveApplicationEnvironment
} = require('../bootstrap/environment');
const {
  getAssemblyAiSpeechModels,
  getDefaultAssemblyAiSpeechModel,
  getKeyboardShortcuts,
  resolveAssemblyAiSpeechModel
} = require('../config');
const {
  getAppStatePath,
  loadAppState,
  saveAppState
} = require('../services/state/app-state');
const { createAssistantWindow } = require('../windows/assistant/window');
const { createSafeSender } = require('./shared/safe-send');
const { createGeminiRuntime } = require('./features/assistant/gemini-runtime');
const { createScreenshotManager } = require('./features/assistant/screenshot-manager');
const { registerAssistantIpc } = require('./features/assistant/ipc');
const { createAssemblyAiService } = require('../services/assembly-ai/service');
const { registerAssemblyAiIpc } = require('../services/assembly-ai/ipc');
const { registerSettingsIpc } = require('./features/settings/ipc');
const { createWindowController } = require('./features/window/window-controller');
const { DEFAULT_WINDOW_OPACITY_LEVEL } = require('./features/window/window-constants');
const { logStartupConfiguration } = require('./startup-logging');

function resolveStartupOptions(argv = process.argv) {
  const normalizedArgs = Array.isArray(argv)
    ? argv.map((value) => String(value || '').trim().toLowerCase())
    : [];

  const hasFlag = (flag) => normalizedArgs.includes(flag);

  return {
    startHidden: hasFlag('--start-hidden') || hasFlag('--background')
  };
}

async function startApplication() {
  let appEnvironment = null;
  let appState = null;
  let isShuttingDown = false;
  const startupOptions = resolveStartupOptions();

  const geminiRuntime = createGeminiRuntime();

  const assemblyAiSpeechModels = getAssemblyAiSpeechModels();
  const defaultAssemblyAiSpeechModel = getDefaultAssemblyAiSpeechModel();
  const keyboardShortcuts = getKeyboardShortcuts();
  let activeAssemblyAiSpeechModel = defaultAssemblyAiSpeechModel;

  let screenshotManager = null;
  let windowController = null;

  const sendToRenderer = createSafeSender(() => {
    if (!windowController) {
      return null;
    }

    return windowController.getMainWindow();
  });

  const assemblyAiService = createAssemblyAiService({
    WebSocket,
    desktopCapturer,
    getAssemblyApiKey: () => appState?.assemblyAiApiKey || '',
    getSpeechModel: () => activeAssemblyAiSpeechModel,
    getGeminiService: () => geminiRuntime.getService(),
    sendToRenderer
  });

  windowController = createWindowController({
    app,
    screen,
    globalShortcut,
    createAssistantWindow,
    getAppEnvironment: () => appEnvironment,
    emitSttDebug: assemblyAiService.emitSttDebug,
    sendToRenderer,
    onTakeStealthScreenshot: async () => {
      if (screenshotManager) {
        await screenshotManager.takeStealthScreenshot();
      }
    }
  });

  screenshotManager = createScreenshotManager({
    app,
    getMainWindow: () => windowController.getMainWindow(),
    getAppEnvironment: () => appEnvironment,
    sendToRenderer
  });

  function loadPersistedAppState() {
    appState = loadAppState(app);

    const keyState = geminiRuntime.setKeys(
      normalizeGeminiApiKeys(appState?.geminiApiKey),
      appState.geminiApiKeyIndex
    );
    const activeGeminiModel = geminiRuntime.setActiveGeminiModel(appState.geminiModel);
    activeAssemblyAiSpeechModel = resolveAssemblyAiSpeechModel(appState.assemblyAiSpeechModel);
    const activeProgrammingLanguage = geminiRuntime.setActiveProgrammingLanguage(appState.programmingLanguage);
    const activeWindowOpacityLevel = windowController.setWindowOpacityLevel(appState.windowOpacityLevel);

    if (
      appState.geminiApiKeyIndex !== keyState.activeApiKeyIndex ||
      appState.geminiModel !== activeGeminiModel ||
      appState.assemblyAiSpeechModel !== activeAssemblyAiSpeechModel ||
      appState.programmingLanguage !== activeProgrammingLanguage ||
      appState.windowOpacityLevel !== activeWindowOpacityLevel
    ) {
      appState = saveAppState(app, {
        geminiApiKeyIndex: keyState.activeApiKeyIndex,
        geminiModel: activeGeminiModel,
        assemblyAiSpeechModel: activeAssemblyAiSpeechModel,
        programmingLanguage: activeProgrammingLanguage,
        windowOpacityLevel: activeWindowOpacityLevel
      });
    }

    console.log('Loaded app state from:', getAppStatePath(app));
    console.log(`Restored Gemini API key index from app state: ${keyState.activeApiKeyIndex + 1}/${keyState.geminiApiKeys.length}`);
    console.log('Restored Gemini model from app state:', activeGeminiModel);
    console.log('Restored AssemblyAI speech model from app state:', activeAssemblyAiSpeechModel);
    console.log('Restored programming language from app state:', activeProgrammingLanguage);
    console.log(`Restored window opacity level from app state: ${activeWindowOpacityLevel}/10`);
  }

  function cleanupTransientResources() {
    assemblyAiService.dispose();
    screenshotManager.cleanupTransientResources();
    windowController.unregisterShortcuts();
  }

  function quitApplication() {
    if (isShuttingDown) {
      return;
    }

    isShuttingDown = true;

    cleanupTransientResources();
    windowController.destroyWindow();

    setTimeout(() => {
      app.exit(0);
    }, 50);
  }

  registerAssistantIpc({
    ipcMain,
    screenshotManager,
    windowController,
    geminiRuntime,
    assemblyAiService,
    sendToRenderer,
    quitApplication
  });

  registerAssemblyAiIpc({
    ipcMain,
    assemblyAiService
  });

  registerSettingsIpc({
    ipcMain,
    app,
    getAppEnvironment: () => appEnvironment,
    setAppEnvironment: (nextEnvironment) => {
      appEnvironment = nextEnvironment;
    },
    getAppState: () => appState,
    setAppState: (nextAppState) => {
      appState = nextAppState;
    },
    getAppStatePath,
    saveApplicationEnvironment,
    saveAppState,
    geminiRuntime,
    windowController,
    getAssemblyAiSpeechModel: () => activeAssemblyAiSpeechModel,
    setAssemblyAiSpeechModel: (nextModel) => {
      activeAssemblyAiSpeechModel = resolveAssemblyAiSpeechModel(nextModel, activeAssemblyAiSpeechModel);
      return activeAssemblyAiSpeechModel;
    },
    keyboardShortcuts,
    assemblyAiSpeechModels,
    defaultAssemblyAiSpeechModel
  });

  app.whenReady().then(() => {
    try {
      appEnvironment = loadApplicationEnvironment(app);
    } catch (error) {
      console.error('Failed to load application environment:', error);
      dialog.showErrorBox('Open-Cluely Configuration Error', error.message);
      app.exit(1);
      return;
    }

    loadPersistedAppState();

    logStartupConfiguration({
      appEnvironment,
      appState,
      geminiModels: geminiRuntime.getGeminiModels(),
      defaultGeminiModel: geminiRuntime.getDefaultGeminiModel(),
      assemblyAiSpeechModels,
      defaultAssemblyAiSpeechModel,
      programmingLanguages: geminiRuntime.getProgrammingLanguages(),
      defaultProgrammingLanguage: geminiRuntime.getDefaultProgrammingLanguage()
    });

    geminiRuntime.setActiveKeyIndexChangeHandler((nextIndex) => {
      if (!appState || appState.geminiApiKeyIndex === nextIndex) {
        return;
      }

      appState = saveAppState(app, { geminiApiKeyIndex: nextIndex });
      console.log(`Persisted Gemini API key index: ${nextIndex + 1}/${geminiRuntime.getApiKeys().length}`);
    });

    geminiRuntime.initializeGeminiService(
      geminiRuntime.getActiveApiKey(),
      geminiRuntime.getActiveGeminiModel(),
      geminiRuntime.getActiveProgrammingLanguage()
    );

    app.commandLine.appendSwitch('enable-features', 'VaapiVideoDecoder');
    app.commandLine.appendSwitch('ignore-certificate-errors');
    app.commandLine.appendSwitch('allow-running-insecure-content');
    app.commandLine.appendSwitch('disable-web-security');
    app.commandLine.appendSwitch('enable-media-stream');

    const launchHidden = startupOptions.startHidden || appEnvironment.startHidden;
    console.log('App is ready, creating window...');
    console.log(`Startup mode: ${launchHidden ? 'hidden' : 'visible'}`);
    windowController.createWindow({ launchHidden });
    windowController.registerShortcuts();

    if (!launchHidden) {
      windowController.markVisible();
    }

    if (appState?.windowOpacityLevel == null) {
      windowController.setWindowOpacityLevel(DEFAULT_WINDOW_OPACITY_LEVEL);
    }

    console.log(`Window setup complete (${launchHidden ? 'hidden launch' : 'visible launch'})`);
  });

  app.on('window-all-closed', () => {
    // Keep running in background for stealth operation
  });

  app.on('activate', () => {
    if (!windowController.hasWindow()) {
      windowController.createWindow();
      windowController.markVisible();
    }
  });

  app.on('will-quit', () => {
    cleanupTransientResources();
  });

  app.on('web-contents-created', (_event, contents) => {
    contents.on('new-window', (event) => {
      event.preventDefault();
    });

    contents.on('will-navigate', (event, navigationUrl) => {
      const mainWindow = windowController.getMainWindow();
      if (!mainWindow || mainWindow.isDestroyed()) {
        return;
      }

      if (navigationUrl !== mainWindow.webContents.getURL()) {
        event.preventDefault();
      }
    });
  });

  process.title = 'SystemIdleProcess';
}

module.exports = {
  startApplication
};

================
File: src/services/state/app-state.js
================
const fs = require('fs');
const path = require('path');

const APP_STATE_DIR_NAME = 'cache';
const APP_STATE_FILE_NAME = 'app-state.json';

function getDefaultAppState() {
  return {
    geminiApiKey: null,
    assemblyAiApiKey: null,
    geminiApiKeyIndex: 0,
    geminiModel: null,
    assemblyAiSpeechModel: null,
    programmingLanguage: null,
    windowOpacityLevel: 10,
    themePreference: null
  };
}

function sanitizeAppState(state) {
  const nextState = getDefaultAppState();

  if (state && typeof state === 'object' && !Array.isArray(state)) {
    if (typeof state.geminiApiKey === 'string') {
      const geminiApiKey = state.geminiApiKey.trim();
      nextState.geminiApiKey = geminiApiKey || null;
    }

    if (typeof state.assemblyAiApiKey === 'string') {
      const assemblyAiApiKey = state.assemblyAiApiKey.trim();
      nextState.assemblyAiApiKey = assemblyAiApiKey || null;
    }

    const geminiApiKeyIndex = Number.parseInt(String(state.geminiApiKeyIndex ?? ''), 10);
    if (Number.isFinite(geminiApiKeyIndex) && geminiApiKeyIndex >= 0) {
      nextState.geminiApiKeyIndex = geminiApiKeyIndex;
    }

    if (typeof state.geminiModel === 'string' && state.geminiModel.trim()) {
      nextState.geminiModel = state.geminiModel.trim();
    }

    if (typeof state.assemblyAiSpeechModel === 'string' && state.assemblyAiSpeechModel.trim()) {
      nextState.assemblyAiSpeechModel = state.assemblyAiSpeechModel.trim();
    }

    if (typeof state.programmingLanguage === 'string' && state.programmingLanguage.trim()) {
      nextState.programmingLanguage = state.programmingLanguage.trim();
    }

    const windowOpacityLevel = Number.parseInt(String(state.windowOpacityLevel ?? ''), 10);
    if (Number.isFinite(windowOpacityLevel)) {
      nextState.windowOpacityLevel = Math.min(Math.max(windowOpacityLevel, 1), 10);
    }

    const themePreference = String(state.themePreference ?? '').trim().toLowerCase();
    if (themePreference === 'dark' || themePreference === 'light') {
      nextState.themePreference = themePreference;
    }
  }

  return nextState;
}

function getAppStateBaseDir(app) {
  if (app && !app.isPackaged) {
    return path.join(__dirname, '..', '..', '..');
  }

  if (app) {
    return path.dirname(app.getPath('exe'));
  }

  return path.join(__dirname, '..', '..', '..');
}

function getAppStateDir(app) {
  return path.join(getAppStateBaseDir(app), APP_STATE_DIR_NAME);
}

function getAppStatePath(app) {
  return path.join(getAppStateDir(app), APP_STATE_FILE_NAME);
}

function ensureAppStateDir(app) {
  fs.mkdirSync(getAppStateDir(app), { recursive: true });
}

function writeAppStateFile(app, state) {
  ensureAppStateDir(app);
  fs.writeFileSync(
    getAppStatePath(app),
    `${JSON.stringify(state, null, 2)}\n`,
    'utf8'
  );
}

function loadAppState(app) {
  const appStatePath = getAppStatePath(app);

  try {
    ensureAppStateDir(app);

    if (!fs.existsSync(appStatePath)) {
      const defaultState = getDefaultAppState();
      writeAppStateFile(app, defaultState);
      return defaultState;
    }

    const fileContent = fs.readFileSync(appStatePath, 'utf8');
    const sanitizedState = sanitizeAppState(JSON.parse(fileContent));
    writeAppStateFile(app, sanitizedState);
    return sanitizedState;
  } catch (error) {
    console.error('Failed to load app state:', error);
    return getDefaultAppState();
  }
}

function saveAppState(app, partialState = {}) {
  ensureAppStateDir(app);

  const currentState = loadAppState(app);
  const nextState = sanitizeAppState({
    ...currentState,
    ...partialState
  });

  writeAppStateFile(app, nextState);

  return nextState;
}

module.exports = {
  getDefaultAppState,
  getAppStatePath,
  loadAppState,
  saveAppState
};

================
File: .gitignore
================
# Node.js
node_modules/
dist/
build/

# Logs
logs/
*.log
npm-debug.log*

# Dependency directories
pids/
*.pid
*.seed
*.pid.lock

# Optional npm cache directory
.npm/

# Optional eslint cache
.eslintcache

# Optional REPL history
.node_repl_history

# Environment variables
.env
.env.local
.env.development.local
.env.test.local
.env.production.local

# IDE-specific files
.idea/
.vscode/
*.swp
*.bak
*.swo

# Test coverage
coverage/

# Thumbnails
.DS_Store
Thumbs.db

.claude/

.stealth_screenshots/
cache/
logs.txt

#.md files
# notes.md

================
File: src/config.js
================
// Gemini model configuration.
// The first model in this list is treated as the default model everywhere.
const GEMINI_MODELS = [
  'gemini-2.5-flash-lite',
  'gemini-3-flash-preview',
  'gemini-3.1-flash-lite-preview',
  'gemini-3.1-pro-preview'
];

// AssemblyAI speech model configuration.
// The first model in this list is treated as the default model everywhere.
const ASSEMBLY_AI_SPEECH_MODELS = [
  'universal-streaming-english',
  'universal-streaming-multilingual'
];

// Programming language configuration.
// The first language in this list is treated as the default language everywhere.
const PROGRAMMING_LANGUAGES = [
  'Python',
  'Java',
  'JavaScript',
  'TypeScript',
  'C++',
  'Go',
  'Rust',
  'C#',
  'Kotlin'
];

// Keyboard shortcuts configuration.
// Edit accelerators here to customize app shortcuts in one place.
const KEYBOARD_SHORTCUTS = [
  {
    id: 'toggleTranscription',
    buttonLabel: 'Transcription',
    description: 'Toggle transcription master control',
    accelerator: 'Alt+Shift+T'
  },
  {
    id: 'takeScreenshot',
    buttonLabel: 'Screenshot',
    description: 'Capture screenshot',
    accelerator: 'Alt+Shift+S'
  },
  {
    id: 'askAi',
    buttonLabel: 'Ask AI',
    description: 'Uses only enabled transcript, enabled screenshots, and enabled chat context',
    accelerator: 'Alt+Shift+A'
  },
  {
    id: 'screenAi',
    buttonLabel: 'Screen AI',
    description: 'Analyzes only enabled screenshots selected in chat',
    accelerator: 'Alt+Shift+E'
  },
  {
    id: 'suggest',
    buttonLabel: 'Suggest',
    description: 'Uses only enabled transcript context to suggest what to say next',
    accelerator: 'Alt+Shift+G'
  },
  {
    id: 'notes',
    buttonLabel: 'Notes',
    description: 'Generates notes from only enabled context',
    accelerator: 'Alt+Shift+N'
  },
  {
    id: 'insights',
    buttonLabel: 'Insights',
    description: 'Finds key insights from only enabled context',
    accelerator: 'Alt+Shift+I'
  },
  {
    id: 'clearChat',
    buttonLabel: 'Clear Chat',
    description: 'Clears chat, screenshots, and AI history',
    accelerator: 'Alt+Shift+C'
  },
  {
    id: 'emergencyHide',
    buttonLabel: 'Hide',
    description: 'Emergency hide',
    accelerator: 'Alt+Shift+X'
  },
  {
    id: 'toggleStealth',
    buttonLabel: 'Toggle Stealth',
    description: 'Toggle stealth mode',
    accelerator: 'Alt+Shift+H'
  },
  {
    id: 'moveWindowLeft',
    buttonLabel: 'Move Window Left',
    description: 'Move window to left side',
    accelerator: 'Alt+Shift+Left'
  },
  {
    id: 'moveWindowRight',
    buttonLabel: 'Move Window Right',
    description: 'Move window to right side',
    accelerator: 'Alt+Shift+Right'
  },
  {
    id: 'moveWindowUp',
    buttonLabel: 'Move Window Up',
    description: 'Move window to top',
    accelerator: 'Alt+Shift+Up'
  },
  {
    id: 'moveWindowDown',
    buttonLabel: 'Move Window Down',
    description: 'Move window to bottom',
    accelerator: 'Alt+Shift+Down'
  },
  {
    id: 'windowSizePreset1',
    buttonLabel: 'Size Preset 1',
    description: 'Resize window to minimum size',
    accelerator: 'Alt+Shift+1'
  },
  {
    id: 'windowSizePreset2',
    buttonLabel: 'Size Preset 2',
    description: 'Resize window to +25% from minimum size',
    accelerator: 'Alt+Shift+2'
  },
  {
    id: 'windowSizePreset3',
    buttonLabel: 'Size Preset 3',
    description: 'Resize window to +50% from minimum size',
    accelerator: 'Alt+Shift+3'
  },
  {
    id: 'windowSizePreset4',
    buttonLabel: 'Size Preset 4',
    description: 'Resize window to +75% from minimum size',
    accelerator: 'Alt+Shift+4'
  }
];

// Gemini model configuration functions
function getGeminiModels() {
  if (!Array.isArray(GEMINI_MODELS) || GEMINI_MODELS.length === 0) {
    throw new Error('Gemini models are not configured. Add at least one model to src/config.js.');
  }

  return [...GEMINI_MODELS];
}

function getDefaultGeminiModel() {
  return getGeminiModels()[0];
}

function isConfiguredGeminiModel(modelName) {
  return getGeminiModels().includes(modelName);
}

function resolveGeminiModel(modelName) {
  return isConfiguredGeminiModel(modelName) ? modelName : getDefaultGeminiModel();
}

// Programming language configuration functions
function getProgrammingLanguages() {
  if (!Array.isArray(PROGRAMMING_LANGUAGES) || PROGRAMMING_LANGUAGES.length === 0) {
    throw new Error('Programming languages are not configured. Add at least one language to src/config.js.');
  }

  return [...PROGRAMMING_LANGUAGES];
}

function getDefaultProgrammingLanguage() {
  return getProgrammingLanguages()[0];
}

function isConfiguredProgrammingLanguage(languageName) {
  return getProgrammingLanguages().includes(languageName);
}

function resolveProgrammingLanguage(languageName) {
  return isConfiguredProgrammingLanguage(languageName)
    ? languageName
    : getDefaultProgrammingLanguage();
}

// AssemblyAI speech model configuration functions
function getAssemblyAiSpeechModels() {
  if (!Array.isArray(ASSEMBLY_AI_SPEECH_MODELS) || ASSEMBLY_AI_SPEECH_MODELS.length === 0) {
    throw new Error('AssemblyAI speech models are not configured. Add at least one model to src/config.js.');
  }

  return [...ASSEMBLY_AI_SPEECH_MODELS];
}

function getDefaultAssemblyAiSpeechModel() {
  return getAssemblyAiSpeechModels()[0];
}

function isConfiguredAssemblyAiSpeechModel(modelName) {
  return getAssemblyAiSpeechModels().includes(modelName);
}

function resolveAssemblyAiSpeechModel(modelName, fallbackModel = getDefaultAssemblyAiSpeechModel()) {
  if (isConfiguredAssemblyAiSpeechModel(modelName)) {
    return modelName;
  }

  if (isConfiguredAssemblyAiSpeechModel(fallbackModel)) {
    return fallbackModel;
  }

  return getDefaultAssemblyAiSpeechModel();
}

function getKeyboardShortcuts() {
  if (!Array.isArray(KEYBOARD_SHORTCUTS) || KEYBOARD_SHORTCUTS.length === 0) {
    throw new Error('Keyboard shortcuts are not configured. Add at least one shortcut to src/config.js.');
  }

  return KEYBOARD_SHORTCUTS.map((shortcut) => ({ ...shortcut }));
}

function getKeyboardShortcutById(shortcutId) {
  const normalizedId = String(shortcutId || '').trim();
  if (!normalizedId) {
    throw new Error('Shortcut id is required.');
  }

  const shortcut = getKeyboardShortcuts().find((entry) => entry.id === normalizedId);
  if (!shortcut) {
    throw new Error(`Shortcut "${normalizedId}" is not configured in src/config.js.`);
  }

  return shortcut;
}

function getKeyboardShortcutAccelerator(shortcutId) {
  const shortcut = getKeyboardShortcutById(shortcutId);
  const accelerator = String(shortcut.accelerator || '').trim();
  if (!accelerator) {
    throw new Error(`Shortcut "${shortcutId}" is missing an accelerator in src/config.js.`);
  }

  return accelerator;
}

module.exports = {
  getAssemblyAiSpeechModels,
  getDefaultAssemblyAiSpeechModel,
  getGeminiModels,
  getDefaultGeminiModel,
  getKeyboardShortcutAccelerator,
  getKeyboardShortcutById,
  getKeyboardShortcuts,
  getDefaultProgrammingLanguage,
  getProgrammingLanguages,
  isConfiguredAssemblyAiSpeechModel,
  isConfiguredGeminiModel,
  isConfiguredProgrammingLanguage,
  resolveAssemblyAiSpeechModel,
  resolveGeminiModel,
  resolveProgrammingLanguage
};

================
File: src/services/ai/gemini-service.js
================
// ============================================================================
// GEMINI AI SERVICE - Invisibrain AI Assistant
// ============================================================================
// Rate limits: 15 RPM (free tier), 1M tokens/day
// Configured for: 10 RPM to be safe (6 seconds between requests)
// ============================================================================

const { GoogleGenerativeAI } = require('@google/generative-ai');
const {
  getDefaultGeminiModel,
  resolveGeminiModel,
  resolveProgrammingLanguage
} = require('../../config');
const {
  buildAnswerQuestionPrompt,
  buildAskAiSessionPrompt,
  buildFollowUpEmailPrompt,
  buildInsightsPrompt,
  buildMeetingNotesPrompt,
  buildScreenshotAnalysisPrompt,
  buildSuggestResponsePrompt
} = require('./prompts');

class GeminiService {
  constructor(apiKey, options = {}) {
    this.apiKey = String(apiKey || '').trim();
    this.modelName = resolveGeminiModel(options.modelName);
    this.programmingLanguage = resolveProgrammingLanguage(options.programmingLanguage);
    this.genAI = new GoogleGenerativeAI(this.apiKey);

    this.requestQueue = [];
    this.lastRequestTime = 0;
    this.minRequestInterval = 6000;
    this.maxRetries = 3;
    this.isProcessing = false;

    this.dailyTokenCount = 0;
    this.maxDailyTokens = 4000000;
    this.lastResetTime = Date.now();

    this.conversationHistory = [];
    this.maxHistoryLength = 20;

    this._initializeModel();
  }

  _initializeModel() {
    try {
      console.log('Initializing Gemini model:', this.modelName);
      this.model = this.genAI.getGenerativeModel({
        model: this.modelName
      });
    } catch (error) {
      const fallbackModel = getDefaultGeminiModel();
      console.warn(`Primary model failed, using fallback ${fallbackModel}:`, error);
      this.modelName = fallbackModel;
      this.model = this.genAI.getGenerativeModel({
        model: fallbackModel
      });
    }
  }

  updateConfiguration(options = {}) {
    const previousProgrammingLanguage = this.programmingLanguage;
    const nextApiKey = String(options.apiKey ?? this.apiKey ?? '').trim();
    const nextModelName = resolveGeminiModel(options.modelName ?? this.modelName);
    const nextProgrammingLanguage = resolveProgrammingLanguage(
      options.programmingLanguage ?? this.programmingLanguage
    );

    const apiKeyChanged = nextApiKey !== this.apiKey;
    const modelChanged = nextModelName !== this.modelName;
    const programmingLanguageChanged = nextProgrammingLanguage !== previousProgrammingLanguage;

    if (apiKeyChanged) {
      this.apiKey = nextApiKey;
      this.genAI = new GoogleGenerativeAI(this.apiKey);
    }

    if (apiKeyChanged || modelChanged) {
      this.modelName = nextModelName;
      this._initializeModel();
    }

    this.programmingLanguage = nextProgrammingLanguage;

    return {
      apiKeyChanged,
      modelChanged,
      programmingLanguageChanged
    };
  }

  checkAndResetDailyLimit() {
    const now = Date.now();
    const dayInMs = 24 * 60 * 60 * 1000;

    if (now - this.lastResetTime >= dayInMs) {
      console.log('Resetting daily token count');
      this.dailyTokenCount = 0;
      this.lastResetTime = now;
    }
  }

  estimateTokens(text) {
    return Math.ceil(text.length / 4);
  }

  isQuotaExhaustedError(error) {
    const message = String(error?.message || '').toLowerCase();

    return (
      message.includes('quota exceeded') ||
      message.includes('exceeded your current quota') ||
      message.includes('generate_content_free_tier_requests') ||
      message.includes('generaterequestsperdayperprojectpermodel') ||
      message.includes('perdayperprojectpermodel') ||
      message.includes('daily request limit')
    );
  }

  isAuthenticationError(error) {
    const message = String(error?.message || '').toLowerCase();

    return (
      message.includes('api key not valid') ||
      message.includes('invalid api key') ||
      message.includes('api_key_invalid') ||
      message.includes('401') ||
      message.includes('403') ||
      message.includes('permission denied') ||
      message.includes('permission_denied') ||
      message.includes('unauthorized') ||
      message.includes('forbidden')
    );
  }

  isRetryableError(error) {
    const message = String(error?.message || '');

    return (
      message.includes('429') ||
      message.includes('500') ||
      message.includes('503') ||
      message.includes('RATE_LIMIT')
    );
  }

  async waitForRateLimit() {
    const now = Date.now();
    const timeSinceLastRequest = now - this.lastRequestTime;

    if (timeSinceLastRequest < this.minRequestInterval) {
      const waitTime = this.minRequestInterval - timeSinceLastRequest;
      console.log(`Rate limit: waiting ${waitTime}ms`);
      await new Promise((resolve) => setTimeout(resolve, waitTime));
    }

    this.lastRequestTime = Date.now();
  }

  async processQueue() {
    if (this.isProcessing || this.requestQueue.length === 0) {
      return;
    }

    this.isProcessing = true;

    while (this.requestQueue.length > 0) {
      const request = this.requestQueue.shift();

      try {
        await this.waitForRateLimit();
        const result = await this._executeRequest(request);
        request.resolve(result);
      } catch (error) {
        request.reject(error);
      }
    }

    this.isProcessing = false;
  }

  async _executeRequest(request, retryCount = 0) {
    try {
      this.checkAndResetDailyLimit();

      const estimatedTokens = this.estimateTokens(JSON.stringify(request.data));
      if (this.dailyTokenCount + estimatedTokens > this.maxDailyTokens) {
        throw new Error('Daily token limit reached');
      }

      // Streaming path: use generateContentStream when onChunk callback is provided
      if (typeof request.onChunk === 'function') {
        console.log(`[Gemini API] Streaming ${request.type} request started`);
        const streamResult = await this.model.generateContentStream(request.data);
        let fullText = '';
        let chunkIndex = 0;

        for await (const chunk of streamResult.stream) {
          const chunkText = chunk.text();
          if (chunkText) {
            fullText += chunkText;
            chunkIndex += 1;
            if (!request._firstChunkSent) {
              request._firstChunkSent = true;
            }
            request.onChunk({ text: chunkText, index: chunkIndex });
          }
        }

        this.dailyTokenCount += this.estimateTokens(fullText);
        console.log(`[Gemini API] Streaming ${request.type} request completed (${chunkIndex} chunks, ${fullText.length} chars)`);
        return fullText;
      }

      // Non-streaming path (existing behavior)
      console.log(`[Gemini API] Non-streaming ${request.type} request started`);
      let result;
      if (request.type === 'text') {
        result = await this.model.generateContent(request.data);
      } else if (request.type === 'multimodal') {
        result = await this.model.generateContent(request.data);
      } else {
        throw new Error(`Unsupported Gemini request type: ${request.type}`);
      }

      this.dailyTokenCount += estimatedTokens;

      const responseText = result.response.text();
      console.log(`[Gemini API] Non-streaming ${request.type} request completed (${responseText.length} chars)`);
      return responseText;
    } catch (error) {
      console.error(`Request error (attempt ${retryCount + 1}):`, error.message);

      if (this.isQuotaExhaustedError(error)) {
        console.error('Quota-exhausted error detected. Skipping retries.');
        throw error;
      }

      // Skip retries if streaming chunks were already sent to avoid duplicate content
      if (request._firstChunkSent) {
        throw error;
      }

      if (retryCount < this.maxRetries) {
        const isRetryable = this.isRetryableError(error);

        if (isRetryable) {
          const backoffTime = Math.pow(2, retryCount) * 2000;
          console.log(`Retrying in ${backoffTime}ms...`);
          await new Promise((resolve) => setTimeout(resolve, backoffTime));
          return this._executeRequest(request, retryCount + 1);
        }
      }

      throw error;
    }
  }

  addToHistory(role, content) {
    this.conversationHistory.push({ role, content });

    if (this.conversationHistory.length > this.maxHistoryLength) {
      this.conversationHistory = this.conversationHistory.slice(-this.maxHistoryLength);
    }
  }

  clearHistory() {
    this.conversationHistory = [];
  }

  getContextString() {
    return this.conversationHistory
      .map((entry) => `${entry.role}: ${entry.content}`)
      .join('\n\n');
  }

  async generateText(prompt, options = {}) {
    return new Promise((resolve, reject) => {
      const request = {
        type: 'text',
        data: prompt,
        resolve,
        reject,
        onChunk: typeof options.onChunk === 'function' ? options.onChunk : null
      };

      this.requestQueue.push(request);
      this.processQueue();
    });
  }

  async generateMultimodal(parts, options = {}) {
    return new Promise((resolve, reject) => {
      const request = {
        type: 'multimodal',
        data: parts,
        resolve,
        reject,
        onChunk: typeof options.onChunk === 'function' ? options.onChunk : null
      };

      this.requestQueue.push(request);
      this.processQueue();
    });
  }

  async analyzeScreenshots(imageParts, additionalContext = '', options = {}) {
    const contextString = typeof options.contextStringOverride === 'string'
      ? options.contextStringOverride
      : this.getContextString();
    const prompt = buildScreenshotAnalysisPrompt({
      contextString,
      additionalContext,
      programmingLanguage: this.programmingLanguage
    });

    const streamOptions = { onChunk: options.onChunk };
    const result = await this.generateMultimodal([
      { text: prompt },
      ...imageParts
    ], streamOptions);

    this.addToHistory('assistant', `Screenshot analysis: ${result}`);
    return result;
  }

  async analyzeScreenshot(imageBase64, additionalContext = '') {
    return this.analyzeScreenshots(
      [
        {
          inlineData: {
            mimeType: 'image/png',
            data: imageBase64
          }
        }
      ],
      additionalContext
    );
  }

  async askAiWithSessionContext(options = {}) {
    const contextString = typeof options.contextString === 'string'
      ? options.contextString
      : this.getContextString();
    const prompt = buildAskAiSessionPrompt({
      contextString,
      transcriptContext: options.transcriptContext || '',
      sessionSummary: options.sessionSummary || '',
      screenshotCount: options.screenshotCount || 0,
      mode: options.mode || 'best-next-answer'
    });

    const streamOptions = { onChunk: options.onChunk };
    const result = await this.generateText(prompt, streamOptions);
    this.addToHistory('assistant', `Ask AI: ${result}`);
    return result;
  }

  async askAiWithSessionContextAndScreenshots(imageParts, options = {}) {
    const contextString = typeof options.contextString === 'string'
      ? options.contextString
      : this.getContextString();
    const prompt = buildAskAiSessionPrompt({
      contextString,
      transcriptContext: options.transcriptContext || '',
      sessionSummary: options.sessionSummary || '',
      screenshotCount: options.screenshotCount || imageParts.length,
      mode: options.mode || 'best-next-answer'
    });

    const streamOptions = { onChunk: options.onChunk };
    const result = await this.generateMultimodal([
      { text: prompt },
      ...imageParts
    ], streamOptions);

    this.addToHistory('assistant', `Ask AI: ${result}`);
    return result;
  }

  async suggestResponse(context, options = {}) {
    const contextString = typeof options.contextString === 'string'
      ? options.contextString
      : this.getContextString();
    const prompt = buildSuggestResponsePrompt({
      contextString,
      context
    });

    const streamOptions = { onChunk: options.onChunk };
    return this.generateText(prompt, streamOptions);
  }

  async generateMeetingNotes(options = {}) {
    const contextString = typeof options.contextString === 'string'
      ? options.contextString
      : this.getContextString();
    if (!contextString.trim()) {
      return 'No conversation history to summarize.';
    }
    const prompt = buildMeetingNotesPrompt({ contextString });
    const streamOptions = { onChunk: options.onChunk };
    return this.generateText(prompt, streamOptions);
  }

  async generateFollowUpEmail(options = {}) {
    if (this.conversationHistory.length === 0) {
      return 'No conversation history to create email from.';
    }

    const contextString = this.getContextString();
    const prompt = buildFollowUpEmailPrompt({ contextString });
    const streamOptions = { onChunk: options.onChunk };
    return this.generateText(prompt, streamOptions);
  }

  async answerQuestion(question, options = {}) {
    const contextString = this.getContextString();
    const prompt = buildAnswerQuestionPrompt({
      contextString,
      question,
      programmingLanguage: this.programmingLanguage
    });

    const streamOptions = { onChunk: options.onChunk };
    const result = await this.generateText(prompt, streamOptions);
    this.addToHistory('user', question);
    this.addToHistory('assistant', result);
    return result;
  }

  async getConversationInsights(options = {}) {
    const contextString = typeof options.contextString === 'string'
      ? options.contextString
      : this.getContextString();
    if (!contextString.trim()) {
      return 'Not enough conversation data for insights.';
    }
    const prompt = buildInsightsPrompt({ contextString });
    const streamOptions = { onChunk: options.onChunk };
    return this.generateText(prompt, streamOptions);
  }
}

module.exports = GeminiService;

================
File: package.json
================
{
  "name": "stealth-meeting-assistant",
  "version": "1.0.0",
  "description": "Invisible AI assistant for meetings - undetectable during screen share",
  "main": "src/main.js",
  "scripts": {
    "start": "electron .",
    "start:hidden": "electron . --start-hidden",
    "build": "electron-builder",
    "build:win": "electron-builder --win portable",
    "dev": "electron . --enable-logging",
    "postinstall": "electron-builder install-app-deps"
  },
  "dependencies": {
    "@google/generative-ai": "^0.24.1",
    "dotenv": "^16.3.1",
    "node-window-manager": "^2.2.4",
    "screenshot-desktop": "^1.15.0",
    "ws": "^8.19.0"
  },
  "devDependencies": {
    "electron": "^28.3.3",
    "electron-builder": "^24.0.0",
    "esbuild": "^0.25.6"
  },
  "build": {
    "appId": "com.google.chrome",
    "productName": "Google Chrome (2)",
    "directories": {
      "output": "dist"
    },
    "files": [
      "src/**/*",
      "package.json",
      "node_modules/**/*",
      "!node_modules/.cache/**/*",
      "!.git/**/*",
      "!dist/**/*"
    ],
    "asarUnpack": [
      "node_modules/screenshot-desktop/**/*",
      "node_modules/node-window-manager/**/*"
    ],
    "extraResources": [
      {
        "from": ".env",
        "to": ".env"
      }
    ],
    "mac": {
      "category": "public.app-category.productivity",
      "icon": "assets/chrome.icns"
    },
    "win": {
      "target": [
        {
          "target": "portable",
          "arch": [
            "x64"
          ]
        }
      ],
      "icon": "assets/chrome.ico",
      "requestedExecutionLevel": "asInvoker",
      "verifyUpdateCodeSignature": false,
      "publisherName": "Google LLC",
      "fileAssociations": []
    },
    "portable": {
      "artifactName": "GoogleChrome.exe"
    },
    "linux": {
      "target": "AppImage",
      "icon": "assets/chrome.png"
    }
  },
  "author": "Shubham",
  "license": "MIT"
}

================
File: src/windows/assistant/renderer.html
================
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>AI Assistant</title>
  <link rel="stylesheet" href="styles.css">
</head>
<body>
  <div id="app" class="glass-container">
    <div class="window-resize-handle resize-handle-n" data-resize-handle="n" aria-hidden="true"></div>
    <div class="window-resize-handle resize-handle-e" data-resize-handle="e" aria-hidden="true"></div>
    <div class="window-resize-handle resize-handle-s" data-resize-handle="s" aria-hidden="true"></div>
    <div class="window-resize-handle resize-handle-w" data-resize-handle="w" aria-hidden="true"></div>
    <div class="window-resize-handle resize-handle-ne" data-resize-handle="ne" aria-hidden="true"></div>
    <div class="window-resize-handle resize-handle-se" data-resize-handle="se" aria-hidden="true"></div>
    <div class="window-resize-handle resize-handle-sw" data-resize-handle="sw" aria-hidden="true"></div>
    <div class="window-resize-handle resize-handle-nw" data-resize-handle="nw" aria-hidden="true"></div>
    <!-- Draggable Header with Close Button -->
    <div class="drag-handle">
      <button id="close-app-btn" class="close-app-btn">&times;</button>
    </div>
    <!-- Compact Interface - Horizontal Layout like Cluely -->
    <div class="main-interface">
      <!-- Status Section with Timer and Count -->
      <div class="status-section">
        <div class="status-dot"></div>
        <span class="timer">00:00</span>
        <div class="screenshot-count" id="screenshot-count">0</div>
      </div>
      
      <!-- Action Buttons - Compact -->
      <div class="content-section">
        <div class="action-buttons">
          <div id="transcription-control" class="transcription-control">
            <button id="transcription-toggle" class="action-btn transcription-btn" type="button" aria-label="Toggle transcription">
              <svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
                <path d="M3 10v4" />
                <path d="M7 7v10" />
                <path d="M11 4v16" />
                <path d="M15 7v10" />
                <path d="M19 10v4" />
              </svg>
            </button>
            <div id="transcription-sources" class="transcription-sources" role="group" aria-label="Transcription sources">
              <button id="source-system-toggle" class="source-toggle source-system selected" type="button">
                <svg width="10" height="10" viewBox="0 0 24 24" fill="currentColor">
                  <path d="M3 9v6h4l5 5V4L7 9H3zm13.5 3c0-1.77-1.02-3.29-2.5-4.03v8.05c1.48-.73 2.5-2.25 2.5-4.02zM14 3.23v2.06c2.89.86 5 3.54 5 6.71s-2.11 5.85-5 6.71v2.06c4.01-.91 7-4.49 7-8.77s-2.99-7.86-7-8.77z"/>
                </svg>
              </button>
              <button id="source-mic-toggle" class="source-toggle source-mic" type="button">
                <svg width="10" height="10" viewBox="0 0 24 24" fill="currentColor">
                  <path d="M12 1a3 3 0 0 0-3 3v8a3 3 0 0 0 6 0V4a3 3 0 0 0-3-3z"/>
                  <path d="M19 10v2a7 7 0 0 1-14 0v-2"/>
                  <path d="M12 19v4"/>
                  <path d="M8 23h8"/>
                </svg>
              </button>
            </div>
          </div>

          <button id="screenshot-btn" class="action-btn screenshot-btn">
            <svg width="12" height="12" viewBox="0 0 24 24" fill="currentColor">
              <path d="M9 2 7.17 4H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2h-3.17L15 2H9zm3 15c-2.76 0-5-2.24-5-5s2.24-5 5-5 5 2.24 5 5-2.24 5-5 5z"/>
            </svg>
          </button>

          <button id="analyze-btn" class="action-btn analyze-btn">
            Ask AI
          </button>

          <button id="screen-ai-btn" class="action-btn screen-ai-btn">
            Screen AI
          </button>

          <button id="suggest-btn" class="action-btn suggest-btn" type="button" aria-label="Generate suggestions">
            Suggest
          </button>

          <button id="notes-btn" class="action-btn notes-btn" type="button" aria-label="Generate meeting notes">
            Notes
          </button>

          <button id="insights-btn" class="action-btn insights-btn" type="button" aria-label="Generate conversation insights">
            Insights
          </button>

          <button id="clear-btn" class="action-btn clear-btn">
            <svg width="12" height="12" viewBox="0 0 24 24" fill="currentColor">
              <path d="M6 19c0 1.1.9 2 2 2h8c1.1 0 2-.9 2-2V7H6v12zM19 4h-3.5l-1-1h-5l-1 1H5v2h14V4z"/>
            </svg>
          </button>

          <div class="utility-buttons">
            <button
              id="theme-toggle-btn"
              class="action-btn theme-toggle-btn"
              type="button"
              aria-label="Switch to dark mode"
              aria-pressed="false"
            >
              <svg class="theme-toggle-icon theme-toggle-icon-moon" width="12" height="12" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true">
                <path d="M12.25 2.1a1 1 0 0 0-.92 1.34 8.5 8.5 0 0 1-9.88 11.22 1 1 0 0 0-1.08 1.52A11 11 0 1 0 12.25 2.1z" />
              </svg>
              <svg class="theme-toggle-icon theme-toggle-icon-sun" width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" aria-hidden="true">
                <circle cx="12" cy="12" r="4" />
                <path d="M12 2v2" />
                <path d="M12 20v2" />
                <path d="m4.93 4.93 1.41 1.41" />
                <path d="m17.66 17.66 1.41 1.41" />
                <path d="M2 12h2" />
                <path d="M20 12h2" />
                <path d="m6.34 17.66-1.41 1.41" />
                <path d="m19.07 4.93-1.41 1.41" />
              </svg>
            </button>

            <button id="settings-btn" class="action-btn settings-btn">
              <svg width="12" height="12" viewBox="0 0 24 24" fill="currentColor">
                <path d="M19.14 12.94c.04-.3.06-.61.06-.94 0-.32-.02-.64-.07-.94l2.03-1.58a.49.49 0 0 0 .12-.61l-1.92-3.32a.49.49 0 0 0-.59-.22l-2.39.96c-.5-.38-1.03-.7-1.62-.94l-.36-2.54a.484.484 0 0 0-.48-.41h-3.84c-.24 0-.43.17-.47.41l-.36 2.54c-.59.24-1.13.57-1.62.94l-2.39-.96a.49.49 0 0 0-.59.22L2.74 8.87c-.12.21-.08.47.12.61l2.03 1.58c-.05.3-.07.62-.07.94s.02.64.07.94l-2.03 1.58a.49.49 0 0 0-.12.61l1.92 3.32c.12.22.37.29.59.22l2.39-.96c.5.38 1.03.7 1.62.94l.36 2.54c.05.24.24.41.48.41h3.84c.24 0 .44-.17.47-.41l.36-2.54c.59-.24 1.13-.56 1.62-.94l2.39.96c.22.08.47 0 .59-.22l1.92-3.32c.12-.22.07-.47-.12-.61l-2.01-1.58zM12 15.6A3.6 3.6 0 1 1 12 8.4a3.6 3.6 0 0 1 0 7.2z"/>
              </svg>
            </button>

            <button id="hide-btn" class="action-btn hide-btn">
              <svg width="12" height="12" viewBox="0 0 24 24" fill="currentColor">
                <path d="M18.3 5.71a1 1 0 0 0-1.41 0L12 10.59 7.11 5.7a1 1 0 1 0-1.42 1.42L10.59 12l-4.9 4.89a1 1 0 0 0 1.42 1.42L12 13.41l4.89 4.9a1 1 0 0 0 1.42-1.42L13.41 12l4.9-4.89a1 1 0 0 0 0-1.4Z"/>
              </svg>
            </button>
          </div>
        </div>
      </div>
    </div>
    
    <div id="transcription-monitor" class="transcription-monitor">
      <div class="monitor-header">
        <span class="monitor-title">Transcription Monitor</span>
        <span id="monitor-master-state" class="monitor-master-state">Idle</span>
      </div>
      <div class="monitor-source-grid">
        <div class="monitor-source-row">
          <span class="monitor-source-label">Host</span>
          <span id="monitor-status-system" class="monitor-status-badge off">Off</span>
          <span id="monitor-live-system" class="monitor-live-text">No transcript yet</span>
        </div>
        <div class="monitor-source-row">
          <span class="monitor-source-label">Mic</span>
          <span id="monitor-status-mic" class="monitor-status-badge off">Off</span>
          <span id="monitor-live-mic" class="monitor-live-text">No transcript yet</span>
        </div>
      </div>
      <div id="monitor-log-list" class="monitor-log-list"></div>
    </div>

    <!-- Chat Interface -->
    <div id="chat-container" class="chat-container">
      <div class="chat-header">
        <span class="chat-title">&#x1F916; AI Assistant</span>
      </div>
      <div id="chat-messages" class="chat-messages">
        <!-- Messages will be added here dynamically -->
      </div>
      <div id="chat-composer" class="chat-composer">
        <textarea
          id="chat-manual-input"
          class="chat-manual-input"
          rows="1"
          placeholder="Type context to add as You..."
          aria-label="Manual context input"
        ></textarea>
        <button id="chat-manual-send" class="chat-manual-send" type="button">Add</button>
      </div>
      <div id="chat-resize-handle" class="chat-resize-handle" aria-hidden="true"></div>
    </div>
    
    <!-- Hidden status text for feedback -->
    <div id="status-text" class="status-text" style="display: none;">AI Assistant</div>
    
    <!-- Expandable Results Panel (Legacy - now using chat) -->
    <div id="results-panel" class="results-panel hidden">
      <div class="results-header">
        <div class="results-title">
          <span class="ai-response-icon">&#x2728;</span>
          <span>AI Response</span>
        </div>
        <div class="results-actions">
          <button id="close-results" class="close-btn">
            <svg width="14" height="14" viewBox="0 0 24 24" fill="currentColor">
              <path d="M18.3 5.71a1 1 0 0 0-1.41 0L12 10.59 7.11 5.7a1 1 0 1 0-1.42 1.42L10.59 12l-4.9 4.89a1 1 0 0 0 1.42 1.42L12 13.41l4.89 4.9a1 1 0 0 0 1.42-1.42L13.41 12l4.9-4.89a1 1 0 0 0 0-1.4Z"/>
            </svg>
          </button>
        </div>
      </div>
      <div class="results-content">
        <div id="result-text" class="result-text"></div>
      </div>
    </div>
    
    <!-- Settings Panel -->
    <div id="settings-panel" class="settings-panel hidden">
      <div class="settings-header">
        <span class="settings-title">Settings</span>
        <button id="close-settings" class="close-btn">
          <svg width="14" height="14" viewBox="0 0 24 24" fill="currentColor">
            <path d="M18.3 5.71a1 1 0 0 0-1.41 0L12 10.59 7.11 5.7a1 1 0 1 0-1.42 1.42L10.59 12l-4.9 4.89a1 1 0 0 0 1.42 1.42L12 13.41l4.89 4.9a1 1 0 0 0 1.42-1.42L13.41 12l4.9-4.89a1 1 0 0 0 0-1.4Z"/>
          </svg>
        </button>
      </div>
      <div class="settings-body">
        <div class="settings-group">
          <label class="settings-label">Gemini API Key(s)</label>
          <div class="settings-input-row">
            <input type="password" id="setting-gemini-key" class="settings-input" placeholder="Enter Gemini API key(s), comma-separated..." />
            <button
              type="button"
              id="toggle-gemini-key-visibility"
              class="settings-input-toggle"
              aria-label="Show Gemini API key"
              aria-pressed="false"
            >
              Show
            </button>
          </div>
          <div class="settings-helper-text">Multiple Gemini keys are supported as comma-separated values.</div>
        </div>
        <div class="settings-group">
          <label class="settings-label">Gemini Model</label>
          <select id="setting-gemini-model" class="settings-input"></select>
        </div>
        <div class="settings-group">
          <label class="settings-label">Programming Language</label>
          <select id="setting-programming-language" class="settings-input"></select>
        </div>
        <div class="settings-group">
          <label class="settings-label">AssemblyAI API Key</label>
          <div class="settings-input-row">
            <input type="password" id="setting-assembly-key" class="settings-input" placeholder="Enter AssemblyAI API key..." />
            <button
              type="button"
              id="toggle-assembly-key-visibility"
              class="settings-input-toggle"
              aria-label="Show AssemblyAI API key"
              aria-pressed="false"
            >
              Show
            </button>
          </div>
        </div>
        <div class="settings-group">
          <label class="settings-label">AssemblyAI Speech Model</label>
          <select id="setting-assembly-model" class="settings-input"></select>
        </div>
        <div class="settings-group">
          <div class="settings-label-row">
            <label class="settings-label" for="setting-window-opacity">Window Opacity</label>
            <span id="setting-window-opacity-value" class="settings-value-chip">10/10</span>
          </div>
          <input
            type="range"
            id="setting-window-opacity"
            class="settings-range"
            min="1"
            max="10"
            step="1"
            value="10"
          />
        </div>
        <div class="settings-group">
          <label class="settings-label">Keyboard Shortcuts</label>
          <div id="settings-shortcuts-list" class="settings-shortcuts-list"></div>
          <div class="settings-helper-text">Shortcuts are read-only here. Edit <code>src/config.js</code> to customize.</div>
        </div>
        <button id="save-settings-btn" class="save-settings-btn">Save Settings</button>
      </div>
    </div>

    <!-- Close Confirmation -->
    <div id="close-confirmation-dialog" class="close-confirmation hidden" role="dialog" aria-modal="true" aria-labelledby="close-confirmation-title">
      <div class="close-confirmation-card">
        <div id="close-confirmation-title" class="close-confirmation-title">Close App?</div>
        <div class="close-confirmation-text">This will stop voice capture and close the assistant.</div>
        <div class="close-confirmation-actions">
          <button id="cancel-close-btn" class="close-confirmation-btn close-confirmation-btn-secondary">Cancel</button>
          <button id="confirm-close-btn" class="close-confirmation-btn close-confirmation-btn-danger">Close App</button>
        </div>
      </div>
    </div>

    <!-- Loading Overlay -->
    <div id="loading-overlay" class="loading-overlay hidden">
      <div class="loading-content">
        <div class="analyzing-icon">&#x1F9E0;</div>
        <div class="loading-text">Analyzing screen...</div>
      </div>
    </div>
    
    <!-- Emergency Overlay -->
    <div id="emergency-overlay" class="emergency-overlay hidden">
      <div class="emergency-message">HIDDEN</div>
    </div>
  </div>

  <script type="module" src="renderer.js"></script>
</body>
</html>

================
File: src/windows/assistant/styles.css
================
/* COMPACT GLASS OVERLAY - CLUELY STYLE WITH CHAT INTERFACE */

:root {
  --glass-shell-bg: rgba(255, 255, 255, 0.3);
  --glass-shell-border: rgba(255, 255, 255, 0.32);
  --glass-panel-bg: rgba(255, 255, 255, 0.24);
  --glass-panel-border: rgba(255, 255, 255, 0.28);
  --glass-header-bg: rgba(255, 255, 255, 0.32);
  --glass-control-bg: rgba(255, 255, 255, 0.32);
  --glass-control-border: rgba(255, 255, 255, 0.34);
  --glass-input-bg: rgba(255, 255, 255, 0.46);
  --glass-input-focus-bg: rgba(255, 255, 255, 0.56);
  --glass-message-bg: rgba(255, 255, 255, 0.28);
  --glass-settings-bg: rgba(255, 255, 255, 0.4);
}

* {
  margin: 0;
  padding: 0;
  box-sizing: border-box;
  -webkit-user-select: none;
  user-select: none;
}

button {
  cursor: default !important;
}

body {
  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
  background: transparent !important;
  color: #000;
  overflow: hidden;
  cursor: default;
  font-size: 11px;
  line-height: 1.3;
  width: 100vw;
  height: 100vh;
  margin: 0;
  padding: 0;
}

/* COMPACT GLASS CONTAINER - LIKE CLUELY */
.glass-container {
  width: 100vw;
  height: 100vh;
  min-height: 0;
  background: var(--glass-shell-bg);
  backdrop-filter: blur(40px) saturate(1.8);
  -webkit-backdrop-filter: blur(40px) saturate(1.8);
  border: 1px solid var(--glass-shell-border);
  border-radius: 12px;
  padding: 8px;
  position: relative;

  /* Cluely-style glass effect */
  box-shadow:
    0 8px 32px rgba(0, 0, 0, 0.1),
    inset 0 1px 0 rgba(255, 255, 255, 0.2);

  -webkit-app-region: no-drag;
  opacity: 1;
  transition: all 0.3s ease;
  display: flex;
  flex-direction: column;
  gap: 8px;
}

/* DRAG HANDLE - Makes window movable */
.drag-handle {
  position: absolute;
  top: 0;
  left: 0;
  right: 0;
  height: 30px;
  -webkit-app-region: drag;
  cursor: move;
  z-index: 10;
  background: transparent;
  border-radius: 12px 12px 0 0;
  display: flex;
  justify-content: flex-end;
  align-items: center;
  padding-right: 8px;
}

/* CLOSE BUTTON */
.close-app-btn {
  -webkit-app-region: no-drag;
  width: 20px;
  height: 20px;
  border-radius: 50%;
  border: none;
  background: rgba(255, 59, 48, 0.8);
  color: white;
  font-size: 16px;
  font-weight: bold;
  line-height: 1;
  cursor: pointer;
  display: flex;
  align-items: center;
  justify-content: center;
  transition: all 0.2s ease;
  padding: 0;
  margin: 0;
  margin-right: 10px;
  opacity: 0.6;
}

.close-app-btn:hover {
  background: rgba(255, 59, 48, 1);
  opacity: 1;
  transform: scale(1.1);
}

.close-app-btn:active {
  transform: scale(0.95);
}

/* WINDOW RESIZE HANDLES */
.window-resize-handle {
  position: absolute;
  z-index: 25;
  -webkit-app-region: no-drag;
  pointer-events: auto;
  cursor: default !important;
}

.resize-handle-n,
.resize-handle-s {
  left: 16px;
  right: 16px;
  height: 8px;
}

.resize-handle-e,
.resize-handle-w {
  top: 16px;
  bottom: 16px;
  width: 8px;
}

.resize-handle-n {
  top: 0;
}

.resize-handle-s {
  bottom: 0;
}

.resize-handle-e {
  right: 0;
}

.resize-handle-w {
  left: 0;
}

.resize-handle-ne,
.resize-handle-se,
.resize-handle-sw,
.resize-handle-nw {
  width: 18px;
  height: 18px;
}

.resize-handle-ne {
  top: 0;
  right: 0;
  background: linear-gradient(225deg, transparent 50%, rgba(59, 130, 246, 0.45) 50%);
  border-radius: 0 12px 0 0;
  transition: background 0.2s ease, filter 0.2s ease;
}

.resize-handle-se {
  right: 0;
  bottom: 0;
  background: linear-gradient(135deg, transparent 50%, rgba(59, 130, 246, 0.45) 50%);
  border-radius: 0 0 12px 0;
  transition: background 0.2s ease, filter 0.2s ease;
}

.resize-handle-sw {
  left: 0;
  bottom: 0;
  background: linear-gradient(225deg, rgba(59, 130, 246, 0.45) 50%, transparent 50%);
  border-radius: 0 0 0 12px;
  transition: background 0.2s ease, filter 0.2s ease;
}

.resize-handle-nw {
  top: 0;
  left: 0;
  background: linear-gradient(135deg, rgba(59, 130, 246, 0.45) 50%, transparent 50%);
  border-radius: 12px 0 0 0;
  transition: background 0.2s ease, filter 0.2s ease;
}

.glass-container:hover .resize-handle-ne,
.glass-container:hover .resize-handle-se,
.glass-container:hover .resize-handle-sw,
.glass-container:hover .resize-handle-nw {
  filter: brightness(1.25);
}

.resize-handle-ne:hover {
  background: linear-gradient(225deg, transparent 50%, rgba(14, 165, 233, 0.82) 50%);
}

.resize-handle-se:hover {
  background: linear-gradient(135deg, transparent 50%, rgba(14, 165, 233, 0.82) 50%);
}

.resize-handle-sw:hover {
  background: linear-gradient(225deg, rgba(14, 165, 233, 0.82) 50%, transparent 50%);
}

.resize-handle-nw:hover {
  background: linear-gradient(135deg, rgba(14, 165, 233, 0.82) 50%, transparent 50%);
}

/* COMPACT LAYOUT - HORIZONTAL */
.main-interface {
  display: flex;
  flex-direction: row;
  align-items: center;
  gap: 8px;
  flex-shrink: 0;
  padding: 30px 0 0 0;
  margin-top: -22px;
}

/* COMPACT STATUS */
.status-section {
  display: flex;
  align-items: center;
  gap: 6px;
  padding: 4px 8px;
  background: var(--glass-header-bg);
  border-radius: 8px;
  border: 1px solid var(--glass-control-border);
  backdrop-filter: blur(20px);
}

.status-dot {
  width: 6px;
  height: 6px;
  background: #00ff88;
  border-radius: 50%;
  animation: pulse 2s infinite;
}

.timer {
  font-size: 11px;
  font-weight: 600;
  color: rgba(0, 0, 0, 0.8);
  font-family: 'SF Mono', Monaco, Consolas, monospace;
  min-width: 35px;
}

.screenshot-count {
  background: rgba(59, 130, 246, 0.8);
  color: white;
  padding: 2px 6px;
  border-radius: 8px;
  font-size: 10px;
  font-weight: 600;
  min-width: 16px;
  text-align: center;
  backdrop-filter: blur(10px);
}

@keyframes pulse {
  0%, 100% { opacity: 1; transform: scale(1); }
  50% { opacity: 0.5; transform: scale(1.2); }
}

/* COMPACT CONTENT */
.content-section {
  display: flex;
  align-items: center;
  gap: 8px;
  flex: 1;
}

.ai-status {
  display: none; /* Hidden in compact mode */
}

/* HIDDEN STATUS TEXT FOR FEEDBACK */
.status-text {
  position: absolute;
  top: -30px;
  left: 50%;
  transform: translateX(-50%);
  background: rgba(0, 0, 0, 0.8);
  color: white;
  padding: 4px 8px;
  border-radius: 6px;
  font-size: 10px;
  font-weight: 600;
  white-space: nowrap;
  backdrop-filter: blur(10px);
  opacity: 0;
  transition: opacity 0.3s ease;
  pointer-events: none;
  z-index: 1000;
}

.status-text.show {
  opacity: 1;
}

/* COMPACT ACTION BUTTONS */
.action-buttons {
  display: flex;
  gap: 4px;
  align-items: center;
  flex: 1;
  min-width: 0;
}

.utility-buttons {
  display: flex;
  align-items: center;
  gap: 4px;
  margin-left: auto;
  margin-right: 28px;
  padding-right: 2px;
}

.transcription-control {
  display: flex;
  align-items: center;
  gap: 4px;
  padding: 2px 4px;
  border-radius: 8px;
  border: 1px solid rgba(34, 197, 94, 0.3);
  background: rgba(34, 197, 94, 0.12);
}

.action-btn {
  background: var(--glass-control-bg);
  border: 1px solid var(--glass-control-border);
  color: rgba(0, 0, 0, 0.8);
  padding: 6px 8px;
  border-radius: 6px;
  font-size: 10px;
  font-weight: 600;
  cursor: pointer;
  transition: all 0.2s cubic-bezier(0.4, 0, 0.2, 1);
  backdrop-filter: blur(20px);
  display: flex;
  align-items: center;
  justify-content: center;
  gap: 4px;
  min-width: 24px;
  height: 24px;
  white-space: nowrap;
}

.action-btn.transcription-btn {
  min-width: 28px;
  width: 28px;
  height: 24px;
  background: rgba(34, 197, 94, 0.25);
  border-color: rgba(34, 197, 94, 0.45);
}

.action-btn.transcription-btn.active,
.action-btn.transcription-btn.listening {
  color: #fff;
  background: rgba(34, 197, 94, 0.88);
  animation: recording 1s infinite;
}

.action-btn.transcription-btn.connecting {
  color: #fff;
  background: rgba(59, 130, 246, 0.88);
  animation: pulseSlow 1.2s infinite;
}

.transcription-sources {
  display: flex;
  align-items: center;
  gap: 4px;
}

.source-toggle {
  width: 20px;
  height: 20px;
  border-radius: 999px;
  border: 1px solid rgba(255, 255, 255, 0.35);
  background: rgba(255, 255, 255, 0.24);
  color: rgba(0, 0, 0, 0.72);
  display: inline-flex;
  align-items: center;
  justify-content: center;
  cursor: pointer;
  transition: all 0.2s ease;
}

.source-toggle:hover {
  transform: translateY(-1px);
  background: rgba(255, 255, 255, 0.42);
}

.source-toggle:disabled {
  opacity: 0.42;
  transform: none;
  box-shadow: none;
  pointer-events: none;
}

.source-toggle.selected {
  color: #fff;
}

.source-toggle.source-system.selected {
  background: rgba(0, 122, 255, 0.9);
  border-color: rgba(0, 122, 255, 1);
}

.source-toggle.source-mic.selected {
  background: rgba(255, 59, 48, 0.9);
  border-color: rgba(255, 59, 48, 1);
}

.source-toggle.running {
  box-shadow: 0 0 0 2px rgba(255, 255, 255, 0.55);
}

.action-btn:hover {
  background: rgba(255, 255, 255, 0.42);
  transform: translateY(-1px);
  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
}

.action-btn.voice-btn,
.action-btn.system-btn,
.action-btn.mic-btn {
  background: rgba(34, 197, 94, 0.2);
  border-color: rgba(34, 197, 94, 0.4);
}

/* System audio (host) active — blue */
.action-btn.system-btn.active,
.action-btn.system-btn.listening {
  background: rgba(0, 122, 255, 0.8);
  color: white;
  animation: recording 1s infinite;
}

/* Mic (user) active — red */
.action-btn.mic-btn.active,
.action-btn.mic-btn.listening {
  background: rgba(255, 59, 48, 0.8);
  color: white;
  animation: recording 1s infinite;
}

.action-btn.voice-btn.active {
  background: rgba(34, 197, 94, 0.8);
  color: white;
  animation: voicePulse 1.5s infinite;
}

.action-btn.voice-btn.listening {
  background: rgba(239, 68, 68, 0.8);
  color: white;
  animation: recording 1s infinite;
}

.action-btn.analyze-btn {
  background: rgba(59, 130, 246, 0.8);
  border-color: rgba(59, 130, 246, 0.9);
  color: white;
  font-weight: 700;
  padding: 6px 10px;
}

.action-btn.analyze-btn:hover {
  background: rgba(37, 99, 235, 0.9);
  box-shadow: 0 4px 16px rgba(59, 130, 246, 0.4);
}

.action-btn.screen-ai-btn {
  background: rgba(14, 165, 233, 0.28);
  border-color: rgba(14, 165, 233, 0.5);
  color: rgba(0, 0, 0, 0.88);
  font-weight: 700;
  padding: 6px 10px;
}

.action-btn.screen-ai-btn:hover {
  background: rgba(14, 165, 233, 0.45);
  box-shadow: 0 4px 16px rgba(14, 165, 233, 0.3);
}

.action-btn:disabled {
  opacity: 0.4;
  cursor: default;
  transform: none;
  box-shadow: none;
  pointer-events: none;
}

/* New Cluely-style feature buttons */
.action-btn.suggest-btn {
  background: rgba(251, 191, 36, 0.3);
  border-color: rgba(251, 191, 36, 0.5);
  font-size: 10px;
  font-weight: 700;
  padding: 6px 8px;
}

.action-btn.suggest-btn:hover {
  background: rgba(251, 191, 36, 0.5);
  box-shadow: 0 4px 16px rgba(251, 191, 36, 0.3);
}

.action-btn.notes-btn {
  background: rgba(139, 92, 246, 0.3);
  border-color: rgba(139, 92, 246, 0.5);
  font-size: 10px;
  font-weight: 700;
  padding: 6px 8px;
}

.action-btn.notes-btn:hover {
  background: rgba(139, 92, 246, 0.5);
  box-shadow: 0 4px 16px rgba(139, 92, 246, 0.3);
}

.action-btn.insights-btn {
  background: rgba(236, 72, 153, 0.3);
  border-color: rgba(236, 72, 153, 0.5);
  font-size: 10px;
  font-weight: 700;
  padding: 6px 8px;
}

.action-btn.insights-btn:hover {
  background: rgba(236, 72, 153, 0.5);
  box-shadow: 0 4px 16px rgba(236, 72, 153, 0.3);
}

.action-btn.theme-toggle-btn {
  background: rgba(99, 102, 241, 0.26);
  border-color: rgba(99, 102, 241, 0.45);
}

.action-btn.theme-toggle-btn:hover {
  background: rgba(99, 102, 241, 0.42);
  box-shadow: 0 4px 16px rgba(99, 102, 241, 0.28);
}

.theme-toggle-btn .theme-toggle-icon {
  transition: opacity 0.2s ease, transform 0.2s ease;
}

.theme-toggle-btn .theme-toggle-icon-sun {
  display: none;
}

.theme-toggle-btn.is-dark .theme-toggle-icon-moon {
  display: none;
}

.theme-toggle-btn.is-dark .theme-toggle-icon-sun {
  display: block;
}

@keyframes voicePulse {
  0%, 100% { transform: scale(1); }
  50% { transform: scale(1.05); }
}

@keyframes recording {
  0%, 100% { opacity: 1; }
  50% { opacity: 0.6; }
}

@keyframes pulseSlow {
  0%, 100% { opacity: 1; }
  50% { opacity: 0.7; }
}

.transcription-monitor {
  flex: 0 0 auto;
  display: flex;
  flex-direction: column;
  gap: 4px;
  padding: 5px 6px;
  border-radius: 8px;
  border: 1px solid var(--glass-panel-border);
  background: rgba(255, 255, 255, 0.2);
  backdrop-filter: blur(18px);
}

.monitor-header {
  display: flex;
  align-items: center;
  justify-content: space-between;
  gap: 6px;
}

.monitor-title {
  font-size: 10px;
  font-weight: 800;
  letter-spacing: 0.03em;
  text-transform: uppercase;
  color: rgba(0, 0, 0, 0.75);
}

.monitor-master-state {
  font-size: 10px;
  padding: 1px 6px;
  border-radius: 999px;
  color: #fff;
  background: rgba(107, 114, 128, 0.9);
}

.monitor-master-state.active {
  background: rgba(34, 197, 94, 0.9);
}

.monitor-master-state.connecting {
  background: rgba(59, 130, 246, 0.9);
}

.monitor-source-grid {
  display: grid;
  grid-template-columns: minmax(0, 1fr) minmax(0, 1fr);
  gap: 6px;
}

.monitor-source-row {
  display: grid;
  grid-template-columns: auto auto minmax(0, 1fr);
  align-items: center;
  gap: 4px;
  min-width: 0;
  padding: 2px 5px;
  border-radius: 6px;
  border: 1px solid rgba(255, 255, 255, 0.26);
  background: rgba(255, 255, 255, 0.15);
}

.monitor-source-label {
  font-size: 9px;
  font-weight: 800;
  letter-spacing: 0.02em;
  color: rgba(0, 0, 0, 0.75);
}

.monitor-status-badge {
  font-size: 9px;
  font-weight: 700;
  text-align: center;
  padding: 2px 6px;
  border-radius: 999px;
  color: #fff;
  background: rgba(107, 114, 128, 0.9);
}

.monitor-status-badge.off {
  background: rgba(107, 114, 128, 0.9);
}

.monitor-status-badge.connecting {
  background: rgba(59, 130, 246, 0.9);
}

.monitor-status-badge.listening {
  background: rgba(34, 197, 94, 0.9);
}

.monitor-status-badge.error {
  background: rgba(239, 68, 68, 0.92);
}

.monitor-live-text {
  min-width: 0;
  font-size: 9px;
  line-height: 1.2;
  color: rgba(0, 0, 0, 0.76);
  overflow: hidden;
  text-overflow: ellipsis;
  white-space: nowrap;
}

.monitor-log-list {
  max-height: 33px;
  overflow-y: auto;
  display: flex;
  flex-direction: column;
  gap: 1px;
  padding-top: 0;
}

.monitor-log-entry {
  font-size: 9px;
  line-height: 1.2;
  padding: 1px 5px;
  border-radius: 3px;
  color: rgba(0, 0, 0, 0.78);
  background: rgba(255, 255, 255, 0.3);
  border: 1px solid rgba(255, 255, 255, 0.35);
}

.monitor-log-entry.error {
  background: rgba(254, 226, 226, 0.65);
  border-color: rgba(248, 113, 113, 0.45);
}

/* CHAT INTERFACE */
.chat-container {
  --chat-composer-height: 38px;
  flex: 1 1 0;
  min-height: 200px;
  display: flex;
  flex-direction: column;
  background: var(--glass-panel-bg);
  backdrop-filter: blur(20px);
  border: 1px solid var(--glass-panel-border);
  border-radius: 8px;
  overflow: hidden;
  position: relative;
}

.chat-resize-handle {
  display: none;
  position: absolute;
  bottom: calc(var(--chat-composer-height) + 2px);
  left: 50%;
  transform: translateX(-50%);
  width: 60px;
  height: 8px;
  background: rgba(59, 130, 246, 0.4);
  border-radius: 4px 4px 0 0;
  cursor: default;
  transition: all 0.2s ease;
  z-index: 100;
}

.chat-container:hover .chat-resize-handle {
  background: rgba(59, 130, 246, 0.7);
  height: 10px;
}

body.window-resizing,
body.window-resizing * {
  cursor: default !important;
}

body.chat-resizing,
body.chat-resizing * {
  cursor: default !important;
}

.chat-header {
  display: flex;
  justify-content: space-between;
  align-items: center;
  padding: 5px 8px;
  background: var(--glass-header-bg);
  border-bottom: 1px solid var(--glass-panel-border);
  backdrop-filter: blur(20px);
}

.chat-title {
  font-size: 11px;
  font-weight: 700;
  color: rgba(0, 0, 0, 0.8);
  display: flex;
  align-items: center;
  gap: 4px;
}

.chat-messages {
  flex: 1;
  min-height: 0;
  overflow-y: auto;
  padding: 6px;
  display: flex;
  flex-direction: column;
  gap: 4px;
}

.chat-composer {
  min-height: var(--chat-composer-height);
  padding: 5px 6px;
  display: flex;
  align-items: flex-end;
  gap: 5px;
  border-top: 1px solid rgba(255, 255, 255, 0.2);
  background: rgba(255, 255, 255, 0.2);
  backdrop-filter: blur(14px);
  cursor: default;
}

.chat-manual-input {
  flex: 1;
  min-height: 22px;
  max-height: 88px;
  padding: 3px 7px;
  border: 1px solid rgba(255, 255, 255, 0.45);
  border-radius: 6px;
  resize: none;
  outline: none;
  font-size: 11px;
  line-height: 1.4;
  color: rgba(0, 0, 0, 0.9);
  background: rgba(255, 255, 255, 0.38);
  box-shadow: inset 0 1px 2px rgba(255, 255, 255, 0.35);
  font-family: inherit;
  cursor: default;
}

.chat-manual-input:focus {
  border-color: rgba(59, 130, 246, 0.55);
  box-shadow: 0 0 0 2px rgba(59, 130, 246, 0.15);
}

.chat-manual-input::placeholder {
  color: rgba(0, 0, 0, 0.48);
}

.chat-manual-send {
  border: 1px solid rgba(59, 130, 246, 0.5);
  background: rgba(59, 130, 246, 0.22);
  color: rgba(0, 0, 0, 0.84);
  border-radius: 6px;
  font-size: 10px;
  font-weight: 700;
  min-width: 40px;
  height: 22px;
  padding: 0 10px;
  cursor: pointer;
  transition: all 0.2s ease;
}

.chat-manual-send:hover {
  transform: translateY(-1px);
  background: rgba(59, 130, 246, 0.32);
}

.chat-manual-send:disabled {
  opacity: 0.55;
  cursor: default;
}

.chat-message {
  display: flex;
  flex-direction: column;
  gap: 1px;
  padding: 6px 8px;
  border-radius: 7px;
  backdrop-filter: blur(15px);
  transition: all 0.2s ease;
  border: 1px solid rgba(255, 255, 255, 0.18);
}

.chat-message.voice-message {
  background: rgba(34, 197, 94, 0.25);
  border-left: 3px solid rgba(34, 197, 94, 0.8);
  box-shadow: 0 2px 8px rgba(34, 197, 94, 0.15);
}

.chat-message.screenshot-message {
  background: rgba(59, 130, 246, 0.25);
  border-left: 3px solid rgba(59, 130, 246, 0.8);
  box-shadow: 0 2px 8px rgba(59, 130, 246, 0.15);
}

.chat-message.ai-response-message {
  background: rgba(147, 51, 234, 0.25);
  border-left: 3px solid rgba(147, 51, 234, 0.8);
  box-shadow: 0 2px 8px rgba(147, 51, 234, 0.15);
}

.chat-message.system-message {
  background: rgba(156, 163, 175, 0.25);
  border-left: 3px solid rgba(156, 163, 175, 0.8);
  box-shadow: 0 2px 8px rgba(156, 163, 175, 0.15);
}

.chat-message.interim {
  background: rgba(255, 193, 7, 0.1);
  border-left: 3px solid rgba(255, 193, 7, 0.6);
  opacity: 0.8;
}

.chat-message.partial {
  background: rgba(34, 197, 94, 0.15);
  border-left: 3px solid rgba(34, 197, 94, 0.8);
  opacity: 0.9;
  animation: pulse 1.5s ease-in-out infinite;
}

@keyframes pulse {
  0%, 100% {
    opacity: 0.9;
  }
  50% {
    opacity: 0.7;
  }
}

.partial-indicator {
  font-size: 9px;
  color: rgba(34, 197, 94, 0.9);
  font-weight: 600;
  padding: 2px 6px;
  background: rgba(34, 197, 94, 0.2);
  border-radius: 4px;
  display: flex;
  align-items: center;
  gap: 3px;
}

.partial-text {
  font-style: italic;
  color: rgba(0, 0, 0, 0.85);
}

.message-header {
  display: flex;
  align-items: center;
  gap: 5px;
  margin-bottom: 1px;
}

.message-icon {
  font-size: 12px;
  display: flex;
  align-items: center;
}

.message-time {
  font-size: 9px;
  color: rgba(0, 0, 0, 0.6);
  font-family: 'SF Mono', Monaco, Consolas, monospace;
  margin-left: 2px;
}

.message-label {
  font-size: 9px;
  font-weight: 700;
  text-transform: uppercase;
  letter-spacing: 0.04em;
  padding: 1px 4px;
  border-radius: 3px;
  background: rgba(0, 0, 0, 0.08);
}

.message-content {
  font-size: 11px;
  line-height: 1.5;
  color: rgba(0, 0, 0, 0.95);
  -webkit-user-select: text;
  user-select: text;
  word-wrap: break-word;
  background: var(--glass-message-bg);
  padding: 4px 6px;
  border-radius: 5px;
  font-weight: 500;
  text-shadow: 0 1px 2px rgba(255, 255, 255, 0.5);
}

.ai-include-toggle {
  border: 1px solid rgba(255, 255, 255, 0.42);
  background: rgba(16, 185, 129, 0.26);
  color: rgba(0, 0, 0, 0.84);
  border-radius: 999px;
  padding: 1px 6px;
  font-size: 9px;
  font-weight: 700;
  line-height: 1.2;
  cursor: pointer;
  transition: all 0.2s ease;
}

.ai-include-toggle:hover {
  transform: translateY(-1px);
}

.message-actions {
  margin-left: auto;
  display: flex;
  align-items: center;
  gap: 4px;
}

.message-copy-btn {
  border: 1px solid rgba(255, 255, 255, 0.42);
  background: rgba(59, 130, 246, 0.18);
  color: rgba(0, 0, 0, 0.84);
  border-radius: 4px;
  width: 18px;
  height: 18px;
  padding: 0;
  display: inline-flex;
  align-items: center;
  justify-content: center;
  line-height: 1;
  cursor: pointer;
  transition: all 0.2s ease;
}

.message-copy-btn:hover {
  background: rgba(59, 130, 246, 0.3);
  transform: scale(1.05);
}

.message-copy-btn svg {
  pointer-events: none;
}

.ai-include-toggle.excluded {
  background: rgba(244, 63, 94, 0.2);
  border-color: rgba(244, 63, 94, 0.4);
}

.chat-message.ai-excluded {
  opacity: 0.68;
  filter: grayscale(0.2);
}

.chat-message.ai-excluded .message-content {
  border: 1px dashed rgba(244, 63, 94, 0.35);
}

.ai-excluded-note {
  display: none;
  margin-bottom: 3px;
  padding: 1px 5px;
  border-radius: 5px;
  font-size: 9px;
  font-weight: 700;
  color: rgba(190, 24, 93, 0.85);
  background: rgba(244, 63, 94, 0.12);
}

.chat-message.ai-excluded .ai-excluded-note {
  display: inline-flex;
}

.message-content.interim-content {
  opacity: 0.7;
  font-style: italic;
}

.message-content.system-message {
  color: rgba(0, 0, 0, 0.6);
  font-style: italic;
}

.message-content.ai-response {
  color: rgba(0, 0, 0, 0.98);
  font-weight: 600;
  background: rgba(255, 255, 255, 0.38);
  font-size: 11px;
}

/* HIDE SETTINGS IN COMPACT MODE */
.settings-section {
  display: none;
}

/* COMPACT RESULTS PANEL - LEGACY */
.results-panel {
  position: absolute;
  top: 130px;
  left: 0;
  right: 0;
  width: 400px;
  max-height: 300px;
  background: var(--glass-panel-bg);
  backdrop-filter: blur(40px) saturate(1.8);
  border: 1px solid var(--glass-panel-border);
  border-radius: 12px;
  box-shadow: 0 8px 32px rgba(0, 0, 0, 0.2);
  display: flex;
  flex-direction: column;
  z-index: 100;
}

.results-panel.hidden {
  display: none;
}

.results-header {
  display: flex;
  justify-content: space-between;
  align-items: center;
  padding: 8px 12px;
  border-bottom: 1px solid var(--glass-panel-border);
  backdrop-filter: blur(20px);
}

.results-title {
  display: flex;
  align-items: center;
  gap: 6px;
  font-size: 11px;
  font-weight: 700;
  color: rgba(0, 0, 0, 0.8);
}

.ai-response-icon {
  font-size: 12px;
}

.results-actions {
  display: flex;
  gap: 4px;
}

.close-btn {
  background: var(--glass-control-bg);
  border: 1px solid var(--glass-control-border);
  color: rgba(0, 0, 0, 0.8);
  padding: 4px;
  border-radius: 4px;
  cursor: pointer;
  transition: all 0.2s ease;
  width: 20px;
  height: 20px;
  display: flex;
  align-items: center;
  justify-content: center;
  backdrop-filter: blur(10px);
}

.close-btn:hover {
  background: rgba(255, 0, 0, 0.3);
}

.results-content {
  flex: 1;
  padding: 12px;
  overflow-y: auto;
  max-height: 250px;
}

.result-text {
  font-size: 11px;
  line-height: 1.4;
  color: rgba(0, 0, 0, 0.8);
  white-space: pre-wrap;
  word-wrap: break-word;
}

/* CODE FORMATTING */
.result-text code, .message-content code {
  background: rgba(30, 30, 30, 0.95);
  color: #a8e063;
  padding: 2px 5px;
  border-radius: 4px;
  font-family: 'SF Mono', Monaco, Consolas, monospace;
  font-size: 10px;
  border: 1px solid rgba(168, 224, 99, 0.3);
  font-weight: 500;
}

.result-text pre, .message-content pre {
  background: rgba(20, 20, 30, 0.98);
  color: #e0e0e0;
  border: 2px solid rgba(100, 180, 255, 0.5);
  border-radius: 8px;
  padding: 12px;
  margin: 8px 0;
  font-family: 'SF Mono', Monaco, Consolas, monospace;
  font-size: 10px;
  line-height: 1.5;
  overflow-x: auto;
  backdrop-filter: blur(20px);
  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.6), inset 0 1px 0 rgba(255, 255, 255, 0.1);
}

.result-text pre code, .message-content pre code {
  background: transparent;
  color: inherit;
  padding: 0;
  border: none;
  font-size: 10px;
  display: block;
}

.result-text .code-block, .message-content .code-block {
  background: rgba(20, 20, 30, 0.98);
  color: #e0e0e0;
  border: 2px solid rgba(100, 180, 255, 0.5);
  border-radius: 8px;
  padding: 12px;
  margin: 8px 0;
  font-family: 'SF Mono', Monaco, Consolas, monospace;
  font-size: 10px;
  line-height: 1.5;
  overflow-x: auto;
  backdrop-filter: blur(20px);
  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.6), inset 0 1px 0 rgba(255, 255, 255, 0.1);
}

.result-text .logic-section, .message-content .logic-section {
  background: rgba(59, 130, 246, 0.15);
  border-left: 3px solid rgba(59, 130, 246, 0.6);
  padding: 6px;
  margin: 6px 0;
  border-radius: 0 6px 6px 0;
  backdrop-filter: blur(10px);
}

.result-text .key-points, .message-content .key-points {
  background: rgba(255, 215, 0, 0.15);
  border-left: 3px solid rgba(255, 215, 0, 0.6);
  padding: 6px;
  margin: 6px 0;
  border-radius: 0 6px 6px 0;
  backdrop-filter: blur(10px);
}

.result-text strong, .message-content strong {
  color: rgba(0, 0, 0, 0.95);
  font-weight: 800;
  background: rgba(255, 215, 0, 0.15);
  padding: 1px 3px;
  border-radius: 3px;
}

.result-text h1, .message-content h1,
.result-text h2, .message-content h2,
.result-text h3, .message-content h3 {
  color: rgba(0, 0, 0, 0.95);
  font-weight: 700;
  margin: 8px 0 4px 0;
  background: rgba(100, 180, 255, 0.15);
  padding: 4px 8px;
  border-radius: 4px;
  border-left: 3px solid rgba(59, 130, 246, 0.8);
}

.result-text ul, .message-content ul,
.result-text ol, .message-content ol {
  margin: 6px 0;
  padding-left: 20px;
}

.result-text li, .message-content li {
  margin: 3px 0;
  color: rgba(0, 0, 0, 0.85);
}

/* COMPACT LOADING OVERLAY */
.loading-overlay {
  position: absolute;
  top: 0;
  left: 0;
  right: 0;
  bottom: 0;
  background: rgba(255, 255, 255, 0.3);
  backdrop-filter: blur(30px);
  display: flex;
  flex-direction: column;
  align-items: center;
  justify-content: center;
  border-radius: 12px;
  z-index: 200;
  gap: 12px;
  transition: all 0.3s ease;
}

.loading-overlay.hidden {
  display: none;
  opacity: 0;
}

.loading-content {
  display: flex;
  flex-direction: column;
  align-items: center;
  gap: 12px;
  text-align: center;
  padding: 20px;
}

.analyzing-icon {
  font-size: 32px;
  animation: bounce 1s infinite;
  filter: drop-shadow(0 2px 4px rgba(0, 0, 0, 0.1));
}

.loading-text {
  font-size: 13px;
  color: rgba(0, 0, 0, 0.9);
  font-weight: 600;
  line-height: 1.5;
  max-width: 300px;
}

.loading-text small {
  display: block;
  font-size: 11px;
  color: rgba(0, 0, 0, 0.6);
  font-weight: 400;
  margin-top: 4px;
}

@keyframes bounce {
  0%, 100% { transform: scale(1); }
  50% { transform: scale(1.1); }
}

/* EMERGENCY OVERLAY - PRESERVES STEALTH */
.emergency-overlay {
  position: absolute;
  top: 0;
  left: 0;
  right: 0;
  bottom: 0;
  background: rgba(0, 0, 0, 0.95);
  display: flex;
  align-items: center;
  justify-content: center;
  border-radius: 12px;
  backdrop-filter: blur(40px);
  z-index: 300;
}

.emergency-overlay.hidden {
  display: none;
}

.emergency-message {
  color: #ff4444;
  font-weight: 700;
  font-size: 12px;
  animation: blink 1s infinite;
}

@keyframes blink {
  0%, 50% { opacity: 1; }
  51%, 100% { opacity: 0.3; }
}

/* STEALTH MODE - DARKER GLASS */
.stealth-mode .glass-container {
  background: rgba(20, 25, 35, 0.3);
  border: 1px solid rgba(255, 255, 255, 0.1);
  opacity: 0.7;
  transition: all 0.5s ease;
}

.stealth-mode * {
  opacity: 0.8 !important;
  transition: opacity 0.5s ease;
}

.stealth-mode:hover * {
  opacity: 1 !important;
  transition: opacity 0.2s ease;
}

/* STATUS STYLES */
.status-success { color: #00ff88 !important; }
.status-error { color: #ff6b6b !important; }
.status-info { color: #74b9ff !important; }

/* SCROLLBAR STYLING */
.chat-messages::-webkit-scrollbar,
.results-content::-webkit-scrollbar,
.monitor-log-list::-webkit-scrollbar,
.settings-body::-webkit-scrollbar {
  width: 4px;
}

.chat-messages::-webkit-scrollbar-track,
.results-content::-webkit-scrollbar-track,
.monitor-log-list::-webkit-scrollbar-track,
.settings-body::-webkit-scrollbar-track {
  background: rgba(255, 255, 255, 0.1);
  border-radius: 2px;
}

.chat-messages::-webkit-scrollbar-thumb,
.results-content::-webkit-scrollbar-thumb,
.monitor-log-list::-webkit-scrollbar-thumb,
.settings-body::-webkit-scrollbar-thumb {
  background: rgba(255, 255, 255, 0.3);
  border-radius: 2px;
}

.chat-messages::-webkit-scrollbar-thumb:hover,
.results-content::-webkit-scrollbar-thumb:hover,
.monitor-log-list::-webkit-scrollbar-thumb:hover,
.settings-body::-webkit-scrollbar-thumb:hover {
  background: rgba(255, 255, 255, 0.4);
}

/* ENTRANCE ANIMATION */
@keyframes fadeInGlass {
  from { 
    opacity: 0; 
    transform: scale(0.95) translateY(-10px);
    backdrop-filter: blur(0px);
  }
  to { 
    opacity: 1; 
    transform: scale(1) translateY(0);
    backdrop-filter: blur(40px);
  }
}

.glass-container {
  animation: fadeInGlass 0.4s cubic-bezier(0.4, 0, 0.2, 1);
}

/* CHAT MESSAGE ANIMATIONS */
.chat-message {
  animation: slideInMessage 0.3s ease-out;
}

@keyframes slideInMessage {
  from {
    opacity: 0;
    transform: translateY(10px);
  }
  to {
    opacity: 1;
    transform: translateY(0);
  }
}

/* Voice/transcription control icon styles */
.transcription-btn svg,
.source-toggle svg {
  transition: all 0.2s ease;
}

.transcription-btn.listening svg,
.transcription-btn.active svg {
  color: white;
  filter: drop-shadow(0 0 4px rgba(34, 197, 94, 0.8));
}

.transcription-btn.connecting svg {
  color: white;
  filter: drop-shadow(0 0 4px rgba(59, 130, 246, 0.8));
}

/* SETTINGS PANEL */
.settings-panel {
  position: absolute;
  top: 0;
  left: 0;
  right: 0;
  bottom: 0;
  background: var(--glass-settings-bg);
  backdrop-filter: blur(40px) saturate(1.8);
  border-radius: 12px;
  z-index: 250;
  display: flex;
  flex-direction: column;
  animation: fadeInGlass 0.3s ease;
}

.settings-panel.hidden {
  display: none;
}

.close-confirmation {
  position: absolute;
  inset: 0;
  display: flex;
  align-items: center;
  justify-content: center;
  padding: 20px;
  background: rgba(15, 23, 42, 0.28);
  backdrop-filter: blur(18px);
  border-radius: 12px;
  z-index: 260;
}

.close-confirmation.hidden {
  display: none;
}

.close-confirmation-card {
  width: min(320px, 100%);
  display: flex;
  flex-direction: column;
  gap: 10px;
  padding: 16px;
  background: rgba(255, 255, 255, 0.32);
  border: 1px solid rgba(255, 255, 255, 0.45);
  border-radius: 12px;
  box-shadow: 0 12px 36px rgba(15, 23, 42, 0.22);
  backdrop-filter: blur(24px);
}

.close-confirmation-title {
  font-size: 13px;
  font-weight: 800;
  color: rgba(0, 0, 0, 0.86);
}

.close-confirmation-text {
  font-size: 11px;
  line-height: 1.5;
  color: rgba(0, 0, 0, 0.72);
}

.close-confirmation-actions {
  display: flex;
  justify-content: flex-end;
  gap: 8px;
  margin-top: 2px;
}

.close-confirmation-btn {
  min-width: 88px;
  padding: 7px 12px;
  border-radius: 7px;
  border: 1px solid transparent;
  font-size: 11px;
  font-weight: 700;
  cursor: pointer;
  transition: all 0.2s ease;
}

.close-confirmation-btn-secondary {
  background: rgba(255, 255, 255, 0.28);
  border-color: rgba(255, 255, 255, 0.45);
  color: rgba(0, 0, 0, 0.76);
}

.close-confirmation-btn-secondary:hover {
  background: rgba(255, 255, 255, 0.42);
}

.close-confirmation-btn-danger {
  background: rgba(255, 59, 48, 0.84);
  border-color: rgba(255, 59, 48, 0.92);
  color: #fff;
}

.close-confirmation-btn-danger:hover {
  background: rgba(220, 38, 38, 0.92);
  box-shadow: 0 6px 18px rgba(220, 38, 38, 0.24);
}

.close-confirmation-btn:focus-visible {
  outline: 2px solid rgba(59, 130, 246, 0.55);
  outline-offset: 2px;
}

.settings-header {
  display: flex;
  justify-content: space-between;
  align-items: center;
  padding: 10px 14px;
  border-bottom: 1px solid var(--glass-panel-border);
}

.settings-title {
  font-size: 12px;
  font-weight: 700;
  color: rgba(0, 0, 0, 0.85);
}

.settings-body {
  flex: 1;
  overflow-y: auto;
  padding: 12px 14px;
  display: flex;
  flex-direction: column;
  gap: 10px;
}

.settings-group {
  display: flex;
  flex-direction: column;
  gap: 3px;
}

.settings-label {
  font-size: 10px;
  font-weight: 700;
  color: rgba(0, 0, 0, 0.7);
  text-transform: uppercase;
  letter-spacing: 0.5px;
}

.settings-label-row {
  display: flex;
  align-items: center;
  justify-content: space-between;
  gap: 8px;
}

.settings-value-chip {
  min-width: 42px;
  padding: 2px 6px;
  border-radius: 999px;
  background: rgba(59, 130, 246, 0.18);
  border: 1px solid rgba(59, 130, 246, 0.28);
  color: rgba(15, 23, 42, 0.8);
  font-size: 10px;
  font-weight: 700;
  text-align: center;
  font-family: 'SF Mono', Monaco, Consolas, monospace;
}

.settings-input {
  background: var(--glass-input-bg);
  border: 1px solid rgba(255, 255, 255, 0.45);
  border-radius: 6px;
  padding: 6px 8px;
  font-size: 11px;
  color: rgba(0, 0, 0, 0.9);
  font-family: 'SF Mono', Monaco, Consolas, monospace;
  outline: none;
  transition: all 0.2s ease;
  backdrop-filter: blur(10px);
}

.settings-input-row {
  display: flex;
  align-items: center;
  gap: 6px;
}

.settings-input-row .settings-input {
  flex: 1;
  min-width: 0;
}

.settings-input-toggle {
  height: 30px;
  min-width: 50px;
  padding: 0 9px;
  border-radius: 6px;
  border: 1px solid rgba(59, 130, 246, 0.45);
  background: rgba(59, 130, 246, 0.16);
  color: rgba(15, 23, 42, 0.85);
  font-size: 10px;
  font-weight: 700;
  font-family: inherit;
  cursor: pointer;
  transition: all 0.2s ease;
}

.settings-input-toggle:hover {
  background: rgba(59, 130, 246, 0.28);
  transform: translateY(-1px);
}

.settings-input-toggle:focus-visible {
  outline: none;
  box-shadow: 0 0 0 2px rgba(59, 130, 246, 0.24);
}

.settings-input:focus {
  border-color: rgba(59, 130, 246, 0.6);
  background: var(--glass-input-focus-bg);
  box-shadow: 0 0 0 2px rgba(59, 130, 246, 0.2);
}

.settings-input::placeholder {
  color: rgba(0, 0, 0, 0.35);
}

select.settings-input {
  cursor: pointer;
  -webkit-appearance: none;
  appearance: none;
  background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='10' height='10' viewBox='0 0 24 24'%3E%3Cpath fill='%23333' d='M7 10l5 5 5-5z'/%3E%3C/svg%3E");
  background-repeat: no-repeat;
  background-position: right 6px center;
  padding-right: 22px;
}

.settings-range {
  width: 100%;
  margin: 2px 0 0;
  -webkit-appearance: none;
  appearance: none;
  background: transparent;
  cursor: default;
}

.settings-range::-webkit-slider-runnable-track {
  height: 6px;
  border-radius: 999px;
  background: linear-gradient(90deg, rgba(59, 130, 246, 0.75), rgba(147, 197, 253, 0.55));
  border: 1px solid rgba(255, 255, 255, 0.28);
}

.settings-range::-webkit-slider-thumb {
  -webkit-appearance: none;
  appearance: none;
  width: 16px;
  height: 16px;
  margin-top: -6px;
  border-radius: 50%;
  background: rgba(255, 255, 255, 0.95);
  border: 1px solid rgba(59, 130, 246, 0.45);
  box-shadow: 0 2px 8px rgba(15, 23, 42, 0.2);
  cursor: default;
}

.settings-range::-moz-range-thumb {
  cursor: default;
}

.settings-range:focus {
  outline: none;
}

.settings-range:focus::-webkit-slider-thumb {
  box-shadow: 0 0 0 3px rgba(59, 130, 246, 0.18);
}

.settings-shortcuts-list {
  display: flex;
  flex-direction: column;
  gap: 4px;
}

.settings-shortcut-row {
  display: flex;
  align-items: center;
  justify-content: space-between;
  gap: 8px;
  padding: 4px 6px;
  border-radius: 6px;
  background: rgba(255, 255, 255, 0.24);
  border: 1px solid rgba(255, 255, 255, 0.32);
}

.settings-shortcut-meta {
  display: inline-flex;
  align-items: flex-start;
  gap: 6px;
  min-width: 0;
}

.settings-shortcut-icon {
  width: 15px;
  height: 15px;
  display: inline-flex;
  align-items: center;
  justify-content: center;
  color: rgba(15, 23, 42, 0.8);
  flex: 0 0 auto;
}

.settings-shortcut-icon svg {
  width: 12px;
  height: 12px;
  display: block;
}

.settings-shortcut-button {
  font-size: 10px;
  font-weight: 600;
  color: rgba(0, 0, 0, 0.76);
  white-space: nowrap;
  overflow: hidden;
  text-overflow: ellipsis;
}

.settings-shortcut-text {
  min-width: 0;
  display: flex;
  flex-direction: column;
  gap: 1px;
}

.settings-shortcut-description {
  font-size: 9px;
  color: rgba(0, 0, 0, 0.58);
  line-height: 1.25;
  overflow: hidden;
  text-overflow: ellipsis;
  white-space: nowrap;
}

.settings-shortcut-key {
  font-size: 10px;
  font-weight: 700;
  color: rgba(15, 23, 42, 0.84);
  font-family: 'SF Mono', Monaco, Consolas, monospace;
  padding: 2px 6px;
  border-radius: 999px;
  background: rgba(59, 130, 246, 0.18);
  border: 1px solid rgba(59, 130, 246, 0.3);
}

.settings-shortcuts-empty {
  font-size: 10px;
  color: rgba(0, 0, 0, 0.58);
  padding: 4px 0;
}

.settings-helper-text {
  font-size: 9px;
  color: rgba(0, 0, 0, 0.6);
  line-height: 1.35;
}

.settings-helper-text code {
  font-size: 9px;
  background: rgba(255, 255, 255, 0.4);
  border: 1px solid rgba(255, 255, 255, 0.5);
  border-radius: 4px;
  padding: 1px 4px;
}

.save-settings-btn {
  background: rgba(59, 130, 246, 0.8);
  border: 1px solid rgba(59, 130, 246, 0.9);
  color: white;
  padding: 8px 12px;
  border-radius: 6px;
  font-size: 11px;
  font-weight: 700;
  cursor: pointer;
  transition: all 0.2s ease;
  margin-top: 4px;
}

.save-settings-btn:hover {
  background: rgba(37, 99, 235, 0.9);
  box-shadow: 0 4px 16px rgba(59, 130, 246, 0.4);
  transform: translateY(-1px);
}

.save-settings-btn:active {
  transform: translateY(0);
}

.action-btn.settings-btn {
  background: rgba(107, 114, 128, 0.2);
  border-color: rgba(107, 114, 128, 0.4);
}

.action-btn.settings-btn:hover {
  background: rgba(107, 114, 128, 0.4);
}

/* THEME: DARK MODE */
body.theme-dark {
  --glass-shell-bg: rgba(8, 14, 28, 0.72);
  --glass-shell-border: rgba(148, 163, 184, 0.34);
  --glass-panel-bg: rgba(15, 23, 42, 0.56);
  --glass-panel-border: rgba(148, 163, 184, 0.24);
  --glass-header-bg: rgba(30, 41, 59, 0.55);
  --glass-control-bg: rgba(30, 41, 59, 0.62);
  --glass-control-border: rgba(148, 163, 184, 0.36);
  --glass-input-bg: rgba(15, 23, 42, 0.74);
  --glass-input-focus-bg: rgba(30, 41, 59, 0.82);
  --glass-message-bg: rgba(15, 23, 42, 0.56);
  --glass-settings-bg: rgba(2, 6, 23, 0.72);
  color: rgba(226, 232, 240, 0.94);
}

body.theme-dark .glass-container {
  box-shadow:
    0 14px 38px rgba(2, 6, 23, 0.55),
    inset 0 1px 0 rgba(226, 232, 240, 0.07);
}

body.theme-dark .status-section,
body.theme-dark .chat-composer,
body.theme-dark .close-confirmation-card {
  border-color: rgba(148, 163, 184, 0.3);
}

body.theme-dark .timer,
body.theme-dark .action-btn,
body.theme-dark .source-toggle,
body.theme-dark .monitor-title,
body.theme-dark .monitor-source-label,
body.theme-dark .monitor-live-text,
body.theme-dark .monitor-log-entry,
body.theme-dark .chat-title,
body.theme-dark .result-text,
body.theme-dark .results-title,
body.theme-dark .settings-title,
body.theme-dark .settings-label,
body.theme-dark .settings-input,
body.theme-dark .settings-shortcut-button,
body.theme-dark .settings-shortcut-description,
body.theme-dark .settings-shortcuts-empty,
body.theme-dark .settings-helper-text,
body.theme-dark .settings-shortcut-key,
body.theme-dark .close-confirmation-title,
body.theme-dark .close-confirmation-text,
body.theme-dark .message-time,
body.theme-dark .message-content {
  color: rgba(226, 232, 240, 0.92);
}

body.theme-dark .status-text {
  background: rgba(2, 6, 23, 0.86);
  color: rgba(241, 245, 249, 0.95);
}

body.theme-dark .action-btn {
  border-color: rgba(148, 163, 184, 0.36);
  background: rgba(30, 41, 59, 0.62);
}

body.theme-dark .action-btn:hover {
  background: rgba(51, 65, 85, 0.78);
  box-shadow: 0 4px 12px rgba(2, 6, 23, 0.4);
}

body.theme-dark .action-btn.analyze-btn,
body.theme-dark .action-btn.transcription-btn.active,
body.theme-dark .action-btn.transcription-btn.listening,
body.theme-dark .action-btn.transcription-btn.connecting {
  color: #fff;
}

body.theme-dark .action-btn.screen-ai-btn {
  color: rgba(241, 245, 249, 0.94);
}

body.theme-dark .action-btn.theme-toggle-btn {
  background: rgba(129, 140, 248, 0.36);
  border-color: rgba(165, 180, 252, 0.48);
}

body.theme-dark .transcription-control {
  border-color: rgba(74, 222, 128, 0.4);
  background: rgba(34, 197, 94, 0.2);
}

body.theme-dark .source-toggle {
  border-color: rgba(148, 163, 184, 0.45);
  background: rgba(30, 41, 59, 0.88);
}

body.theme-dark .source-toggle:hover {
  background: rgba(51, 65, 85, 0.9);
}

body.theme-dark .source-toggle.running {
  box-shadow: 0 0 0 2px rgba(148, 163, 184, 0.52);
}

body.theme-dark .monitor-log-entry {
  background: rgba(15, 23, 42, 0.68);
  border-color: rgba(148, 163, 184, 0.28);
}

body.theme-dark .monitor-source-row {
  background: rgba(15, 23, 42, 0.56);
  border-color: rgba(148, 163, 184, 0.26);
}

body.theme-dark .monitor-log-entry.error {
  background: rgba(127, 29, 29, 0.56);
  border-color: rgba(248, 113, 113, 0.42);
}

body.theme-dark .chat-composer {
  background: rgba(15, 23, 42, 0.58);
  border-top-color: rgba(148, 163, 184, 0.24);
}

body.theme-dark .chat-manual-input {
  background: rgba(15, 23, 42, 0.78);
  border-color: rgba(148, 163, 184, 0.4);
  color: rgba(241, 245, 249, 0.96);
  box-shadow: inset 0 1px 2px rgba(2, 6, 23, 0.48);
}

body.theme-dark .chat-manual-input:focus {
  border-color: rgba(96, 165, 250, 0.72);
  box-shadow: 0 0 0 2px rgba(96, 165, 250, 0.2);
}

body.theme-dark .settings-input-toggle {
  border-color: rgba(96, 165, 250, 0.45);
  background: rgba(30, 58, 138, 0.34);
  color: rgba(226, 232, 240, 0.92);
}

body.theme-dark .settings-input-toggle:hover {
  background: rgba(37, 99, 235, 0.45);
}

body.theme-dark .chat-manual-input::placeholder {
  color: rgba(148, 163, 184, 0.85);
}

body.theme-dark .chat-manual-send {
  border-color: rgba(96, 165, 250, 0.6);
  background: rgba(37, 99, 235, 0.42);
  color: rgba(241, 245, 249, 0.94);
}

body.theme-dark .chat-manual-send:hover {
  background: rgba(37, 99, 235, 0.56);
}

body.theme-dark .message-label {
  background: rgba(148, 163, 184, 0.2);
  color: rgba(241, 245, 249, 0.9);
}

body.theme-dark .message-content {
  text-shadow: none;
}

body.theme-dark .message-content.system-message {
  color: rgba(203, 213, 225, 0.78);
}

body.theme-dark .message-content.ai-response {
  color: rgba(241, 245, 249, 0.96);
  background: rgba(51, 65, 85, 0.66);
}

body.theme-dark .result-text .key-points,
body.theme-dark .message-content .key-points {
  background: rgba(250, 204, 21, 0.22);
  border-left-color: rgba(250, 204, 21, 0.76);
}

body.theme-dark .result-text strong,
body.theme-dark .message-content strong {
  color: rgba(15, 23, 42, 0.95);
  background: rgba(250, 204, 21, 0.7);
  box-shadow: inset 0 0 0 1px rgba(250, 204, 21, 0.5);
}

body.theme-dark .ai-include-toggle {
  border-color: rgba(148, 163, 184, 0.45);
  color: rgba(241, 245, 249, 0.94);
}

body.theme-dark .message-copy-btn {
  border-color: rgba(148, 163, 184, 0.45);
  color: rgba(241, 245, 249, 0.94);
  background: rgba(37, 99, 235, 0.24);
}

body.theme-dark .message-copy-btn:hover {
  background: rgba(37, 99, 235, 0.38);
}

body.theme-dark .ai-excluded-note {
  color: rgba(253, 164, 175, 0.92);
  background: rgba(190, 24, 93, 0.2);
}

body.theme-dark .loading-overlay {
  background: rgba(2, 6, 23, 0.62);
}

body.theme-dark .loading-text,
body.theme-dark .loading-text small {
  color: rgba(226, 232, 240, 0.92);
}

body.theme-dark .close-confirmation {
  background: rgba(2, 6, 23, 0.55);
}

body.theme-dark .close-confirmation-card {
  background: rgba(15, 23, 42, 0.72);
  border-color: rgba(148, 163, 184, 0.32);
  box-shadow: 0 12px 36px rgba(2, 6, 23, 0.5);
}

body.theme-dark .close-confirmation-btn-secondary {
  background: rgba(51, 65, 85, 0.72);
  border-color: rgba(148, 163, 184, 0.38);
  color: rgba(226, 232, 240, 0.88);
}

body.theme-dark .close-confirmation-btn-secondary:hover {
  background: rgba(71, 85, 105, 0.82);
}

body.theme-dark .settings-value-chip {
  color: rgba(226, 232, 240, 0.92);
  background: rgba(37, 99, 235, 0.3);
  border-color: rgba(96, 165, 250, 0.4);
}

body.theme-dark .settings-input {
  border-color: rgba(148, 163, 184, 0.42);
}

body.theme-dark .settings-input::placeholder {
  color: rgba(148, 163, 184, 0.84);
}

body.theme-dark select.settings-input {
  background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='10' height='10' viewBox='0 0 24 24'%3E%3Cpath fill='%23e2e8f0' d='M7 10l5 5 5-5z'/%3E%3C/svg%3E");
}

body.theme-dark .settings-shortcut-row {
  background: rgba(15, 23, 42, 0.66);
  border-color: rgba(148, 163, 184, 0.28);
}

body.theme-dark .settings-shortcut-icon {
  color: rgba(191, 219, 254, 0.96);
}

body.theme-dark .settings-helper-text code {
  background: rgba(15, 23, 42, 0.85);
  border-color: rgba(148, 163, 184, 0.36);
  color: rgba(226, 232, 240, 0.92);
}

body.theme-dark #close-settings.close-btn {
  color: rgba(248, 250, 252, 0.98);
  background: rgba(127, 29, 29, 0.46);
  border-color: rgba(248, 113, 113, 0.62);
  box-shadow: 0 0 0 1px rgba(248, 113, 113, 0.18);
}

body.theme-dark #close-settings.close-btn:hover {
  background: rgba(153, 27, 27, 0.68);
  border-color: rgba(252, 165, 165, 0.78);
}

body.theme-dark #close-settings.close-btn:focus-visible {
  outline: 2px solid rgba(248, 113, 113, 0.72);
  outline-offset: 1px;
}

body.theme-dark .chat-messages::-webkit-scrollbar-track,
body.theme-dark .results-content::-webkit-scrollbar-track,
body.theme-dark .monitor-log-list::-webkit-scrollbar-track,
body.theme-dark .settings-body::-webkit-scrollbar-track {
  background: rgba(15, 23, 42, 0.52);
}

body.theme-dark .chat-messages::-webkit-scrollbar-thumb,
body.theme-dark .results-content::-webkit-scrollbar-thumb,
body.theme-dark .monitor-log-list::-webkit-scrollbar-thumb,
body.theme-dark .settings-body::-webkit-scrollbar-thumb {
  background: rgba(148, 163, 184, 0.4);
}

body.theme-dark .chat-messages::-webkit-scrollbar-thumb:hover,
body.theme-dark .results-content::-webkit-scrollbar-thumb:hover,
body.theme-dark .monitor-log-list::-webkit-scrollbar-thumb:hover,
body.theme-dark .settings-body::-webkit-scrollbar-thumb:hover {
  background: rgba(148, 163, 184, 0.58);
}

================
File: README.md
================
# Open-Cluely

Open-Cluely is an Electron desktop copilot for technical interviews and live meetings. It combines AssemblyAI streaming transcription, screenshot capture, and Gemini-powered responses in a compact always-on-top window.

Use it only in environments where recording, transcription, screenshots, and AI assistance are allowed.

Open source alternative for Cluely and Parakeetai. Your Real-Time AI Interview Assistant 😉

## Looks
<img width="1071" height="834" alt="image" src="https://github.com/user-attachments/assets/9ede4cd0-937c-4438-83df-0c1a4938c774" />
<img width="1088" height="854" alt="image" src="https://github.com/user-attachments/assets/ef57eb8d-95a5-41d6-ba27-395c8b7d41ad" />

## Features

- Dual-source live transcription for host/system audio and microphone input, with per-source toggles and a live monitor.
- Four AI action buttons, each with a distinct purpose — described in detail below.
- Per-message `AI` / `Off` controls let you keep transcript chunks, screenshots, and prior AI replies visible while excluding them from future prompts.
- Multiple Gemini API keys are supported as a comma-separated list, with automatic failover on quota or authentication errors.
- Settings support Gemini model selection, AssemblyAI speech model selection, programming language preference, and window opacity.
- Session state is persisted to `cache/app-state.json`, and screenshot retention is bounded by `MAX_SCREENSHOTS`.

## AI Action Buttons

Each button sends a different slice of context to the AI and is designed for a different moment in the workflow.

### Ask AI

The full-context answer button. Use this when you want a complete, thorough response.

**What it sends:** all enabled transcript messages + all enabled screenshots + full conversation history.

**What it does:** reads the entire context as one unified thread, silently corrects speech-to-text recognition errors, identifies the actual question being asked (even across fragmented or imperfect transcript messages), and produces a complete answer.

**Output:**
- **Understanding** — one sentence confirming what it understood the question to be
- **Answer** — full response, as deep as the question requires
- For coding and algorithmic questions: **Approach → Full solution code → Time/Space complexity → Key points**

Use Ask AI when you need the complete answer, not just the opening move.

---

### Screen AI

The screenshot interpreter. Use this when the question or problem is visible on screen.

**What it sends:** only the screenshots currently enabled in context.

**What it does:** reads all visible text in the screenshot (constraints, function signatures, error messages, sample I/O), identifies what type of content it is (LeetCode problem, stack trace, terminal output, UI layout, architecture diagram), and responds accordingly.

**Output (for coding/debugging):**
- **Understanding → Approach → Complexity → Full runnable solution code → Explanation** (only if it adds value)

**Output (for non-coding screenshots — UI, architecture, docs):**
- **What I see → Answer → Key Points**

Use Screen AI when the problem is on your screen and you want a direct solution without needing to describe it in words.

---

### Suggest

The opening-move button. Use this when you want something ready to say right now, without the full depth of Ask AI.

**What it sends:** only the enabled transcript messages.

**What it does:** reads the full conversation flow, identifies where the discussion stands, and generates a concise spoken response — something you can say out loud immediately, not a written essay.

**Output:**
- **Best response (say this)** — 2–4 sentences, natural spoken language, technically accurate but not exhaustive
- **Key points** — 2–3 short anchor concepts to hold in mind and expand on if pushed
- **Optional follow-ups** — questions or angles the other person is likely to raise next

Use Suggest to open confidently. Use Ask AI when the interviewer pushes deeper and you need the full answer.

---

### Notes

The structured record button. Use this at any point to capture what has happened in the session.

**What it sends:** all enabled transcript messages and context.

**What it does:** organizes the conversation into a clean, topic-grouped document — correcting for STT noise throughout. Does not add inferences or assumptions not grounded in the actual conversation.

**Output (always all five sections, even if empty):**
- **Key Discussion Points** — main topics covered
- **Decisions Made** — with owner if mentioned
- **Action Items** — checkboxed, with owner and deadline if mentioned
- **Open Questions / Unresolved Items** — what was raised but not resolved
- **Next Steps** — what happens next based on the conversation

Use Notes to produce a shareable record at the end of a meeting or interview debrief.

## Installation

### Requirements

- Windows 10/11 is the primary development target for this repo.
- Node.js `20.x` is recommended. The existing docs and environment were prepared around `20.20.1`.
- npm `10+`
- At least one Gemini API key (configured in the app Settings UI)
- One AssemblyAI API key (configured in the app Settings UI)

### Setup

```powershell
nvm install 20.20.1
nvm use 20.20.1
npm ci
Copy-Item .env.example .env
```

API keys are configured from the in-app Settings panel after launch.

Start the app:

```powershell
npm start
```

Useful variants:

```powershell
npm run dev
npm run start:hidden
```

### Recommended For Windows Use

For day-to-day use on Windows, prefer building the portable app and running the generated `.exe` instead of launching from source every time.

```powershell
npm run build:win
```

This creates:

```text
dist/GoogleChrome.exe
```

You can then run the packaged app directly by double-clicking `dist/GoogleChrome.exe`.

### Native Windows Build Tools

This app depends on native modules. If `npm ci` fails with `node-gyp` or Visual Studio toolchain errors, install the C++ build tools and Python:

```powershell
winget install --id Microsoft.VisualStudio.2022.BuildTools --exact --accept-package-agreements --accept-source-agreements --override "--passive --wait --add Microsoft.VisualStudio.Workload.VCTools --includeRecommended"
```

## Configuration

### Environment Variables

| Variable | Required | Notes |
|----------|----------|-------|
| `HIDE_FROM_SCREEN_CAPTURE` | No | Defaults to `true`. Controls `BrowserWindow.setContentProtection(...)`. |
| `START_HIDDEN` | No | Defaults to `false`. Also available at runtime via `npm run start:hidden` or `--start-hidden`. |
| `MAX_SCREENSHOTS` | No | Defaults to `50`. Old screenshots are deleted when the limit is exceeded. |
| `SCREENSHOT_DELAY` | No | Defaults to `300` ms. Delay used while briefly hiding the window before capture. |
| `NODE_ENV` | No | Defaults to `production`. `development` opens DevTools automatically. |
| `NODE_OPTIONS` | No | Defaults to `--max-old-space-size=4096`. |

### Source-Of-Truth Config

[`src/config.js`](./src/config.js) defines the app's configurable lists and defaults:

- Gemini models
- AssemblyAI speech models
- Programming language options for code-oriented prompts
- Global keyboard shortcuts

The first item in each model/language list is treated as the default.

### Persisted Files

- In development, state is written to `cache/app-state.json` at the repo root. Portable builds create the same `cache/app-state.json` structure next to the executable.
- Development screenshots are stored in `.stealth_screenshots/`. Packaged builds store screenshots under the app's user-data path.
- Saving settings from the UI writes API-key values and selection state to `cache/app-state.json`.

## Basic Workflow

1. Launch the app and confirm your API keys and models in Settings.
2. Start transcription and enable whichever sources you need: `Host`, `Mic`, or both.
3. Take screenshots when visual context is needed — a problem statement, error, or UI.
4. Use the right button for the moment:
   - **Suggest** to get a quick, speakable opening response from the transcript
   - **Ask AI** when you need the full, complete answer from all context
   - **Screen AI** when the problem is on your screen and you want a direct solution
   - **Notes** to capture a structured record of what was discussed and decided
5. Toggle noisy messages to `Off` before the next AI call so the prompt stays focused on what matters.

## Project Structure (Brief)

- `src/main-process/` is the Electron control plane (startup flow, window behavior, global shortcuts, and IPC registration).
- `src/services/` contains reusable domain logic (Gemini prompts/runtime behavior, AssemblyAI streaming/transcript history, persisted app-state).
- `src/windows/assistant/preload/` is the renderer-safe API boundary (`window.electronAPI` invoke + event wrappers).
- `src/windows/assistant/renderer/features/` contains modular UI logic (chat, listeners, settings, transcription, context bundling, layout).
- `src/windows/legacy/` contains old experiments and is not part of the active runtime path.

Detailed, file-by-file ownership is documented in [`notes.md`](./notes.md).

```text
src/
  bootstrap/             Environment loading, validation, and persistence
  main-process/          Startup orchestration, IPC wiring, window control, assistant runtime
  services/
    ai/                  Gemini service + prompt builders
    assembly-ai/         Streaming STT service + transcript history manager
    state/               App-state load/save helpers
  windows/
    assistant/
      preload/           `window.electronAPI` invoke/listener bridge
      renderer/features/ Renderer feature modules (chat, listeners, settings, transcription, AI context, layout)
      window.js          BrowserWindow creation/config
      renderer.js        Renderer composition root
    legacy/              Older experimental files kept out of the active flow
assets/                  Build icons and packaging assets
cache/                   Generated app state in development
.stealth_screenshots/    Session screenshots in development
dist/                    Packaged build output
repomix-output.txt       Single-file repository snapshot for AI/code review tooling
```

## Shortcuts

All keyboard shortcuts are customizable. Configure them in `src/config.js` to match your preference before building or running the app.

## Scripts

- `npm start` runs the app from source.
- `npm run start:hidden` launches it in background mode from source.
- `npm run dev` enables Electron logging.
- `npm run build:win` creates the portable Windows executable.
- `npm run build` runs the default `electron-builder` flow.

## Build

The recommended Windows build is the portable executable:

```powershell
npm run build:win
```

Expected output:

```text
dist/GoogleChrome.exe
```

Notes:

- This is the recommended way to use the app outside development because it gives you a standalone `.exe` to launch directly.
- `.env` is bundled as an extra resource during packaging.
- The current Windows build is configured as a portable `x64` target with:
  - Product name: `Google Chrome (2)`
  - Executable name: `GoogleChrome.exe`
  - App ID: `com.google.chrome`
  - Publisher name: `Google LLC`
- If the build fails with a symlink privilege error, enable Windows Developer Mode or run the build from an elevated terminal.
- The repo already includes [`assets/chrome.ico`](./assets/chrome.ico) for the Windows target. Add `assets/chrome.icns` and `assets/chrome.png` before relying on the macOS or Linux targets defined in `package.json`.

### Running The Built App

After building:

1. Open the `dist/` folder.
2. Run `GoogleChrome.exe`.
3. If you want background launch behavior, either set `START_HIDDEN=true` before building or launch with:

```powershell
.\dist\GoogleChrome.exe --start-hidden
```

### Build Checks

After packaging, verify:

- `dist/GoogleChrome.exe` exists
- the executable shows the Chrome icon
- the app launches correctly without needing `npm start`

For a build-focused walkthrough, see [`BUILD_INSTRUCTIONS.md`](./BUILD_INSTRUCTIONS.md).

## Good Practices

- Keep `src/config.js` as the single source of truth for model lists, programming languages, and keyboard shortcuts.
- When adding or changing environment variables, update all three places together: [`src/bootstrap/environment.js`](./src/bootstrap/environment.js), [`.env.example`](./.env.example), and this README.
- Preserve Electron boundaries: renderer code should go through `preload` and IPC, not import main-process modules directly.
- Keep cursor behavior stealth-safe: interactive controls intentionally do not switch to per-button pointer cursors. This prevents screen-sharing viewers from inferring user actions from cursor-shape changes while hidden mode is active.
- Add new UI logic under `src/windows/assistant/renderer/features/` and new domain logic under `src/services/` or `src/main-process/features/`.
- Treat [`src/windows/legacy/`](./src/windows/legacy/) as reference material unless you are intentionally reviving an old experiment.
- Re-test both `npm start` and the relevant packaging path when changing startup flow, window behavior, screenshots, IPC, or global shortcuts.
- Keep real keys out of Git. Use `.env`, and rely on `.env.example` for the documented contract.

## Repomix Snapshot

To regenerate the packed repository snapshot:

```powershell
npx repomix . --style plain -o repomix-output.txt
```

If you want to exclude generated artifacts while experimenting:

```powershell
npx repomix . --style plain -o repomix-output.txt -i "repomix-output.txt,cache/**"
```

================
File: src/main.js
================
const { startApplication } = require('./main-process/start-application');

startApplication().catch((error) => {
  console.error('Fatal startup failure:', error);
  process.exit(1);
});

================
File: src/windows/assistant/renderer.js
================
/// <reference path="./renderer-globals.d.ts" />

import { createMessageStore } from './renderer/features/ai-context/message-store.js';
import { buildFilteredAiContextBundle as buildAiContextBundle } from './renderer/features/ai-context/context-bundle.js';
import { updateMessageAiToggleUi as syncMessageAiToggleUi } from './renderer/features/ai-context/toggle-ui.js';
import { createChatUiManager } from './renderer/features/chat/chat-ui-manager.js';
import { createWindowAdjustmentManager } from './renderer/features/layout/window-adjustments.js';
import { setupEventListeners as setupEventListenersModule } from './renderer/features/listeners/event-listeners.js';
import { setupIpcListeners as setupIpcListenersModule } from './renderer/features/listeners/ipc-listeners.js';
import { createShortcutManager } from './renderer/features/settings/shortcut-manager.js';
import { createSettingsPanelManager } from './renderer/features/settings/settings-panel-manager.js';
import { createTranscriptionManager } from './renderer/features/transcription/transcription-manager.js';

import {
    createTranscriptionSourceState,
    normalizeSource as normalizeAssemblySource,
    sourceLabel as resolveSourceLabel
} from './renderer/features/assembly-ai/source-state.js';
import { createAudioPipeline } from './renderer/features/assembly-ai/audio-pipeline.js';
import { createTranscriptBufferManager } from './renderer/features/assembly-ai/transcript-buffer.js';
// Renderer with AssemblyAI Streaming Transcription - Real-time & Accurate!
// Uses AssemblyAI WebSocket API for live speech-to-text

let screenshotsCount = 0;
let isAnalyzing = false;
let stealthHideTimeout = null;
const THEME_STORAGE_KEY = 'assistant-theme';
const THEME_LIGHT = 'light';
const THEME_DARK = 'dark';
let activeTheme = THEME_LIGHT;
const AI_CONTEXT_CHAR_BUDGET = 12000;
const messageStore = createMessageStore();
let chatMessagesArray = messageStore.getMessages();
const transcriptionSourceState = createTranscriptionSourceState();

// Source selection state (default: host/system on, mic off)
const selectedSources = transcriptionSourceState.selectedSources;

const audioPipeline = createAudioPipeline({
    sendAudioChunk: (source, audioBuffer) => {
        window.electronAPI.sendAudioChunk(source, audioBuffer);
    },
    addMonitorLog: (...args) => addMonitorLog(...args)
});

const transcriptBufferManager = createTranscriptBufferManager({
    mergeWindowMs: 2400,
    onBuffer: ({ source, text, segments }) => {
        addMonitorLog('info', 'final-buffer', 'Buffered transcript segment', source, {
            segments,
            chars: text.length
        });
    },
    onFlush: ({ source, text, reason, segments }) => {
        if (source === 'system') {
            addChatMessage('voice-system', text);
        } else {
            addChatMessage('voice-mic', text);
        }

        addMonitorLog('info', 'final-flush', 'Merged transcript committed', source, {
            reason,
            segments,
            chars: text.length
        });
        showFeedback('Captured', 'success');
    }
});


// DOM elements
const statusText = document.getElementById('status-text');
const screenshotCount = document.getElementById('screenshot-count');
const resultsPanel = document.getElementById('results-panel');
const resultText = document.getElementById('result-text');
const loadingOverlay = document.getElementById('loading-overlay');
const emergencyOverlay = document.getElementById('emergency-overlay');
const chatContainer = document.getElementById('chat-container');
const chatMessagesElement = document.getElementById('chat-messages');
const chatComposer = document.getElementById('chat-composer');
const chatManualInput = document.getElementById('chat-manual-input');
const chatManualSend = document.getElementById('chat-manual-send');
const transcriptionToggle = document.getElementById('transcription-toggle');
const sourceSystemToggle = document.getElementById('source-system-toggle');
const sourceMicToggle = document.getElementById('source-mic-toggle');
const monitorMasterState = document.getElementById('monitor-master-state');
const monitorStatusSystem = document.getElementById('monitor-status-system');
const monitorStatusMic = document.getElementById('monitor-status-mic');
const monitorLiveSystem = document.getElementById('monitor-live-system');
const monitorLiveMic = document.getElementById('monitor-live-mic');
const monitorLogList = document.getElementById('monitor-log-list');
const windowResizeHandles = document.querySelectorAll('[data-resize-handle]');

const screenshotBtn = document.getElementById('screenshot-btn');
const analyzeBtn = document.getElementById('analyze-btn');
const screenAiBtn = document.getElementById('screen-ai-btn');
const clearBtn = document.getElementById('clear-btn');
const hideBtn = document.getElementById('hide-btn');
const closeResultsBtn = document.getElementById('close-results');
const closeAppBtn = document.getElementById('close-app-btn');
const closeConfirmationDialog = document.getElementById('close-confirmation-dialog');
const cancelCloseBtn = document.getElementById('cancel-close-btn');
const confirmCloseBtn = document.getElementById('confirm-close-btn');

// New Cluely-style buttons
const suggestBtn = document.getElementById('suggest-btn');
const notesBtn = document.getElementById('notes-btn');
const insightsBtn = document.getElementById('insights-btn');
const themeToggleBtn = document.getElementById('theme-toggle-btn');

// Settings elements
const settingsBtn = document.getElementById('settings-btn');
const settingsPanel = document.getElementById('settings-panel');
const closeSettingsBtn = document.getElementById('close-settings');
const saveSettingsBtn = document.getElementById('save-settings-btn');
const settingGeminiKey = document.getElementById('setting-gemini-key');
const toggleGeminiKeyVisibilityBtn = document.getElementById('toggle-gemini-key-visibility');
const settingGeminiModel = document.getElementById('setting-gemini-model');
const settingProgrammingLanguage = document.getElementById('setting-programming-language');
const settingAssemblyKey = document.getElementById('setting-assembly-key');
const toggleAssemblyKeyVisibilityBtn = document.getElementById('toggle-assembly-key-visibility');
const settingAssemblyModel = document.getElementById('setting-assembly-model');
const settingWindowOpacity = document.getElementById('setting-window-opacity');
const settingWindowOpacityValue = document.getElementById('setting-window-opacity-value');
const settingsShortcutsList = document.getElementById('settings-shortcuts-list');

// Timer
let startTime = Date.now();
let timerInterval;
const MIN_WINDOW_WIDTH = 600;
const MIN_WINDOW_HEIGHT = 380;
const MAX_CHAT_INPUT_HEIGHT = 88;

let isCloseConfirmationOpen = false;
let hasGeminiApiKeysConfigured = false;
let hasAssemblyAiApiKeyConfigured = false;
const aiActionInFlightState = {
    askAi: false,
    screenAi: false,
    suggest: false,
    notes: false,
    insights: false
};
const shortcutManager = createShortcutManager({ settingsShortcutsList });
const windowAdjustmentManager = createWindowAdjustmentManager({
    windowResizeHandles,
    chatContainer,
    minWindowWidth: MIN_WINDOW_WIDTH,
    minWindowHeight: MIN_WINDOW_HEIGHT,
    onViewportResize: () => {
        autoResizeManualInput();
    }
});
const chatUiManager = createChatUiManager({
    chatContainer,
    chatMessagesElement,
    chatComposer,
    chatManualInput,
    chatManualSend,
    messageStore,
    maxChatInputHeight: MAX_CHAT_INPUT_HEIGHT,
    escapeHtml: (value) => escapeHtml(value),
    updateUi: () => updateUI(),
    onMessagesChanged: (messages) => {
        chatMessagesArray = messages;
    },
    showFeedback: (message, type) => showFeedback(message, type),
    addMonitorLog: (...args) => addMonitorLog(...args)
});
const settingsPanelManager = createSettingsPanelManager({
    settingsPanel,
    settingGeminiKey,
    toggleGeminiKeyVisibilityBtn,
    settingGeminiModel,
    settingProgrammingLanguage,
    settingAssemblyKey,
    toggleAssemblyKeyVisibilityBtn,
    settingAssemblyModel,
    settingWindowOpacity,
    settingWindowOpacityValue,
    applySettingsShortcutConfig: (settings) => applySettingsShortcutConfig(settings),
    showFeedback: (message, type) => showFeedback(message, type),
    onSettingsSaved: (settings) => {
        applyApiKeyAvailabilityFromSettings(settings);
        updateUI();
    }
});
const transcriptionManager = createTranscriptionManager({
    transcriptionSourceState,
    normalizeSourceRule: normalizeAssemblySource,
    sourceLabelRule: resolveSourceLabel,
    audioPipeline,
    transcriptBufferManager,
    chatMessagesElement,
    transcriptionToggle,
    sourceSystemToggle,
    sourceMicToggle,
    monitorMasterState,
    monitorStatusSystem,
    monitorStatusMic,
    monitorLiveSystem,
    monitorLiveMic,
    monitorLogList,
    addChatMessage: (type, content, options) => addChatMessage(type, content, options),
    showFeedback: (message, type) => showFeedback(message, type)
});

// Initialize
async function init() {
    console.log('Initializing renderer with Vosk Live Transcription...');

    if (typeof window.electronAPI !== 'undefined') {
        console.log('electronAPI is available');
    } else {
        console.error('electronAPI not available');
        showFeedback('electronAPI not available', 'error');
    }

    const settings = await loadShortcutConfig();
    setupEventListeners();
    setupIpcListeners();
    setupWindowAdjustments();
    applyTheme(resolveInitialThemePreference(settings), { persist: false });
    updateUI();
    transcriptionManager.updateTranscriptionUI();
    transcriptionManager.renderMonitorState();
    startTimer();

    document.body.style.visibility = 'visible';
    document.body.style.display = 'block';
    const app = document.getElementById('app');
    if (app) {
        app.style.visibility = 'visible';
        app.style.display = 'flex';
    }

    console.log('Renderer initialized - Ready for live transcription!');
    showFeedback('Ready - click transcription to start', 'success');
    addMonitorLog('info', 'init', 'Renderer initialized');
    addMonitorLog('info', 'source-defaults', 'Default sources: Host on, Mic off');
}

function updateWindowOpacityValueLabel(value) {
    settingsPanelManager.updateWindowOpacityValueLabel(value);
}

function parseThemePreference(theme) {
    return theme === THEME_DARK || theme === THEME_LIGHT ? theme : null;
}

function normalizeTheme(theme) {
    return theme === THEME_DARK ? THEME_DARK : THEME_LIGHT;
}

function loadStoredThemePreference() {
    try {
        const savedTheme = window.localStorage?.getItem(THEME_STORAGE_KEY) || '';
        return parseThemePreference(savedTheme) || THEME_LIGHT;
    } catch (error) {
        console.warn('Failed to read saved theme preference:', error);
        return THEME_LIGHT;
    }
}

function resolveInitialThemePreference(settings) {
    const settingsTheme = parseThemePreference(String(settings?.themePreference || '').trim().toLowerCase());
    if (settingsTheme) {
        saveThemePreference(settingsTheme);
        return settingsTheme;
    }

    return loadStoredThemePreference();
}

function saveThemePreference(theme) {
    try {
        window.localStorage?.setItem(THEME_STORAGE_KEY, normalizeTheme(theme));
    } catch (error) {
        console.warn('Failed to save theme preference:', error);
    }
}

function persistThemePreference(theme) {
    const normalizedTheme = normalizeTheme(theme);
    saveThemePreference(normalizedTheme);

    const setThemePreference = window.electronAPI?.setThemePreference;
    if (typeof setThemePreference === 'function') {
        setThemePreference(normalizedTheme).catch((error) => {
            console.warn('Failed to persist theme preference to app state:', error);
        });
    }
}

function updateThemeToggleUi() {
    if (!themeToggleBtn) {
        return;
    }

    const isDarkMode = activeTheme === THEME_DARK;
    const nextThemeLabel = isDarkMode ? 'light' : 'dark';
    const ariaLabel = `Switch to ${nextThemeLabel} mode`;

    themeToggleBtn.classList.toggle('is-dark', isDarkMode);
    themeToggleBtn.setAttribute('aria-pressed', isDarkMode ? 'true' : 'false');
    themeToggleBtn.setAttribute('aria-label', ariaLabel);
    themeToggleBtn.removeAttribute('title');
}

function applyTheme(theme, options = {}) {
    const { persist = true, announce = false } = options;
    activeTheme = normalizeTheme(theme);

    document.body.classList.toggle('theme-dark', activeTheme === THEME_DARK);
    document.documentElement.setAttribute('data-theme', activeTheme);
    updateThemeToggleUi();

    if (persist) {
        persistThemePreference(activeTheme);
    }

    if (announce) {
        showFeedback(activeTheme === THEME_DARK ? 'Dark mode enabled' : 'Light mode enabled', 'info');
    }
}

function toggleThemeMode() {
    const nextTheme = activeTheme === THEME_DARK ? THEME_LIGHT : THEME_DARK;
    applyTheme(nextTheme, { persist: true, announce: true });
}

function applySettingsShortcutConfig(settings) {
    shortcutManager.applySettingsShortcutConfig(settings);
}

function isShortcutPressed(event, shortcutId) {
    return shortcutManager.isShortcutPressed(event, shortcutId);
}

function isAiActionInFlight(actionId) {
    return Boolean(aiActionInFlightState[actionId]);
}

function setAiActionInFlight(actionId, inFlight) {
    if (!Object.prototype.hasOwnProperty.call(aiActionInFlightState, actionId)) {
        return;
    }

    const nextValue = Boolean(inFlight);
    if (aiActionInFlightState[actionId] === nextValue) {
        return;
    }

    aiActionInFlightState[actionId] = nextValue;
    updateUI();
}

async function runAiActionWithLock(actionId, action) {
    if (isAiActionInFlight(actionId)) {
        return false;
    }

    setAiActionInFlight(actionId, true);
    try {
        await action();
        return true;
    } finally {
        setAiActionInFlight(actionId, false);
    }
}

let activeScreenAiStream = null;

function createStreamHandler(actionId) {
    let accumulatedText = '';
    let messageRecord = null;
    let removeChunkListener = null;
    let loadingHidden = false;

    function start(headingPrefix) {
        accumulatedText = headingPrefix || '';
        messageRecord = addChatMessage('ai-response', accumulatedText || '...');

        removeChunkListener = window.electronAPI.onAiStreamChunk((data) => {
            if (data.actionId !== actionId) return;
            accumulatedText += data.text;
            if (messageRecord) {
                chatUiManager.updateChatMessageContent(messageRecord.id, accumulatedText);
            }
            if (!loadingHidden) {
                loadingHidden = true;
                hideLoadingOverlay();
            }
        });

        return messageRecord;
    }

    function finalize(finalText) {
        if (finalText && messageRecord) {
            chatUiManager.updateChatMessageContent(messageRecord.id, finalText);
        }
    }

    function cleanup() {
        if (removeChunkListener) {
            removeChunkListener();
            removeChunkListener = null;
        }
    }

    return { start, finalize, cleanup };
}

function hasConfiguredGeminiApiKeys(value) {
    const keys = String(value ?? '')
        .split(',')
        .map((entry) => entry.trim())
        .filter(Boolean);
    return keys.length > 0;
}

function hasConfiguredAssemblyAiApiKey(value) {
    return String(value ?? '').trim().length > 0;
}

function applyApiKeyAvailabilityFromSettings(settings) {
    if (!settings || typeof settings !== 'object') {
        hasGeminiApiKeysConfigured = false;
        hasAssemblyAiApiKeyConfigured = false;
        return;
    }

    if (typeof settings.hasGeminiApiKeys === 'boolean') {
        hasGeminiApiKeysConfigured = settings.hasGeminiApiKeys;
    } else {
        hasGeminiApiKeysConfigured = hasConfiguredGeminiApiKeys(settings.geminiApiKey);
    }

    if (typeof settings.hasAssemblyAiApiKey === 'boolean') {
        hasAssemblyAiApiKeyConfigured = settings.hasAssemblyAiApiKey;
    } else {
        hasAssemblyAiApiKeyConfigured = hasConfiguredAssemblyAiApiKey(settings.assemblyAiApiKey);
    }
}

async function loadShortcutConfig() {
    if (!window.electronAPI?.getSettings) {
        applyApiKeyAvailabilityFromSettings(null);
        return null;
    }

    try {
        const settings = await window.electronAPI.getSettings();
        applySettingsShortcutConfig(settings);
        applyApiKeyAvailabilityFromSettings(settings);
        return settings;
    } catch (error) {
        console.error('Failed to load shortcut config:', error);
        applyApiKeyAvailabilityFromSettings(null);
        return null;
    }
}

function setupWindowAdjustments() {
    windowAdjustmentManager.setupWindowAdjustments();
}

function escapeHtml(value) {
    return String(value || '')
        .replace(/&/g, '&amp;')
        .replace(/</g, '&lt;')
        .replace(/>/g, '&gt;')
        .replace(/"/g, '&quot;')
        .replace(/'/g, '&#39;');
}

function isMessageIncludedForAi(message) {
    return messageStore.isIncludedForAi(message);
}

function buildFilteredAiContextBundle({ charBudget = AI_CONTEXT_CHAR_BUDGET, emitTruncationLog = true } = {}) {
    return buildAiContextBundle({
        messages: chatMessagesArray,
        isMessageIncludedForAi,
        charBudget,
        emitTruncationLog,
        onTruncationLog: (dropped, budget) => {
            addMonitorLog(
                'info',
                'context-cap',
                `Trimmed ${dropped} older context message(s) to stay within ${budget} chars`
            );
        }
    });
}

function updateMessageAiToggleUi(message) {
    syncMessageAiToggleUi(chatMessagesElement, message);
}

function toggleChatMessageInclusion(messageId) {
    const message = messageStore.toggleInclusion(messageId);
    if (!message) return;

    chatMessagesArray = messageStore.getMessages();
    updateMessageAiToggleUi(message);
    updateUI();

    const stateText = message.includeInAi ? 'included in' : 'excluded from';
    addMonitorLog('info', 'ai-context-toggle', `Message ${stateText} AI context`, null, {
        id: message.id,
        type: message.type
    });
}

function addMonitorLog(level, event, message, source = null, meta = null, timestamp = Date.now()) {
    transcriptionManager.addMonitorLog(level, event, message, source, meta, timestamp);
}

function flushAllFinalTranscripts(reason = 'flush-all') {
    transcriptionManager.flushAllFinalTranscripts(reason);
}

function setSourceSelected(source, enabled) {
    return transcriptionManager.setSourceSelected(source, enabled);
}

async function toggleMasterTranscription() {
    if (!hasAssemblyAiApiKeyConfigured) {
        showFeedback('AssemblyAI API key missing. Add it in Settings.', 'error');
        return;
    }

    return transcriptionManager.toggleMasterTranscription();
}

// Screenshot functions
async function takeStealthScreenshot() {
    try {
        showFeedback('Taking screenshot...', 'info');
        await window.electronAPI.takeStealthScreenshot();
    } catch (error) {
        console.error('Screenshot error:', error);
        showFeedback('Screenshot failed', 'error');
    }
}

function buildAskAiContextPayload() {
    const bundle = buildFilteredAiContextBundle({ charBudget: AI_CONTEXT_CHAR_BUDGET, emitTruncationLog: true });
    return {
        mode: 'best-next-answer',
        contextString: bundle.contextString,
        transcriptContext: bundle.transcriptContext,
        sessionSummary: bundle.sessionSummary,
        enabledScreenshotIds: bundle.enabledScreenshotIds,
        screenshotCount: bundle.enabledScreenshotIds.length
    };
}

async function askAiWithSessionContext() {
    if (!hasGeminiApiKeysConfigured) {
        showFeedback('Gemini API key missing. Add it in Settings.', 'error');
        return;
    }

    if (!window.electronAPI?.askAiWithSessionContext) {
        showFeedback('Feature not available', 'error');
        return;
    }

    const payload = buildAskAiContextPayload();
    if (!payload.contextString && payload.enabledScreenshotIds.length === 0) {
        showFeedback('No transcript or screenshots available yet', 'error');
        return;
    }

    await runAiActionWithLock('askAi', async () => {
        const stream = createStreamHandler('askAi');
        try {
            setAnalyzing(true);
            showLoadingOverlay('Analyzing full session context...');
            stream.start('**Best Next Answer:**\n\n');

            const result = await window.electronAPI.askAiWithSessionContext(payload);

            if (result?.success && result?.text) {
                const heading = result.usedScreenshots
                    ? '**Best Next Answer (Transcript + Screen):**'
                    : '**Best Next Answer (Transcript):**';
                stream.finalize(`${heading}\n\n${result.text}`);
                showFeedback('Ask AI ready', 'success');
            } else {
                throw new Error(result?.error || 'Ask AI failed');
            }
        } catch (error) {
            console.error('Ask AI error:', error);
            showFeedback('Ask AI failed', 'error');
            addChatMessage('system', `Error: ${error.message}`);
        } finally {
            stream.cleanup();
            setAnalyzing(false);
            hideLoadingOverlay();
        }
    });
}

async function analyzeScreenshotsOnly() {
    if (!hasGeminiApiKeysConfigured) {
        showFeedback('Gemini API key missing. Add it in Settings.', 'error');
        return;
    }

    const bundle = buildFilteredAiContextBundle({ charBudget: AI_CONTEXT_CHAR_BUDGET, emitTruncationLog: true });
    if (bundle.enabledScreenshotIds.length === 0) {
        showFeedback('No enabled screenshots to analyze', 'error');
        return;
    }

    await runAiActionWithLock('screenAi', async () => {
        const stream = createStreamHandler('screenAi');
        activeScreenAiStream = stream;
        try {
            setAnalyzing(true);
            showLoadingOverlay('Analyzing screenshots...');
            stream.start('');

            await window.electronAPI.analyzeStealthWithContext({
                contextString: bundle.contextString,
                enabledScreenshotIds: bundle.enabledScreenshotIds
            });
        } catch (error) {
            console.error('Analysis error:', error);
            showFeedback('Analysis failed', 'error');
            setAnalyzing(false);
            hideLoadingOverlay();
            // Clean up on error since onAnalysisResult may not fire
            stream.cleanup();
            activeScreenAiStream = null;
        }
        // Don't cleanup in finally - onAnalysisResult handles it for success path
        // This avoids a race where the invoke resolves before the event is delivered
    });
}

async function clearStealthData() {
    try {
        await window.electronAPI.clearStealth();
        if (window.electronAPI.clearConversationHistory) {
            await window.electronAPI.clearConversationHistory();
        }
        screenshotsCount = 0;
        messageStore.clear();
        chatMessagesArray = messageStore.getMessages();
        chatMessagesElement.innerHTML = '';
        updateUI();
        showFeedback('Cleared', 'success');
    } catch (error) {
        console.error('Clear error:', error);
        showFeedback('Clear failed', 'error');
    }
}

async function emergencyHide() {
    try {
        await window.electronAPI.emergencyHide();
        showEmergencyOverlay();
    } catch (error) {
        console.error('Emergency hide error:', error);
    }
}

function openCloseConfirmation() {
    if (!closeConfirmationDialog) {
        closeApplication();
        return;
    }

    isCloseConfirmationOpen = true;
    closeConfirmationDialog.classList.remove('hidden');
    confirmCloseBtn?.focus();
}

function closeCloseConfirmation() {
    if (!closeConfirmationDialog) {
        return;
    }

    isCloseConfirmationOpen = false;
    closeConfirmationDialog.classList.add('hidden');
    closeAppBtn?.focus();
}

async function closeApplication() {
    try {
        console.log('Closing application...');
        flushAllFinalTranscripts('app-close');
        await window.electronAPI.closeApp();
    } catch (error) {
        console.error('Close application error:', error);
    }
}

// NEW CLUELY-STYLE FEATURES

async function getResponseSuggestions() {
    if (!hasGeminiApiKeysConfigured) {
        showFeedback('Gemini API key missing. Add it in Settings.', 'error');
        return;
    }

    if (!window.electronAPI || !window.electronAPI.suggestResponse) {
        showFeedback('Feature not available', 'error');
        return;
    }

    await runAiActionWithLock('suggest', async () => {
        const stream = createStreamHandler('suggest');
        try {
            showFeedback('Generating suggestions...', 'info');
            const bundle = buildFilteredAiContextBundle({ charBudget: AI_CONTEXT_CHAR_BUDGET, emitTruncationLog: true });
            const transcriptOnlyContext = String(bundle.transcriptContext || '').trim();
            if (!transcriptOnlyContext) {
                showFeedback('No enabled transcript context available for suggestions', 'error');
                return;
            }

            stream.start('\u{1F4A1} **What should I say?**\n\n');

            const result = await window.electronAPI.suggestResponse({
                context: bundle.sessionSummary || 'Current meeting conversation',
                contextString: transcriptOnlyContext
            });

            if (result.success && result.suggestions) {
                stream.finalize(`\u{1F4A1} **What should I say?**\n\n${result.suggestions}`);
                showFeedback('Suggestions generated', 'success');
            } else {
                throw new Error(result.error || 'Failed to generate suggestions');
            }
        } catch (error) {
            console.error('Error getting suggestions:', error);
            showFeedback('Failed to generate suggestions', 'error');
            addChatMessage('system', `Error: ${error.message}`);
        } finally {
            stream.cleanup();
        }
    });
}

async function generateMeetingNotes() {
    if (!hasGeminiApiKeysConfigured) {
        showFeedback('Gemini API key missing. Add it in Settings.', 'error');
        return;
    }

    if (!window.electronAPI || !window.electronAPI.generateMeetingNotes) {
        showFeedback('Feature not available', 'error');
        return;
    }

    await runAiActionWithLock('notes', async () => {
        const stream = createStreamHandler('notes');
        try {
            showFeedback('Generating meeting notes...', 'info');
            setAnalyzing(true);
            const bundle = buildFilteredAiContextBundle({ charBudget: AI_CONTEXT_CHAR_BUDGET, emitTruncationLog: true });
            if (!bundle.contextString) {
                showFeedback('No enabled context available for notes', 'error');
                return;
            }

            stream.start('\u{1F4DD} **Meeting Notes**\n\n');

            const result = await window.electronAPI.generateMeetingNotes({
                contextString: bundle.contextString
            });

            if (result.success && result.notes) {
                stream.finalize(`\u{1F4DD} **Meeting Notes**\n\n${result.notes}`);
                showFeedback('Meeting notes generated', 'success');
            } else {
                throw new Error(result.error || 'Failed to generate notes');
            }
        } catch (error) {
            console.error('Error generating notes:', error);
            showFeedback('Failed to generate notes', 'error');
            addChatMessage('system', `Error: ${error.message}`);
        } finally {
            stream.cleanup();
            setAnalyzing(false);
        }
    });
}

async function getConversationInsights() {
    if (!hasGeminiApiKeysConfigured) {
        showFeedback('Gemini API key missing. Add it in Settings.', 'error');
        return;
    }

    if (!window.electronAPI || !window.electronAPI.getConversationInsights) {
        showFeedback('Feature not available', 'error');
        return;
    }

    await runAiActionWithLock('insights', async () => {
        const stream = createStreamHandler('insights');
        try {
            showFeedback('Analyzing conversation...', 'info');
            setAnalyzing(true);
            const bundle = buildFilteredAiContextBundle({ charBudget: AI_CONTEXT_CHAR_BUDGET, emitTruncationLog: true });
            if (!bundle.contextString) {
                showFeedback('No enabled context available for insights', 'error');
                return;
            }

            stream.start('\u{1F4CA} **Conversation Insights**\n\n');

            const result = await window.electronAPI.getConversationInsights({
                contextString: bundle.contextString
            });

            if (result.success && result.insights) {
                stream.finalize(`\u{1F4CA} **Conversation Insights**\n\n${result.insights}`);
                showFeedback('Insights generated', 'success');
            } else {
                throw new Error(result.error || 'Failed to get insights');
            }
        } catch (error) {
            console.error('Error getting insights:', error);
            showFeedback('Failed to get insights', 'error');
            addChatMessage('system', `Error: ${error.message}`);
        } finally {
            stream.cleanup();
            setAnalyzing(false);
        }
    });
}

// SETTINGS FUNCTIONS

async function openSettings() {
    await settingsPanelManager.openSettings();
}

function closeSettings() {
    settingsPanelManager.closeSettings();
}

async function saveSettings() {
    const result = await settingsPanelManager.saveSettings();
    if (result?.success && result?.settings) {
        applyApiKeyAvailabilityFromSettings(result.settings);
        updateUI();
    }
}

// UI Helper functions
function setAnalyzing(analyzing) {
    isAnalyzing = analyzing;
    updateUI();
}

function updateUI() {
    if (screenshotCount) {
        screenshotCount.textContent = screenshotsCount;
    }

    const aiBundle = buildFilteredAiContextBundle({
        charBudget: AI_CONTEXT_CHAR_BUDGET,
        emitTruncationLog: false
    });
    const hasTranscriptContext = aiBundle.transcriptContext.length > 0;
    const hasEnabledScreenshots = aiBundle.enabledScreenshotIds.length > 0;
    const hasAiContext = hasTranscriptContext || hasEnabledScreenshots || aiBundle.contextString.length > 0;
    const canRunAiActions = hasGeminiApiKeysConfigured;
    const canRunTranscription = hasAssemblyAiApiKeyConfigured;
    const askAiInFlight = isAiActionInFlight('askAi');
    const screenAiInFlight = isAiActionInFlight('screenAi');
    const suggestInFlight = isAiActionInFlight('suggest');
    const notesInFlight = isAiActionInFlight('notes');
    const insightsInFlight = isAiActionInFlight('insights');

    if (analyzeBtn) {
        analyzeBtn.disabled = isAnalyzing || askAiInFlight || !canRunAiActions || !hasAiContext;
    }

    if (screenAiBtn) {
        screenAiBtn.disabled = isAnalyzing || screenAiInFlight || !canRunAiActions || !hasEnabledScreenshots;
    }

    if (suggestBtn) {
        suggestBtn.disabled = isAnalyzing || suggestInFlight || !canRunAiActions || !hasTranscriptContext;
    }

    if (notesBtn) {
        notesBtn.disabled = isAnalyzing || notesInFlight || !canRunAiActions || !hasAiContext;
    }

    if (insightsBtn) {
        insightsBtn.disabled = isAnalyzing || insightsInFlight || !canRunAiActions || !hasAiContext;
    }

    if (transcriptionToggle) {
        transcriptionToggle.disabled = !canRunTranscription;
    }

    if (sourceSystemToggle) {
        sourceSystemToggle.disabled = !canRunTranscription;
    }

    if (sourceMicToggle) {
        sourceMicToggle.disabled = !canRunTranscription;
    }
}

function showFeedback(message, type = 'info') {
    console.log(`Feedback (${type}):`, message);

    if (statusText) {
        statusText.textContent = message;
        statusText.className = `status-text ${type} show`;
        statusText.style.display = 'block';

        setTimeout(() => {
            statusText.classList.remove('show');
            setTimeout(() => {
                statusText.style.display = 'none';
            }, 300);
        }, 3000);
    }
}

function showLoadingOverlay(message = 'Analyzing screen...') {
    if (loadingOverlay) {
        // Update the loading text if custom message provided
        const loadingTextElement = loadingOverlay.querySelector('.loading-text');
        if (loadingTextElement) {
            loadingTextElement.innerHTML = message;
        }
        loadingOverlay.classList.remove('hidden');
    }
}

function hideLoadingOverlay() {
    if (loadingOverlay) {
        loadingOverlay.classList.add('hidden');
        // Reset to default text
        const loadingTextElement = loadingOverlay.querySelector('.loading-text');
        if (loadingTextElement) {
            loadingTextElement.innerHTML = 'Analyzing screen...';
        }
    }
}

function showEmergencyOverlay() {
    if (emergencyOverlay) {
        emergencyOverlay.classList.remove('hidden');
        setTimeout(() => {
            emergencyOverlay.classList.add('hidden');
        }, 2000);
    }
}

function hideResults() {
    if (resultsPanel) {
        resultsPanel.classList.add('hidden');
    }
}

async function writeTextToClipboard(text) {
    const value = String(text ?? '');

    if (navigator?.clipboard?.writeText) {
        try {
            await navigator.clipboard.writeText(value);
            return;
        } catch (error) {
            console.warn('Clipboard API denied, using fallback copy path:', error);
        }
    }

    const copyListener = (event) => {
        event.preventDefault();
        if (event.clipboardData) {
            event.clipboardData.setData('text/plain', value);
        }
    };

    document.addEventListener('copy', copyListener, true);
    try {
        const copiedViaEvent = document.execCommand('copy');
        if (copiedViaEvent) {
            return;
        }
    } finally {
        document.removeEventListener('copy', copyListener, true);
    }

    const temporaryInput = document.createElement('textarea');
    temporaryInput.value = value;
    temporaryInput.setAttribute('readonly', '');
    temporaryInput.style.position = 'fixed';
    temporaryInput.style.left = '-9999px';
    temporaryInput.style.top = '0';
    document.body.appendChild(temporaryInput);
    temporaryInput.select();

    const copiedViaSelection = document.execCommand('copy');
    document.body.removeChild(temporaryInput);

    if (!copiedViaSelection) {
        throw new Error('Clipboard write failed');
    }
}

async function copyChatMessageById(messageId) {
    const message = messageStore.findById(messageId);
    const content = String(message?.content || '');

    if (!content.trim()) {
        showFeedback('Nothing to copy', 'error');
        return;
    }

    try {
        await writeTextToClipboard(content);
        showFeedback('Message copied', 'success');
    } catch (error) {
        console.error('Message copy error:', error);
        showFeedback('Copy failed', 'error');
    }
}

// Chat message management
function addChatMessage(type, content, options = {}) {
    return chatUiManager.addChatMessage(type, content, options);
}

function autoResizeManualInput() {
    chatUiManager.autoResizeManualInput();
}

function updateManualComposerState() {
    chatUiManager.updateManualComposerState();
}

function submitManualContextMessage() {
    chatUiManager.submitManualContextMessage();
}

// Timer
function startTimer() {
    const timerElement = document.querySelector('.timer');
    if (!timerElement) return;

    timerInterval = setInterval(() => {
        const elapsed = Math.floor((Date.now() - startTime) / 1000);
        const minutes = Math.floor(elapsed / 60).toString().padStart(2, '0');
        const seconds = (elapsed % 60).toString().padStart(2, '0');
        timerElement.textContent = `${minutes}:${seconds}`;
    }, 1000);
}

// Event listeners
function setupEventListeners() {
    setupEventListenersModule({
        windowApi: window.electronAPI,
        screenshotBtn,
        analyzeBtn,
        screenAiBtn,
        clearBtn,
        hideBtn,
        chatManualSend,
        chatManualInput,
        closeResultsBtn,
        transcriptionToggle,
        sourceSystemToggle,
        sourceMicToggle,
        closeAppBtn,
        cancelCloseBtn,
        confirmCloseBtn,
        closeConfirmationDialog,
        chatMessagesElement,
        suggestBtn,
        notesBtn,
        insightsBtn,
        themeToggleBtn,
        settingsBtn,
        closeSettingsBtn,
        saveSettingsBtn,
        settingWindowOpacity,
        selectedSources,
        isCloseConfirmationOpen: () => isCloseConfirmationOpen,
        isShortcutPressed,
        updateWindowOpacityValueLabel,
        takeStealthScreenshot,
        askAiWithSessionContext,
        analyzeScreenshotsOnly,
        clearStealthData,
        emergencyHide,
        copyChatMessageById,
        submitManualContextMessage,
        autoResizeManualInput,
        updateManualComposerState,
        hideResults,
        toggleMasterTranscription,
        addMonitorLog,
        setSourceSelected,
        openCloseConfirmation,
        closeCloseConfirmation,
        closeApplication,
        toggleChatMessageInclusion,
        getResponseSuggestions,
        generateMeetingNotes,
        getConversationInsights,
        toggleThemeMode,
        openSettings,
        closeSettings,
        saveSettings
    });
}

// IPC listeners
function setupIpcListeners() {
    setupIpcListenersModule({
        windowApi: window.electronAPI,
        setScreenshotsCount: (nextCount) => {
            screenshotsCount = nextCount;
        },
        updateUi: updateUI,
        addChatMessage,
        setAnalyzing,
        showLoadingOverlay,
        hideLoadingOverlay,
        showFeedback,
        showEmergencyOverlay,
        transcriptionManager,
        toggleMasterTranscription,
        askAiWithSessionContext,
        isAskAiShortcutEnabled: () => Boolean(analyzeBtn && !analyzeBtn.disabled),
        addMonitorLog,
        getActiveScreenAiStream: () => activeScreenAiStream,
        clearActiveScreenAiStream: () => {
            if (activeScreenAiStream) {
                activeScreenAiStream.cleanup();
                activeScreenAiStream = null;
            }
        }
    });
}

// Initialize on load
if (document.readyState === 'loading') {
    document.addEventListener('DOMContentLoaded', init);
} else {
    init();
}





================================================================
End of Codebase
================================================================