diff --git a/.entire/.gitignore b/.entire/.gitignore
index 2cffdef..b129f25 100644
--- a/.entire/.gitignore
+++ b/.entire/.gitignore
@@ -2,3 +2,5 @@ tmp/
 settings.local.json
 metadata/
 logs/
+.crush/logs
+.entire/metadata/
diff --git a/KNOWN_ISSUES.md b/KNOWN_ISSUES.md
deleted file mode 100644
index e838eb9..0000000
--- a/KNOWN_ISSUES.md
+++ /dev/null
@@ -1,64 +0,0 @@
-# Known Issues
-
-## macOS: Tray "Show DevToolbox" doesn't restore hidden window
-
-**GitHub Issue:** [#51](https://github.com/vuon9/devtoolbox/issues/51)  
-**Status:** Open  
-**Platform:** macOS only  
-**Severity:** Medium  
-**Component:** System Tray / Window Management
-
-### Description
-When the window is hidden to the system tray (via close button with "Close minimizes to tray" setting enabled), clicking "Show DevToolbox" from the tray menu does not restore the window.
-
-### Steps to Reproduce
-1. Enable "Close button minimizes to tray" in Settings
-2. Click the window's close button (X)
-3. Window hides to tray (app continues running)
-4. Click the tray icon and select "Show DevToolbox"
-5. Window does not appear (logs show `Window visible: false`)
-
-### Expected Behavior
-Window should be restored and shown when clicking "Show DevToolbox" from the tray menu.
-
-### Actual Behavior
-Window remains hidden. Logs show:
-```
-Tray menu 'Show DevToolbox' clicked
-Window visible: false, minimized: false
-Activating application
-Window is not visible, showing it
-Focusing window
-After show - Window visible: false, minimized: false
-```
-
-### Technical Details
-The current implementation attempts:
-1. `app.Show()` - calls `[NSApp unhide:nil]` to activate the app
-2. `mainWindow.Show()` - show the window
-3. `mainWindow.Focus()` - focus the window
-
-However, on macOS, when a window is hidden via `Hide()` (which calls `[window orderOut:nil]`), the standard `Show()` and `Focus()` methods are insufficient to restore it.
-
-### Potential Solutions
-
-1. **Use `AttachedWindow` pattern** (recommended by Wails docs):
-   - Attach the window to the system tray
-   - Let Wails handle the show/hide toggle automatically
-   - This is the built-in mechanism for tray-attached windows
-
-2. **Platform-specific handling**:
-   - On macOS, may need to use `makeKeyAndOrderFront` directly
-   - Or use different window state management
-
-3. **Window state tracking**:
-   - Instead of `Hide()`, minimize the window
-   - `Minimise()` + `Restore()` works correctly on macOS
-
-### References
-- Wails v3 System Tray docs: https://v3alpha.wails.io/features/menus/systray/
-- Wails v3 Window docs: https://v3alpha.wails.io/reference/window/
-- Related code: `main.go` tray menu click handler
-
-### Workaround
-Users can use the global hotkey `Cmd+Ctrl+M` to open the command palette, which will also show the window.
diff --git a/README.md b/README.md
index 6f84219..ca3f4bf 100644
--- a/README.md
+++ b/README.md
@@ -6,6 +6,8 @@ A single app for 45+ common development tasks. Works offline, zero setup.
 
 Base64, JWT, JSON formatting, hashing, encoding, escaping, color conversion, regex testing, cron parsing, diff checking, Unix time conversion, barcode generation, mock data, and 30+ more.
 
+**Features Spotlight-like Command Palette:** Press `Cmd+Ctrl+M` (macOS) or `Ctrl+Alt+M` (Windows/Linux) from anywhere to open the floating command palette. Works even over fullscreen apps!
+
 <img width="1552" height="922" alt="DevToolbox interface" src="https://github.com/user-attachments/assets/7dc24777-7330-485a-b6b4-b522739536c0" />
 
 No browser tabs. No data sent to servers. Just open and use.
diff --git a/docs/plans/2025-03-03-faster-ci-pipeline.md b/docs/plans/2025-03-03-faster-ci-pipeline.md
new file mode 100644
index 0000000..d9a1150
--- /dev/null
+++ b/docs/plans/2025-03-03-faster-ci-pipeline.md
@@ -0,0 +1,949 @@
+# Faster CI Pipeline Implementation Plan
+
+> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.
+
+**Goal:** Reduce PR check time from ~5-10 minutes to under 2 minutes by adding aggressive caching and frontend test infrastructure.
+
+**Architecture:** Add comprehensive GitHub Actions caching (Go modules, Bun dependencies, Wails CLI binary, APT packages) + Vitest frontend testing setup with utility and component tests. Three independent work streams allow parallel execution by different agents.
+
+**Tech Stack:** GitHub Actions, Vitest, React Testing Library, Bun, Wails v3
+
+---
+
+## Parallel Work Streams
+
+This plan has 3 independent work streams that can be executed by different agents:
+- **Work Stream A:** CI Optimization (GitHub Actions caching)
+- **Work Stream B:** Frontend Testing Setup (Vitest configuration)
+- **Work Stream C:** Frontend Tests (Utility and component tests)
+
+---
+
+## Work Stream A: CI Optimization (GitHub Actions Caching)
+
+**Dependencies:** None - can run independently
+
+### Task A1: Add Go Module Caching to Go Tests Job
+
+**Files:**
+- Modify: `.github/workflows/ci.yml:21-56`
+
+**Step 1: Add Go module caching to go-tests job**
+
+Update the go-tests job to enable caching:
+
+```yaml
+      - name: Setup Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: "1.25.0"
+          check-latest: true
+          cache: true
+          cache-dependency-path: go.sum
+```
+
+**Step 2: Verify the change**
+
+Check that the Setup Go step now includes `cache: true`.
+
+**Step 3: Commit**
+
+```bash
+git add .github/workflows/ci.yml
+git commit -m "ci: add Go module caching to go-tests job"
+```
+
+---
+
+### Task A2: Optimize Wails CLI Installation with Caching
+
+**Files:**
+- Modify: `.github/workflows/ci.yml:79-86`
+- Modify: `.github/workflows/ci.yml:88-90`
+
+**Step 1: Add Wails CLI binary caching**
+
+Replace the Wails CLI installation with cached version:
+
+```yaml
+      - name: Cache Wails CLI
+        id: cache-wails
+        uses: actions/cache@v4
+        with:
+          path: ~/go/bin/wails3
+          key: wails-cli-${{ runner.os }}-${{ hashFiles('go.mod') }}
+
+      - name: Install Wails CLI
+        if: steps.cache-wails.outputs.cache-hit != 'true'
+        run: |
+          go install github.com/wailsapp/wails/v3/cmd/wails3@latest
+
+      - name: Setup Wails CLI PATH
+        run: |
+          mkdir -p /usr/local/bin
+          cp $(go env GOPATH)/bin/wails3 /usr/local/bin/wails
+          chmod +x /usr/local/bin/wails
+          echo "/usr/local/bin" >> $GITHUB_PATH
+```
+
+**Step 2: Verify the change**
+
+Ensure caching logic and conditional installation are correct.
+
+**Step 3: Commit**
+
+```bash
+git add .github/workflows/ci.yml
+git commit -m "ci: cache Wails CLI binary to avoid recompiling"
+```
+
+---
+
+### Task A3: Add APT Package Caching
+
+**Files:**
+- Modify: `.github/workflows/ci.yml:79-86`
+
+**Step 1: Add APT caching for native dependencies**
+
+Add caching before installing APT packages:
+
+```yaml
+      - name: Cache APT packages
+        uses: awalsh128/cache-apt-pkgs-action@latest
+        with:
+          packages: libgtk-3-dev libwebkit2gtk-4.1-dev
+          version: 1.0
+          execute_install_scripts: false
+```
+
+Remove the `apt-get update` and `apt-get install` commands since the cache action handles them.
+
+**Step 2: Remove old APT commands**
+
+Delete these lines:
+```yaml
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libgtk-3-dev libwebkit2gtk-4.1-dev
+```
+
+**Step 3: Commit**
+
+```bash
+git add .github/workflows/ci.yml
+git commit -m "ci: cache APT packages for faster native deps installation"
+```
+
+---
+
+### Task A4: Add Bun Dependency Caching
+
+**Files:**
+- Modify: `.github/workflows/ci.yml:74-78`
+
+**Step 1: Add Bun cache configuration**
+
+Update Bun setup to enable caching:
+
+```yaml
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v1
+        with:
+          bun-version: latest
+
+      - name: Cache Bun dependencies
+        uses: actions/cache@v4
+        with:
+          path: |
+            frontend/node_modules
+            ~/.bun/install/cache
+          key: bun-deps-${{ runner.os }}-${{ hashFiles('frontend/bun.lockb') }}
+          restore-keys: |
+            bun-deps-${{ runner.os }}-
+```
+
+**Step 2: Commit**
+
+```bash
+git add .github/workflows/ci.yml
+git commit -m "ci: add Bun dependency caching"
+```
+
+---
+
+### Task A5: Optimize Go Test Execution
+
+**Files:**
+- Modify: `.github/workflows/ci.yml:31-35`
+
+**Step 1: Optimize test execution**
+
+Replace test command with optimized version:
+
+```yaml
+      - name: Run Go Tests
+        run: |
+          go test -race -count=1 ./internal/... -coverprofile=coverage.out
+          go install github.com/boumenot/gocover-cobertura@latest
+          gocover-cobertura < coverage.out > coverage.xml
+```
+
+Changes:
+- Removed `-v` (verbose) flag for cleaner output
+- Added `-count=1` to disable test caching (ensures fresh runs)
+- Kept `-race` for race detection
+
+**Step 2: Commit**
+
+```bash
+git add .github/workflows/ci.yml
+git commit -m "ci: optimize Go test execution"
+```
+
+---
+
+### Task A6: Parallelize Jobs and Add Frontend Checks
+
+**Files:**
+- Modify: `.github/workflows/ci.yml` (restructure jobs)
+
+**Step 1: Rename app-build to frontend-checks and restructure**
+
+```yaml
+  frontend-checks:
+    name: Frontend Checks
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: write
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v1
+        with:
+          bun-version: latest
+
+      - name: Cache Bun dependencies
+        uses: actions/cache@v4
+        with:
+          path: |
+            frontend/node_modules
+            ~/.bun/install/cache
+          key: bun-deps-${{ runner.os }}-${{ hashFiles('frontend/bun.lockb') }}
+          restore-keys: |
+            bun-deps-${{ runner.os }}-
+
+      - name: Install frontend dependencies
+        run: |
+          cd frontend && bun install
+
+      - name: Format check
+        run: |
+          cd frontend && bun run format:check
+
+      - name: Build frontend
+        run: |
+          cd frontend && bun run build
+```
+
+**Step 2: Update job name from `app-build` to `frontend-checks`**
+
+**Step 3: Commit**
+
+```bash
+git add .github/workflows/ci.yml
+git commit -m "ci: restructure frontend job and add format checks"
+```
+
+---
+
+## Work Stream B: Frontend Testing Setup (Vitest)
+
+**Dependencies:** None - can run independently
+
+### Task B1: Install Vitest and Testing Dependencies
+
+**Files:**
+- Modify: `frontend/package.json`
+
+**Step 1: Add test scripts and devDependencies**
+
+Add to `scripts` section:
+```json
+"test": "vitest run",
+"test:watch": "vitest",
+"test:coverage": "vitest run --coverage"
+```
+
+Add to `devDependencies`:
+```json
+"@testing-library/react": "^14.2.1",
+"@testing-library/jest-dom": "^6.4.2",
+"@testing-library/user-event": "^14.5.2",
+"@vitest/coverage-v8": "^1.3.1",
+"jsdom": "^24.0.0",
+"vitest": "^1.3.1"
+```
+
+**Step 2: Install dependencies**
+
+```bash
+cd frontend
+bun install
+```
+
+**Step 3: Verify installation**
+
+Check `frontend/node_modules` contains `vitest`, `@testing-library/react`.
+
+**Step 4: Commit**
+
+```bash
+git add frontend/package.json
+bun install
+git add bun.lockb
+git commit -m "chore: install Vitest and React Testing Library"
+```
+
+---
+
+### Task B2: Configure Vitest
+
+**Files:**
+- Create: `frontend/vitest.config.js`
+
+**Step 1: Create Vitest configuration**
+
+```javascript
+import { defineConfig } from 'vitest/config';
+import react from '@vitejs/plugin-react';
+
+export default defineConfig({
+  plugins: [react()],
+  test: {
+    globals: true,
+    environment: 'jsdom',
+    setupFiles: ['./src/test/setup.js'],
+    include: ['src/**/*.{test,spec}.{js,jsx}'],
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+      exclude: [
+        'node_modules/',
+        'src/test/',
+        'src/**/*.d.ts',
+      ],
+    },
+  },
+});
+```
+
+**Step 2: Create test setup file**
+
+**Files:**
+- Create: `frontend/src/test/setup.js`
+
+```javascript
+import { expect, afterEach } from 'vitest';
+import { cleanup } from '@testing-library/react';
+import * as matchers from '@testing-library/jest-dom/matchers';
+
+// Extend Vitest's expect with jest-dom matchers
+expect.extend(matchers);
+
+// Cleanup after each test
+afterEach(() => {
+  cleanup();
+});
+```
+
+**Step 3: Verify configuration**
+
+```bash
+cd frontend
+bun run test --help
+```
+
+Expected: Shows Vitest help output without errors.
+
+**Step 4: Commit**
+
+```bash
+git add frontend/vitest.config.js frontend/src/test/setup.js
+git commit -m "chore: configure Vitest with jsdom and testing-library"
+```
+
+---
+
+### Task B3: Add Frontend Tests to CI
+
+**Files:**
+- Modify: `.github/workflows/ci.yml` (frontend-checks job)
+
+**Step 1: Add frontend test step**
+
+Add after the "Build frontend" step in the `frontend-checks` job:
+
+```yaml
+      - name: Run frontend tests
+        run: |
+          cd frontend && bun run test
+```
+
+**Step 2: Update job name to reflect tests**
+
+Change job name from "Frontend Checks" to "Frontend Tests & Build".
+
+**Step 3: Commit**
+
+```bash
+git add .github/workflows/ci.yml
+git commit -m "ci: add frontend test execution to CI"
+```
+
+---
+
+## Work Stream C: Frontend Tests (Utilities and Components)
+
+**Dependencies:** Work Stream B must be complete first
+
+### Task C1: Test Utility - storage.js
+
+**Files:**
+- Create: `frontend/src/utils/storage.test.js`
+
+**Step 1: Write failing tests**
+
+```javascript
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import storage from './storage';
+
+describe('storage', () => {
+  beforeEach(() => {
+    // Clear localStorage before each test
+    window.localStorage.clear();
+    vi.clearAllMocks();
+  });
+
+  describe('get', () => {
+    it('should return null for non-existent key', () => {
+      expect(storage.get('non-existent')).toBeNull();
+    });
+
+    it('should return parsed value for existing key', () => {
+      window.localStorage.setItem('test-key', JSON.stringify({ foo: 'bar' }));
+      expect(storage.get('test-key')).toEqual({ foo: 'bar' });
+    });
+
+    it('should return null and log error for invalid JSON', () => {
+      window.localStorage.setItem('invalid', 'not-json');
+      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      
+      expect(storage.get('invalid')).toBeNull();
+      expect(consoleSpy).toHaveBeenCalled();
+      
+      consoleSpy.mockRestore();
+    });
+  });
+
+  describe('set', () => {
+    it('should store value as JSON', () => {
+      storage.set('test', { data: 'value' });
+      expect(window.localStorage.getItem('test')).toBe('{"data":"value"}');
+    });
+
+    it('should return true on success', () => {
+      expect(storage.set('test', 'value')).toBe(true);
+    });
+
+    it('should return false and log error on failure', () => {
+      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      vi.spyOn(window.localStorage, 'setItem').mockImplementation(() => {
+        throw new Error('Storage full');
+      });
+
+      expect(storage.set('test', 'value')).toBe(false);
+      expect(consoleSpy).toHaveBeenCalled();
+      
+      consoleSpy.mockRestore();
+    });
+  });
+
+  describe('getArray', () => {
+    it('should return empty array for non-existent key', () => {
+      expect(storage.getArray('non-existent')).toEqual([]);
+    });
+
+    it('should return parsed array for existing key', () => {
+      window.localStorage.setItem('array-key', JSON.stringify([1, 2, 3]));
+      expect(storage.getArray('array-key')).toEqual([1, 2, 3]);
+    });
+
+    it('should return empty array for non-array value', () => {
+      window.localStorage.setItem('not-array', JSON.stringify({ foo: 'bar' }));
+      expect(storage.getArray('not-array')).toEqual([]);
+    });
+  });
+
+  describe('setArray', () => {
+    it('should store array as JSON', () => {
+      storage.setArray('test', [1, 2, 3]);
+      expect(window.localStorage.getItem('test')).toBe('[1,2,3]');
+    });
+
+    it('should return false for non-array value', () => {
+      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      expect(storage.setArray('test', 'not-array')).toBe(false);
+      consoleSpy.mockRestore();
+    });
+  });
+});
+```
+
+**Step 2: Run tests to verify they pass**
+
+```bash
+cd frontend
+bun run test src/utils/storage.test.js
+```
+
+Expected: All 9 tests pass.
+
+**Step 3: Commit**
+
+```bash
+git add frontend/src/utils/storage.test.js
+git commit -m "test: add tests for storage utility"
+```
+
+---
+
+### Task C2: Test Utility - inputUtils.js
+
+**Files:**
+- Create: `frontend/src/utils/inputUtils.test.js`
+
+**Step 1: Write tests**
+
+```javascript
+import { describe, it, expect } from 'vitest';
+import {
+  getMonospaceFontFamily,
+  getDataFontSize,
+  getTextareaResize,
+  validateJson,
+  formatJson,
+  objectToKeyValueString,
+} from './inputUtils';
+
+describe('inputUtils', () => {
+  describe('getMonospaceFontFamily', () => {
+    it('should return IBM Plex Mono font family', () => {
+      expect(getMonospaceFontFamily()).toBe("'IBM Plex Mono', monospace");
+    });
+  });
+
+  describe('getDataFontSize', () => {
+    it('should return 0.875rem', () => {
+      expect(getDataFontSize()).toBe('0.875rem');
+    });
+  });
+
+  describe('getTextareaResize', () => {
+    it('should return none when both are false', () => {
+      expect(getTextareaResize(false, false)).toBe('none');
+    });
+
+    it('should return vertical when only height is true', () => {
+      expect(getTextareaResize(true, false)).toBe('vertical');
+    });
+
+    it('should return horizontal when only width is true', () => {
+      expect(getTextareaResize(false, true)).toBe('horizontal');
+    });
+
+    it('should return both when both are true', () => {
+      expect(getTextareaResize(true, true)).toBe('both');
+    });
+
+    it('should default to vertical resize', () => {
+      expect(getTextareaResize()).toBe('vertical');
+    });
+  });
+
+  describe('validateJson', () => {
+    it('should return valid for empty string', () => {
+      const result = validateJson('');
+      expect(result.isValid).toBe(true);
+      expect(result.data).toBeNull();
+      expect(result.error).toBeNull();
+    });
+
+    it('should return valid for whitespace-only string', () => {
+      const result = validateJson('   ');
+      expect(result.isValid).toBe(true);
+    });
+
+    it('should parse valid JSON object', () => {
+      const result = validateJson('{"key": "value"}');
+      expect(result.isValid).toBe(true);
+      expect(result.data).toEqual({ key: 'value' });
+      expect(result.error).toBeNull();
+    });
+
+    it('should parse valid JSON array', () => {
+      const result = validateJson('[1, 2, 3]');
+      expect(result.isValid).toBe(true);
+      expect(result.data).toEqual([1, 2, 3]);
+    });
+
+    it('should return invalid for malformed JSON', () => {
+      const result = validateJson('{"key": value}');
+      expect(result.isValid).toBe(false);
+      expect(result.data).toBeNull();
+      expect(result.error).toContain('Unexpected token');
+    });
+  });
+
+  describe('formatJson', () => {
+    it('should format object with default indentation', () => {
+      const result = formatJson({ key: 'value' });
+      expect(result).toBe('{\n  "key": "value"\n}');
+    });
+
+    it('should format with custom indentation', () => {
+      const result = formatJson({ key: 'value' }, 4);
+      expect(result).toBe('{\n    "key": "value"\n}');
+    });
+
+    it('should return empty string for null', () => {
+      expect(formatJson(null)).toBe('');
+    });
+
+    it('should return empty string for undefined', () => {
+      expect(formatJson(undefined)).toBe('');
+    });
+  });
+
+  describe('objectToKeyValueString', () => {
+    it('should convert object to key-value string', () => {
+      const result = objectToKeyValueString({ foo: 'bar', num: 42 });
+      expect(result).toBe('foo: "bar"\nnum: 42');
+    });
+
+    it('should return empty string for null', () => {
+      expect(objectToKeyValueString(null)).toBe('');
+    });
+
+    it('should return empty string for non-object', () => {
+      expect(objectToKeyValueString('string')).toBe('');
+    });
+
+    it('should handle nested objects', () => {
+      const result = objectToKeyValueString({ nested: { a: 1 } });
+      expect(result).toBe('nested: {"a":1}');
+    });
+  });
+});
+```
+
+**Step 2: Run tests**
+
+```bash
+cd frontend
+bun run test src/utils/inputUtils.test.js
+```
+
+Expected: All tests pass.
+
+**Step 3: Commit**
+
+```bash
+git add frontend/src/utils/inputUtils.test.js
+git commit -m "test: add tests for inputUtils utility"
+```
+
+---
+
+### Task C3: Test Utility - layoutUtils.js
+
+**Files:**
+- Read: `frontend/src/utils/layoutUtils.js`
+- Create: `frontend/src/utils/layoutUtils.test.js`
+
+**Step 1: Read existing layoutUtils.js**
+
+Check if file exists and understand its contents.
+
+**Step 2: Create tests**
+
+```javascript
+import { describe, it, expect } from 'vitest';
+// Import functions from layoutUtils.js once you read it
+
+describe('layoutUtils', () => {
+  it('should have tests for layout utilities', () => {
+    // Write tests based on actual functions in layoutUtils.js
+    expect(true).toBe(true);
+  });
+});
+```
+
+**Step 3: Run and commit**
+
+```bash
+cd frontend
+bun run test src/utils/layoutUtils.test.js
+git add frontend/src/utils/layoutUtils.test.js
+git commit -m "test: add tests for layoutUtils utility"
+```
+
+---
+
+### Task C4: Test Component - ToolCopyButton
+
+**Files:**
+- Create: `frontend/src/components/inputs/ToolCopyButton.test.jsx`
+
+**Step 1: Write tests**
+
+```javascript
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen, fireEvent } from '@testing-library/react';
+import ToolCopyButton from './ToolCopyButton';
+
+describe('ToolCopyButton', () => {
+  it('should render copy button', () => {
+    render(<ToolCopyButton text="test content" />);
+    expect(screen.getByRole('button')).toBeInTheDocument();
+  });
+
+  it('should have aria-label for accessibility', () => {
+    render(<ToolCopyButton text="test" />);
+    expect(screen.getByLabelText(/copy/i)).toBeInTheDocument();
+  });
+
+  it('should call clipboard API when clicked', async () => {
+    const mockWriteText = vi.fn().mockResolvedValue(undefined);
+    Object.assign(navigator, {
+      clipboard: { writeText: mockWriteText },
+    });
+
+    render(<ToolCopyButton text="test content" />);
+    fireEvent.click(screen.getByRole('button'));
+
+    expect(mockWriteText).toHaveBeenCalledWith('test content');
+  });
+
+  it('should show checkmark after successful copy', async () => {
+    vi.useFakeTimers();
+    Object.assign(navigator, {
+      clipboard: {
+        writeText: vi.fn().mockResolvedValue(undefined),
+      },
+    });
+
+    render(<ToolCopyButton text="test" />);
+    fireEvent.click(screen.getByRole('button'));
+
+    // Wait for async operation
+    await vi.advanceTimersByTimeAsync(0);
+
+    // Check that success state is shown (implementation dependent)
+    // This test may need adjustment based on actual component behavior
+    
+    vi.useRealTimers();
+  });
+});
+```
+
+**Step 2: Run tests**
+
+```bash
+cd frontend
+bun run test src/components/inputs/ToolCopyButton.test.jsx
+```
+
+**Step 3: Commit**
+
+```bash
+git add frontend/src/components/inputs/ToolCopyButton.test.jsx
+git commit -m "test: add tests for ToolCopyButton component"
+```
+
+---
+
+### Task C5: Test Hook - useLayoutToggle
+
+**Files:**
+- Create: `frontend/src/hooks/useLayoutToggle.test.js`
+
+**Step 1: Write tests**
+
+```javascript
+import { describe, it, expect } from 'vitest';
+import { renderHook, act } from '@testing-library/react';
+import useLayoutToggle from './useLayoutToggle';
+
+describe('useLayoutToggle', () => {
+  it('should initialize with default layout', () => {
+    const { result } = renderHook(() => useLayoutToggle());
+    expect(result.current.layout).toBeDefined();
+  });
+
+  it('should toggle layout', () => {
+    const { result } = renderHook(() => useLayoutToggle());
+    const initialLayout = result.current.layout;
+
+    act(() => {
+      result.current.toggleLayout();
+    });
+
+    expect(result.current.layout).not.toBe(initialLayout);
+  });
+
+  it('should persist layout to storage', () => {
+    const { result } = renderHook(() => useLayoutToggle());
+    
+    act(() => {
+      result.current.setLayout('split');
+    });
+
+    // Re-render hook and check if persisted value is loaded
+    const { result: result2 } = renderHook(() => useLayoutToggle());
+    expect(result2.current.layout).toBe('split');
+  });
+});
+```
+
+**Step 2: Run tests**
+
+```bash
+cd frontend
+bun run test src/hooks/useLayoutToggle.test.js
+```
+
+**Step 3: Commit**
+
+```bash
+git add frontend/src/hooks/useLayoutToggle.test.js
+git commit -m "test: add tests for useLayoutToggle hook"
+```
+
+---
+
+## Integration and Validation
+
+### Task I1: Run Full Test Suite Locally
+
+**Step 1: Run all frontend tests**
+
+```bash
+cd frontend
+bun run test
+```
+
+Expected: All tests pass.
+
+**Step 2: Run with coverage**
+
+```bash
+bun run test:coverage
+```
+
+Expected: Coverage report generated.
+
+**Step 3: Verify build still works**
+
+```bash
+bun run build
+```
+
+Expected: Build completes without errors.
+
+---
+
+### Task I2: Validate CI Workflow
+
+**Step 1: Test locally with act (optional)**
+
+If `act` is installed:
+
+```bash
+act -j go-tests
+act -j frontend-checks
+```
+
+**Step 2: Push branch and create PR**
+
+```bash
+git push origin feature/faster-ci
+```
+
+Create PR and observe CI execution times.
+
+---
+
+### Task I3: Performance Validation
+
+**Step 1: Record baseline timing**
+
+Before changes: Note current CI time (~5-10 minutes)
+
+**Step 2: Measure after changes**
+
+With all optimizations, expected times:
+- Go Tests: ~30-60 seconds (cached modules)
+- Frontend Tests & Build: ~45-90 seconds (cached deps)
+- Total PR check: ~1-2 minutes
+
+**Step 3: Document improvements**
+
+Update README or CONTRIBUTING with new CI times.
+
+---
+
+## Summary of Changes
+
+### Files Created:
+- `frontend/vitest.config.js` - Vitest configuration
+- `frontend/src/test/setup.js` - Test setup file
+- `frontend/src/utils/storage.test.js` - Storage utility tests
+- `frontend/src/utils/inputUtils.test.js` - Input utility tests
+- `frontend/src/utils/layoutUtils.test.js` - Layout utility tests
+- `frontend/src/components/inputs/ToolCopyButton.test.jsx` - Component tests
+- `frontend/src/hooks/useLayoutToggle.test.js` - Hook tests
+
+### Files Modified:
+- `frontend/package.json` - Added test dependencies
+- `.github/workflows/ci.yml` - Added caching and frontend tests
+
+### Expected Outcomes:
+- PR check time reduced from 5-10 min to 1-2 min
+- Frontend tests running in CI
+- 15-20+ unit tests covering core utilities and components
+
+---
+
+## Execution Options
+
+**This plan has 3 independent work streams:**
+
+1. **Work Stream A** (CI Optimization) - Modifies `.github/workflows/ci.yml`
+2. **Work Stream B** (Frontend Testing Setup) - Modifies `frontend/package.json` and creates config
+3. **Work Stream C** (Frontend Tests) - Creates test files (depends on Work Stream B)
+
+**Parallel execution:**
+- Agent 1: Work Stream A (independent)
+- Agent 2: Work Stream B (independent)
+- Agent 3: Work Stream C (waits for B)
+
+**Or serial execution:**
+- Complete Work Stream B first
+- Then Work Streams A and C can run in parallel
+
+Choose execution method based on available agents.
diff --git a/docs/spotlight-testing.md b/docs/spotlight-testing.md
new file mode 100644
index 0000000..9147dc7
--- /dev/null
+++ b/docs/spotlight-testing.md
@@ -0,0 +1,26 @@
+# Spotlight Command Palette Testing Guide
+
+## Manual Testing Checklist
+
+### Basic Functionality
+- [ ] Press `Cmd+Ctrl+M` (macOS) or `Ctrl+Alt+M` (Windows/Linux) opens spotlight
+- [ ] Spotlight window appears centered on screen
+- [ ] Spotlight has translucent backdrop
+- [ ] Typing filters commands
+- [ ] Arrow keys navigate the list
+- [ ] Enter selects a command
+- [ ] Escape closes spotlight
+
+### Navigation
+- [ ] Selecting a tool command opens main window and navigates
+- [ ] Selecting "Toggle Dark Mode" toggles theme
+- [ ] Selecting "Show/Hide Main Window" toggles visibility
+- [ ] Selecting "Quit DevToolbox" quits app
+
+### macOS-Specific Features
+- [ ] Spotlight appears on all Spaces
+- [ ] Spotlight overlays fullscreen apps
+
+### Recent Commands
+- [ ] Recently used commands appear at top
+- [ ] Recent commands persist across restarts
diff --git a/frontend/bindings/github.com/wailsapp/wails/v3/internal/eventdata.d.ts b/frontend/bindings/github.com/wailsapp/wails/v3/internal/eventdata.d.ts
index b1e8586..7c23682 100644
--- a/frontend/bindings/github.com/wailsapp/wails/v3/internal/eventdata.d.ts
+++ b/frontend/bindings/github.com/wailsapp/wails/v3/internal/eventdata.d.ts
@@ -11,6 +11,9 @@ declare module "@wailsio/runtime" {
             "app:quit": string;
             "command-palette:open": string;
             "settings:changed": { [_ in string]?: any };
+            "spotlight:closed": string;
+            "spotlight:command-selected": string;
+            "spotlight:opened": string;
             "time": string;
             "window:toggle": string;
         }
diff --git a/frontend/bindings/github.com/wailsapp/wails/v3/pkg/application/index.js b/frontend/bindings/github.com/wailsapp/wails/v3/pkg/application/index.js
new file mode 100644
index 0000000..66677ba
--- /dev/null
+++ b/frontend/bindings/github.com/wailsapp/wails/v3/pkg/application/index.js
@@ -0,0 +1,7 @@
+// @ts-check
+// Cynhyrchwyd y ffeil hon yn awtomatig. PEIDIWCH Â MODIWL
+// This file is automatically generated. DO NOT EDIT
+
+export {
+    WebviewWindow
+} from "./models.js";
diff --git a/frontend/bindings/github.com/wailsapp/wails/v3/pkg/application/models.js b/frontend/bindings/github.com/wailsapp/wails/v3/pkg/application/models.js
new file mode 100644
index 0000000..858c3ed
--- /dev/null
+++ b/frontend/bindings/github.com/wailsapp/wails/v3/pkg/application/models.js
@@ -0,0 +1,28 @@
+// @ts-check
+// Cynhyrchwyd y ffeil hon yn awtomatig. PEIDIWCH Â MODIWL
+// This file is automatically generated. DO NOT EDIT
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore: Unused imports
+import { Create as $Create } from "@wailsio/runtime";
+
+export class WebviewWindow {
+    /**
+     * Creates a new WebviewWindow instance.
+     * @param {Partial<WebviewWindow>} [$$source = {}] - The source object to create the WebviewWindow.
+     */
+    constructor($$source = {}) {
+
+        Object.assign(this, $$source);
+    }
+
+    /**
+     * Creates a new WebviewWindow instance from a string or object.
+     * @param {any} [$$source = {}]
+     * @returns {WebviewWindow}
+     */
+    static createFrom($$source = {}) {
+        let $$parsedSource = typeof $$source === 'string' ? JSON.parse($$source) : $$source;
+        return new WebviewWindow(/** @type {Partial<WebviewWindow>} */($$parsedSource));
+    }
+}
diff --git a/frontend/spotlight.html b/frontend/spotlight.html
new file mode 100644
index 0000000..91835d7
--- /dev/null
+++ b/frontend/spotlight.html
@@ -0,0 +1,30 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>DevToolbox Spotlight</title>
+    <style>
+      * {
+        margin: 0;
+        padding: 0;
+        box-sizing: border-box;
+      }
+      html,
+      body {
+        width: 100%;
+        height: 100%;
+        overflow: hidden;
+        background: transparent;
+      }
+      #root {
+        width: 100%;
+        height: 100%;
+      }
+    </style>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/spotlight.jsx"></script>
+  </body>
+</html>
diff --git a/frontend/src/App.jsx b/frontend/src/App.jsx
index e654e56..8e61aaf 100644
--- a/frontend/src/App.jsx
+++ b/frontend/src/App.jsx
@@ -1,5 +1,5 @@
 import React, { useState, useEffect, useCallback } from 'react';
-import { Routes, Route, Navigate } from 'react-router-dom';
+import { Routes, Route, Navigate, useNavigate } from 'react-router-dom';
 import './App.css';
 import { Sidebar } from './components/Sidebar';
 import { TitleBar } from './components/TitleBar';
@@ -54,6 +54,7 @@ class ErrorBoundary extends React.Component {
 
 function App() {
   console.log('App mounting');
+  const navigate = useNavigate();
   const [isSidebarOpen, setIsSidebarOpen] = useState(true);
   const [isCommandPaletteOpen, setIsCommandPaletteOpen] = useState(false);
   const [theme, setTheme] = useState('g100'); // 'white', 'g10', 'g90', 'g100'
@@ -61,7 +62,7 @@ function App() {
 
   const toggleSidebar = () => setIsSidebarOpen(!isSidebarOpen);
   const toggleCommandPalette = useCallback(() => {
-    setIsCommandPaletteOpen(prev => !prev);
+    setIsCommandPaletteOpen((prev) => !prev);
   }, []);
   const closeCommandPalette = useCallback(() => setIsCommandPaletteOpen(false), []);
 
@@ -112,6 +113,28 @@ function App() {
     };
   }, [toggleCommandPalette]);
 
+  // Listen for navigation from spotlight
+  useEffect(() => {
+    const unsubscribe = window.runtime?.EventsOn?.('navigate:to', (path) => {
+      navigate(path);
+    });
+
+    return () => {
+      if (unsubscribe) unsubscribe();
+    };
+  }, [navigate]);
+
+  // Listen for theme toggle from spotlight
+  useEffect(() => {
+    const unsubscribe = window.runtime?.EventsOn?.('theme:toggle', () => {
+      setThemeMode(prev => prev === 'dark' ? 'light' : 'dark');
+    });
+
+    return () => {
+      if (unsubscribe) unsubscribe();
+    };
+  }, [setThemeMode]);
+
   return (
     <ErrorBoundary>
       <Theme theme={theme} style={{ height: '100%' }}>
diff --git a/frontend/src/ToolRouter.jsx b/frontend/src/ToolRouter.jsx
index 88676ba..fe400c1 100644
--- a/frontend/src/ToolRouter.jsx
+++ b/frontend/src/ToolRouter.jsx
@@ -19,21 +19,21 @@ const toolComponents = {
   'text-converter': TextConverter,
   'string-utilities': StringUtilities,
   'datetime-converter': DateTimeConverter,
-  'jwt': JwtDebugger,
-  'barcode': BarcodeGenerator,
+  jwt: JwtDebugger,
+  barcode: BarcodeGenerator,
   'data-generator': DataGenerator,
   'code-formatter': CodeFormatter,
   'color-converter': ColorConverter,
-  'regexp': RegExpTester,
-  'cron': CronJobParser,
-  'diff': TextDiffChecker,
+  regexp: RegExpTester,
+  cron: CronJobParser,
+  diff: TextDiffChecker,
   'number-converter': NumberConverter,
 };
 
 function ToolRouter() {
   const { toolId } = useParams();
   const ToolComponent = toolComponents[toolId];
-  
+
   if (!ToolComponent) {
     return (
       <div className="tool-container" style={{ padding: '2rem' }}>
@@ -42,8 +42,8 @@ function ToolRouter() {
       </div>
     );
   }
-  
+
   return <ToolComponent />;
 }
 
-export default ToolRouter;
\ No newline at end of file
+export default ToolRouter;
diff --git a/frontend/src/components/CommandPalette.jsx b/frontend/src/components/CommandPalette.jsx
index 5fa3a15..da06316 100644
--- a/frontend/src/components/CommandPalette.jsx
+++ b/frontend/src/components/CommandPalette.jsx
@@ -197,47 +197,47 @@ export function CommandPalette({ isOpen, onClose, themeMode, setThemeMode }) {
   // Fuzzy match function - checks if query characters appear in order in target
   const fuzzyMatch = (target, query) => {
     if (!query) return true;
-    
+
     const targetLower = target.toLowerCase();
     const queryLower = query.toLowerCase();
     let targetIndex = 0;
     let queryIndex = 0;
-    
+
     while (targetIndex < targetLower.length && queryIndex < queryLower.length) {
       if (targetLower[targetIndex] === queryLower[queryIndex]) {
         queryIndex++;
       }
       targetIndex++;
     }
-    
+
     return queryIndex === queryLower.length;
   };
 
   // Calculate fuzzy match score (lower is better)
   const fuzzyScore = (target, query) => {
     if (!query) return 0;
-    
+
     const targetLower = target.toLowerCase();
     const queryLower = query.toLowerCase();
-    
+
     // Exact match gets highest priority
     if (targetLower === queryLower) return -1000;
-    
+
     // Starts with query gets high priority
     if (targetLower.startsWith(queryLower)) return -100;
-    
+
     // Word boundary match gets medium priority
     const words = targetLower.split(/[\s>]/);
     for (let word of words) {
       if (word.startsWith(queryLower)) return -50;
     }
-    
+
     // Calculate distance score for fuzzy match
     let targetIndex = 0;
     let queryIndex = 0;
     let score = 0;
     let lastMatchIndex = -1;
-    
+
     while (targetIndex < targetLower.length && queryIndex < queryLower.length) {
       if (targetLower[targetIndex] === queryLower[queryIndex]) {
         if (lastMatchIndex !== -1) {
@@ -249,10 +249,10 @@ export function CommandPalette({ isOpen, onClose, themeMode, setThemeMode }) {
       }
       targetIndex++;
     }
-    
+
     // If didn't match all query characters, return high score (bad match)
     if (queryIndex < queryLower.length) return 9999;
-    
+
     return score;
   };
 
@@ -271,19 +271,19 @@ export function CommandPalette({ isOpen, onClose, themeMode, setThemeMode }) {
     }
 
     const query = searchQuery.toLowerCase();
-    
+
     // Filter and score commands
-    const scored = COMMANDS.map(cmd => {
+    const scored = COMMANDS.map((cmd) => {
       const labelScore = fuzzyScore(cmd.label, query);
       const categoryScore = fuzzyScore(cmd.category, query);
       const bestScore = Math.min(labelScore, categoryScore);
       return { cmd, score: bestScore };
-    }).filter(item => item.score < 9999);
-    
+    }).filter((item) => item.score < 9999);
+
     // Sort by score (lower is better)
     scored.sort((a, b) => a.score - b.score);
-    
-    setCommands(scored.map(item => item.cmd));
+
+    setCommands(scored.map((item) => item.cmd));
     setSelectedIndex(0);
   }, [searchQuery, recentCommands]);
 
diff --git a/frontend/src/components/SettingsModal.jsx b/frontend/src/components/SettingsModal.jsx
index ccb66d2..35502b1 100644
--- a/frontend/src/components/SettingsModal.jsx
+++ b/frontend/src/components/SettingsModal.jsx
@@ -12,12 +12,7 @@ import { Settings } from '@carbon/icons-react';
 import { GetCloseMinimizesToTray, SetCloseMinimizesToTray } from '../generated';
 import './SettingsModal.css';
 
-export function SettingsModal({
-  isOpen,
-  onClose,
-  themeMode,
-  setThemeMode,
-}) {
+export function SettingsModal({ isOpen, onClose, themeMode, setThemeMode }) {
   const [closeMinimizesToTray, setCloseMinimizesToTray] = useState(true);
   const [isLoading, setIsLoading] = useState(false);
 
@@ -39,17 +34,8 @@ export function SettingsModal({
   };
 
   return (
-    <ComposedModal
-      open={isOpen}
-      onClose={onClose}
-      size="sm"
-      className="settings-modal"
-    >
-      <ModalHeader
-        icon={<Settings size={20} />}
-        label=""
-        title="Application Settings"
-      />
+    <ComposedModal open={isOpen} onClose={onClose} size="sm" className="settings-modal">
+      <ModalHeader icon={<Settings size={20} />} label="" title="Application Settings" />
       <ModalBody className="settings-modal-body">
         <FormGroup legendText="Appearance">
           <RadioButtonGroup
@@ -93,7 +79,8 @@ export function SettingsModal({
             id="close-minimizes"
           />
           <p className="settings-description">
-            When enabled, clicking the close button will minimize the app to the system tray instead of quitting.
+            When enabled, clicking the close button will minimize the app to the system tray instead
+            of quitting.
           </p>
         </FormGroup>
       </ModalBody>
diff --git a/frontend/src/components/SpotlightPalette.css b/frontend/src/components/SpotlightPalette.css
new file mode 100644
index 0000000..230b7da
--- /dev/null
+++ b/frontend/src/components/SpotlightPalette.css
@@ -0,0 +1,157 @@
+.spotlight-container {
+  width: 640px;
+  max-width: 90vw;
+  background: rgba(30, 30, 30, 0.35);
+  border: 1px solid rgba(255, 255, 255, 0.08);
+  border-radius: 16px;
+  box-shadow: 0 25px 50px -12px rgba(0, 0, 0, 0.5), 0 0 0 1px rgba(255, 255, 255, 0.03);
+  overflow: hidden;
+  backdrop-filter: blur(32px) saturate(200%);
+  -webkit-backdrop-filter: blur(32px) saturate(200%);
+}
+
+.spotlight-search-box {
+  display: flex;
+  align-items: center;
+  gap: 0.75rem;
+  padding: 1.25rem 1.5rem;
+  border-bottom: 1px solid rgba(255, 255, 255, 0.06);
+}
+
+.spotlight-search-icon {
+  color: var(--cds-text-secondary);
+  flex-shrink: 0;
+  opacity: 0.7;
+}
+
+.spotlight-input {
+  flex: 1;
+  background: transparent;
+  border: none;
+  color: var(--cds-text-primary);
+  font-size: 1.25rem;
+  font-weight: 400;
+  padding: 0;
+  outline: none;
+  font-family: var(--cds-font-sans);
+  letter-spacing: -0.01em;
+}
+
+.spotlight-input::placeholder {
+  color: var(--cds-text-secondary);
+  opacity: 0.6;
+}
+
+.spotlight-clear-btn {
+  background: transparent;
+  border: none;
+  color: var(--cds-text-secondary);
+  cursor: pointer;
+  padding: 0.25rem;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  border-radius: 4px;
+  transition: all 0.15s ease;
+  opacity: 0.7;
+}
+
+.spotlight-clear-btn:hover {
+  background: var(--cds-layer-hover);
+  opacity: 1;
+}
+
+.spotlight-results {
+  max-height: 360px;
+  overflow: hidden;
+}
+
+.spotlight-empty {
+  padding: 2.5rem 1.5rem;
+  text-align: center;
+  color: var(--cds-text-secondary);
+  font-size: 0.875rem;
+  opacity: 0.8;
+}
+
+.spotlight-list {
+  overflow-y: auto;
+  max-height: 360px;
+  padding: 0.5rem 0;
+}
+
+.spotlight-item {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 0.625rem 1.5rem;
+  cursor: pointer;
+  transition: all 0.12s ease;
+  margin: 0 0.5rem;
+  border-radius: 6px;
+}
+
+.spotlight-item:hover,
+.spotlight-item.selected {
+  background: var(--cds-layer-hover);
+}
+
+.spotlight-item.selected {
+  background: var(--cds-layer-selected);
+}
+
+.spotlight-item-content {
+  display: flex;
+  align-items: center;
+  gap: 0.875rem;
+  flex: 1;
+  min-width: 0;
+}
+
+.spotlight-item-icon {
+  color: var(--cds-text-secondary);
+  flex-shrink: 0;
+  opacity: 0.8;
+}
+
+.spotlight-item-label {
+  color: var(--cds-text-primary);
+  font-size: 0.9375rem;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  font-weight: 400;
+}
+
+.spotlight-item-category {
+  color: var(--cds-text-secondary);
+  font-size: 0.6875rem;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  flex-shrink: 0;
+  margin-left: 1rem;
+  padding: 0.25rem 0.625rem;
+  background: var(--cds-layer-active);
+  border-radius: 4px;
+  font-weight: 500;
+  opacity: 0.8;
+}
+
+/* Scrollbar styling */
+.spotlight-list::-webkit-scrollbar {
+  width: 6px;
+}
+
+.spotlight-list::-webkit-scrollbar-track {
+  background: transparent;
+  margin: 0.5rem 0;
+}
+
+.spotlight-list::-webkit-scrollbar-thumb {
+  background: var(--cds-border-subtle);
+  border-radius: 3px;
+}
+
+.spotlight-list::-webkit-scrollbar-thumb:hover {
+  background: var(--cds-text-secondary);
+}
diff --git a/frontend/src/components/SpotlightPalette.jsx b/frontend/src/components/SpotlightPalette.jsx
new file mode 100644
index 0000000..21dce15
--- /dev/null
+++ b/frontend/src/components/SpotlightPalette.jsx
@@ -0,0 +1,383 @@
+import React, { useState, useEffect, useRef, useCallback } from 'react';
+import { useNavigate } from 'react-router-dom';
+import { Search, Close, Moon, Application, Power } from '@carbon/icons-react';
+import './SpotlightPalette.css';
+
+// Command definitions - simplified for spotlight
+const COMMANDS = [
+  // Code Formatter presets
+  {
+    id: 'formatter-json',
+    label: 'Format JSON',
+    path: '/tool/code-formatter?format=json',
+    category: 'Formatter',
+  },
+  {
+    id: 'formatter-xml',
+    label: 'Format XML',
+    path: '/tool/code-formatter?format=xml',
+    category: 'Formatter',
+  },
+  {
+    id: 'formatter-html',
+    label: 'Format HTML',
+    path: '/tool/code-formatter?format=html',
+    category: 'Formatter',
+  },
+  {
+    id: 'formatter-sql',
+    label: 'Format SQL',
+    path: '/tool/code-formatter?format=sql',
+    category: 'Formatter',
+  },
+  {
+    id: 'formatter-js',
+    label: 'Format JavaScript',
+    path: '/tool/code-formatter?format=javascript',
+    category: 'Formatter',
+  },
+
+  // Text Converter - Encoding
+  {
+    id: 'converter-base64',
+    label: 'Base64 Encode/Decode',
+    path: '/tool/text-converter?category=Encode%20-%20Decode&method=Base64',
+    category: 'Converter',
+  },
+  {
+    id: 'converter-url',
+    label: 'URL Encode/Decode',
+    path: '/tool/text-converter?category=Encode%20-%20Decode&method=URL',
+    category: 'Converter',
+  },
+  {
+    id: 'converter-hex',
+    label: 'Hex Encode/Decode',
+    path: '/tool/text-converter?category=Encode%20-%20Decode&method=Base16%20(Hex)',
+    category: 'Converter',
+  },
+
+  // Text Converter - Hashing
+  {
+    id: 'converter-md5',
+    label: 'MD5 Hash',
+    path: '/tool/text-converter?category=Hash&method=MD5',
+    category: 'Hash',
+  },
+  {
+    id: 'converter-sha256',
+    label: 'SHA-256 Hash',
+    path: '/tool/text-converter?category=Hash&method=SHA-256',
+    category: 'Hash',
+  },
+  {
+    id: 'converter-all-hashes',
+    label: 'All Hashes',
+    path: '/tool/text-converter?category=Hash&method=All',
+    category: 'Hash',
+  },
+
+  // Text Converter - Conversions
+  {
+    id: 'converter-json-yaml',
+    label: 'JSON ↔ YAML',
+    path: '/tool/text-converter?category=Convert&method=JSON%20%E2%86%94%20YAML',
+    category: 'Convert',
+  },
+  {
+    id: 'converter-json-xml',
+    label: 'JSON ↔ XML',
+    path: '/tool/text-converter?category=Convert&method=JSON%20%E2%86%94%20XML',
+    category: 'Convert',
+  },
+  {
+    id: 'converter-markdown-html',
+    label: 'Markdown ↔ HTML',
+    path: '/tool/text-converter?category=Convert&method=Markdown%20%E2%86%94%20HTML',
+    category: 'Convert',
+  },
+
+  // Direct navigation
+  { id: 'jwt', label: 'JWT Debugger', path: '/tool/jwt', category: 'Tools' },
+  { id: 'barcode', label: 'Barcode Generator', path: '/tool/barcode', category: 'Tools' },
+  { id: 'regexp', label: 'RegExp Tester', path: '/tool/regexp', category: 'Tools' },
+  { id: 'cron', label: 'Cron Job Parser', path: '/tool/cron', category: 'Tools' },
+  { id: 'diff', label: 'Text Diff Checker', path: '/tool/diff', category: 'Tools' },
+  { id: 'number', label: 'Number Converter', path: '/tool/number-converter', category: 'Tools' },
+  { id: 'color', label: 'Color Converter', path: '/tool/color-converter', category: 'Tools' },
+  { id: 'string', label: 'String Utilities', path: '/tool/string-utilities', category: 'Tools' },
+  {
+    id: 'datetime',
+    label: 'DateTime Converter',
+    path: '/tool/datetime-converter',
+    category: 'Tools',
+  },
+
+  // Data Generator
+  {
+    id: 'data-user',
+    label: 'Generate User Data',
+    path: '/tool/data-generator?preset=User',
+    category: 'Generator',
+  },
+  {
+    id: 'data-address',
+    label: 'Generate Address Data',
+    path: '/tool/data-generator?preset=Address',
+    category: 'Generator',
+  },
+
+  // System commands
+  {
+    id: 'theme-toggle',
+    label: 'Toggle Dark Mode',
+    action: 'toggle-theme',
+    category: 'System',
+    icon: Moon,
+  },
+  {
+    id: 'window-toggle',
+    label: 'Show/Hide Main Window',
+    action: 'toggle-window',
+    category: 'System',
+    icon: Application,
+  },
+  { id: 'app-quit', label: 'Quit DevToolbox', action: 'quit', category: 'System', icon: Power },
+];
+
+export function SpotlightPalette() {
+  const navigate = useNavigate();
+  const [searchQuery, setSearchQuery] = useState('');
+  const [selectedIndex, setSelectedIndex] = useState(0);
+  const [commands, setCommands] = useState(COMMANDS);
+  const [recentCommands, setRecentCommands] = useState(() => {
+    try {
+      return JSON.parse(localStorage.getItem('spotlightRecent')) || [];
+    } catch {
+      return [];
+    }
+  });
+  const inputRef = useRef(null);
+  const listRef = useRef(null);
+  const timeoutRef = useRef(null);
+
+  // Fuzzy match function
+  const fuzzyMatch = (target, query) => {
+    if (!query) return true;
+    const targetLower = target.toLowerCase();
+    const queryLower = query.toLowerCase();
+    let targetIndex = 0;
+    let queryIndex = 0;
+    while (targetIndex < targetLower.length && queryIndex < queryLower.length) {
+      if (targetLower[targetIndex] === queryLower[queryIndex]) {
+        queryIndex++;
+      }
+      targetIndex++;
+    }
+    return queryIndex === queryLower.length;
+  };
+
+  // Calculate fuzzy match score
+  const fuzzyScore = (target, query) => {
+    if (!query) return 0;
+    const targetLower = target.toLowerCase();
+    const queryLower = query.toLowerCase();
+    if (targetLower === queryLower) return -1000;
+    if (targetLower.startsWith(queryLower)) return -100;
+    const words = targetLower.split(/[\s>]/);
+    for (let word of words) {
+      if (word.startsWith(queryLower)) return -50;
+    }
+    let targetIndex = 0;
+    let queryIndex = 0;
+    let score = 0;
+    let lastMatchIndex = -1;
+    while (targetIndex < targetLower.length && queryIndex < queryLower.length) {
+      if (targetLower[targetIndex] === queryLower[queryIndex]) {
+        if (lastMatchIndex !== -1) {
+          score += targetIndex - lastMatchIndex - 1;
+        }
+        lastMatchIndex = targetIndex;
+        queryIndex++;
+      }
+      targetIndex++;
+    }
+    if (queryIndex < queryLower.length) return 9999;
+    return score;
+  };
+
+  // Filter commands based on search query
+  useEffect(() => {
+    if (!searchQuery.trim()) {
+      const recentIds = new Set(recentCommands);
+      const sortedCommands = [...COMMANDS].sort((a, b) => {
+        const aRecent = recentIds.has(a.id) ? 1 : 0;
+        const bRecent = recentIds.has(b.id) ? 1 : 0;
+        return bRecent - aRecent;
+      });
+      setCommands(sortedCommands);
+      return;
+    }
+    const query = searchQuery.toLowerCase();
+    const scored = COMMANDS.map((cmd) => {
+      const labelScore = fuzzyScore(cmd.label, query);
+      const categoryScore = fuzzyScore(cmd.category, query);
+      const bestScore = Math.min(labelScore, categoryScore);
+      return { cmd, score: bestScore };
+    }).filter((item) => item.score < 9999);
+    scored.sort((a, b) => a.score - b.score);
+    setCommands(scored.map((item) => item.cmd));
+    setSelectedIndex(0);
+  }, [searchQuery, recentCommands]);
+
+  // Focus input on mount
+  useEffect(() => {
+    timeoutRef.current = setTimeout(() => inputRef.current?.focus(), 100);
+    return () => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+    };
+  }, []);
+
+  // Listen for spotlight opened event
+  useEffect(() => {
+    const unsubscribe = window.runtime?.EventsOn?.('spotlight:opened', () => {
+      setSearchQuery('');
+      setSelectedIndex(0);
+      timeoutRef.current = setTimeout(() => inputRef.current?.focus(), 100);
+    });
+    return () => {
+      if (unsubscribe) unsubscribe();
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+    };
+  }, []);
+
+  // Save recent command
+  const saveRecentCommand = useCallback((commandId) => {
+    setRecentCommands((prev) => {
+      const updated = [commandId, ...prev.filter((id) => id !== commandId)].slice(0, 10);
+      localStorage.setItem('spotlightRecent', JSON.stringify(updated));
+      return updated;
+    });
+  }, []);
+
+  // Execute command
+  const executeCommand = useCallback(
+    (command) => {
+      saveRecentCommand(command.id);
+
+      if (command.action) {
+        switch (command.action) {
+          case 'toggle-theme':
+            // Emit to main window
+            window.runtime?.EventsEmit?.('theme:toggle');
+            break;
+          case 'toggle-window':
+            window.runtime?.EventsEmit?.('window:toggle');
+            break;
+          case 'quit':
+            window.runtime?.EventsEmit?.('app:quit');
+            break;
+          default:
+            break;
+        }
+      } else if (command.path) {
+        // Emit command selected event with path
+        window.runtime?.EventsEmit?.('spotlight:command-selected', command.path);
+      }
+
+      // Close spotlight
+      window.runtime?.EventsEmit?.('spotlight:close');
+    },
+    [saveRecentCommand]
+  );
+
+  // Handle input change
+  const handleInputChange = useCallback((e) => {
+    setSearchQuery(e.target.value);
+  }, []);
+
+  // Handle keyboard navigation
+  const handleKeyDown = useCallback(
+    (e) => {
+      if (e.key === 'ArrowDown') {
+        e.preventDefault();
+        setSelectedIndex((prev) => (prev + 1) % commands.length);
+      } else if (e.key === 'ArrowUp') {
+        e.preventDefault();
+        setSelectedIndex((prev) => (prev - 1 + commands.length) % commands.length);
+      } else if (e.key === 'Enter') {
+        e.preventDefault();
+        if (commands[selectedIndex]) {
+          executeCommand(commands[selectedIndex]);
+        }
+      } else if (e.key === 'Escape') {
+        e.preventDefault();
+        window.runtime?.EventsEmit?.('spotlight:close');
+      }
+    },
+    [commands, selectedIndex, executeCommand]
+  );
+
+  // Scroll selected item into view
+  useEffect(() => {
+    const selectedElement = listRef.current?.children[selectedIndex];
+    if (selectedElement) {
+      selectedElement.scrollIntoView({ block: 'nearest', behavior: 'smooth' });
+    }
+  }, [selectedIndex]);
+
+  return (
+    <div className="spotlight-container">
+      <div className="spotlight-search-box">
+        <Search size={20} className="spotlight-search-icon" />
+        <input
+          ref={inputRef}
+          type="text"
+          className="spotlight-input"
+          placeholder="Search tools..."
+          value={searchQuery}
+          onChange={handleInputChange}
+          onKeyDown={handleKeyDown}
+          autoComplete="off"
+        />
+        {searchQuery && (
+          <button className="spotlight-clear-btn" onClick={() => setSearchQuery('')}>
+            <Close size={16} />
+          </button>
+        )}
+      </div>
+
+      <div className="spotlight-results">
+        {commands.length === 0 ? (
+          <div className="spotlight-empty">No commands found matching "{searchQuery}"</div>
+        ) : (
+          <div ref={listRef} className="spotlight-list" role="listbox" aria-label="Search results">
+            {commands.map((command, index) => {
+              const Icon = command.icon || null;
+              return (
+                <div
+                  key={command.id}
+                  className={`spotlight-item ${index === selectedIndex ? 'selected' : ''}`}
+                  onClick={() => executeCommand(command)}
+                  onMouseEnter={() => setSelectedIndex(index)}
+                  role="option"
+                  aria-selected={index === selectedIndex}
+                >
+                  <div className="spotlight-item-content">
+                    {Icon && <Icon size={16} className="spotlight-item-icon" />}
+                    <span className="spotlight-item-label">{command.label}</span>
+                  </div>
+                  <span className="spotlight-item-category">{command.category}</span>
+                </div>
+              );
+            })}
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}
diff --git a/frontend/src/components/ToolUI.jsx b/frontend/src/components/ToolUI.jsx
index b57da13..71c20fe 100644
--- a/frontend/src/components/ToolUI.jsx
+++ b/frontend/src/components/ToolUI.jsx
@@ -5,7 +5,16 @@ import { Copy } from '@carbon/icons-react';
 // Re-export new layout components
 export { ToolLayout, ToolLayoutToggle, ToolVerticalSplit } from './layout';
 export { LAYOUT_DIRECTIONS, TOGGLE_POSITIONS } from './layout/constants';
-export { ToolCopyButton, ToolTextArea, ToolInput, ToolInputGroup, ToolTabBar, CodeEditor, HighlightedCode, EditorToggle } from './inputs';
+export {
+  ToolCopyButton,
+  ToolTextArea,
+  ToolInput,
+  ToolInputGroup,
+  ToolTabBar,
+  CodeEditor,
+  HighlightedCode,
+  EditorToggle,
+} from './inputs';
 
 export function ToolHeader({ title, description }) {
   return (
diff --git a/frontend/src/index.scss b/frontend/src/index.scss
index 63d03a6..5e44203 100644
--- a/frontend/src/index.scss
+++ b/frontend/src/index.scss
@@ -128,31 +128,31 @@ body {
 // Neon Syntax Highlighting Colors for CodeMirror
 // SQL Categorized Keywords
 .cm-sql-ddl {
-  color: #FF6B9D !important; // Hot Pink - CREATE, DROP, ALTER
+  color: #ff6b9d !important; // Hot Pink - CREATE, DROP, ALTER
   font-weight: 600;
 }
 
 .cm-sql-dml {
-  color: #00F0FF !important; // Electric Cyan - SELECT, INSERT
+  color: #00f0ff !important; // Electric Cyan - SELECT, INSERT
   font-weight: 600;
 }
 
 .cm-sql-conditional {
-  color: #B388FF !important; // Electric Purple - WHERE, AND, OR
+  color: #b388ff !important; // Electric Purple - WHERE, AND, OR
   font-weight: 600;
 }
 
 .cm-sql-join {
-  color: #FFAB40 !important; // Bright Orange - JOIN, INNER, LEFT
+  color: #ffab40 !important; // Bright Orange - JOIN, INNER, LEFT
   font-weight: 600;
 }
 
 .cm-sql-aggregate {
-  color: #69F0AE !important; // Bright Mint - COUNT, SUM, AVG
+  color: #69f0ae !important; // Bright Mint - COUNT, SUM, AVG
   font-weight: 600;
 }
 
 .cm-sql-ordering {
-  color: #FFD740 !important; // Golden Yellow - ORDER BY, GROUP BY
+  color: #ffd740 !important; // Golden Yellow - ORDER BY, GROUP BY
   font-weight: 600;
 }
diff --git a/frontend/src/pages/BarcodeGenerator.jsx b/frontend/src/pages/BarcodeGenerator.jsx
index 8bdf472..8ec4a7b 100644
--- a/frontend/src/pages/BarcodeGenerator.jsx
+++ b/frontend/src/pages/BarcodeGenerator.jsx
@@ -257,167 +257,167 @@ export default function BarcodeGenerator() {
             borderRadius: '4px',
           }}
         >
-        <div style={{ flex: 2, minWidth: '200px' }}>
-          <Dropdown
-            id="barcode-standard"
-            titleText="Barcode Standard"
-            label="Select standard"
-            items={BARCODE_STANDARDS}
-            itemToString={(item) => item?.label || ''}
-            selectedItem={BARCODE_STANDARDS.find((s) => s.value === standard)}
-            onChange={handleStandardChange}
-            size="sm"
-          />
-        </div>
-
-        <div style={{ flex: 1, minWidth: '150px' }}>
-          <Dropdown
-            id="barcode-size"
-            titleText="Size"
-            label="Select size"
-            items={BARCODE_SIZES}
-            itemToString={(item) => item?.label || ''}
-            selectedItem={BARCODE_SIZES.find((s) => s.value === size)}
-            onChange={({ selectedItem }) => {
-              setSize(selectedItem?.value || 256);
-              setQrImage('');
-            }}
-            size="sm"
-          />
-        </div>
+          <div style={{ flex: 2, minWidth: '200px' }}>
+            <Dropdown
+              id="barcode-standard"
+              titleText="Barcode Standard"
+              label="Select standard"
+              items={BARCODE_STANDARDS}
+              itemToString={(item) => item?.label || ''}
+              selectedItem={BARCODE_STANDARDS.find((s) => s.value === standard)}
+              onChange={handleStandardChange}
+              size="sm"
+            />
+          </div>
 
-        {isQR && (
           <div style={{ flex: 1, minWidth: '150px' }}>
             <Dropdown
-              id="qr-level"
-              titleText="Error Correction"
-              label="Select level"
-              items={QR_ERROR_LEVELS}
+              id="barcode-size"
+              titleText="Size"
+              label="Select size"
+              items={BARCODE_SIZES}
               itemToString={(item) => item?.label || ''}
-              selectedItem={QR_ERROR_LEVELS.find((l) => l.value === level)}
+              selectedItem={BARCODE_SIZES.find((s) => s.value === size)}
               onChange={({ selectedItem }) => {
-                setLevel(selectedItem?.value || 'M');
+                setSize(selectedItem?.value || 256);
                 setQrImage('');
               }}
               size="sm"
             />
           </div>
-        )}
 
-        <Button
-          renderIcon={Renew}
-          onClick={generateBarcode}
-          disabled={loading || !content.trim()}
-          size="sm"
-        >
-          Generate
-        </Button>
-
-        <div style={{ marginLeft: 'auto', paddingBottom: '4px' }}>
-          <ToolLayoutToggle
-            direction={layout.direction}
-            onToggle={layout.toggleDirection}
-            position="controls"
-          />
+          {isQR && (
+            <div style={{ flex: 1, minWidth: '150px' }}>
+              <Dropdown
+                id="qr-level"
+                titleText="Error Correction"
+                label="Select level"
+                items={QR_ERROR_LEVELS}
+                itemToString={(item) => item?.label || ''}
+                selectedItem={QR_ERROR_LEVELS.find((l) => l.value === level)}
+                onChange={({ selectedItem }) => {
+                  setLevel(selectedItem?.value || 'M');
+                  setQrImage('');
+                }}
+                size="sm"
+              />
+            </div>
+          )}
+
+          <Button
+            renderIcon={Renew}
+            onClick={generateBarcode}
+            disabled={loading || !content.trim()}
+            size="sm"
+          >
+            Generate
+          </Button>
+
+          <div style={{ marginLeft: 'auto', paddingBottom: '4px' }}>
+            <ToolLayoutToggle
+              direction={layout.direction}
+              onToggle={layout.toggleDirection}
+              position="controls"
+            />
+          </div>
         </div>
-      </div>
       </Column>
 
       <Column style={{ flex: 1, minHeight: 0 }}>
-      <ToolSplitPane columnCount={layout.direction === 'horizontal' ? 2 : 1}>
-        {/* Input Pane */}
-        <ToolPane
-          label="Content"
-          value={content}
-          onChange={handleContentChange}
-          placeholder={getPlaceholder(standard)}
-          invalid={!!error}
-          invalidText={error}
-        />
+        <ToolSplitPane columnCount={layout.direction === 'horizontal' ? 2 : 1}>
+          {/* Input Pane */}
+          <ToolPane
+            label="Content"
+            value={content}
+            onChange={handleContentChange}
+            placeholder={getPlaceholder(standard)}
+            invalid={!!error}
+            invalidText={error}
+          />
 
-        {/* Output Pane */}
-        <div
-          className="pane"
-          style={{
-            display: 'flex',
-            flexDirection: 'column',
-            height: '100%',
-            minHeight: '50vh',
-            flex: 1,
-          }}
-        >
+          {/* Output Pane */}
           <div
+            className="pane"
             style={{
               display: 'flex',
-              justifyContent: 'space-between',
-              alignItems: 'center',
-              minHeight: '30px',
-              overflowX: 'hidden',
+              flexDirection: 'column',
+              height: '100%',
+              minHeight: '50vh',
+              flex: 1,
             }}
           >
-            <label
+            <div
               style={{
-                fontSize: '0.75rem',
-                fontWeight: 400,
-                lineHeight: 1.5,
-                letterSpacing: '0.32px',
-                color: 'var(--cds-text-secondary)',
-                textTransform: 'uppercase',
+                display: 'flex',
+                justifyContent: 'space-between',
+                alignItems: 'center',
+                minHeight: '30px',
+                overflowX: 'hidden',
               }}
             >
-              {isQR ? 'QR Code' : `${standard} Barcode`}
-            </label>
-            {qrImage && (
-              <Button
-                renderIcon={Download}
-                onClick={downloadBarcode}
-                kind="ghost"
-                size="sm"
-                iconDescription="Download barcode"
-                hasIconOnly
-              />
-            )}
-          </div>
-
-          <div
-            style={{
-              flex: 1,
-              display: 'flex',
-              alignItems: 'center',
-              justifyContent: 'center',
-              backgroundColor: 'var(--cds-layer)',
-              padding: '1rem',
-              overflow: 'auto',
-            }}
-          >
-            {loading ? (
-              <InlineLoading description="Generating barcode..." />
-            ) : qrImage ? (
-              <img
-                src={qrImage}
-                alt={`Generated ${standard}`}
-                style={{
-                  maxWidth: '100%',
-                  maxHeight: '100%',
-                  objectFit: 'contain',
-                }}
-              />
-            ) : (
-              <div
+              <label
                 style={{
+                  fontSize: '0.75rem',
+                  fontWeight: 400,
+                  lineHeight: 1.5,
+                  letterSpacing: '0.32px',
                   color: 'var(--cds-text-secondary)',
-                  textAlign: 'center',
+                  textTransform: 'uppercase',
                 }}
               >
-                <p>{isQR ? 'QR code' : `${standard} barcode`} will appear here</p>
-                <p style={{ fontSize: '0.875rem', marginTop: '0.5rem' }}>
-                  Enter content and click Generate
-                </p>
-              </div>
-            )}
+                {isQR ? 'QR Code' : `${standard} Barcode`}
+              </label>
+              {qrImage && (
+                <Button
+                  renderIcon={Download}
+                  onClick={downloadBarcode}
+                  kind="ghost"
+                  size="sm"
+                  iconDescription="Download barcode"
+                  hasIconOnly
+                />
+              )}
+            </div>
+
+            <div
+              style={{
+                flex: 1,
+                display: 'flex',
+                alignItems: 'center',
+                justifyContent: 'center',
+                backgroundColor: 'var(--cds-layer)',
+                padding: '1rem',
+                overflow: 'auto',
+              }}
+            >
+              {loading ? (
+                <InlineLoading description="Generating barcode..." />
+              ) : qrImage ? (
+                <img
+                  src={qrImage}
+                  alt={`Generated ${standard}`}
+                  style={{
+                    maxWidth: '100%',
+                    maxHeight: '100%',
+                    objectFit: 'contain',
+                  }}
+                />
+              ) : (
+                <div
+                  style={{
+                    color: 'var(--cds-text-secondary)',
+                    textAlign: 'center',
+                  }}
+                >
+                  <p>{isQR ? 'QR code' : `${standard} barcode`} will appear here</p>
+                  <p style={{ fontSize: '0.875rem', marginTop: '0.5rem' }}>
+                    Enter content and click Generate
+                  </p>
+                </div>
+              )}
+            </div>
           </div>
-        </div>
-      </ToolSplitPane>
+        </ToolSplitPane>
       </Column>
     </Grid>
   );
diff --git a/frontend/src/pages/CodeFormatter/index.jsx b/frontend/src/pages/CodeFormatter/index.jsx
index f91d1c5..6d1e0bd 100644
--- a/frontend/src/pages/CodeFormatter/index.jsx
+++ b/frontend/src/pages/CodeFormatter/index.jsx
@@ -27,32 +27,37 @@ const FORMATTERS = [
     name: 'XML',
     supportsFilter: true,
     filterPlaceholder: '//book[price<30]/title',
-    sample: '<?xml version="1.0"?>\n<catalog>\n  <book id="bk101">\n    <author>Gambardella, Matthew</author>\n    <title>XML Developer\'s Guide</title>\n    <genre>Computer</genre>\n    <price>44.95</price>\n  </book>\n</catalog>',
+    sample:
+      '<?xml version="1.0"?>\n<catalog>\n  <book id="bk101">\n    <author>Gambardella, Matthew</author>\n    <title>XML Developer\'s Guide</title>\n    <genre>Computer</genre>\n    <price>44.95</price>\n  </book>\n</catalog>',
   },
   {
     id: 'html',
     name: 'HTML',
     supportsFilter: true,
     filterPlaceholder: 'div.container > h1',
-    sample: '<!DOCTYPE html>\n<html>\n<body>\n  <div class="container">\n    <h1>Hello World</h1>\n    <p>This is a paragraph.</p>\n  </div>\n</body>\n</html>',
+    sample:
+      '<!DOCTYPE html>\n<html>\n<body>\n  <div class="container">\n    <h1>Hello World</h1>\n    <p>This is a paragraph.</p>\n  </div>\n</body>\n</html>',
   },
   {
     id: 'sql',
     name: 'SQL',
     supportsFilter: false,
-    sample: 'SELECT u.id, u.name, o.order_date FROM users u JOIN orders o ON u.id = o.user_id WHERE u.active = 1 ORDER BY o.order_date DESC;',
+    sample:
+      'SELECT u.id, u.name, o.order_date FROM users u JOIN orders o ON u.id = o.user_id WHERE u.active = 1 ORDER BY o.order_date DESC;',
   },
   {
     id: 'css',
     name: 'CSS',
     supportsFilter: false,
-    sample: '.container { display: flex; flex-direction: column; padding: 1rem; } .container h1 { color: blue; font-size: 2rem; }',
+    sample:
+      '.container { display: flex; flex-direction: column; padding: 1rem; } .container h1 { color: blue; font-size: 2rem; }',
   },
   {
     id: 'javascript',
     name: 'JavaScript',
     supportsFilter: false,
-    sample: 'function greet(name) { const message = `Hello, ${name}!`; console.log(message); return message; } greet("World");',
+    sample:
+      'function greet(name) { const message = `Hello, ${name}!`; console.log(message); return message; } greet("World");',
   },
 ];
 
@@ -78,10 +83,10 @@ export default function CodeFormatter() {
 
   // Check for format preset in URL params
   const urlFormat = searchParams.get('format');
-  const validFormats = FORMATTERS.map(f => f.id);
+  const validFormats = FORMATTERS.map((f) => f.id);
   const initialFormatType = validFormats.includes(urlFormat)
     ? urlFormat
-    : (persisted?.formatType || 'json');
+    : persisted?.formatType || 'json';
 
   const [formatType, setFormatType] = useState(initialFormatType);
   const [input, setInput] = useState(persisted?.input || '');
@@ -133,23 +138,23 @@ export default function CodeFormatter() {
   // Handle format type changes - cache current input/filter and restore cached for new type
   useEffect(() => {
     const prevType = prevFormatTypeRef.current;
-    
+
     if (formatType !== prevType) {
       // Save current input and filter to cache for previous type
       inputCacheRef.current[prevType] = input;
       filterCacheRef.current[prevType] = filter;
-      
+
       // Load cached input and filter for new type, or empty string if not cached
       const cachedInput = inputCacheRef.current[formatType];
       const cachedFilter = filterCacheRef.current[formatType];
       setInput(cachedInput !== undefined ? cachedInput : '');
       setFilter(cachedFilter !== undefined ? cachedFilter : '');
-      
+
       // Clear output when switching languages
       setOutput('');
       setFormattedOutput('');
       setError(null);
-      
+
       // Update ref
       prevFormatTypeRef.current = formatType;
     }
@@ -300,51 +305,47 @@ export default function CodeFormatter() {
 
       <Column>
         <ToolControls>
-        <div style={{ display: 'flex', gap: '1rem', alignItems: 'flex-end', flexWrap: 'wrap' }}>
-          <Select
-            id="format-type"
-            labelText="Format Type"
-            value={formatType}
-            onChange={(e) => setFormatType(e.target.value)}
-            style={{ minWidth: '150px' }}
-          >
-            {FORMATTERS.map((f) => (
-              <SelectItem key={f.id} value={f.id} text={f.name} />
-            ))}
-          </Select>
-
-          <Button onClick={format} renderIcon={Code} size="md">
-            Format
-          </Button>
-          <Button onClick={minify} kind="secondary" size="md">
-            Minify
-          </Button>
-
-          <EditorToggle
-            enabled={highlightEnabled}
-            onToggle={setHighlightEnabled}
-            toolKey="codeFormatter"
-          />
-
-          {currentFormatter?.sample && (
-            <Button
-              kind="tertiary"
-              size="md"
-              onClick={() => setInput(currentFormatter.sample)}
+          <div style={{ display: 'flex', gap: '1rem', alignItems: 'flex-end', flexWrap: 'wrap' }}>
+            <Select
+              id="format-type"
+              labelText="Format Type"
+              value={formatType}
+              onChange={(e) => setFormatType(e.target.value)}
+              style={{ minWidth: '150px' }}
             >
-              Load Sample
+              {FORMATTERS.map((f) => (
+                <SelectItem key={f.id} value={f.id} text={f.name} />
+              ))}
+            </Select>
+
+            <Button onClick={format} renderIcon={Code} size="md">
+              Format
+            </Button>
+            <Button onClick={minify} kind="secondary" size="md">
+              Minify
             </Button>
-          )}
 
-          <div style={{ marginLeft: 'auto', paddingBottom: '4px' }}>
-            <ToolLayoutToggle
-              direction={layout.direction}
-              onToggle={layout.toggleDirection}
-              position="controls"
+            <EditorToggle
+              enabled={highlightEnabled}
+              onToggle={setHighlightEnabled}
+              toolKey="codeFormatter"
             />
+
+            {currentFormatter?.sample && (
+              <Button kind="tertiary" size="md" onClick={() => setInput(currentFormatter.sample)}>
+                Load Sample
+              </Button>
+            )}
+
+            <div style={{ marginLeft: 'auto', paddingBottom: '4px' }}>
+              <ToolLayoutToggle
+                direction={layout.direction}
+                onToggle={layout.toggleDirection}
+                position="controls"
+              />
+            </div>
           </div>
-        </div>
-      </ToolControls>
+        </ToolControls>
       </Column>
 
       {error && (
@@ -364,50 +365,50 @@ export default function CodeFormatter() {
       )}
 
       <Column style={{ flex: 1, minHeight: 0 }}>
-      <ToolSplitPane columnCount={layout.direction === 'horizontal' ? 2 : 1}>
-        <CodeEditor
-          label="Input"
-          language={formatType}
-          value={input}
-          onChange={setInput}
-          highlight={false}
-          placeholder={`Paste ${currentFormatter?.name || 'code'} here...`}
-          style={{ minHeight: '100%' }}
-        />
-        <div style={{ display: 'flex', flexDirection: 'column', height: '100%', gap: '0.5rem' }}>
+        <ToolSplitPane columnCount={layout.direction === 'horizontal' ? 2 : 1}>
           <CodeEditor
-            label={isMinified ? 'Output (Minified)' : 'Output (Formatted)'}
-            language={formatType.toLowerCase()}
-            value={output}
-            highlight={highlightEnabled}
-            readOnly
-            placeholder={`Formatted ${currentFormatter?.name || 'code'} will appear here...`}
-            style={{ flex: 1, minHeight: 0 }}
+            label="Input"
+            language={formatType}
+            value={input}
+            onChange={setInput}
+            highlight={false}
+            placeholder={`Paste ${currentFormatter?.name || 'code'} here...`}
+            style={{ minHeight: '100%' }}
           />
-          {currentFormatter?.supportsFilter && (
-            <div
-              style={{
-                display: 'flex',
-                gap: '0.5rem',
-                alignItems: 'flex-end',
-                alignContent: 'flex-end',
-              }}
-            >
-              <TextInput
-                id="filter-input"
-                labelText="Filter"
-                placeholder={currentFormatter.filterPlaceholder}
-                value={filter}
-                onChange={(e) => setFilter(e.target.value)}
-                style={{ flex: 1 }}
-              />
-              <IconButton label="Clear filter" onClick={clearFilter} disabled={!filter} size="md">
-                <Close />
-              </IconButton>
-            </div>
-          )}
-        </div>
-      </ToolSplitPane>
+          <div style={{ display: 'flex', flexDirection: 'column', height: '100%', gap: '0.5rem' }}>
+            <CodeEditor
+              label={isMinified ? 'Output (Minified)' : 'Output (Formatted)'}
+              language={formatType.toLowerCase()}
+              value={output}
+              highlight={highlightEnabled}
+              readOnly
+              placeholder={`Formatted ${currentFormatter?.name || 'code'} will appear here...`}
+              style={{ flex: 1, minHeight: 0 }}
+            />
+            {currentFormatter?.supportsFilter && (
+              <div
+                style={{
+                  display: 'flex',
+                  gap: '0.5rem',
+                  alignItems: 'flex-end',
+                  alignContent: 'flex-end',
+                }}
+              >
+                <TextInput
+                  id="filter-input"
+                  labelText="Filter"
+                  placeholder={currentFormatter.filterPlaceholder}
+                  value={filter}
+                  onChange={(e) => setFilter(e.target.value)}
+                  style={{ flex: 1 }}
+                />
+                <IconButton label="Clear filter" onClick={clearFilter} disabled={!filter} size="md">
+                  <Close />
+                </IconButton>
+              </div>
+            )}
+          </div>
+        </ToolSplitPane>
       </Column>
     </Grid>
   );
diff --git a/frontend/src/pages/ColorConverter/components/CodeSnippetsPanel.jsx b/frontend/src/pages/ColorConverter/components/CodeSnippetsPanel.jsx
index 44e29eb..98c6186 100644
--- a/frontend/src/pages/ColorConverter/components/CodeSnippetsPanel.jsx
+++ b/frontend/src/pages/ColorConverter/components/CodeSnippetsPanel.jsx
@@ -18,13 +18,12 @@ const languageTabs = [
 
 export default function CodeSnippetsPanel({ codeSnippets, selectedTab, onTabChange, onCopy }) {
   return (
-    <Tabs
-      selectedIndex={selectedTab}
-      onChange={({ selectedIndex }) => onTabChange(selectedIndex)}
-    >
+    <Tabs selectedIndex={selectedTab} onChange={({ selectedIndex }) => onTabChange(selectedIndex)}>
       <TabList aria-label="Language tabs" contained>
         {languageTabs.map((tab) => (
-          <Tab key={tab.id} style={{ flexShrink: 0 }}>{tab.label}</Tab>
+          <Tab key={tab.id} style={{ flexShrink: 0 }}>
+            {tab.label}
+          </Tab>
         ))}
       </TabList>
 
diff --git a/frontend/src/pages/ColorConverter/components/ColorInputRow.jsx b/frontend/src/pages/ColorConverter/components/ColorInputRow.jsx
index 6983d58..ab6f338 100644
--- a/frontend/src/pages/ColorConverter/components/ColorInputRow.jsx
+++ b/frontend/src/pages/ColorConverter/components/ColorInputRow.jsx
@@ -75,10 +75,7 @@ export default function ColorInputRow({ label, value, onChange, copyValue, onCop
         size="md"
       />
 
-      <CopyButton
-        autoAlign
-        onClick={() => onCopy(copyValue)}
-      />
+      <CopyButton autoAlign onClick={() => onCopy(copyValue)} />
     </div>
   );
 }
diff --git a/frontend/src/pages/CronJobParser.jsx b/frontend/src/pages/CronJobParser.jsx
index 995f3b9..d162b03 100644
--- a/frontend/src/pages/CronJobParser.jsx
+++ b/frontend/src/pages/CronJobParser.jsx
@@ -57,177 +57,181 @@ export default function CronJobParser() {
 
       <Column style={{ flex: 1, minHeight: 0 }}>
         <ToolSplitPane columnCount={layout.direction === 'horizontal' ? 2 : 1}>
-        <div
-          className="pane"
-          style={{
-            display: 'flex',
-            flexDirection: 'column',
-            height: '100%',
-            minHeight: 0,
-            flex: 1,
-          }}
-        >
           <div
+            className="pane"
             style={{
               display: 'flex',
-              justifyContent: 'space-between',
-              alignItems: 'center',
-              minHeight: '30px',
-              marginBottom: '0.5rem',
+              flexDirection: 'column',
+              height: '100%',
+              minHeight: 0,
+              flex: 1,
             }}
           >
-            <label
+            <div
               style={{
-                fontSize: '0.75rem',
-                fontWeight: 400,
-                lineHeight: 1.5,
-                letterSpacing: '0.32px',
-                color: 'var(--cds-text-secondary)',
-                textTransform: 'uppercase',
+                display: 'flex',
+                justifyContent: 'space-between',
+                alignItems: 'center',
+                minHeight: '30px',
+                marginBottom: '0.5rem',
               }}
             >
-              Cron Expression
-            </label>
-          </div>
-          <div style={{ marginBottom: '1rem' }}>
-            <TextInput
-              id="cron-input"
-              value={cron}
-              onChange={(e) => setCron(e.target.value)}
-              invalid={!!error}
-              invalidText={error}
-              placeholder="* * * * *"
+              <label
+                style={{
+                  fontSize: '0.75rem',
+                  fontWeight: 400,
+                  lineHeight: 1.5,
+                  letterSpacing: '0.32px',
+                  color: 'var(--cds-text-secondary)',
+                  textTransform: 'uppercase',
+                }}
+              >
+                Cron Expression
+              </label>
+            </div>
+            <div style={{ marginBottom: '1rem' }}>
+              <TextInput
+                id="cron-input"
+                value={cron}
+                onChange={(e) => setCron(e.target.value)}
+                invalid={!!error}
+                invalidText={error}
+                placeholder="* * * * *"
+                style={{
+                  fontFamily: "'IBM Plex Mono', monospace",
+                  fontSize: '1.25rem',
+                }}
+              />
+            </div>
+
+            <div
               style={{
-                fontFamily: "'IBM Plex Mono', monospace",
-                fontSize: '1.25rem',
+                flex: 1,
+                display: 'flex',
+                flexDirection: 'column',
+                justifyContent: 'center',
+                alignItems: 'center',
+                padding: '2rem',
+                backgroundColor: 'var(--cds-layer)',
+                border: '1px solid var(--cds-border-strong)',
               }}
-            />
-          </div>
-
-          <div
-            style={{
-              flex: 1,
-              display: 'flex',
-              flexDirection: 'column',
-              justifyContent: 'center',
-              alignItems: 'center',
-              padding: '2rem',
-              backgroundColor: 'var(--cds-layer)',
-              border: '1px solid var(--cds-border-strong)',
-            }}
-          >
-            {desc ? (
-              <>
-                <p
-                  style={{
-                    fontSize: '1.5rem',
-                    color: 'var(--cds-text-primary)',
-                    fontWeight: 600,
-                    textAlign: 'center',
-                    marginBottom: '0.5rem',
-                  }}
-                >
-                  {desc}
-                </p>
-                <p
-                  style={{
-                    fontSize: '0.875rem',
-                    color: 'var(--cds-text-secondary)',
-                    fontFamily: "'IBM Plex Mono', monospace",
-                  }}
-                >
-                  {cron}
+            >
+              {desc ? (
+                <>
+                  <p
+                    style={{
+                      fontSize: '1.5rem',
+                      color: 'var(--cds-text-primary)',
+                      fontWeight: 600,
+                      textAlign: 'center',
+                      marginBottom: '0.5rem',
+                    }}
+                  >
+                    {desc}
+                  </p>
+                  <p
+                    style={{
+                      fontSize: '0.875rem',
+                      color: 'var(--cds-text-secondary)',
+                      fontFamily: "'IBM Plex Mono', monospace",
+                    }}
+                  >
+                    {cron}
+                  </p>
+                </>
+              ) : (
+                <p style={{ color: 'var(--cds-text-secondary)', textAlign: 'center' }}>
+                  Enter a cron expression to see the translation
                 </p>
-              </>
-            ) : (
-              <p style={{ color: 'var(--cds-text-secondary)', textAlign: 'center' }}>
-                Enter a cron expression to see the translation
-              </p>
-            )}
+              )}
+            </div>
           </div>
-        </div>
 
-        <div
-          className="pane"
-          style={{
-            display: 'flex',
-            flexDirection: 'column',
-            height: '100%',
-            minHeight: 0,
-            flex: 1,
-          }}
-        >
           <div
+            className="pane"
             style={{
               display: 'flex',
-              justifyContent: 'space-between',
-              alignItems: 'center',
-              minHeight: '30px',
-              marginBottom: '0.5rem',
+              flexDirection: 'column',
+              height: '100%',
+              minHeight: 0,
+              flex: 1,
             }}
           >
-            <label
+            <div
               style={{
-                fontSize: '0.75rem',
-                fontWeight: 400,
-                lineHeight: 1.5,
-                letterSpacing: '0.32px',
-                color: 'var(--cds-text-secondary)',
-                textTransform: 'uppercase',
+                display: 'flex',
+                justifyContent: 'space-between',
+                alignItems: 'center',
+                minHeight: '30px',
+                marginBottom: '0.5rem',
               }}
             >
-              Common Examples
-            </label>
-          </div>
-          <div
-            style={{
-              flex: 1,
-              overflowY: 'auto',
-              padding: '0.75rem',
-              backgroundColor: 'var(--cds-layer)',
-              border: '1px solid var(--cds-border-strong)',
-            }}
-          >
-            {examples.map((example, idx) => (
-              <Tile
-                key={idx}
+              <label
                 style={{
-                  marginBottom: '0.5rem',
-                  padding: '0.75rem',
-                  backgroundColor: idx % 2 === 0 ? 'var(--cds-layer-01)' : 'var(--cds-layer-02)',
-                  cursor: 'pointer',
-                  transition: 'background-color 0.2s',
-                }}
-                onClick={() => setCron(example.cron)}
-                onMouseEnter={(e) => {
-                  e.currentTarget.style.backgroundColor = 'var(--cds-layer-hover)';
-                }}
-                onMouseLeave={(e) => {
-                  e.currentTarget.style.backgroundColor =
-                    idx % 2 === 0 ? 'var(--cds-layer-01)' : 'var(--cds-layer-02)';
+                  fontSize: '0.75rem',
+                  fontWeight: 400,
+                  lineHeight: 1.5,
+                  letterSpacing: '0.32px',
+                  color: 'var(--cds-text-secondary)',
+                  textTransform: 'uppercase',
                 }}
               >
-                <div
-                  style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center' }}
+                Common Examples
+              </label>
+            </div>
+            <div
+              style={{
+                flex: 1,
+                overflowY: 'auto',
+                padding: '0.75rem',
+                backgroundColor: 'var(--cds-layer)',
+                border: '1px solid var(--cds-border-strong)',
+              }}
+            >
+              {examples.map((example, idx) => (
+                <Tile
+                  key={idx}
+                  style={{
+                    marginBottom: '0.5rem',
+                    padding: '0.75rem',
+                    backgroundColor: idx % 2 === 0 ? 'var(--cds-layer-01)' : 'var(--cds-layer-02)',
+                    cursor: 'pointer',
+                    transition: 'background-color 0.2s',
+                  }}
+                  onClick={() => setCron(example.cron)}
+                  onMouseEnter={(e) => {
+                    e.currentTarget.style.backgroundColor = 'var(--cds-layer-hover)';
+                  }}
+                  onMouseLeave={(e) => {
+                    e.currentTarget.style.backgroundColor =
+                      idx % 2 === 0 ? 'var(--cds-layer-01)' : 'var(--cds-layer-02)';
+                  }}
                 >
-                  <span
+                  <div
                     style={{
-                      fontFamily: "'IBM Plex Mono', monospace",
-                      color: 'var(--cds-text-primary)',
-                      fontWeight: 600,
+                      display: 'flex',
+                      justifyContent: 'space-between',
+                      alignItems: 'center',
                     }}
                   >
-                    {example.cron}
-                  </span>
-                  <span style={{ color: 'var(--cds-text-secondary)', fontSize: '0.875rem' }}>
-                    {example.text}
-                  </span>
-                </div>
-              </Tile>
-            ))}
+                    <span
+                      style={{
+                        fontFamily: "'IBM Plex Mono', monospace",
+                        color: 'var(--cds-text-primary)',
+                        fontWeight: 600,
+                      }}
+                    >
+                      {example.cron}
+                    </span>
+                    <span style={{ color: 'var(--cds-text-secondary)', fontSize: '0.875rem' }}>
+                      {example.text}
+                    </span>
+                  </div>
+                </Tile>
+              ))}
+            </div>
           </div>
-        </div>
-      </ToolSplitPane>
+        </ToolSplitPane>
       </Column>
     </Grid>
   );
diff --git a/frontend/src/pages/DataGenerator/index.jsx b/frontend/src/pages/DataGenerator/index.jsx
index 2cb0911..f0e74a1 100644
--- a/frontend/src/pages/DataGenerator/index.jsx
+++ b/frontend/src/pages/DataGenerator/index.jsx
@@ -44,9 +44,10 @@ export default function DataGenerator() {
           // Check for URL preset, otherwise use first preset
           let selectedPreset = presets[0];
           if (urlPreset) {
-            const urlPresetMatch = presets.find(p =>
-              p.id.toLowerCase() === urlPreset.toLowerCase() ||
-              p.name.toLowerCase() === urlPreset.toLowerCase()
+            const urlPresetMatch = presets.find(
+              (p) =>
+                p.id.toLowerCase() === urlPreset.toLowerCase() ||
+                p.name.toLowerCase() === urlPreset.toLowerCase()
             );
             if (urlPresetMatch) {
               selectedPreset = urlPresetMatch;
@@ -180,22 +181,22 @@ export default function DataGenerator() {
 
       <Column>
         <ToolControls>
-        <GeneratorControls
-          state={state}
-          dispatch={dispatch}
-          presetItems={presetItems}
-          presetLabels={presetLabels}
-          onPresetChange={handlePresetChange}
-          onGenerate={handleGenerate}
-        />
-        <div style={{ marginLeft: 'auto', paddingBottom: '4px' }}>
-          <ToolLayoutToggle
-            direction={layout.direction}
-            onToggle={layout.toggleDirection}
-            position="controls"
+          <GeneratorControls
+            state={state}
+            dispatch={dispatch}
+            presetItems={presetItems}
+            presetLabels={presetLabels}
+            onPresetChange={handlePresetChange}
+            onGenerate={handleGenerate}
           />
-        </div>
-      </ToolControls>
+          <div style={{ marginLeft: 'auto', paddingBottom: '4px' }}>
+            <ToolLayoutToggle
+              direction={layout.direction}
+              onToggle={layout.toggleDirection}
+              position="controls"
+            />
+          </div>
+        </ToolControls>
       </Column>
 
       <Column>
diff --git a/frontend/src/pages/DateTimeConverter/api/dateTimeAPI.js b/frontend/src/pages/DateTimeConverter/api/dateTimeAPI.js
index e4c2358..23ef853 100644
--- a/frontend/src/pages/DateTimeConverter/api/dateTimeAPI.js
+++ b/frontend/src/pages/DateTimeConverter/api/dateTimeAPI.js
@@ -7,13 +7,12 @@ import * as httpDateTime from '../../../generated/http/dateTimeService';
 export const dateTimeAPI = {
   async GetAvailableTimezones() {
     // Check if we're in Wails environment (desktop app)
-    const isWails = typeof window !== 'undefined' && 
-                    window.go && 
-                    typeof window.go.main !== 'undefined';
-    
+    const isWails =
+      typeof window !== 'undefined' && window.go && typeof window.go.main !== 'undefined';
+
     console.log('Environment check - isWails:', isWails);
     console.log('Window.go:', typeof window !== 'undefined' ? window.go : 'undefined');
-    
+
     if (isWails) {
       try {
         console.log('Trying Wails API...');
@@ -25,7 +24,7 @@ export const dateTimeAPI = {
         console.log('Falling back to HTTP API...');
       }
     }
-    
+
     // Fallback to HTTP API (web app)
     try {
       console.log('Trying HTTP API...');
@@ -36,7 +35,7 @@ export const dateTimeAPI = {
       console.error('HTTP API failed:', e);
       throw e;
     }
-  }
+  },
 };
 
 // Expose for debugging
diff --git a/frontend/src/pages/DateTimeConverter/components/DateTimeOutputField.jsx b/frontend/src/pages/DateTimeConverter/components/DateTimeOutputField.jsx
index 6b127c9..6d21eae 100644
--- a/frontend/src/pages/DateTimeConverter/components/DateTimeOutputField.jsx
+++ b/frontend/src/pages/DateTimeConverter/components/DateTimeOutputField.jsx
@@ -13,7 +13,10 @@ import { getMonospaceFontFamily, getDataFontSize } from '../../../utils/inputUti
  */
 export default function DateTimeOutputField({ label, value, className, style }) {
   return (
-    <Tile className={className} style={{ padding: '0.75rem', background: 'var(--cds-layer)', ...style }}>
+    <Tile
+      className={className}
+      style={{ padding: '0.75rem', background: 'var(--cds-layer)', ...style }}
+    >
       <div
         style={{
           fontSize: '0.75rem',
diff --git a/frontend/src/pages/DateTimeConverter/components/InputSection.jsx b/frontend/src/pages/DateTimeConverter/components/InputSection.jsx
index 562b924..c85bf7e 100644
--- a/frontend/src/pages/DateTimeConverter/components/InputSection.jsx
+++ b/frontend/src/pages/DateTimeConverter/components/InputSection.jsx
@@ -3,7 +3,17 @@ import { Button, TextInput, ComboBox } from '@carbon/react';
 import { Add } from '@carbon/icons-react';
 import { ToolControls } from '../../../components/ToolUI';
 
-export function InputSection({ availableTimezones, input, setInput, timezone, setTimezone, selectedNewTimezone, setSelectedNewTimezone, onAddTimezone, disabled }) {
+export function InputSection({
+  availableTimezones,
+  input,
+  setInput,
+  timezone,
+  setTimezone,
+  selectedNewTimezone,
+  setSelectedNewTimezone,
+  onAddTimezone,
+  disabled,
+}) {
   return (
     <ToolControls>
       <div style={{ display: 'flex', gap: '0.5rem', alignItems: 'flex-end' }}>
@@ -19,7 +29,7 @@ export function InputSection({ availableTimezones, input, setInput, timezone, se
           <ComboBox
             id="timezone"
             titleText="Input timezone"
-            placeholder={availableTimezones.length === 0 ? "Loading..." : "Select timezone"}
+            placeholder={availableTimezones.length === 0 ? 'Loading...' : 'Select timezone'}
             items={availableTimezones}
             itemToString={(item) => (item ? item.label : '')}
             selectedItem={availableTimezones.find((tz) => tz.id === timezone)}
@@ -31,7 +41,7 @@ export function InputSection({ availableTimezones, input, setInput, timezone, se
         <ComboBox
           id="add-timezone"
           titleText="Add timezone"
-          placeholder={disabled ? "Loading timezones..." : "Search timezone..."}
+          placeholder={disabled ? 'Loading timezones...' : 'Search timezone...'}
           items={availableTimezones}
           itemToString={(item) => (item ? item.label : '')}
           selectedItem={selectedNewTimezone}
diff --git a/frontend/src/pages/DateTimeConverter/components/ResultsGrid.jsx b/frontend/src/pages/DateTimeConverter/components/ResultsGrid.jsx
index 1fcdb5a..cd6ed4b 100644
--- a/frontend/src/pages/DateTimeConverter/components/ResultsGrid.jsx
+++ b/frontend/src/pages/DateTimeConverter/components/ResultsGrid.jsx
@@ -8,22 +8,40 @@ import {
   getRelativeTime,
   getDayOfYear,
   getWeekOfYear,
-  isLeapYear
+  isLeapYear,
 } from '../datetimeHelpers';
 
-export function ResultsGrid({ parsedDate, timezone, customTimezones, getTimezoneLabel, onRemoveTimezone }) {
+export function ResultsGrid({
+  parsedDate,
+  timezone,
+  customTimezones,
+  getTimezoneLabel,
+  onRemoveTimezone,
+}) {
   return (
     <Grid>
-
       {/* Column 1: Custom Timezones */}
       <Column lg={4} md={8} sm={4}>
         <div style={{ display: 'flex', flexDirection: 'column', gap: '0.5rem' }}>
-          <div style={{ fontSize: '0.75rem', color: 'var(--cds-text-secondary)', marginBottom: '0.25rem', textTransform: 'uppercase' }}>
+          <div
+            style={{
+              fontSize: '0.75rem',
+              color: 'var(--cds-text-secondary)',
+              marginBottom: '0.25rem',
+              textTransform: 'uppercase',
+            }}
+          >
             Other timezones
           </div>
 
           {customTimezones.length === 0 && (
-            <div style={{ fontSize: '0.875rem', color: 'var(--cds-text-secondary)', fontStyle: 'italic' }}>
+            <div
+              style={{
+                fontSize: '0.875rem',
+                color: 'var(--cds-text-secondary)',
+                fontStyle: 'italic',
+              }}
+            >
               Select a timezone above to add
             </div>
           )}
@@ -56,23 +74,24 @@ export function ResultsGrid({ parsedDate, timezone, customTimezones, getTimezone
 
       {/* Column 2: Primary Outputs */}
       <Column lg={4} md={4} sm={4}>
-        <div style={{ fontSize: '0.75rem', color: 'var(--cds-text-secondary)', marginBottom: '0.5rem', textTransform: 'uppercase' }}>
+        <div
+          style={{
+            fontSize: '0.75rem',
+            color: 'var(--cds-text-secondary)',
+            marginBottom: '0.5rem',
+            textTransform: 'uppercase',
+          }}
+        >
           Format
         </div>
         {/* Three fields in a row */}
         <div style={{ display: 'flex', flexDirection: 'column', gap: '0.75rem' }}>
-          <DateTimeOutputField
-            label="Local"
-            value={formatDate(parsedDate, 'sql', 'local')}
-          />
+          <DateTimeOutputField label="Local" value={formatDate(parsedDate, 'sql', 'local')} />
           <DateTimeOutputField
             label="UTC (ISO 8601)"
             value={formatDate(parsedDate, 'iso', 'UTC')}
           />
-          <DateTimeOutputField
-            label="Relative"
-            value={getRelativeTime(parsedDate)}
-          />
+          <DateTimeOutputField label="Relative" value={getRelativeTime(parsedDate)} />
           <DateTimeOutputField
             label="Unix time"
             value={Math.floor(parsedDate.getTime() / 1000).toString()}
@@ -85,7 +104,14 @@ export function ResultsGrid({ parsedDate, timezone, customTimezones, getTimezone
         <div style={{ display: 'flex', flexDirection: 'column', gap: '0.75rem' }}>
           {/* Other formats section - 2 per row */}
           <div style={{ marginTop: '0.5rem' }}>
-            <div style={{ fontSize: '0.75rem', color: 'var(--cds-text-secondary)', marginBottom: '0.5rem', textTransform: 'uppercase' }}>
+            <div
+              style={{
+                fontSize: '0.75rem',
+                color: 'var(--cds-text-secondary)',
+                marginBottom: '0.5rem',
+                textTransform: 'uppercase',
+              }}
+            >
               Other formats
             </div>
             <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '0.2rem' }}>
@@ -97,7 +123,15 @@ export function ResultsGrid({ parsedDate, timezone, customTimezones, getTimezone
                 />
               ))}
             </div>
-            <div style={{ fontSize: '0.75rem', color: 'var(--cds-text-secondary)', marginBottom: '0.5rem', marginTop: '1rem', textTransform: 'uppercase' }}>
+            <div
+              style={{
+                fontSize: '0.75rem',
+                color: 'var(--cds-text-secondary)',
+                marginBottom: '0.5rem',
+                marginTop: '1rem',
+                textTransform: 'uppercase',
+              }}
+            >
               Additional
             </div>
             <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr 1fr', gap: '0.2rem' }}>
diff --git a/frontend/src/pages/DateTimeConverter/hooks/useDateTime.js b/frontend/src/pages/DateTimeConverter/hooks/useDateTime.js
index ef67e9a..ca7e94c 100644
--- a/frontend/src/pages/DateTimeConverter/hooks/useDateTime.js
+++ b/frontend/src/pages/DateTimeConverter/hooks/useDateTime.js
@@ -35,10 +35,10 @@ export function useDateTime() {
             id: tz.timezone,
             label: tz.label || tz.timezone,
           }));
-          
+
           // Add 'local' as the first option
           const allTimezonesList = [{ id: 'local', label: 'Local Time' }, ...tzList];
-          
+
           console.log(`Loaded ${allTimezonesList.length} timezones from backend`);
           setAllTimezones(allTimezonesList);
         } else {
@@ -85,9 +85,7 @@ export function useDateTime() {
   };
 
   // Get available timezones for dropdown (exclude already added only)
-  const availableTimezones = allTimezones.filter(
-    (tz) => !customTimezones.includes(tz.id)
-  );
+  const availableTimezones = allTimezones.filter((tz) => !customTimezones.includes(tz.id));
 
   // Get timezone label by ID
   const getTimezoneLabel = (tzId) => {
diff --git a/frontend/src/pages/NumberConverter/components/BitCell.jsx b/frontend/src/pages/NumberConverter/components/BitCell.jsx
index 613bb29..46910b3 100644
--- a/frontend/src/pages/NumberConverter/components/BitCell.jsx
+++ b/frontend/src/pages/NumberConverter/components/BitCell.jsx
@@ -4,7 +4,7 @@ import { BIT_CELL_CONFIG } from '../constants';
 /**
  * Individual bit cell component
  * Displays a single bit (0 or 1) as a clickable toggle
- * 
+ *
  * @param {Object} props
  * @param {number} props.bitValue - Current bit value (0 or 1)
  * @param {number} props.position - Bit position (0-31)
@@ -35,12 +35,8 @@ const BitCell = ({ bitValue, position, onToggle, isActive = false }) => {
       style={{
         width: `${BIT_CELL_CONFIG.SIZE}px`,
         height: `${BIT_CELL_CONFIG.SIZE}px`,
-        border: isSet
-          ? 'none'
-          : `2px solid ${BIT_CELL_CONFIG.INACTIVE_BORDER}`,
-        backgroundColor: isSet
-          ? BIT_CELL_CONFIG.ACTIVE_COLOR
-          : 'transparent',
+        border: isSet ? 'none' : `2px solid ${BIT_CELL_CONFIG.INACTIVE_BORDER}`,
+        backgroundColor: isSet ? BIT_CELL_CONFIG.ACTIVE_COLOR : 'transparent',
         borderRadius: '4px',
         cursor: 'pointer',
         display: 'flex',
@@ -49,14 +45,10 @@ const BitCell = ({ bitValue, position, onToggle, isActive = false }) => {
         fontFamily: "'IBM Plex Mono', monospace",
         fontSize: '14px',
         fontWeight: 600,
-        color: isSet
-          ? 'var(--cds-text-inverse)'
-          : 'var(--cds-text-primary)',
+        color: isSet ? 'var(--cds-text-inverse)' : 'var(--cds-text-primary)',
         transition: 'all 0.15s ease',
         transform: isActive ? `scale(${BIT_CELL_CONFIG.HOVER_SCALE})` : 'scale(1)',
-        boxShadow: isActive
-          ? '0 2px 8px rgba(0, 0, 0, 0.3)'
-          : 'none',
+        boxShadow: isActive ? '0 2px 8px rgba(0, 0, 0, 0.3)' : 'none',
         outline: 'none',
       }}
       onMouseEnter={(e) => {
diff --git a/frontend/src/pages/NumberConverter/components/BitGrid.jsx b/frontend/src/pages/NumberConverter/components/BitGrid.jsx
index 30749bf..f2096b4 100644
--- a/frontend/src/pages/NumberConverter/components/BitGrid.jsx
+++ b/frontend/src/pages/NumberConverter/components/BitGrid.jsx
@@ -6,7 +6,7 @@ import { getBit, getByte, formatByte } from '../utils';
 /**
  * BitGrid component
  * Displays a 32-bit value as a 4×8 grid of bit cells
- * 
+ *
  * @param {Object} props
  * @param {number} props.value - Current 32-bit value
  * @param {function} props.onToggleBit - Callback when a bit is toggled
@@ -88,9 +88,10 @@ const BitGrid = ({ value, onToggleBit, layout = 'horizontal' }) => {
                     <span
                       style={{
                         fontSize: '0.6rem',
-                        color: hoveredBit === bitPosition
-                          ? 'var(--cds-text-primary)'
-                          : 'var(--cds-text-secondary)',
+                        color:
+                          hoveredBit === bitPosition
+                            ? 'var(--cds-text-primary)'
+                            : 'var(--cds-text-secondary)',
                         marginTop: '2px',
                         fontFamily: "'IBM Plex Mono', monospace",
                         transition: 'color 0.15s ease',
diff --git a/frontend/src/pages/NumberConverter/components/BitwiseToolbar.jsx b/frontend/src/pages/NumberConverter/components/BitwiseToolbar.jsx
index 54c8db3..1bfb47e 100644
--- a/frontend/src/pages/NumberConverter/components/BitwiseToolbar.jsx
+++ b/frontend/src/pages/NumberConverter/components/BitwiseToolbar.jsx
@@ -5,7 +5,7 @@ import { BITWISE_OPERATIONS } from '../constants';
 /**
  * BitwiseToolbar component
  * Displays buttons for common bitwise operations
- * 
+ *
  * @param {Object} props
  * @param {function} props.onOperation - Callback when an operation is clicked
  */
diff --git a/frontend/src/pages/NumberConverter/components/ConversionCard.jsx b/frontend/src/pages/NumberConverter/components/ConversionCard.jsx
index 3967337..2726392 100644
--- a/frontend/src/pages/NumberConverter/components/ConversionCard.jsx
+++ b/frontend/src/pages/NumberConverter/components/ConversionCard.jsx
@@ -7,7 +7,7 @@ import { formatNumber } from '../utils';
 /**
  * ConversionCard component
  * Displays a number input for a specific base with copy/sync functionality
- * 
+ *
  * @param {Object} props
  * @param {string} props.label - Display label (e.g., "Decimal")
  * @param {number} props.base - Numeric base (2, 8, 10, 16, or custom)
@@ -118,7 +118,13 @@ const ConversionCard = ({
         hideLabel
         value={displayValue}
         onChange={handleInputChange}
-        placeholder={placeholder || (isCustom ? `Base ${customBase}` : BASES[Object.keys(BASES).find(k => BASES[k].base === base)]?.placeholder || `Enter ${label.toLowerCase()}...`)}
+        placeholder={
+          placeholder ||
+          (isCustom
+            ? `Base ${customBase}`
+            : BASES[Object.keys(BASES).find((k) => BASES[k].base === base)]?.placeholder ||
+              `Enter ${label.toLowerCase()}...`)
+        }
         invalid={!!error}
         invalidText={error}
         style={{
diff --git a/frontend/src/pages/NumberConverter/constants.js b/frontend/src/pages/NumberConverter/constants.js
index 03851e1..610afe7 100644
--- a/frontend/src/pages/NumberConverter/constants.js
+++ b/frontend/src/pages/NumberConverter/constants.js
@@ -64,13 +64,13 @@ export const BITWISE_OPERATIONS = {
     id: 'not',
     label: 'NOT',
     description: 'Flip all bits',
-    apply: (value) => (~value) >>> 0,
+    apply: (value) => ~value >>> 0,
   },
   MASK_BYTE: {
     id: 'maskByte',
     label: '& 0xFF',
     description: 'Keep only lowest byte',
-    apply: (value) => value & 0xFF,
+    apply: (value) => value & 0xff,
   },
   SET_LSB: {
     id: 'setLSB',
@@ -120,7 +120,7 @@ export const ERROR_MESSAGES = {
  * Numeric limits
  */
 export const LIMITS = {
-  MAX_32BIT: 0xFFFFFFFF, // 4,294,967,295
+  MAX_32BIT: 0xffffffff, // 4,294,967,295
   MIN_32BIT: 0,
   MAX_32BIT_DECIMAL: 4294967295,
 };
diff --git a/frontend/src/pages/NumberConverter/index.jsx b/frontend/src/pages/NumberConverter/index.jsx
index a901582..e23af79 100644
--- a/frontend/src/pages/NumberConverter/index.jsx
+++ b/frontend/src/pages/NumberConverter/index.jsx
@@ -51,7 +51,7 @@ const NumberConverter = () => {
   const handleBaseChange = (baseId) => {
     setInputBase(baseId);
     // Convert current value to new base format
-    const base = bases.find(b => b.id === baseId)?.base || 10;
+    const base = bases.find((b) => b.id === baseId)?.base || 10;
     const newValue = formatNumber(currentValue, base);
     setInputValue(newValue);
     setError('');
@@ -67,12 +67,13 @@ const NumberConverter = () => {
     navigator.clipboard.writeText(text);
   };
 
-  const currentBase = bases.find(b => b.id === inputBase);
+  const currentBase = bases.find((b) => b.id === inputBase);
 
   return (
     <Grid
       fullWidth
-      style={{ display: 'flex', flexDirection: 'column', gap: '0.75rem', height: '100%' }}>
+      style={{ display: 'flex', flexDirection: 'column', gap: '0.75rem', height: '100%' }}
+    >
       <Column>
         <ToolHeader
           title="Number Converter"
@@ -83,197 +84,214 @@ const NumberConverter = () => {
       {/* Main Input Section */}
       <Column>
         <Tile style={{ padding: '1.5rem' }}>
-        <div style={{ marginBottom: '1rem' }}>
-          <label style={{
-            display: 'block',
-            fontSize: '0.75rem',
-            fontWeight: 600,
-            textTransform: 'uppercase',
-            letterSpacing: '0.32px',
-            color: 'var(--cds-text-secondary)',
-            marginBottom: '0.5rem',
-          }}>
-            Enter Number
-          </label>
+          <div style={{ marginBottom: '1rem' }}>
+            <label
+              style={{
+                display: 'block',
+                fontSize: '0.75rem',
+                fontWeight: 600,
+                textTransform: 'uppercase',
+                letterSpacing: '0.32px',
+                color: 'var(--cds-text-secondary)',
+                marginBottom: '0.5rem',
+              }}
+            >
+              Enter Number
+            </label>
 
-          <div style={{ display: 'flex', gap: '0.5rem', marginBottom: '0.75rem' }}>
-            {bases.map((base) => (
-              <Button
-                key={base.id}
-                kind={inputBase === base.id ? 'primary' : 'tertiary'}
-                size="sm"
-                onClick={() => handleBaseChange(base.id)}
-              >
-                {base.label}
-              </Button>
-            ))}
-          </div>
+            <div style={{ display: 'flex', gap: '0.5rem', marginBottom: '0.75rem' }}>
+              {bases.map((base) => (
+                <Button
+                  key={base.id}
+                  kind={inputBase === base.id ? 'primary' : 'tertiary'}
+                  size="sm"
+                  onClick={() => handleBaseChange(base.id)}
+                >
+                  {base.label}
+                </Button>
+              ))}
+            </div>
 
-          <TextInput
-            id="main-input"
-            labelText="Number"
-            hideLabel
-            value={inputValue}
-            onChange={(e) => handleInputChange(e.target.value)}
-            placeholder={`Enter ${currentBase?.label.toLowerCase()} number...`}
-            invalid={!!error}
-            invalidText={error}
-            size="lg"
-            style={{
-              fontFamily: "'IBM Plex Mono', monospace",
-            }}
-          />
-        </div>
+            <TextInput
+              id="main-input"
+              labelText="Number"
+              hideLabel
+              value={inputValue}
+              onChange={(e) => handleInputChange(e.target.value)}
+              placeholder={`Enter ${currentBase?.label.toLowerCase()} number...`}
+              invalid={!!error}
+              invalidText={error}
+              size="lg"
+              style={{
+                fontFamily: "'IBM Plex Mono', monospace",
+              }}
+            />
+          </div>
 
-        {inputValue && (
-          <div style={{
-            display: 'flex',
-            justifyContent: 'space-between',
-            alignItems: 'center',
-            padding: '0.75rem',
-            backgroundColor: 'var(--cds-layer-02)',
-            borderRadius: '4px',
-          }}>
-            <span style={{ fontSize: '0.875rem', color: 'var(--cds-text-secondary)' }}>
-              Decimal value: <strong>{currentValue.toLocaleString()}</strong>
-            </span>
-            <Button
-              kind="ghost"
-              size="sm"
-              renderIcon={TrashCan}
-              onClick={handleClear}
+          {inputValue && (
+            <div
+              style={{
+                display: 'flex',
+                justifyContent: 'space-between',
+                alignItems: 'center',
+                padding: '0.75rem',
+                backgroundColor: 'var(--cds-layer-02)',
+                borderRadius: '4px',
+              }}
             >
-              Clear
-            </Button>
-          </div>
-        )}
+              <span style={{ fontSize: '0.875rem', color: 'var(--cds-text-secondary)' }}>
+                Decimal value: <strong>{currentValue.toLocaleString()}</strong>
+              </span>
+              <Button kind="ghost" size="sm" renderIcon={TrashCan} onClick={handleClear}>
+                Clear
+              </Button>
+            </div>
+          )}
         </Tile>
       </Column>
 
       {/* Results Grid */}
       <Column>
-        <div style={{
-        display: 'grid',
-        gridTemplateColumns: 'repeat(auto-fit, minmax(200px, 1fr))',
-        gap: '1rem',
-      }}>
-        {bases.map((base) => {
-          if (base.id === inputBase) return null; // Skip current input base
+        <div
+          style={{
+            display: 'grid',
+            gridTemplateColumns: 'repeat(auto-fit, minmax(200px, 1fr))',
+            gap: '1rem',
+          }}
+        >
+          {bases.map((base) => {
+            if (base.id === inputBase) return null; // Skip current input base
 
-          const value = formatNumber(currentValue, base.base);
-          const displayValue = value || '-';
+            const value = formatNumber(currentValue, base.base);
+            const displayValue = value || '-';
 
-          return (
-            <Tile
-              key={base.id}
-              style={{
-                padding: '1rem',
-                position: 'relative',
-                opacity: inputValue ? 1 : 0.5,
-              }}
-            >
-              <div style={{
-                display: 'flex',
-                justifyContent: 'space-between',
-                alignItems: 'flex-start',
-                marginBottom: '0.5rem',
-              }}>
-                <div>
-                  <div style={{
-                    fontSize: '0.75rem',
-                    fontWeight: 600,
-                    textTransform: 'uppercase',
-                    color: 'var(--cds-text-secondary)',
-                    letterSpacing: '0.32px',
-                  }}>
-                    {base.label}
-                  </div>
-                  <div style={{
-                    fontSize: '0.75rem',
-                    color: 'var(--cds-text-helper)',
-                  }}>
-                    Base {base.base}
+            return (
+              <Tile
+                key={base.id}
+                style={{
+                  padding: '1rem',
+                  position: 'relative',
+                  opacity: inputValue ? 1 : 0.5,
+                }}
+              >
+                <div
+                  style={{
+                    display: 'flex',
+                    justifyContent: 'space-between',
+                    alignItems: 'flex-start',
+                    marginBottom: '0.5rem',
+                  }}
+                >
+                  <div>
+                    <div
+                      style={{
+                        fontSize: '0.75rem',
+                        fontWeight: 600,
+                        textTransform: 'uppercase',
+                        color: 'var(--cds-text-secondary)',
+                        letterSpacing: '0.32px',
+                      }}
+                    >
+                      {base.label}
+                    </div>
+                    <div
+                      style={{
+                        fontSize: '0.75rem',
+                        color: 'var(--cds-text-helper)',
+                      }}
+                    >
+                      Base {base.base}
+                    </div>
                   </div>
-                </div>
 
-                <Button
-                  kind="ghost"
-                  size="sm"
-                  renderIcon={Copy}
-                  iconDescription="Copy"
-                  onClick={() => copyToClipboard(value)}
-                  disabled={!value}
-                  hasIconOnly
-                />
-              </div>
-
-              <div style={{
-                fontFamily: "'IBM Plex Mono', monospace",
-                fontSize: '1rem',
-                fontWeight: 400,
-                color: 'var(--cds-text-primary)',
-                wordBreak: 'break-all',
-                lineHeight: 1.4,
-              }}>
-                {base.prefix}{displayValue}
-              </div>
+                  <Button
+                    kind="ghost"
+                    size="sm"
+                    renderIcon={Copy}
+                    iconDescription="Copy"
+                    onClick={() => copyToClipboard(value)}
+                    disabled={!value}
+                    hasIconOnly
+                  />
+                </div>
 
-              {!inputValue && (
-                <div style={{
-                  fontSize: '0.75rem',
-                  color: 'var(--cds-text-helper)',
-                  marginTop: '0.5rem',
-                  fontStyle: 'italic',
-                }}>
-                  e.g., {base.prefix}{base.example}
+                <div
+                  style={{
+                    fontFamily: "'IBM Plex Mono', monospace",
+                    fontSize: '1rem',
+                    fontWeight: 400,
+                    color: 'var(--cds-text-primary)',
+                    wordBreak: 'break-all',
+                    lineHeight: 1.4,
+                  }}
+                >
+                  {base.prefix}
+                  {displayValue}
                 </div>
-              )}
-            </Tile>
-          );
-        })}
-      </div>
+
+                {!inputValue && (
+                  <div
+                    style={{
+                      fontSize: '0.75rem',
+                      color: 'var(--cds-text-helper)',
+                      marginTop: '0.5rem',
+                      fontStyle: 'italic',
+                    }}
+                  >
+                    e.g., {base.prefix}
+                    {base.example}
+                  </div>
+                )}
+              </Tile>
+            );
+          })}
+        </div>
       </Column>
 
       {/* Quick Tips */}
       <Column>
         <Tile style={{ padding: '1rem' }}>
-        <div style={{
-          fontSize: '0.75rem',
-          fontWeight: 600,
-          textTransform: 'uppercase',
-          color: 'var(--cds-text-secondary)',
-          marginBottom: '0.75rem',
-          letterSpacing: '0.32px',
-        }}>
-          Common Values
-        </div>
+          <div
+            style={{
+              fontSize: '0.75rem',
+              fontWeight: 600,
+              textTransform: 'uppercase',
+              color: 'var(--cds-text-secondary)',
+              marginBottom: '0.75rem',
+              letterSpacing: '0.32px',
+            }}
+          >
+            Common Values
+          </div>
 
-        <div style={{
-          display: 'flex',
-          flexWrap: 'wrap',
-          gap: '0.5rem',
-        }}>
-          {[
-            { dec: '255', hex: 'FF', bin: '11111111' },
-            { dec: '256', hex: '100', bin: '100000000' },
-            { dec: '1024', hex: '400', bin: '10000000000' },
-            { dec: '4096', hex: '1000', bin: '1000000000000' },
-          ].map((row, idx) => (
-            <Button
-              key={idx}
-              kind="ghost"
-              size="sm"
-              onClick={() => {
-                setInputBase('decimal');
-                handleInputChange(row.dec);
-              }}
-              style={{ fontFamily: "'IBM Plex Mono', monospace" }}
-            >
-              {row.dec} <ChevronRight size={14} /> 0x{row.hex}
-            </Button>
-          ))}
-        </div>
-      </Tile>
+          <div
+            style={{
+              display: 'flex',
+              flexWrap: 'wrap',
+              gap: '0.5rem',
+            }}
+          >
+            {[
+              { dec: '255', hex: 'FF', bin: '11111111' },
+              { dec: '256', hex: '100', bin: '100000000' },
+              { dec: '1024', hex: '400', bin: '10000000000' },
+              { dec: '4096', hex: '1000', bin: '1000000000000' },
+            ].map((row, idx) => (
+              <Button
+                key={idx}
+                kind="ghost"
+                size="sm"
+                onClick={() => {
+                  setInputBase('decimal');
+                  handleInputChange(row.dec);
+                }}
+                style={{ fontFamily: "'IBM Plex Mono', monospace" }}
+              >
+                {row.dec} <ChevronRight size={14} /> 0x{row.hex}
+              </Button>
+            ))}
+          </div>
+        </Tile>
       </Column>
     </Grid>
   );
diff --git a/frontend/src/pages/NumberConverter/numberConverterReducer.js b/frontend/src/pages/NumberConverter/numberConverterReducer.js
index 242d799..dc92dd4 100644
--- a/frontend/src/pages/NumberConverter/numberConverterReducer.js
+++ b/frontend/src/pages/NumberConverter/numberConverterReducer.js
@@ -77,16 +77,16 @@ export function numberConverterReducer(state = INITIAL_STATE, action) {
 
       switch (operation) {
         case 'shiftLeft':
-          newValue = ((state.value << 1) >>> 0);
+          newValue = (state.value << 1) >>> 0;
           break;
         case 'shiftRight':
-          newValue = (state.value >>> 1);
+          newValue = state.value >>> 1;
           break;
         case 'not':
-          newValue = (~state.value >>> 0);
+          newValue = ~state.value >>> 0;
           break;
         case 'maskByte':
-          newValue = (state.value & 0xFF) >>> 0;
+          newValue = (state.value & 0xff) >>> 0;
           break;
         case 'setLSB':
           newValue = (state.value | 1) >>> 0;
@@ -217,7 +217,7 @@ export function clearAll() {
  */
 export function handleConversionInput(dispatch, input, base, field, parseFn) {
   const result = parseFn(input);
-  
+
   if (result.error) {
     // Set error but keep current value
     dispatch(setError(field, result.error));
diff --git a/frontend/src/pages/NumberConverter/utils.js b/frontend/src/pages/NumberConverter/utils.js
index 016fde0..6f1c89f 100644
--- a/frontend/src/pages/NumberConverter/utils.js
+++ b/frontend/src/pages/NumberConverter/utils.js
@@ -22,13 +22,13 @@ export function sanitizeInput(input) {
  */
 export function validateInputChars(input, base) {
   const validChars = getValidCharsForBase(base);
-  
+
   for (const char of input) {
     if (!validChars.includes(char)) {
       return { valid: false, invalidChar: char };
     }
   }
-  
+
   return { valid: true, invalidChar: null };
 }
 
@@ -40,50 +40,50 @@ export function validateInputChars(input, base) {
  */
 export function parseInput(input, base) {
   const sanitized = sanitizeInput(input);
-  
+
   if (sanitized === '') {
     return { value: null, error: null }; // Empty is valid (no change)
   }
-  
+
   // Check for negative sign
   if (sanitized.startsWith('-')) {
     return { value: null, error: ERROR_MESSAGES.NEGATIVE };
   }
-  
+
   // Check for scientific notation
   if (/[eE]/.test(sanitized)) {
     return { value: null, error: ERROR_MESSAGES.PARSE_ERROR(base) };
   }
-  
+
   // Validate characters
   const { valid, invalidChar } = validateInputChars(sanitized, base);
   if (!valid) {
     return { value: null, error: ERROR_MESSAGES.INVALID_CHAR(invalidChar, base) };
   }
-  
+
   // Parse the number
   const parsed = parseInt(sanitized, base);
-  
+
   if (isNaN(parsed)) {
     return { value: null, error: ERROR_MESSAGES.PARSE_ERROR(base) };
   }
-  
+
   // Check for overflow and clamp
   let value = parsed;
   let error = null;
-  
+
   if (value < 0) {
     return { value: null, error: ERROR_MESSAGES.NEGATIVE };
   }
-  
+
   if (value > LIMITS.MAX_32BIT_DECIMAL) {
     value = LIMITS.MAX_32BIT;
     error = ERROR_MESSAGES.OVERFLOW;
   }
-  
+
   // Ensure unsigned 32-bit
   value = value >>> 0;
-  
+
   return { value, error };
 }
 
@@ -103,12 +103,12 @@ export function parseDecimal(input) {
  */
 export function parseHex(input) {
   let sanitized = sanitizeInput(input);
-  
+
   // Remove 0x or 0X prefix if present
   if (sanitized.toLowerCase().startsWith('0x')) {
     sanitized = sanitized.slice(2);
   }
-  
+
   return parseInput(sanitized, 16);
 }
 
@@ -119,12 +119,12 @@ export function parseHex(input) {
  */
 export function parseBinary(input) {
   let sanitized = sanitizeInput(input);
-  
+
   // Remove 0b or 0B prefix if present
   if (sanitized.toLowerCase().startsWith('0b')) {
     sanitized = sanitized.slice(2);
   }
-  
+
   return parseInput(sanitized, 2);
 }
 
@@ -135,12 +135,12 @@ export function parseBinary(input) {
  */
 export function parseOctal(input) {
   let sanitized = sanitizeInput(input);
-  
+
   // Remove 0o or 0O prefix if present
   if (sanitized.toLowerCase().startsWith('0o')) {
     sanitized = sanitized.slice(2);
   }
-  
+
   return parseInput(sanitized, 8);
 }
 
@@ -260,7 +260,7 @@ export function getBit(value, position) {
   if (position < 0 || position > 31) {
     return 0;
   }
-  return ((value >>> position) & 1);
+  return (value >>> position) & 1;
 }
 
 /**
@@ -273,7 +273,7 @@ export function toggleBit(value, position) {
   if (position < 0 || position > 31) {
     return value >>> 0;
   }
-  return ((value ^ (1 << position)) >>> 0);
+  return (value ^ (1 << position)) >>> 0;
 }
 
 /**
@@ -286,7 +286,7 @@ export function setBit(value, position) {
   if (position < 0 || position > 31) {
     return value >>> 0;
   }
-  return ((value | (1 << position)) >>> 0);
+  return (value | (1 << position)) >>> 0;
 }
 
 /**
@@ -299,7 +299,7 @@ export function clearBit(value, position) {
   if (position < 0 || position > 31) {
     return value >>> 0;
   }
-  return ((value & ~(1 << position)) >>> 0);
+  return (value & ~(1 << position)) >>> 0;
 }
 
 /**
@@ -313,7 +313,7 @@ export function shiftLeft(value, n = 1) {
   if (shiftAmount >= 32) {
     return 0;
   }
-  return ((value << shiftAmount) >>> 0);
+  return (value << shiftAmount) >>> 0;
 }
 
 /**
@@ -327,7 +327,7 @@ export function shiftRight(value, n = 1) {
   if (shiftAmount >= 32) {
     return 0;
   }
-  return (value >>> shiftAmount);
+  return value >>> shiftAmount;
 }
 
 /**
@@ -336,7 +336,7 @@ export function shiftRight(value, n = 1) {
  * @returns {number} Inverted value (32-bit)
  */
 export function bitwiseNot(value) {
-  return (~value >>> 0);
+  return ~value >>> 0;
 }
 
 /**
@@ -346,7 +346,7 @@ export function bitwiseNot(value) {
  * @returns {number} Result (32-bit)
  */
 export function bitwiseAnd(value, mask) {
-  return ((value & mask) >>> 0);
+  return (value & mask) >>> 0;
 }
 
 /**
@@ -356,7 +356,7 @@ export function bitwiseAnd(value, mask) {
  * @returns {number} Result (32-bit)
  */
 export function bitwiseOr(value, mask) {
-  return ((value | mask) >>> 0);
+  return (value | mask) >>> 0;
 }
 
 /**
@@ -369,7 +369,7 @@ export function getByte(value, bytePos) {
   if (bytePos < 0 || bytePos > 3) {
     return 0;
   }
-  return ((value >>> (bytePos * 8)) & 0xFF);
+  return (value >>> (bytePos * 8)) & 0xff;
 }
 
 /**
diff --git a/frontend/src/pages/RegExpTester.jsx b/frontend/src/pages/RegExpTester.jsx
index 46bb312..f78c92e 100644
--- a/frontend/src/pages/RegExpTester.jsx
+++ b/frontend/src/pages/RegExpTester.jsx
@@ -870,109 +870,109 @@ export default function RegExpTester() {
 
       {/* Regex Input Row - Unified Input Group */}
       <Column>
-      <div
-        style={{
-          display: 'flex',
-          alignItems: 'stretch',
-          padding: '0 0.5rem',
-          backgroundColor: 'var(--cds-layer)',
-          border: error
-            ? '2px solid var(--cds-support-error)'
-            : '1px solid var(--cds-border-strong)',
-          borderRadius: '4px',
-          transition: 'all 0.2s cubic-bezier(0.4, 0, 0.2, 1)',
-          boxShadow: 'inset 0 1px 2px rgba(0,0,0,0.1)',
-          position: 'relative',
-          overflow: 'visible', // For popover
-        }}
-        className="regex-input-row"
-      >
-        {/* Prefix / */}
         <div
           style={{
             display: 'flex',
-            alignItems: 'flex-start',
-            justifyContent: 'center',
-            padding: '0.75rem 0.5rem 0',
-            userSelect: 'none',
-            borderRight: '1px solid var(--cds-border-subtle)',
-            minWidth: '40px',
+            alignItems: 'stretch',
+            padding: '0 0.5rem',
+            backgroundColor: 'var(--cds-layer)',
+            border: error
+              ? '2px solid var(--cds-support-error)'
+              : '1px solid var(--cds-border-strong)',
+            borderRadius: '4px',
+            transition: 'all 0.2s cubic-bezier(0.4, 0, 0.2, 1)',
+            boxShadow: 'inset 0 1px 2px rgba(0,0,0,0.1)',
+            position: 'relative',
+            overflow: 'visible', // For popover
           }}
+          className="regex-input-row"
         >
-          <span
+          {/* Prefix / */}
+          <div
             style={{
-              color: 'var(--cds-text-secondary)',
-              fontSize: '1.25rem',
-              fontFamily: "'IBM Plex Mono', monospace",
-              opacity: 0.7,
-              lineHeight: '1.2',
+              display: 'flex',
+              alignItems: 'flex-start',
+              justifyContent: 'center',
+              padding: '0.75rem 0.5rem 0',
+              userSelect: 'none',
+              borderRight: '1px solid var(--cds-border-subtle)',
+              minWidth: '40px',
             }}
           >
-            /
-          </span>
-        </div>
+            <span
+              style={{
+                color: 'var(--cds-text-secondary)',
+                fontSize: '1.25rem',
+                fontFamily: "'IBM Plex Mono', monospace",
+                opacity: 0.7,
+                lineHeight: '1.2',
+              }}
+            >
+              /
+            </span>
+          </div>
 
-        <div
-          style={{
-            flex: 1,
-            display: 'flex',
-            alignItems: 'stretch',
-            padding: '0',
-          }}
-        >
-          <ExpandableRegexInput value={regexStr} onChange={setRegexStr} error={error} />
-        </div>
+          <div
+            style={{
+              flex: 1,
+              display: 'flex',
+              alignItems: 'stretch',
+              padding: '0',
+            }}
+          >
+            <ExpandableRegexInput value={regexStr} onChange={setRegexStr} error={error} />
+          </div>
 
-        {/* Suffix / */}
-        <div
-          style={{
-            display: 'flex',
-            alignItems: 'flex-start',
-            justifyContent: 'center',
-            padding: '0.75rem 0.5rem 0',
-            userSelect: 'none',
-            borderLeft: '1px solid var(--cds-border-subtle)',
-            minWidth: '40px',
-          }}
-        >
-          <span
+          {/* Suffix / */}
+          <div
             style={{
-              color: 'var(--cds-text-secondary)',
-              fontSize: '1.25rem',
-              fontFamily: "'IBM Plex Mono', monospace",
-              opacity: 0.7,
-              lineHeight: '1.2',
+              display: 'flex',
+              alignItems: 'flex-start',
+              justifyContent: 'center',
+              padding: '0.75rem 0.5rem 0',
+              userSelect: 'none',
+              borderLeft: '1px solid var(--cds-border-subtle)',
+              minWidth: '40px',
             }}
           >
-            /
-          </span>
-        </div>
+            <span
+              style={{
+                color: 'var(--cds-text-secondary)',
+                fontSize: '1.25rem',
+                fontFamily: "'IBM Plex Mono', monospace",
+                opacity: 0.7,
+                lineHeight: '1.2',
+              }}
+            >
+              /
+            </span>
+          </div>
 
-        {/* Flags Input */}
-        <FlagsInputWithPopover flags={flags} setFlags={setFlags} />
+          {/* Flags Input */}
+          <FlagsInputWithPopover flags={flags} setFlags={setFlags} />
 
-        {/* Copy Button */}
-        <div
-          style={{
-            display: 'flex',
-            alignItems: 'center',
-            justifyContent: 'center',
-            borderLeft: '1px solid var(--cds-border-subtle)',
-            minWidth: '48px',
-          }}
-        >
-          <CopyButton
-            onClick={handleCopyFullRegex}
-            disabled={!regexStr}
-            size="md"
-            iconDescription="Copy full regex string"
-            align="center"
-            kind="ghost"
-            className="transparent-copy-btn"
-          />
-        </div>
+          {/* Copy Button */}
+          <div
+            style={{
+              display: 'flex',
+              alignItems: 'center',
+              justifyContent: 'center',
+              borderLeft: '1px solid var(--cds-border-subtle)',
+              minWidth: '48px',
+            }}
+          >
+            <CopyButton
+              onClick={handleCopyFullRegex}
+              disabled={!regexStr}
+              size="md"
+              iconDescription="Copy full regex string"
+              align="center"
+              kind="ghost"
+              className="transparent-copy-btn"
+            />
+          </div>
 
-        <style>{`
+          <style>{`
                     .regex-input-row:focus-within {
                         border-color: var(--cds-focus) !important;
                         box-shadow: 0 0 0 2px var(--cds-focus), inset 0 1px 2px rgba(0,0,0,0.1);
@@ -990,7 +990,7 @@ export default function RegExpTester() {
                         background-color: var(--cds-layer-hover-01) !important;
                     }
                 `}</style>
-      </div>
+        </div>
       </Column>
 
       {/* Error Display */}
@@ -1012,36 +1012,36 @@ export default function RegExpTester() {
       )}
 
       <Column style={{ flex: 1, minHeight: 0 }}>
-      <ToolSplitPane columnCount={layout.direction === 'horizontal' ? 2 : 1}>
-        {/* Left Pane: Live Highlighted Input */}
-        <ToolPaneWithLabel
-          label={`Test String${matches.length > 0 ? ` (${matches.length} match${matches.length !== 1 ? 'es' : ''})` : ''}`}
-        >
-          <LiveHighlightedEditor text={text} setText={setText} regex={regexStr} flags={flags} />
-        </ToolPaneWithLabel>
-
-        {/* Right Pane: Match Information */}
-        <ToolPaneWithLabel label="MATCH INFORMATION">
-          <div
-            style={{
-              flex: 1,
-              overflowY: 'auto',
-              backgroundColor: 'var(--cds-layer)',
-              border: '1px solid var(--cds-border-strong)',
-              fontFamily: "'IBM Plex Mono', monospace",
-              fontSize: '0.875rem',
-            }}
+        <ToolSplitPane columnCount={layout.direction === 'horizontal' ? 2 : 1}>
+          {/* Left Pane: Live Highlighted Input */}
+          <ToolPaneWithLabel
+            label={`Test String${matches.length > 0 ? ` (${matches.length} match${matches.length !== 1 ? 'es' : ''})` : ''}`}
           >
-            {output.length > 0 ? (
-              output
-            ) : (
-              <div style={{ padding: '1rem', color: 'var(--cds-text-secondary)' }}>
-                Matching results will appear here...
-              </div>
-            )}
-          </div>
-        </ToolPaneWithLabel>
-      </ToolSplitPane>
+            <LiveHighlightedEditor text={text} setText={setText} regex={regexStr} flags={flags} />
+          </ToolPaneWithLabel>
+
+          {/* Right Pane: Match Information */}
+          <ToolPaneWithLabel label="MATCH INFORMATION">
+            <div
+              style={{
+                flex: 1,
+                overflowY: 'auto',
+                backgroundColor: 'var(--cds-layer)',
+                border: '1px solid var(--cds-border-strong)',
+                fontFamily: "'IBM Plex Mono', monospace",
+                fontSize: '0.875rem',
+              }}
+            >
+              {output.length > 0 ? (
+                output
+              ) : (
+                <div style={{ padding: '1rem', color: 'var(--cds-text-secondary)' }}>
+                  Matching results will appear here...
+                </div>
+              )}
+            </div>
+          </ToolPaneWithLabel>
+        </ToolSplitPane>
       </Column>
     </Grid>
   );
diff --git a/frontend/src/pages/StringUtilities/index.jsx b/frontend/src/pages/StringUtilities/index.jsx
index 81b289d..2531785 100644
--- a/frontend/src/pages/StringUtilities/index.jsx
+++ b/frontend/src/pages/StringUtilities/index.jsx
@@ -77,9 +77,7 @@ export default function StringUtilities() {
         </div>
       </Column>
 
-      <Column style={{ flex: 1, minHeight: 0 }}>
-        {renderPane()}
-      </Column>
+      <Column style={{ flex: 1, minHeight: 0 }}>{renderPane()}</Column>
     </Grid>
   );
 }
diff --git a/frontend/src/pages/TextConverter/index.jsx b/frontend/src/pages/TextConverter/index.jsx
index b9e0293..cbdfba8 100644
--- a/frontend/src/pages/TextConverter/index.jsx
+++ b/frontend/src/pages/TextConverter/index.jsx
@@ -32,12 +32,12 @@ export default function TextBasedConverter() {
   const validCategories = Object.keys(CONVERTER_MAP);
   const initialCategory = validCategories.includes(urlCategory)
     ? urlCategory
-    : (localStorage.getItem(STORAGE_KEYS.CATEGORY) || DEFAULTS.CATEGORY);
+    : localStorage.getItem(STORAGE_KEYS.CATEGORY) || DEFAULTS.CATEGORY;
 
   const validMethods = CONVERTER_MAP[initialCategory] || [];
   const initialMethod = validMethods.includes(urlMethod)
     ? urlMethod
-    : (localStorage.getItem(STORAGE_KEYS.METHOD) || DEFAULTS.METHOD);
+    : localStorage.getItem(STORAGE_KEYS.METHOD) || DEFAULTS.METHOD;
 
   // Persistent state initialization
   const [category, setCategory] = useState(initialCategory);
@@ -235,80 +235,80 @@ export default function TextBasedConverter() {
 
       <Column style={{ flex: 1, minHeight: 0 }}>
         <ToolSplitPane columnCount={layout.direction === 'horizontal' ? 2 : 1}>
-        <ToolPane
-          label={LABELS.INPUT(category, subMode, method)}
-          value={input}
-          onChange={(e) => setInput(e.target.value)}
-          placeholder={PLACEHOLDERS.INPUT}
-        />
+          <ToolPane
+            label={LABELS.INPUT(category, subMode, method)}
+            value={input}
+            onChange={(e) => setInput(e.target.value)}
+            placeholder={PLACEHOLDERS.INPUT}
+          />
 
-        {isAllHashes ? (
-          <div
-            className="pane"
-            style={{
-              display: 'flex',
-              flexDirection: 'column',
-              height: '100%',
-              minHeight: 0,
-              flex: 1,
-            }}
-          >
+          {isAllHashes ? (
             <div
+              className="pane"
               style={{
                 display: 'flex',
-                justifyContent: 'space-between',
-                alignItems: 'center',
-                minHeight: '30px',
+                flexDirection: 'column',
+                height: '100%',
+                minHeight: 0,
+                flex: 1,
               }}
             >
-              <label
+              <div
+                style={{
+                  display: 'flex',
+                  justifyContent: 'space-between',
+                  alignItems: 'center',
+                  minHeight: '30px',
+                }}
+              >
+                <label
+                  style={{
+                    fontSize: '0.75rem',
+                    fontWeight: 400,
+                    lineHeight: 1.5,
+                    letterSpacing: '0.32px',
+                    color: 'var(--cds-text-secondary)',
+                    textTransform: 'uppercase',
+                  }}
+                >
+                  {LABELS.OUTPUT}
+                </label>
+              </div>
+              <div
                 style={{
-                  fontSize: '0.75rem',
-                  fontWeight: 400,
-                  lineHeight: 1.5,
-                  letterSpacing: '0.32px',
-                  color: 'var(--cds-text-secondary)',
-                  textTransform: 'uppercase',
+                  flex: 1,
+                  overflowY: 'auto',
+                  padding: '0.75rem',
+                  backgroundColor: 'var(--cds-layer)',
                 }}
               >
-                {LABELS.OUTPUT}
-              </label>
+                <MultiHashOutput value={output} error={error} />
+              </div>
             </div>
+          ) : isImageOutput ? (
             <div
+              className="pane"
               style={{
+                display: 'flex',
+                flexDirection: 'column',
+                height: '100%',
+                minHeight: 0,
                 flex: 1,
-                overflowY: 'auto',
-                padding: '0.75rem',
-                backgroundColor: 'var(--cds-layer)',
               }}
             >
-              <MultiHashOutput value={output} error={error} />
+              <ImageOutput value={output} />
             </div>
-          </div>
-        ) : isImageOutput ? (
-          <div
-            className="pane"
-            style={{
-              display: 'flex',
-              flexDirection: 'column',
-              height: '100%',
-              minHeight: 0,
-              flex: 1,
-            }}
-          >
-            <ImageOutput value={output} />
-          </div>
-        ) : (
-          <ToolPane
-            label={LABELS.OUTPUT}
-            value={output}
-            readOnly
-            placeholder={PLACEHOLDERS.OUTPUT}
-            invalid={!!error}
-            invalidText={error}
-          />
-        )}
-      </ToolSplitPane>
+          ) : (
+            <ToolPane
+              label={LABELS.OUTPUT}
+              value={output}
+              readOnly
+              placeholder={PLACEHOLDERS.OUTPUT}
+              invalid={!!error}
+              invalidText={error}
+            />
+          )}
+        </ToolSplitPane>
       </Column>
     </Grid>
   );
diff --git a/frontend/src/spotlight.css b/frontend/src/spotlight.css
new file mode 100644
index 0000000..3fde626
--- /dev/null
+++ b/frontend/src/spotlight.css
@@ -0,0 +1,13 @@
+/* Spotlight window specific styles */
+html, body, #root {
+  background: transparent !important;
+  margin: 0;
+  padding: 0;
+}
+
+#root {
+  display: flex;
+  align-items: flex-start;
+  justify-content: center;
+  padding-top: 20vh;
+}
diff --git a/frontend/src/spotlight.jsx b/frontend/src/spotlight.jsx
new file mode 100644
index 0000000..1a20546
--- /dev/null
+++ b/frontend/src/spotlight.jsx
@@ -0,0 +1,38 @@
+import React from 'react';
+import ReactDOM from 'react-dom/client';
+import { BrowserRouter } from 'react-router-dom';
+import { Theme } from '@carbon/react';
+import { SpotlightPalette } from './components/SpotlightPalette';
+import './spotlight.css';
+
+function SpotlightApp() {
+  const [theme, setTheme] = React.useState('g100');
+
+  // Listen for system theme changes
+  React.useEffect(() => {
+    const matchMedia = window.matchMedia('(prefers-color-scheme: dark)');
+
+    const updateTheme = () => {
+      setTheme(matchMedia.matches ? 'g100' : 'white');
+    };
+
+    updateTheme();
+    matchMedia.addEventListener('change', updateTheme);
+    return () => matchMedia.removeEventListener('change', updateTheme);
+  }, []);
+
+  return (
+    <Theme theme={theme} style={{ height: '100%' }}>
+      <BrowserRouter>
+        <SpotlightPalette />
+      </BrowserRouter>
+    </Theme>
+  );
+}
+
+const root = ReactDOM.createRoot(document.getElementById('root'));
+root.render(
+  <React.StrictMode>
+    <SpotlightApp />
+  </React.StrictMode>
+);
diff --git a/frontend/src/utils/storage.js b/frontend/src/utils/storage.js
index 80b6f34..f7c0eac 100644
--- a/frontend/src/utils/storage.js
+++ b/frontend/src/utils/storage.js
@@ -71,7 +71,7 @@ const storage = {
       console.error(`Error setting array in localStorage: ${key}`, error);
       return false;
     }
-  }
+  },
 };
 
 export default storage;
diff --git a/internal/codeformatter/css_selector_test.go b/internal/codeformatter/css_selector_test.go
index f0a8d5f..22b24b9 100644
--- a/internal/codeformatter/css_selector_test.go
+++ b/internal/codeformatter/css_selector_test.go
@@ -8,9 +8,6 @@ import (
 )
 
 func TestApplyCSSSelector(t *testing.T) {
-	// TODO: Fix these tests - they're failing due to newline formatting issues
-	// and incomplete CSS selector support
-	t.Skip("Skipping test: known issue with CSS selector formatting")
 	tests := []struct {
 		name      string
 		html      string
@@ -22,7 +19,7 @@ func TestApplyCSSSelector(t *testing.T) {
 			name:     "Element selector - find all divs",
 			html:     `<div class="a">First</div><div class="b">Second</div>`,
 			selector: "div",
-			want:     `<div class="a">First</div>\n<div class="b">Second</div>`,
+			want:     "<div class=\"a\">First</div>\n<div class=\"b\">Second</div>",
 		},
 		{
 			name:     "Class selector - find by class",
@@ -61,13 +58,13 @@ func TestApplyCSSSelector(t *testing.T) {
 				<article class="post"><h2>Post 2</h2></article>
 			</body></html>`,
 			selector: "article",
-			want:     `<article class="post"><h2>Post 1</h2></article>\n<article class="post"><h2>Post 2</h2></article>`,
+			want:     "<article class=\"post\"><h2>Post 1</h2></article>\n<article class=\"post\"><h2>Post 2</h2></article>",
 		},
 		{
 			name:     "No html/body wrapper - elements extracted directly",
 			html:     `<genre>Computer</genre><genre>Tech</genre>`,
 			selector: "genre",
-			want:     `<genre>Computer</genre>\n<genre>Tech</genre>`,
+			want:     "<genre>Computer</genre>\n<genre>Tech</genre>",
 		},
 		{
 			name:      "No matching elements",
@@ -162,14 +159,26 @@ func TestFindElementByID(t *testing.T) {
 }
 
 func TestFindElementsByDescendant(t *testing.T) {
-	// TODO: Fix this test - CSS selector implementation incomplete
-	t.Skip("Skipping test: known issue with CSS selector descendant implementation")
+	html := `<div class="container"><h1>Title</h1><p>Text</p><div class="inner"><h1>Inner Title</h1></div></div>`
+	doc := parseHTML(t, html)
+
+	// Test element with class selector
+	results := findElementsByDescendant(doc, "div.container > h1")
+	if len(results) != 1 {
+		t.Errorf("Expected 1 h1 inside div.container, got %d", len(results))
+	}
+
+	// Test simple tag selector at end
+	results = findElementsByDescendant(doc, "div h1")
+	if len(results) != 2 {
+		t.Errorf("Expected 2 h1 elements inside div, got %d", len(results))
+	}
 }
 
 // Helper function to parse HTML for testing
-func parseHTML(t *testing.T, htmlStr string) *html.Node {
+func parseHTML(t *testing.T, htmlContent string) *html.Node {
 	t.Helper()
-	doc, err := html.Parse(strings.NewReader(htmlStr))
+	doc, err := html.Parse(strings.NewReader(htmlContent))
 	if err != nil {
 		t.Fatalf("Failed to parse HTML: %v", err)
 	}
diff --git a/internal/codeformatter/service.go b/internal/codeformatter/service.go
index 640afcb..ed22445 100644
--- a/internal/codeformatter/service.go
+++ b/internal/codeformatter/service.go
@@ -162,8 +162,8 @@ func applyXPathFilter(xml string, xpath string) (string, error) {
 
 	xpath = strings.TrimSpace(xpath)
 
-	// Handle element[@attr='value'] pattern - extract element with specific attribute
-	if strings.Contains(xpath, "[@") && strings.Contains(xpath, "='") {
+	// Handle element[@attr='value'] or element[@attr="value"] pattern - extract element with specific attribute
+	if strings.Contains(xpath, "[@") && (strings.Contains(xpath, "='") || strings.Contains(xpath, "=\"")) {
 		return extractElementByAttribute(xml, xpath)
 	}
 
@@ -278,30 +278,59 @@ func extractElementByAttribute(xmlStr, xpath string) (string, error) {
 
 	attrValue := attrSelector[valueStart+1 : valueEnd]
 
-	// Find elements with matching attribute
-	searchPattern := "<" + elementName + " " + attrName + "=" + string(quoteChar) + attrValue + string(quoteChar)
+	// Find elements with matching attribute by searching for element tags first,
+	// then checking if they have the specified attribute
+	startTag := "<" + elementName
 	endTag := "</" + elementName + ">"
 
 	var results []string
 	start := 0
 
 	for {
-		// Find element with this attribute
-		idx := strings.Index(xmlStr[start:], searchPattern)
+		// Find the next occurrence of the element start tag
+		idx := strings.Index(xmlStr[start:], startTag)
 		if idx == -1 {
-			// Try alternate quote style
-			altQuote := "'"
-			if quoteChar == '\'' {
-				altQuote = "\""
-			}
-			searchPattern = "<" + elementName + " " + attrName + "=" + altQuote + attrValue + altQuote
-			idx = strings.Index(xmlStr[start:], searchPattern)
-			if idx == -1 {
-				break
-			}
+			break
 		}
 		idx += start
 
+		// Check that this is a complete tag name (not a prefix)
+		afterTag := idx + len(startTag)
+		if afterTag < len(xmlStr) {
+			nextChar := xmlStr[afterTag]
+			if nextChar != ' ' && nextChar != '>' && nextChar != '/' {
+				// This is a prefix match (e.g., "book" matching "bookmark"), skip it
+				start = idx + len(startTag)
+				continue
+			}
+		}
+
+		// Find the end of the opening tag to extract attributes
+		tagEnd := idx + len(startTag)
+		for tagEnd < len(xmlStr) && xmlStr[tagEnd] != '>' && xmlStr[tagEnd] != '/' {
+			tagEnd++
+		}
+
+		// Extract the tag content (attributes)
+		tagContent := xmlStr[idx:tagEnd]
+
+		// Check if this tag has the attribute with the specified value
+		// Look for attr="value" or attr='value'
+		attrPattern1 := attrName + "=" + string(quoteChar) + attrValue + string(quoteChar)
+		attrPattern2 := attrName + "=" + string(quoteChar) + attrValue + string(quoteChar)
+		if quoteChar == '\'' {
+			attrPattern2 = attrName + "=\"" + attrValue + "\""
+		} else {
+			attrPattern2 = attrName + "='" + attrValue + "'"
+		}
+
+		if !strings.Contains(tagContent, attrPattern1) && !strings.Contains(tagContent, attrPattern2) {
+			// Attribute not found in this tag, skip to next
+			start = idx + len(startTag)
+			continue
+		}
+
+		// Found matching element, extract it
 		// Find end of this element
 		endIdx := strings.Index(xmlStr[idx:], endTag)
 		if endIdx == -1 {
@@ -349,20 +378,18 @@ func extractNestedXMLElements(xmlStr string, pathParts []string) (string, error)
 	// Get the first element in the path
 	currentElement := pathParts[0]
 
-	// Extract all elements with the first name
-	extracted, err := extractXMLElements(xmlStr, currentElement)
+	// Extract all elements with the first name (returns slice to avoid newline issues)
+	matches, err := extractXMLElementsSlice(xmlStr, currentElement)
 	if err != nil {
 		return "", err
 	}
 
-	// If this is the last part, return it
+	// If this is the last part, return joined results
 	if len(pathParts) == 1 {
-		return extracted, nil
+		return strings.Join(matches, "\n"), nil
 	}
 
 	// Continue with the rest of the path
-	// Split the extracted content by newlines and process each match
-	matches := strings.Split(extracted, "\n")
 	var finalResults []string
 
 	for _, match := range matches {
@@ -385,6 +412,15 @@ func extractNestedXMLElements(xmlStr string, pathParts []string) (string, error)
 
 // extractXMLElements extracts elements by name from XML
 func extractXMLElements(xmlStr, elementName string) (string, error) {
+	elements, err := extractXMLElementsSlice(xmlStr, elementName)
+	if err != nil {
+		return "", err
+	}
+	return strings.Join(elements, "\n"), nil
+}
+
+// extractXMLElementsSlice extracts elements by name from XML and returns as a slice
+func extractXMLElementsSlice(xmlStr, elementName string) ([]string, error) {
 	// Simple extraction using string manipulation
 	// In production, use proper XML parsing
 	startTag := "<" + elementName
@@ -400,6 +436,17 @@ func extractXMLElements(xmlStr, elementName string) (string, error) {
 		}
 		idx += start
 
+		// Check that this is a complete tag name (not a prefix like "item" matching "items")
+		afterTag := idx + len(startTag)
+		if afterTag < len(xmlStr) {
+			nextChar := xmlStr[afterTag]
+			if nextChar != ' ' && nextChar != '>' && nextChar != '/' {
+				// This is a prefix match, skip it
+				start = idx + len(startTag)
+				continue
+			}
+		}
+
 		// Find end of this element
 		endIdx := strings.Index(xmlStr[idx:], endTag)
 		if endIdx == -1 {
@@ -417,10 +464,10 @@ func extractXMLElements(xmlStr, elementName string) (string, error) {
 	}
 
 	if len(results) == 0 {
-		return "", fmt.Errorf("no elements found with name: %s", elementName)
+		return nil, fmt.Errorf("no elements found with name: %s", elementName)
 	}
 
-	return strings.Join(results, "\n"), nil
+	return results, nil
 }
 
 // extractXMLAttributes extracts attribute values from XML elements
@@ -691,6 +738,20 @@ func applyCSSSelector(htmlStr, selector string) (string, error) {
 		return result, nil
 	}
 
+	// Handle element with class selector (e.g., "div.header")
+	if strings.Contains(selector, ".") && !strings.Contains(selector, " ") && !strings.Contains(selector, ">") {
+		parts := strings.Split(selector, ".")
+		if len(parts) == 2 {
+			tagName := parts[0]
+			className := parts[1]
+			results := findElementsByTagAndClass(doc, tagName, className)
+			if len(results) == 0 {
+				return "", fmt.Errorf("no elements found matching selector: %s", selector)
+			}
+			return strings.Join(results, "\n"), nil
+		}
+	}
+
 	// Handle descendant selector (e.g., "div.container > h1")
 	if strings.Contains(selector, " ") || strings.Contains(selector, ">") {
 		results := findElementsByDescendant(doc, selector)
@@ -793,6 +854,34 @@ func findElementsByClass(n *html.Node, className string) []string {
 	return results
 }
 
+// findElementsByTagAndClass finds elements by tag name and class
+func findElementsByTagAndClass(n *html.Node, tagName, className string) []string {
+	var results []string
+
+	var traverse func(*html.Node)
+	traverse = func(node *html.Node) {
+		if node.Type == html.ElementNode && node.Data == tagName {
+			for _, attr := range node.Attr {
+				if attr.Key == "class" {
+					classes := strings.Fields(attr.Val)
+					for _, c := range classes {
+						if c == className {
+							results = append(results, renderNodeToString(node))
+							break
+						}
+					}
+				}
+			}
+		}
+		for c := node.FirstChild; c != nil; c = c.NextSibling {
+			traverse(c)
+		}
+	}
+
+	traverse(n)
+	return results
+}
+
 // findElementByID finds element by ID
 func findElementByID(n *html.Node, id string) string {
 	var result string
@@ -819,51 +908,220 @@ func findElementByID(n *html.Node, id string) string {
 	return result
 }
 
+// cssSelectorPart represents a part of a CSS selector chain
+type cssSelectorPart struct {
+	selector    string
+	directChild bool
+}
+
 // findElementsByDescendant finds elements by descendant selector
 func findElementsByDescendant(n *html.Node, selector string) []string {
-	// Parse simple descendant selectors like "div.container > h1"
-	parts := strings.FieldsFunc(selector, func(r rune) bool {
-		return r == ' ' || r == '>'
-	})
+	// Parse selector into parts with relationship info
+	// e.g., "div.container > h1" becomes [(div.container, >), (h1, )]
+	var parts []cssSelectorPart
+	current := ""
+	directChild := false
+
+	for i, r := range selector {
+		if r == '>' {
+			if strings.TrimSpace(current) != "" {
+				parts = append(parts, cssSelectorPart{selector: strings.TrimSpace(current), directChild: directChild})
+			}
+			current = ""
+			directChild = true
+		} else if r == ' ' {
+			// Check if next non-space char is >
+			nextIsDirect := false
+			for j := i + 1; j < len(selector); j++ {
+				if selector[j] == '>' {
+					nextIsDirect = true
+					break
+				} else if selector[j] != ' ' {
+					break
+				}
+			}
+
+			if strings.TrimSpace(current) != "" && !nextIsDirect {
+				parts = append(parts, cssSelectorPart{selector: strings.TrimSpace(current), directChild: directChild})
+				current = ""
+				directChild = false
+			}
+		} else {
+			current += string(r)
+		}
+	}
+
+	if strings.TrimSpace(current) != "" {
+		parts = append(parts, cssSelectorPart{selector: strings.TrimSpace(current), directChild: directChild})
+	}
 
 	if len(parts) == 0 {
 		return nil
 	}
 
-	// For now, just find the last element
-	lastPart := parts[len(parts)-1]
+	// Find elements matching the full selector chain
+	return findElementsMatchingSelectorChain(n, parts)
+}
 
-	// Check if it has a class
-	if strings.Contains(lastPart, ".") {
-		classParts := strings.Split(lastPart, ".")
-		tagName := classParts[0]
-		className := classParts[1]
+// findElementsMatchingSelectorChain finds elements matching a chain of selectors
+func findElementsMatchingSelectorChain(n *html.Node, parts []cssSelectorPart) []string {
+	if len(parts) == 0 {
+		return nil
+	}
 
+	// Find all nodes matching the first selector
+	firstMatches := findNodesMatchingSimpleSelector(n, parts[0].selector)
+
+	if len(parts) == 1 {
+		// Last part - convert nodes to strings (deduplicate)
+		seen := make(map[*html.Node]bool)
 		var results []string
-		var traverse func(*html.Node)
-		traverse = func(node *html.Node) {
-			if node.Type == html.ElementNode && (tagName == "" || node.Data == tagName) {
-				for _, attr := range node.Attr {
-					if attr.Key == "class" {
-						classes := strings.Fields(attr.Val)
-						for _, c := range classes {
-								if c == className {
-									results = append(results, renderNodeToString(node))
-									break
-								}
+		for _, node := range firstMatches {
+			if !seen[node] {
+				seen[node] = true
+				results = append(results, renderNodeToString(node))
+			}
+		}
+		return results
+	}
+
+	// For each match, search its descendants for the rest of the chain
+	// Use a map to deduplicate nodes (same node found through different paths)
+	seen := make(map[*html.Node]bool)
+	var results []string
+
+	for _, matchNode := range firstMatches {
+		if parts[1].directChild {
+			// For direct child (>), check if immediate children match the next selector
+			for c := matchNode.FirstChild; c != nil; c = c.NextSibling {
+				if c.Type == html.ElementNode && matchesSimpleSelector(c, parts[1].selector) {
+					// Found a match - continue with rest of chain
+					if len(parts) == 2 {
+						// This is the last selector in chain
+						if !seen[c] {
+							seen[c] = true
+							results = append(results, renderNodeToString(c))
+						}
+					} else {
+						// More selectors to match - search from this node
+						subResults := findElementsMatchingSelectorChain(c, parts[2:])
+						for _, r := range subResults {
+							results = append(results, r)
 						}
 					}
 				}
 			}
-			for c := node.FirstChild; c != nil; c = c.NextSibling {
-				traverse(c)
+		} else {
+			// For descendant (space), search entire subtree
+			for c := matchNode.FirstChild; c != nil; c = c.NextSibling {
+				subResults := findElementsMatchingSelectorChain(c, parts[1:])
+				for _, r := range subResults {
+					results = append(results, r)
+				}
 			}
 		}
-		traverse(n)
-		return results
 	}
 
-	return findHTMLElements(n, lastPart)
+	// Deduplicate results by string content
+	seenStr := make(map[string]bool)
+	var uniqueResults []string
+	for _, r := range results {
+		if !seenStr[r] {
+			seenStr[r] = true
+			uniqueResults = append(uniqueResults, r)
+		}
+	}
+
+	return uniqueResults
+}
+
+// findNodesMatchingSimpleSelector finds nodes (not strings) matching a simple selector
+func findNodesMatchingSimpleSelector(n *html.Node, selector string) []*html.Node {
+	var results []*html.Node
+
+	var traverse func(*html.Node)
+	traverse = func(node *html.Node) {
+		if node.Type == html.ElementNode && matchesSimpleSelector(node, selector) {
+			results = append(results, node)
+		}
+		for c := node.FirstChild; c != nil; c = c.NextSibling {
+			traverse(c)
+		}
+	}
+
+	traverse(n)
+	return results
+}
+
+// findElementsMatchingSimpleSelector finds elements matching a simple selector (e.g., "div", ".class", "div.class")
+func findElementsMatchingSimpleSelector(n *html.Node, selector string) []string {
+	var results []string
+
+	var traverse func(*html.Node)
+	traverse = func(node *html.Node) {
+		if node.Type == html.ElementNode && matchesSimpleSelector(node, selector) {
+			results = append(results, renderNodeToString(node))
+		}
+		for c := node.FirstChild; c != nil; c = c.NextSibling {
+			traverse(c)
+		}
+	}
+
+	traverse(n)
+	return results
+}
+
+// matchesSimpleSelector checks if a node matches a simple CSS selector
+func matchesSimpleSelector(node *html.Node, selector string) bool {
+	selector = strings.TrimSpace(selector)
+
+	// Handle class selector: .classname or tag.classname
+	if strings.Contains(selector, ".") {
+		parts := strings.Split(selector, ".")
+		tagName := parts[0]
+		className := parts[1]
+
+		// Check tag name if specified
+		if tagName != "" && node.Data != tagName {
+			return false
+		}
+
+		// Check class
+		for _, attr := range node.Attr {
+			if attr.Key == "class" {
+				classes := strings.Fields(attr.Val)
+				for _, c := range classes {
+					if c == className {
+						return true
+					}
+				}
+			}
+		}
+		return false
+	}
+
+	// Handle ID selector: #id or tag#id
+	if strings.Contains(selector, "#") {
+		parts := strings.Split(selector, "#")
+		tagName := parts[0]
+		id := parts[1]
+
+		// Check tag name if specified
+		if tagName != "" && node.Data != tagName {
+			return false
+		}
+
+		// Check ID
+		for _, attr := range node.Attr {
+			if attr.Key == "id" && attr.Val == id {
+				return true
+			}
+		}
+		return false
+	}
+
+	// Simple tag selector
+	return node.Data == selector
 }
 
 // formatHTMLPretty formats HTML with indentation
diff --git a/internal/codeformatter/xpath_filter_test.go b/internal/codeformatter/xpath_filter_test.go
index 3201b7e..5ab0a40 100644
--- a/internal/codeformatter/xpath_filter_test.go
+++ b/internal/codeformatter/xpath_filter_test.go
@@ -6,8 +6,6 @@ import (
 )
 
 func TestApplyXPathFilter(t *testing.T) {
-	// TODO: Fix these tests - XPath filter implementation is incomplete
-	t.Skip("Skipping test: known issue with XPath filter implementation")
 	tests := []struct {
 		name      string
 		xml       string
@@ -19,7 +17,7 @@ func TestApplyXPathFilter(t *testing.T) {
 			name:  "Simple element selector with //",
 			xml:   `<root><item>One</item><item>Two</item></root>`,
 			xpath: "//item",
-			want:  `<item>One</item>\n<item>Two</item>`,
+			want:  "<item>One</item>\n<item>Two</item>",
 		},
 		{
 			name:  "Simple element selector with /",
@@ -103,16 +101,16 @@ func TestApplyXPathFilter(t *testing.T) {
 }
 
 func TestExtractXMLElements(t *testing.T) {
-	// TODO: Fix this test - XML extraction implementation is incomplete
-	t.Skip("Skipping test: known issue with XML element extraction")
 	xml := `<root><item>First</item><item>Second</item><other>Other</other></root>`
 
 	results, err := extractXMLElements(xml, "item")
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 	}
-	if len(results) != 2 {
-		t.Errorf("Expected 2 items, got %d", len(results))
+	// Split by newline to count elements since function returns joined string
+	elements := strings.Split(strings.TrimSpace(results), "\n")
+	if len(elements) != 2 {
+		t.Errorf("Expected 2 items, got %d", len(elements))
 	}
 
 	_, err = extractXMLElements(xml, "nonexistent")
@@ -122,8 +120,6 @@ func TestExtractXMLElements(t *testing.T) {
 }
 
 func TestExtractNestedXMLElements(t *testing.T) {
-	// TODO: Fix this test - nested XML extraction implementation is incomplete
-	t.Skip("Skipping test: known issue with nested XML element extraction")
 	xml := `<catalog>
 		<book>
 			<author>Author1</author>
@@ -145,19 +141,17 @@ func TestExtractNestedXMLElements(t *testing.T) {
 		t.Errorf("Expected to find both authors, got: %s", results)
 	}
 
-	// Test single level
-	results, err = extractNestedXMLElements(xml, []string{"book"})
+	// Test single level - use extractXMLElementsSlice to get slice and count properly
+	booksSlice, err := extractXMLElementsSlice(xml, "book")
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 	}
-	if len(results) != 2 {
-		t.Errorf("Expected 2 books, got %d", len(results))
+	if len(booksSlice) != 2 {
+		t.Errorf("Expected 2 books, got %d", len(booksSlice))
 	}
 }
 
 func TestExtractElementByAttribute(t *testing.T) {
-	// TODO: Fix this test - attribute extraction implementation is incomplete
-	t.Skip("Skipping test: known issue with XML attribute extraction")
 	xml := `<library>
 		<book id="bk101" genre="fiction"><title>Book1</title></book>
 		<book id="bk102" genre="tech"><title>Book2</title></book>
diff --git a/main.go b/main.go
index 4d935c0..43790a3 100644
--- a/main.go
+++ b/main.go
@@ -33,6 +33,11 @@ func init() {
 
 	// Register settings changed event
 	application.RegisterEvent[map[string]interface{}]("settings:changed")
+
+	// Register spotlight events
+	application.RegisterEvent[string]("spotlight:opened")
+	application.RegisterEvent[string]("spotlight:closed")
+	application.RegisterEvent[string]("spotlight:command-selected") // Event triggered when user selects a command from spotlight - used for navigation from spotlight to main window
 }
 
 func main() {
@@ -93,7 +98,12 @@ func main() {
 	app.RegisterService(application.NewService(service.NewDataGeneratorService(app)))
 	app.RegisterService(application.NewService(service.NewCodeFormatterService(app)))
 	app.RegisterService(application.NewService(service.NewSettingsService(app, settingsManager)))
-	// WindowControls service will be registered after window creation
+
+	// Create and register spotlight service
+	spotlightService := service.NewSpotlightService(app)
+	app.RegisterService(application.NewService(spotlightService))
+
+	// WindowControls service must be registered after main window creation (see line 149)
 
 	// Start HTTP server for browser support (background)
 	go func() {
@@ -138,14 +148,91 @@ func main() {
 	// Register WindowControls service after window creation
 	app.RegisterService(application.NewService(service.NewWindowControls(mainWindow)))
 
+	// Create spotlight window with special behaviors
+	// Note: MacWindowLevelFloating and ActivationPolicyAccessory may require
+	// platform-specific code. CollectionBehaviors provide most spotlight functionality.
+	spotlightWindow := app.Window.NewWithOptions(application.WebviewWindowOptions{
+		Title:     "DevToolbox Spotlight",
+		Width:     640,
+		Height:    480,
+		Frameless: true, // Hide window controls (close/minimize/maximize buttons)
+		BackgroundColour: application.RGBA{
+			Red:   27,
+			Green: 38,
+			Blue:  54,
+			Alpha: 220, // ~86% opacity for better transparency
+		},
+		Mac: application.MacWindow{
+			InvisibleTitleBarHeight: 0,
+			Backdrop:                application.MacBackdropTranslucent,
+			TitleBar:                application.MacTitleBarHidden,
+			// Collection behaviors for Spotlight-like functionality:
+			// - CanJoinAllSpaces: Appears on all Spaces (virtual desktops)
+			// - FullScreenAuxiliary: Can overlay fullscreen apps
+			// - Transient: Temporary window, doesn't affect window order
+			CollectionBehavior: application.MacWindowCollectionBehaviorCanJoinAllSpaces |
+				application.MacWindowCollectionBehaviorFullScreenAuxiliary |
+				application.MacWindowCollectionBehaviorTransient,
+		},
+		Windows: application.WindowsWindow{
+			HiddenOnTaskbar: true, // Hide from taskbar for tool window behavior
+		},
+		Hidden: true,
+		URL:    "/spotlight",
+	})
+
+	// Set the window in spotlight service
+	spotlightService.SetWindow(spotlightWindow)
+
+	// Handle spotlight window close - hide instead of close
+	spotlightWindow.OnWindowEvent(events.Common.WindowClosing, func(event *application.WindowEvent) {
+		event.Cancel()
+		spotlightWindow.Hide()
+		spotlightWindow.EmitEvent("spotlight:closed", "")
+	})
+
+	// Listen for spotlight navigation events
+	app.Event.On("spotlight:command-selected", func(event *application.CustomEvent) {
+		path := event.Data.(string)
+		log.Printf("Spotlight command selected: %s", path)
+
+		// Show and focus main window
+		mainWindow.Show()
+		mainWindow.Focus()
+
+		// Emit navigation event to frontend
+		mainWindow.EmitEvent("navigate:to", path)
+	})
+
+	// Listen for close request from spotlight
+	app.Event.On("spotlight:closed", func(event *application.CustomEvent) {
+		spotlightWindow.Hide()
+	})
+
+	// Listen for system commands from spotlight
+	app.Event.On("theme:toggle", func(event *application.CustomEvent) {
+		mainWindow.EmitEvent("theme:toggle", "")
+	})
+
+	app.Event.On("window:toggle", func(event *application.CustomEvent) {
+		if mainWindow.IsVisible() {
+			mainWindow.Hide()
+		} else {
+			mainWindow.Show()
+			mainWindow.Focus()
+		}
+	})
+
+	app.Event.On("app:quit", func(event *application.CustomEvent) {
+		app.Quit()
+	})
+
 	// Setup system tray
 	systray := app.SystemTray.New()
 
 	// Create tray menu
 	trayMenu := app.NewMenu()
 	trayMenu.Add("Show DevToolbox").OnClick(func(ctx *application.Context) {
-		// NOTE: macOS window restore from tray has known issues
-		// See: KNOWN_ISSUES.md - "macOS: Tray 'Show DevToolbox' doesn't restore hidden window"
 		log.Println("Tray menu 'Show DevToolbox' clicked")
 		log.Printf("Window visible: %v, minimized: %v", mainWindow.IsVisible(), mainWindow.IsMinimised())
 
@@ -168,6 +255,10 @@ func main() {
 		mainWindow.Focus()
 		log.Printf("After show - Window visible: %v, minimized: %v", mainWindow.IsVisible(), mainWindow.IsMinimised())
 	})
+	trayMenu.Add("Open Spotlight (Cmd+Ctrl+M)").OnClick(func(ctx *application.Context) {
+		log.Println("Tray menu 'Open Spotlight' clicked")
+		spotlightService.Toggle()
+	})
 	trayMenu.AddSeparator()
 	trayMenu.Add("Quit").OnClick(func(ctx *application.Context) {
 		app.Quit()
@@ -184,10 +275,9 @@ func main() {
 	}
 
 	app.KeyBinding.Add(hotkeyAccelerator, func(window application.Window) {
-		mainWindow.Show()
-		mainWindow.Focus()
-		mainWindow.EmitEvent("command-palette:open", "")
+		spotlightService.Toggle()
 	})
+	// Note: Wails v3 doesn't return an error from KeyBinding.Add - errors are logged internally
 
 	if err := app.Run(); err != nil {
 		panic(err)
diff --git a/service/spotlight.go b/service/spotlight.go
new file mode 100644
index 0000000..bc04cd2
--- /dev/null
+++ b/service/spotlight.go
@@ -0,0 +1,71 @@
+package service
+
+import (
+	"github.com/wailsapp/wails/v3/pkg/application"
+)
+
+// SpotlightService manages the spotlight command palette window
+type SpotlightService struct {
+	window *application.WebviewWindow
+	app    *application.App
+}
+
+// NewSpotlightService creates a new spotlight service
+func NewSpotlightService(app *application.App) *SpotlightService {
+	return &SpotlightService{
+		app: app,
+	}
+}
+
+// SetWindow sets the spotlight window (called after window creation)
+func (s *SpotlightService) SetWindow(window *application.WebviewWindow) {
+	s.window = window
+}
+
+// Show shows the spotlight window and focuses it
+func (s *SpotlightService) Show() {
+	if s.window == nil {
+		return
+	}
+
+	s.window.Show()
+	s.window.Focus()
+	s.window.EmitEvent("spotlight:opened", "")
+}
+
+// Hide hides the spotlight window
+func (s *SpotlightService) Hide() {
+	if s.window == nil {
+		return
+	}
+
+	s.window.Hide()
+}
+
+// Toggle shows or hides the spotlight window
+func (s *SpotlightService) Toggle() {
+	if s.window == nil {
+		return
+	}
+
+	if s.window.IsVisible() {
+		s.Hide()
+	} else {
+		s.Show()
+	}
+}
+
+// IsVisible returns whether the spotlight window is visible
+func (s *SpotlightService) IsVisible() bool {
+	if s.window == nil {
+		return false
+	}
+	return s.window.IsVisible()
+}
+
+// Close closes the spotlight window
+func (s *SpotlightService) Close() {
+	if s.window != nil {
+		s.window.Close()
+	}
+}
diff --git a/service/spotlight_test.go b/service/spotlight_test.go
new file mode 100644
index 0000000..a3bff3b
--- /dev/null
+++ b/service/spotlight_test.go
@@ -0,0 +1,63 @@
+package service
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewSpotlightService(t *testing.T) {
+	t.Run("creates new service", func(t *testing.T) {
+		service := NewSpotlightService(nil)
+		assert.NotNil(t, service)
+	})
+}
+
+func TestSpotlightService_Operations(t *testing.T) {
+	tests := []struct {
+		name string
+		test func(t *testing.T, s *SpotlightService)
+	}{
+		{
+			name: "Toggle with nil window",
+			test: func(t *testing.T, s *SpotlightService) {
+				// Initially not visible
+				assert.False(t, s.IsVisible())
+
+				// Toggle should not panic with nil window
+				s.Toggle()
+				assert.False(t, s.IsVisible())
+			},
+		},
+		{
+			name: "Show with nil window",
+			test: func(t *testing.T, s *SpotlightService) {
+				// Should not panic with nil window
+				s.Show()
+				assert.False(t, s.IsVisible())
+			},
+		},
+		{
+			name: "Hide with nil window",
+			test: func(t *testing.T, s *SpotlightService) {
+				// Should not panic with nil window
+				s.Hide()
+				assert.False(t, s.IsVisible())
+			},
+		},
+		{
+			name: "IsVisible with nil window",
+			test: func(t *testing.T, s *SpotlightService) {
+				// Should return false with nil window
+				assert.False(t, s.IsVisible())
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			service := NewSpotlightService(nil)
+			tt.test(t, service)
+		})
+	}
+}
diff --git a/vite.config.js b/vite.config.js
index 96bd637..85c7b67 100644
--- a/vite.config.js
+++ b/vite.config.js
@@ -33,5 +33,13 @@ export default defineConfig({
       // Ensure @ibm/plex can be resolved
       '@ibm/plex': path.resolve(__dirname, 'node_modules/@ibm/plex')
     }
+  },
+  build: {
+    rollupOptions: {
+      input: {
+        main: path.resolve(__dirname, 'frontend/index.html'),
+        spotlight: path.resolve(__dirname, 'frontend/spotlight.html'),
+      },
+    },
   }
 })
\ No newline at end of file