@bobfrankston/msger 0.1.74 → 0.1.75

package/msger-native/bin/msgernative.exe.WebView2/EBWebView/Default/Cache/Cache_Data/f_000003

@@ -0,0 +1,2153 @@
+import { VoiceController, DEFAULT_VOICE_CONFIG } from './voice-controller.js';
+import { AIParser } from './ai-parser.js';
+import { addToDebugLog, addToDebugWarn, addToDebugErr, addToDebugPriority, toggleDebugLog, clearDebugLog, copyLogToClipboard, saveLogToFile, setAppVersion, isLogVisible } from './logging.js';
+import { loadSettings, saveSettings, applyLoadedSettings, resetSettings, applyTheme, initializeSettings, getShowDigitalTime, getSilentMode, getListeningTimeout, setShowDigitalTime, setSilentMode, setTheme, setListeningTimeout, setWasFullscreen } from './settings.js';
+import { initializeWeather, getCurrentTemperature } from './weather.js';
+import { watchForDSTChange } from './time-utils.js';
+// Helper to reduce repetitive getElementById calls
+function dv(id) {
+    return document.getElementById(id);
+}
+// Type-safe CSS class helpers
+function classAdd(element, ...classes) {
+    element.classList.add(...classes);
+}
+function classRemove(element, ...classes) {
+    element.classList.remove(...classes);
+}
+function classToggle(element, className, force) {
+    return element.classList.toggle(className, force);
+}
+// Get all DOM elements once at module level since script loads after HTML
+// Note: Banner elements accessed dynamically via banner-content container
+const startTimerBtn = dv('start-timer');
+const cancelTimerBtn = dv('cancel-timer');
+const floatingCancelBtn = dv('timer-cancel-floating');
+const timerCountdown = dv('timer-countdown');
+const timerMinutesInput = dv('timer-minutes');
+const timerSecondsInput = dv('timer-seconds');
+const hourMarkers = dv('hour-markers');
+const digitalTimeOverlay = dv('digital-time-overlay');
+const secondHand = dv('second-hand');
+const minuteHand = dv('minute-hand');
+const hourHand = dv('hour-hand');
+const countdownDots = dv('countdown-dots');
+const ampmIndicator = dv('ampm-indicator');
+const showDigitalCheckbox = dv('show-digital');
+const silentModeCheckbox = dv('silent-mode');
+const themeSelect = dv('theme-select');
+const voiceToggleBtn = dv('voice-toggle');
+// Module-level state
+let userTimer = {
+    active: false,
+    totalSeconds: 0,
+    remainingSeconds: 0,
+    startTime: 0
+};
+let timerAnnounced = false;
+let voice = {
+    enabled: true // Re-enabled for wall clock use
+};
+let voiceManuallyStopped = false;
+let lastVoiceActivity = Date.now();
+let voiceActivityTimeouts = 0;
+let lastCommand = '';
+let lastCommandTime = 0;
+let lastSpokenText = '';
+let lastSpokenTime = 0;
+let clockInterval = 0;
+let userTimerInterval = 0;
+let bannerCountdownInterval;
+let voiceListeningTimeoutInterval;
+let listeningTimeoutStart = 0;
+let listeningTimeoutDuration = 0;
+let isSpeakingHelp = false;
+let helpTimeoutInterval;
+// DST change tracking
+let dstChangeTimestamp = 0; // Timestamp of last DST change
+let dstStopWatcher; // Function to stop DST watcher
+// AI parsing configuration
+let aiParser;
+// App version tracking
+let appVersion = 'v0.0.0'; // Will be loaded from sw.js
+// Command canonicalization to prevent duplicate/misparsed commands
+let recentCommands = [];
+const COMMAND_DEDUP_WINDOW = 3000; // 3 seconds to prevent duplicates
+// Default inactivity policy - easy to modify
+const INACTIVITY_POLICY = {
+    hideAfterSeconds: 30, // Hide after 30 seconds
+    hideCursor: true, // Hide cursor when inactive
+    hideBanner: true, // Hide banner when inactive
+    fadeTransitionMs: 500, // 500ms fade transition
+    showOnWakeWord: true, // Show UI on wake word
+    showOnVoiceCommand: true // Show UI on voice commands
+};
+let inactivityTimer;
+let isUIHidden = false;
+let lastActivityTime = Date.now();
+let lastHideTime = 0;
+let inactivityCountdownInterval;
+// DST and timezone functions
+function getTimezoneAbbreviation() {
+    const now = new Date();
+    const dateStr = now.toLocaleString('en-US', { timeZoneName: 'short' });
+    const match = dateStr.match(/\b([A-Z]{3,5})\b/);
+    return match ? match[1] : '';
+}
+function shouldShowDSTNotification() {
+    if (dstChangeTimestamp === 0)
+        return false;
+    const hoursSinceChange = (Date.now() - dstChangeTimestamp) / (1000 * 60 * 60);
+    return hoursSinceChange < 24;
+}
+function handleDSTChange(newOffsetMinutes, oldOffsetMinutes) {
+    const tzAbbr = getTimezoneAbbreviation();
+    const offsetChange = oldOffsetMinutes - newOffsetMinutes; // Positive = spring forward
+    const changeType = offsetChange > 0 ? 'forward' : 'back';
+    addToDebugPriority(`[DST] Clock adjusted: ${changeType} (${Math.abs(offsetChange)} minutes) - Now ${tzAbbr}`);
+    // Store the timestamp for 24-hour notification
+    dstChangeTimestamp = Date.now();
+    try {
+        localStorage.setItem('wallclock-dst-change', dstChangeTimestamp.toString());
+    }
+    catch (error) {
+        addToDebugErr(`[DST] Error saving timestamp: ${error.message}`);
+    }
+    // Force UI update to show new timezone notification
+    updateAmPmIndicator(new Date());
+}
+// Inactivity management functions
+function resetInactivityTimer() {
+    lastActivityTime = Date.now();
+    if (isUIHidden) {
+        showUI();
+    }
+    // Clear existing timers
+    if (inactivityTimer !== null) {
+        clearTimeout(inactivityTimer);
+    }
+    if (inactivityCountdownInterval !== null) {
+        clearInterval(inactivityCountdownInterval);
+    }
+    // Update countdown display
+    const countdownEl = dv('inactivity-countdown');
+    if (countdownEl) {
+        countdownEl.textContent = `${INACTIVITY_POLICY.hideAfterSeconds}s`;
+    }
+    if (INACTIVITY_POLICY.hideAfterSeconds > 0) {
+        // Start countdown interval
+        inactivityCountdownInterval = window.setInterval(() => {
+            const elapsed = (Date.now() - lastActivityTime) / 1000;
+            const remaining = Math.max(0, INACTIVITY_POLICY.hideAfterSeconds - elapsed);
+            if (countdownEl) {
+                countdownEl.textContent = `${Math.ceil(remaining)}s`;
+            }
+            if (remaining <= 0) {
+                clearInterval(inactivityCountdownInterval);
+                inactivityCountdownInterval = null;
+            }
+        }, 100); // Update every 100ms for smooth countdown
+        inactivityTimer = window.setTimeout(() => {
+            hideUI();
+        }, INACTIVITY_POLICY.hideAfterSeconds * 1000);
+    }
+}
+function showUI() {
+    if (!isUIHidden)
+        return;
+    // Log the transition with stack trace to see what triggered it
+    const timestamp = new Date().toISOString();
+    addToDebugWarn(`[UI WAKE] UI transitioning from HIDDEN to VISIBLE at ${timestamp}`);
+    console.trace('[UI WAKE] Stack trace for UI activation:');
+    isUIHidden = false;
+    document.body.classList.remove('hide-cursor');
+    // Show fader elements
+    const faders = document.querySelectorAll('.fader');
+    faders.forEach(el => {
+        el.classList.remove('hidden');
+    });
+}
+function hideUI() {
+    if (isUIHidden)
+        return;
+    // Don't hide if timer is active or voice is actively listening
+    if (userTimer.active || microphoneState === 'listening') {
+        addToDebugLog(`[UI] Not hiding - timer active: ${userTimer.active}, mic state: ${microphoneState}`);
+        // Reset the timer to check again later
+        resetInactivityTimer();
+        return;
+    }
+    const timestamp = new Date().toISOString();
+    addToDebugWarn(`[UI HIDE] UI transitioning from VISIBLE to HIDDEN at ${timestamp}`);
+    isUIHidden = true;
+    lastHideTime = Date.now();
+    if (INACTIVITY_POLICY.hideCursor) {
+        document.body.classList.add('hide-cursor');
+        addToDebugLog('[UI] Cursor hidden');
+    }
+    if (INACTIVITY_POLICY.hideBanner) {
+        // Hide fader elements
+        const faders = document.querySelectorAll('.fader');
+        addToDebugLog(`[UI] Hiding ${faders.length} fader elements`);
+        faders.forEach(el => {
+            el.classList.add('hidden');
+            addToDebugLog(`[UI] Added 'hidden' to ${el.id || el.className}`);
+        });
+    }
+    // Ensure voice controller is still listening for wake words
+    if (voice.controller && voice.enabled) {
+        addToDebugLog(`[UI] Voice controller status: enabled=${voice.enabled}, state=${microphoneState}`);
+        if (microphoneState === 'waiting') {
+            addToDebugLog('[UI] Voice controller should be listening for wake words');
+        }
+        else {
+            addToDebugLog(`[UI] Voice controller state is ${microphoneState}, may need to restart wake word listening`);
+            // Ensure we're back to waiting/listening for wake words (direct update, don't wake UI)
+            microphoneState = 'waiting';
+            updateBannerDisplay();
+            voice.controller.startListening();
+        }
+    }
+    else {
+        addToDebugWarn('[UI] Voice controller not available while hiding UI');
+    }
+    addToDebugLog('[UI] UI hidden due to inactivity');
+}
+// Green indicator functions removed - wake word showing UI is sufficient feedback
+function cleanVoiceStatus() {
+    // Removed - not needed
+}
+function checkVoiceController() {
+    if (!voice.enabled) {
+        return; // Voice control is disabled, nothing to check
+    }
+    if (!voice.controller) {
+        addToDebugWarn('[VOICE CHECK] Voice controller missing - attempting to reinitialize');
+        initializeVoiceController();
+        return;
+    }
+    // Check if we should be in waiting state but aren't
+    if (microphoneState !== 'listening' && microphoneState !== 'waiting' && !userTimer.active) {
+        addToDebugWarn(`[VOICE CHECK] Voice controller in unexpected state: ${microphoneState} - resetting to waiting`);
+        // Directly update state without waking UI (this is automatic health check, not user activity)
+        microphoneState = 'waiting';
+        updateBannerDisplay();
+        voice.controller.startListening();
+        return;
+    }
+    // Critical: Check for silent voice controller death
+    const timeSinceActivity = Date.now() - lastVoiceActivity;
+    const maxSilentTime = 300000; // 5 minutes with no voice events = likely dead
+    if (timeSinceActivity > maxSilentTime && microphoneState === 'waiting') {
+        voiceActivityTimeouts++;
+        addToDebugPriority(`[VOICE CHECK] *** VOICE CONTROLLER APPEARS DEAD *** - No activity for ${Math.round(timeSinceActivity / 1000)}s (timeout #${voiceActivityTimeouts})`);
+        addToDebugPriority(`[VOICE CHECK] Attempting to restart voice controller...`);
+        // Force restart the voice controller - properly destroy old instance first
+        (async () => {
+            try {
+                // Properly shutdown the old controller before creating a new one
+                await shutdownVoiceController();
+                // Wait a bit for cleanup to complete
+                setTimeout(async () => {
+                    try {
+                        await initializeVoiceController();
+                        // Reset lastVoiceActivity to prevent immediate re-detection of death
+                        lastVoiceActivity = Date.now();
+                        addToDebugPriority(`[VOICE CHECK] Voice controller restarted after death detection`);
+                    }
+                    catch (restartError) {
+                        addToDebugErr(`[VOICE CHECK] Failed to restart voice controller: ${restartError.message}`);
+                    }
+                }, 1000);
+            }
+            catch (error) {
+                addToDebugErr(`[VOICE CHECK] Error stopping dead voice controller: ${error.message}`);
+            }
+        })();
+        return;
+    }
+    // Only log when there's been significant silence (reduces log spam during normal operation)
+    if (timeSinceActivity > 120000) { // Only log if silent for over 2 minutes
+        addToDebugLog(`[VOICE CHECK] Voice controller status: enabled=${voice.enabled}, state=${microphoneState}, controller=${!!voice.controller}, silent=${Math.round(timeSinceActivity / 1000)}s`);
+    }
+}
+function monitorVoiceStatus() {
+    // Removed - not needed
+}
+async function init() {
+    // Initialize AI parser
+    try {
+        await loadVersionFromServiceWorker();
+        aiParser = new AIParser({ enabled: false, service: 'openai', apiKey: '' }, (message) => addToDebugLog(message));
+        // Note: Removed console.log override to avoid line number confusion and violations
+        initializeSettings(aiParser, voice); // Initialize settings with dependencies
+        loadSettings(); // Load settings before initializing
+        addToDebugLog('WallClock app starting...');
+        // Check voice controller health periodically
+        setInterval(checkVoiceController, 10000); // Check voice controller every 10 seconds
+        // Initialize weather system
+        await initializeWeather();
+        // Load and start DST watcher
+        try {
+            const savedDSTTimestamp = localStorage.getItem('wallclock-dst-change');
+            if (savedDSTTimestamp) {
+                dstChangeTimestamp = parseInt(savedDSTTimestamp, 10);
+            }
+            addToDebugLog(`[DST] Starting DST watcher (last change: ${dstChangeTimestamp ? new Date(dstChangeTimestamp).toLocaleString() : 'never'})`);
+            dstStopWatcher = watchForDSTChange(handleDSTChange, 60000); // Check every minute
+        }
+        catch (error) {
+            addToDebugErr(`[DST] Error initializing DST watcher: ${error.message}`);
+        }
+        //        addToDebugLog(`[VERSION] WallClock v${app_version}`, '#e8f5e8'); // Light green background
+        // Debug AI parser configuration
+        const aiConfig = aiParser.getConfig();
+        addToDebugLog(`[AI INIT] AI Parser - enabled: ${aiConfig.enabled}, hasApiKey: ${!!aiConfig.apiKey}, service: ${aiConfig.service}, available: ${aiParser.isAvailable()}`);
+        if (aiConfig.apiKey && aiConfig.apiKey.length > 10) {
+            addToDebugLog(`[AI INIT] API Key: ${aiConfig.apiKey.substring(0, 10)}...`);
+        }
+        // Initialize async components first
+        // await initializeElements();
+        initializeClock();
+        setupEventListeners();
+        startClockAnimation();
+        addToDebugLog('Clock animation started');
+        await initializeVoiceController();
+        addToDebugLog('Voice controller initialized');
+        // Refresh microphone list after voice controller is initialized
+        if (voice.controller && voice.enabled) {
+            await refreshMicrophoneList();
+        }
+        // Check initial install button state
+        updateInstallButtonVisibility();
+        // Fullscreen restoration handled by PWA manifest display mode
+    }
+    catch (error) {
+        addToDebugErr(`[VOICE ERROR] Failed to initialize: ${error.message}`);
+        alert(`Error initializing ${error.message}`);
+    }
+}
+async function initializeElements() {
+    // Read version from service worker file
+    await loadVersionFromServiceWorker();
+    document.title = `Wall Clock - ${appVersion}`;
+    addToDebugPriority(`Version ${appVersion}`, '#2e7d32');
+    // Update version display in HTML
+    dv('version-box').textContent = appVersion;
+    addToDebugLog('Element references initialized');
+}
+async function loadVersionFromServiceWorker() {
+    try {
+        addToDebugLog('[SW] Loading version from sw.js');
+        const response = await fetch('./sw.js', {
+            cache: 'no-cache'
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        const swCode = await response.text();
+        // Extract version from service worker code
+        const versionMatch = swCode.match(/const CACHE_VERSION = '([^']+)'/);
+        if (versionMatch) {
+            appVersion = `v${versionMatch[1]}`;
+            setAppVersion(appVersion);
+            dv('version-box').textContent = appVersion;
+            document.title = `Wall Clock ${appVersion}`;
+            addToDebugPriority(`[SW] Version loaded: ${appVersion}`);
+        }
+        else {
+            appVersion = 'v?.???';
+            setAppVersion(appVersion);
+            addToDebugWarn('[SW] Could not extract version from service worker');
+        }
+    }
+    catch (error) {
+        // NON-FATAL: App can work without version from service worker
+        appVersion = 'v1.308'; // Fallback to hardcoded version
+        setAppVersion(appVersion);
+        dv('version-box').textContent = appVersion + ' (offline)';
+        document.title = `Wall Clock ${appVersion}`;
+        // Log appropriate error message based on error type
+        if (error.name === 'TypeError' && error.message.includes('Failed to fetch')) {
+            addToDebugWarn('[SW] Cannot load version - app running offline or no server available');
+        }
+        else {
+            addToDebugErr(`[SW] Failed to load version from service worker: ${error.message}`);
+        }
+        // App continues to work normally in offline mode
+        addToDebugLog('[SW] App will continue in offline mode with fallback version');
+    }
+}
+async function handleFatalError(reason) {
+    try {
+        addToDebugErr(`[FATAL] ${reason} - Unregistering service worker`);
+        if ('serviceWorker' in navigator) {
+            const registrations = await navigator.serviceWorker.getRegistrations();
+            for (const registration of registrations) {
+                addToDebugLog(`[FATAL] Unregistering service worker: ${registration.scope}`);
+                await registration.unregister();
+            }
+            addToDebugLog(`[FATAL] All service workers unregistered`);
+        }
+    }
+    catch (error) {
+        addToDebugErr(`[FATAL] Failed to unregister service worker: ${error.message}`);
+    }
+}
+function initializeClock() {
+    const hourMarkers = dv('hour-markers');
+    for (let i = 1; i <= 12; i++) {
+        const angle = (i * 30 - 90) * Math.PI / 180;
+        const x = 200 + 160 * Math.cos(angle);
+        const y = 200 + 160 * Math.sin(angle);
+        const text = document.createElementNS('http://www.w3.org/2000/svg', 'text');
+        text.setAttribute('x', x.toString());
+        text.setAttribute('y', (y + 10).toString());
+        text.setAttribute('text-anchor', 'middle');
+        text.setAttribute('font-size', '28');
+        text.setAttribute('font-family', 'var(--clock-font)');
+        text.setAttribute('fill', 'var(--clock-numbers)');
+        text.textContent = i.toString();
+        hourMarkers.appendChild(text);
+        const tickLength = i % 3 === 0 ? 15 : 8;
+        const tickStart = 190 - tickLength;
+        const tick = document.createElementNS('http://www.w3.org/2000/svg', 'line');
+        tick.setAttribute('x1', (200 + tickStart * Math.cos(angle)).toString());
+        tick.setAttribute('y1', (200 + tickStart * Math.sin(angle)).toString());
+        tick.setAttribute('x2', (200 + 190 * Math.cos(angle)).toString());
+        tick.setAttribute('y2', (200 + 190 * Math.sin(angle)).toString());
+        tick.setAttribute('stroke-width', i % 3 === 0 ? '3' : '1');
+        tick.classList.add('hour-markers');
+        hourMarkers.appendChild(tick);
+    }
+    for (let i = 0; i < 60; i++) {
+        if (i % 5 !== 0) {
+            const angle = (i * 6 - 90) * Math.PI / 180;
+            const tick = document.createElementNS('http://www.w3.org/2000/svg', 'line');
+            tick.setAttribute('x1', (200 + 185 * Math.cos(angle)).toString());
+            tick.setAttribute('y1', (200 + 185 * Math.sin(angle)).toString());
+            tick.setAttribute('x2', (200 + 190 * Math.cos(angle)).toString());
+            tick.setAttribute('y2', (200 + 190 * Math.sin(angle)).toString());
+            tick.setAttribute('stroke-width', '0.5');
+            tick.classList.add('minute-markers');
+            hourMarkers.appendChild(tick);
+        }
+    }
+    // Initialize static timer dots
+    initializeStaticDots();
+}
+// PWA Install functionality
+let deferredPrompt = null;
+function setupEventListeners() {
+    const onclick = (id, handler) => { dv(id).addEventListener('click', handler); };
+    // Track user activity with debouncing to prevent immediate re-trigger
+    const handleActivity = (e) => {
+        const timeSinceHide = Date.now() - lastHideTime;
+        const eventType = e.type;
+        const eventTarget = e.target?.tagName || 'unknown';
+        // Ignore ALL activity when debug log is visible (except Ctrl+L to close it)
+        if (isLogVisible()) {
+            // Only special case is Ctrl+L which toggles the log
+            if (eventType === 'keydown') {
+                const keyEvent = e;
+                if ((keyEvent.ctrlKey || keyEvent.metaKey) && keyEvent.key.toLowerCase() === 'l') {
+                    // Allow Ctrl+L through but don't reset inactivity timer
+                    return;
+                }
+            }
+            // Ignore all other activity while log is visible
+            return;
+        }
+        // Don't reset if we just hid the UI (within 1 second)
+        if (isUIHidden && timeSinceHide < 1000) {
+            addToDebugLog(`[UI] Ignoring ${eventType} on ${eventTarget} - too soon after hide (${timeSinceHide}ms)`);
+            return;
+        }
+        // Only log if UI was hidden (state change)
+        if (isUIHidden) {
+            addToDebugLog(`[UI] Activity detected: ${eventType} on ${eventTarget} - showing UI (${timeSinceHide}ms after hide)`);
+        }
+        resetInactivityTimer();
+    };
+    document.addEventListener('mousemove', handleActivity);
+    document.addEventListener('keydown', handleActivity);
+    document.addEventListener('touchstart', handleActivity);
+    document.addEventListener('click', handleActivity);
+    // Start inactivity timer
+    resetInactivityTimer();
+    // const settingsToggle = dv('settings-toggle');
+    const settingsPanel = dv('settings-panel');
+    const showDigitalCheckbox = dv('show-digital');
+    const silentModeCheckbox = dv('silent-mode');
+    const themeSelect = dv('theme-select');
+    const helpDialog = dv('help-dialog');
+    // settingsToggle.addEventListener('click', () => {
+    //     settingsPanel.classList.toggle('collapsed');
+    // });
+    onclick('settings-toggle', () => settingsPanel.classList.toggle('collapsed'));
+    onclick('start-timer', () => {
+        const minutes = parseInt(timerMinutesInput.value || '0') || 0;
+        const seconds = parseInt(timerSecondsInput.value || '0') || 0;
+        startUserTimer(minutes * 60 + seconds);
+    });
+    onclick('cancel-timer', () => cancelUserTimer());
+    onclick('timer-cancel-floating', () => cancelUserTimer());
+    onclick('voice-toggle', () => toggleVoiceControl());
+    onclick('install-button', () => handleInstallClick());
+    // Microphone selection event listeners
+    dv('microphone-select').addEventListener('change', () => {
+        handleMicrophoneChange();
+    });
+    dv('refresh-microphones').addEventListener('click', () => {
+        refreshMicrophoneList();
+    });
+    showDigitalCheckbox.addEventListener('change', () => {
+        setShowDigitalTime(showDigitalCheckbox.checked);
+        if (dv('digital-time-overlay')) {
+            dv('digital-time-overlay').style.display = getShowDigitalTime() ? 'block' : 'none';
+        }
+        saveSettings();
+    });
+    silentModeCheckbox.addEventListener('change', () => {
+        setSilentMode(silentModeCheckbox.checked);
+        saveSettings();
+    });
+    themeSelect.addEventListener('change', () => {
+        setTheme(themeSelect.value);
+        applyTheme();
+        saveSettings();
+    });
+    const listeningTimeoutInput = dv('listening-timeout');
+    listeningTimeoutInput.addEventListener('change', () => {
+        setListeningTimeout(parseInt(listeningTimeoutInput.value) || 15);
+        saveSettings();
+    });
+    // Click events are now handled by VoiceController module
+    onclick('log-toggle', () => toggleDebugLog());
+    onclick('clear-log', () => clearDebugLog());
+    // Help dialog listeners
+    onclick('help-close', () => closeHelpDialog());
+    helpDialog.addEventListener('click', (event) => {
+        if (event.target === helpDialog) {
+            closeHelpDialog();
+        }
+    });
+    onclick('banner-listening', () => {
+        if (microphoneState === 'listening') {
+            showHelpDialog();
+        }
+    });
+    // Reset settings button
+    onclick('reset-settings', () => {
+        if (confirm('Reset all settings to default values? This cannot be undone.')) {
+            resetSettings();
+        }
+    });
+    // Apply loaded settings to UI after event listeners are set up
+    applyLoadedSettings();
+    // AI Configuration event listeners
+    const aiParsingCheckbox = dv('ai-parsing');
+    const aiConfigDiv = dv('ai-config');
+    const aiServiceSelect = dv('ai-service');
+    const aiApiKeyInput = dv('ai-api-key');
+    if (aiParsingCheckbox) {
+        aiParsingCheckbox.addEventListener('change', () => {
+            aiParser.updateConfig({ enabled: aiParsingCheckbox.checked });
+            if (aiConfigDiv) {
+                aiConfigDiv.classList.toggle('hidden', !aiParsingCheckbox.checked);
+            }
+            saveSettings();
+            addToDebugLog(`[AI CONFIG] AI parsing ${aiParsingCheckbox.checked ? 'enabled' : 'disabled'}`);
+        });
+    }
+    if (aiServiceSelect) {
+        aiServiceSelect.addEventListener('change', () => {
+            aiParser.updateConfig({ service: aiServiceSelect.value });
+            saveSettings();
+            addToDebugLog(`[AI CONFIG] Service changed to ${aiServiceSelect.value}`);
+        });
+    }
+    if (aiApiKeyInput) {
+        aiApiKeyInput.addEventListener('input', () => {
+            aiParser.updateConfig({ apiKey: aiApiKeyInput.value });
+            saveSettings();
+            addToDebugLog(`[AI CONFIG] API key ${aiApiKeyInput.value ? 'set' : 'cleared'}`);
+        });
+    }
+    // Click outside settings panel to close it
+    document.addEventListener('click', (event) => {
+        const settingsPanel = dv('settings-panel');
+        const settingsToggle = dv('settings-toggle');
+        const debugLog = dv('debug-log');
+        const logToggle = dv('log-toggle');
+        // Close settings panel
+        if (!settingsPanel.contains(event.target) &&
+            !settingsToggle.contains(event.target) &&
+            !settingsPanel.classList.contains('collapsed')) {
+            settingsPanel.classList.add('collapsed');
+        }
+        // Close debug log
+        if (!debugLog.contains(event.target) &&
+            !logToggle.contains(event.target) &&
+            isLogVisible()) {
+            toggleDebugLog();
+        }
+    });
+    document.addEventListener('fullscreenchange', () => {
+        const isFullscreen = !!document.fullscreenElement;
+        if (isFullscreen) {
+            settingsPanel.classList.add('collapsed');
+            addToDebugLog('[FULLSCREEN] Entered fullscreen mode');
+        }
+        else {
+            addToDebugLog('[FULLSCREEN] Exited fullscreen mode');
+        }
+        // Save fullscreen state for next startup
+        setWasFullscreen(isFullscreen);
+        saveSettings();
+    });
+    document.addEventListener('dblclick', () => {
+        if (!document.fullscreenElement) {
+            addToDebugLog('[FULLSCREEN] Double-click: attempting to enter fullscreen');
+            // Check for browser support
+            const docEl = document.documentElement;
+            const requestFullscreen = docEl.requestFullscreen ||
+                docEl.webkitRequestFullscreen ||
+                docEl.mozRequestFullScreen ||
+                docEl.msRequestFullscreen;
+            if (requestFullscreen) {
+                requestFullscreen.call(docEl).then(() => {
+                    addToDebugLog('[FULLSCREEN] Double-click: successfully entered fullscreen');
+                }).catch((error) => {
+                    addToDebugErr(`[FULLSCREEN] Double-click: failed to enter fullscreen: ${error.message}`);
+                });
+            }
+            else {
+                addToDebugErr('[FULLSCREEN] Double-click: Fullscreen API not supported');
+            }
+        }
+        else {
+            addToDebugLog('[FULLSCREEN] Double-click: exiting fullscreen');
+            document.exitFullscreen();
+        }
+    });
+    // Keyboard shortcuts - Ctrl+L opens/toggles log, Ctrl+C/F work when visible, ESC closes
+    // Use capture phase to handle before the activity listener
+    document.addEventListener('keydown', (event) => {
+        if ((event.ctrlKey || event.metaKey) && event.key === 'l') {
+            event.preventDefault(); // Prevent browser address bar focus
+            event.stopPropagation(); // Don't let this trigger handleActivity
+            event.stopImmediatePropagation(); // Really stop it from reaching other handlers
+            // Ctrl+L always works to toggle the log open/closed
+            if (!isLogVisible()) {
+                addToDebugLog('[CTRL+L] Opening debug log');
+            }
+            else {
+                addToDebugLog('[CTRL+L] Closing debug log');
+            }
+            toggleDebugLog();
+        }
+        else if ((event.ctrlKey || event.metaKey) && event.key === 'c') {
+            // Only handle if debug log is visible
+            if (isLogVisible()) {
+                addToDebugLog('[CLIPBOARD] Ctrl+C pressed - calling copyLogToClipboard');
+                copyLogToClipboard();
+            }
+        }
+        else if ((event.ctrlKey || event.metaKey) && event.key === 'f') {
+            // Only handle if debug log is visible
+            if (isLogVisible()) {
+                event.preventDefault(); // Prevent browser find dialog
+                addToDebugLog('[FILE] Ctrl+F pressed - calling saveLogToFile');
+                saveLogToFile();
+                // Don't close the dialog - let user continue viewing
+            }
+        }
+        else if (event.key === 'Escape') {
+            // Close debug log if it's visible, or exit fullscreen
+            if (isLogVisible()) {
+                event.preventDefault();
+                addToDebugLog('[ESC] Closing debug log');
+                toggleDebugLog();
+            }
+            else if (document.fullscreenElement) {
+                event.preventDefault();
+                addToDebugLog('[ESC] Exiting fullscreen');
+                document.exitFullscreen();
+            }
+        }
+    }, { capture: true }); // Handle in capture phase before activity listener
+}
+function startClockAnimation() {
+    // Initialize clock hands with CSS animations
+    initializeClockHandsCSS();
+    // Update digital display and dots every second
+    clockInterval = window.setInterval(() => {
+        updateDigitalDisplay();
+        updateAmPmIndicator(new Date());
+    }, 1000);
+    // Initial update
+    updateDigitalDisplay();
+    updateAmPmIndicator(new Date());
+    // Force service worker update in development
+    if ('serviceWorker' in navigator) {
+        navigator.serviceWorker.getRegistration().then(registration => {
+            if (registration) {
+                registration.update();
+            }
+        });
+    }
+}
+function initializeClockHandsCSS() {
+    const now = new Date();
+    const hours = now.getHours() % 12;
+    const minutes = now.getMinutes();
+    const seconds = now.getSeconds() + now.getMilliseconds() / 1000;
+    // Just set CSS custom properties for the initial time offsets
+    // Let CSS handle all the animations
+    const clockSvg = dv('analog-clock');
+    clockSvg.style.setProperty('--seconds-offset', `-${seconds}s`);
+    clockSvg.style.setProperty('--minutes-offset', `-${minutes * 60 + seconds}s`);
+    clockSvg.style.setProperty('--hours-offset', `-${(hours * 3600) + (minutes * 60) + seconds}s`);
+}
+function updateDigitalDisplay() {
+    const now = new Date();
+    const hours = now.getHours();
+    const minutes = now.getMinutes();
+    const seconds = now.getSeconds();
+    if (getShowDigitalTime() && dv('digital-time-overlay')) {
+        const hoursStr = hours.toString().padStart(2, '0');
+        const minutesStr = minutes.toString().padStart(2, '0');
+        const secondsStr = seconds.toString().padStart(2, '0');
+        dv('digital-time-overlay').textContent = `${hoursStr}:${minutesStr}:${secondsStr}`;
+    }
+}
+function updateAmPmIndicator(now) {
+    const ampmElement = ampmIndicator;
+    if (ampmElement) {
+        const hours24 = now.getHours();
+        const ampm = hours24 >= 12 ? 'PM' : 'AM';
+        ampmElement.textContent = ampm;
+        // Add distinctive styling classes
+        if (hours24 >= 12) {
+            ampmElement.classList.remove('am');
+            ampmElement.classList.add('pm');
+        }
+        else {
+            ampmElement.classList.remove('pm');
+            ampmElement.classList.add('am');
+        }
+    }
+}
+function startUserTimer(seconds) {
+    addToDebugPriority(`[TIMER] *** START TIMER CALLED *** - seconds: ${seconds}`);
+    if (seconds <= 0) {
+        addToDebugPriority(`[TIMER] *** TIMER START REJECTED *** - invalid seconds: ${seconds}`);
+        return;
+    }
+    userTimer = {
+        active: true,
+        totalSeconds: seconds,
+        remainingSeconds: seconds,
+        startTime: Date.now()
+    };
+    addToDebugPriority(`[TIMER] *** TIMER STARTED SUCCESSFULLY *** - ${Math.floor(seconds / 60)}:${(seconds % 60).toString().padStart(2, '0')} (${seconds}s total)`);
+    if (startTimerBtn)
+        startTimerBtn.disabled = true;
+    if (cancelTimerBtn)
+        cancelTimerBtn.disabled = false;
+    // Show floating cancel button and countdown display
+    floatingCancelBtn.classList.remove('hidden');
+    floatingCancelBtn.classList.add('active');
+    timerCountdown.classList.add('visible');
+    createCountdownDots();
+    updateCountdownDisplay();
+    // Start updating the banner with a live countdown
+    updateBannerCountdown();
+    // Update timer every second instead of 60fps
+    if (userTimerInterval)
+        clearInterval(userTimerInterval);
+    userTimerInterval = window.setInterval(() => {
+        if (userTimer.active) {
+            updateUserTimer();
+        }
+        else {
+            clearInterval(userTimerInterval);
+            userTimerInterval = 0;
+        }
+    }, 1000);
+    addToDebugPriority('[TIMER] *** TIMER INTERVAL STARTED ***');
+}
+function cancelUserTimer() {
+    addToDebugPriority(`[TIMER] *** TIMER CANCELLED *** - was active: ${userTimer.active}, remaining: ${userTimer.remainingSeconds}s`);
+    userTimer.active = false;
+    timerAnnounced = false; // Reset announcement flag
+    clearCountdownDots();
+    // Clear timer interval
+    if (userTimerInterval) {
+        clearInterval(userTimerInterval);
+        userTimerInterval = 0;
+    }
+    // Hide floating cancel button and countdown display
+    floatingCancelBtn.classList.add('hidden');
+    floatingCancelBtn.classList.remove('active');
+    timerCountdown.classList.remove('visible');
+    if (startTimerBtn)
+        startTimerBtn.disabled = false;
+    if (cancelTimerBtn)
+        cancelTimerBtn.disabled = true;
+    // Clear banner countdown interval if present
+    if (bannerCountdownInterval) {
+        clearInterval(bannerCountdownInterval);
+        bannerCountdownInterval = null;
+    }
+    // Clear progress bar display
+    // Resume wake word listening after timer cancel
+    if (voice.controller && voice.enabled) {
+        voice.controller.startListening();
+        addToDebugLog('[VOICE] Resumed wake word listening after timer cancel');
+        setBannerState('waiting');
+    }
+}
+let lastTimerUpdateTime = 0;
+function updateUserTimer() {
+    const elapsed = (Date.now() - userTimer.startTime) / 1000;
+    userTimer.remainingSeconds = Math.max(0, userTimer.totalSeconds - elapsed);
+    // Use <= instead of === to handle floating point precision issues
+    if (userTimer.remainingSeconds <= 0) {
+        userTimerComplete();
+    }
+    else {
+        // Throttle timer updates to reduce performance impact
+        const now = Date.now();
+        if (now - lastTimerUpdateTime > 100) { // Update max 10 times per second
+            updateCountdownDots();
+            updateCountdownDisplay();
+            lastTimerUpdateTime = now;
+        }
+    }
+}
+function initializeStaticDots() {
+    countdownDots.innerHTML = '';
+    // Create all 60 dots positioned at second marks
+    for (let i = 0; i < 60; i++) {
+        const angle = (i * 6 - 90) * Math.PI / 180; // Every 6 degrees starting at 12 o'clock
+        const dot = document.createElementNS('http://www.w3.org/2000/svg', 'circle');
+        dot.setAttribute('cx', (200 + 195 * Math.cos(angle)).toString());
+        dot.setAttribute('cy', (200 + 195 * Math.sin(angle)).toString());
+        dot.setAttribute('r', '3');
+        dot.classList.add('countdown-dot');
+        dot.dataset.second = i.toString();
+        countdownDots.appendChild(dot);
+    }
+    addToDebugLog(`[DOTS INIT] Created 60 static dots`);
+}
+function createCountdownDots() {
+    // Just set the CSS custom property - CSS will compute everything else
+    countdownDots.style.setProperty('--timer-remaining', userTimer.totalSeconds.toString());
+    addToDebugLog(`[DOTS] Timer started - set --timer-remaining: ${userTimer.totalSeconds}s`);
+}
+function updateCountdownDots() {
+    const container = countdownDots;
+    const remainingSeconds = Math.ceil(userTimer.remainingSeconds);
+    const dots = container.querySelectorAll('.countdown-dot');
+    if (remainingSeconds > 60) {
+        // Minutes mode: show red dots for remaining minutes starting from 12 o'clock
+        const remainingMinutes = Math.floor(remainingSeconds / 60);
+        dots.forEach((dot) => {
+            const second = parseInt(dot.getAttribute('data-second') || '0');
+            // Show exactly remainingMinutes dots: positions 0, 1, 2, ... up to remainingMinutes-1
+            if (second < remainingMinutes) {
+                dot.style.setProperty('--dot-opacity', '1');
+                dot.style.setProperty('--dot-color', 'var(--timer-minutes-color)');
+            }
+            else {
+                dot.style.setProperty('--dot-opacity', '0.1');
+                dot.style.setProperty('--dot-color', 'var(--timer-seconds-color)');
+            }
+        });
+        // Don't clutter the log
+        // addToDebugLog(`[DOTS] Minutes mode: ${remainingMinutes} minutes remaining`);
+    }
+    else {
+        // Seconds mode: show yellow dots for remaining seconds
+        dots.forEach((dot) => {
+            const second = parseInt(dot.getAttribute('data-second') || '0');
+            if (second < remainingSeconds) {
+                dot.style.setProperty('--dot-opacity', '1');
+                dot.style.setProperty('--dot-color', 'var(--timer-seconds-color)');
+            }
+            else {
+                dot.style.setProperty('--dot-opacity', '0.1');
+                dot.style.setProperty('--dot-color', 'var(--timer-seconds-color)');
+            }
+        });
+        // DOn't clutter the log
+        // addToDebugLog(`[DOTS] Seconds mode: ${remainingSeconds} seconds remaining`);
+    }
+}
+function clearCountdownDots() {
+    const container = countdownDots;
+    if (container) {
+        // Clear individual dot properties
+        const dots = container.querySelectorAll('.countdown-dot');
+        dots.forEach((dot) => {
+            dot.style.removeProperty('--dot-opacity');
+            dot.style.removeProperty('--dot-color');
+        });
+        addToDebugLog('[DOTS] Cleared all dot properties');
+    }
+}
+function updateCountdownDisplay() {
+    const countdownElement = timerCountdown;
+    if (!countdownElement)
+        return;
+    const remaining = Math.ceil(userTimer.remainingSeconds);
+    if (remaining > 0) {
+        const minutes = Math.floor(remaining / 60);
+        const seconds = remaining % 60;
+        // Always show mm:ss format
+        countdownElement.textContent = `${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`;
+        // Change color in final 10 seconds
+        if (remaining <= 10) {
+            countdownElement.setAttribute('fill', 'var(--timer-seconds-color)');
+        }
+        else {
+            countdownElement.setAttribute('fill', 'var(--timer-minutes-color)');
+        }
+    }
+}
+function formatMmSs(seconds) {
+    const m = Math.floor(seconds / 60);
+    const s = Math.floor(seconds % 60);
+    const mm = m.toString().padStart(2, '0');
+    const ss = s.toString().padStart(2, '0');
+    return `${mm}:${ss}`;
+}
+let lastBannerUpdate = 0;
+// Banner system (see md/stopfuckingup.md for principles):
+// - All banners are in the same div
+// - Only ONE banner is active at a time
+// - Coloring is done using CSS classes with NO JavaScript
+// - This routine has NO parameters and chooses the appropriate banner for current conditions
+let microphoneState = 'unavailable';
+function updateBannerDisplay() {
+    // Show UI on state changes if configured
+    if (INACTIVITY_POLICY.showOnVoiceCommand && isUIHidden) {
+        showUI();
+    }
+    const banners = dv('banner-content').getElementsByTagName('div');
+    [...banners].forEach(b => b.classList.remove('active'));
+    // CRITICAL: Always clear any existing listening timeout to prevent interval leaks
+    // This must happen even if state hasn't changed, because listeningStarted can fire multiple times
+    if (voiceListeningTimeoutInterval) {
+        clearInterval(voiceListeningTimeoutInterval);
+        voiceListeningTimeoutInterval = null;
+        addToDebugLog('[BANNER] Cleared existing listening timeout interval');
+    }
+    // Hide progress bar when changing states
+    const progressContainer = dv('progress-container');
+    if (progressContainer) {
+        progressContainer.classList.add('hidden');
+    }
+    // Set active on the appropriate banner using the same dynamic approach
+    const bannerId = microphoneState === 'denied' ? 'banner-unavailable' : `banner-${microphoneState}`;
+    const targetBanner = dv(bannerId);
+    if (targetBanner) {
+        targetBanner.classList.add('active');
+        // Start listening timeout only for listening state
+        if (microphoneState === 'listening') {
+            startListeningTimeout(getListeningTimeout(), bannerId);
+        }
+    }
+}
+function setBannerState(state) {
+    const previousState = microphoneState;
+    // Special case: if setting to 'listening' state (even if already listening),
+    // allow it through so updateBannerDisplay() can restart the progress bar properly
+    // The interval clearing is handled in updateBannerDisplay()
+    if (state === 'listening' && previousState === 'listening') {
+        addToDebugLog(`[BANNER] ${previousState} → ${state} (duplicate listening state - will restart progress bar)`, 'orange');
+        // Don't return early - let updateBannerDisplay() handle it properly
+    }
+    else if (previousState === state) {
+        // Don't update if state hasn't changed (prevents spurious UI wake)
+        addToDebugLog(`[BANNER] ${previousState} → ${state} (no change)`, 'blue');
+        return;
+    }
+    microphoneState = state;
+    // Log banner state change
+    addToDebugLog(`[BANNER] ${previousState} → ${state}`, 'blue');
+    updateBannerDisplay();
+}
+function startListeningTimeout(durationSeconds, bannerId, continueFromPrevious = false) {
+    // Clear any existing timeout interval
+    if (voiceListeningTimeoutInterval) {
+        clearInterval(voiceListeningTimeoutInterval);
+    }
+    // Get the current active banner based on state, not hardcode based on bannerId
+    const bannerMap = {
+        'banner-unavailable': dv('banner-unavailable'),
+        'banner-waiting': dv('banner-waiting'),
+        'banner-listening': dv('banner-listening'),
+        'banner-speech-blocked': dv('banner-speech-blocked'),
+        'banner-disabled': dv('banner-disabled')
+    };
+    const banner = bannerMap[bannerId];
+    if (!banner)
+        return;
+    // Find the shared progress bar container
+    const progressContainer = dv('progress-container');
+    const progressBar = progressContainer?.querySelector('.timeout-progress-bar');
+    if (!progressContainer || !progressBar)
+        return;
+    // Show the progress container only for listening banner
+    if (bannerId === 'banner-listening') {
+        progressContainer.classList.remove('hidden');
+    }
+    // If continuing, keep the original start time and duration
+    if (!continueFromPrevious || listeningTimeoutStart === 0) {
+        listeningTimeoutStart = Date.now();
+        listeningTimeoutDuration = durationSeconds * 1000;
+        addToDebugLog(`[LISTENING TIMEOUT] Started ${durationSeconds}s timeout at ${new Date().toLocaleTimeString()}`);
+        // Show initial progress (full width, will decrease)
+        if (progressBar) {
+            progressBar.style.width = '100%';
+        }
+    }
+    else {
+        const elapsed = Date.now() - listeningTimeoutStart;
+        addToDebugLog(`[LISTENING TIMEOUT] Continuing with ${Math.ceil((listeningTimeoutDuration - elapsed) / 1000)}s remaining`);
+    }
+    // Update progress bar every 100ms
+    voiceListeningTimeoutInterval = window.setInterval(() => {
+        // Safety check: if we're not in listening state anymore, clear the interval
+        if (microphoneState !== 'listening') {
+            const elapsed = Date.now() - listeningTimeoutStart;
+            addToDebugWarn(`[VOICE TIMEOUT] ABORTED EARLY after ${(elapsed / 1000).toFixed(1)}s - state changed to ${microphoneState}`);
+            if (voiceListeningTimeoutInterval) {
+                clearInterval(voiceListeningTimeoutInterval);
+                voiceListeningTimeoutInterval = null;
+            }
+            return;
+        }
+        const elapsed = Date.now() - listeningTimeoutStart;
+        const remainingPercent = Math.max(0, 100 - (elapsed / listeningTimeoutDuration) * 100);
+        const remainingSeconds = Math.ceil((listeningTimeoutDuration - elapsed) / 1000);
+        if (progressBar) {
+            progressBar.style.width = `${remainingPercent}%`;
+        }
+        // Log when we hit 0 seconds to track the "blue banner with 0s" issue
+        if (remainingSeconds === 0 && elapsed < listeningTimeoutDuration) {
+            addToDebugLog(`[LISTENING TIMEOUT] Progress at 0s (elapsed: ${(elapsed / 1000).toFixed(1)}s, banner state: ${microphoneState})`);
+        }
+        // Do not update banner text - keep it static per md/stopfuckingup.md
+        if (elapsed >= listeningTimeoutDuration) {
+            // Timeout reached - clean up first, then transition
+            const actualDuration = elapsed / 1000;
+            const expectedDuration = listeningTimeoutDuration / 1000;
+            if (voiceListeningTimeoutInterval) {
+                clearInterval(voiceListeningTimeoutInterval);
+                voiceListeningTimeoutInterval = null;
+            }
+            // Hide progress bar immediately
+            progressBar.style.width = '0%';
+            progressContainer.classList.add('hidden');
+            listeningTimeoutStart = 0;
+            addToDebugLog(`[LISTENING TIMEOUT] Completed after ${actualDuration.toFixed(1)}s (expected ${expectedDuration}s)`);
+            // Transition back to waiting state (blue banner) - do this AFTER hiding progress
+            setBannerState('waiting');
+            // Resume listening for wake words after timeout
+            if (voice.controller) {
+                voice.controller.startListening();
+                addToDebugLog('[VOICE] Resumed wake word listening after timeout');
+            }
+            // Hide UI and cursor after listening timeout expires
+            hideUI();
+            addToDebugLog('[UI] Hidden after listening timeout expired');
+        }
+    }, 100);
+}
+function updateBannerCountdown() {
+    // This method is no longer needed since we don't show timer in the banner
+    // Keeping it empty for backward compatibility
+}
+function isCanonicalCommand(commandType, seconds) {
+    // Check for duplicate/similar timer commands within the deduplication window
+    // This prevents "timer 5 minutes" and "timer 300 seconds" from being parsed as separate commands
+    const now = Date.now();
+    const canonical = `timer:${seconds}`;
+    // Clean up old commands
+    recentCommands = recentCommands.filter(cmd => now - cmd.timestamp < COMMAND_DEDUP_WINDOW);
+    // Check if we've seen this exact timer duration recently
+    const isDuplicate = recentCommands.some(cmd => cmd.command === canonical && Math.abs(cmd.seconds - seconds) < 2 // Allow 1-2 second variance
+    );
+    if (isDuplicate) {
+        addToDebugLog(`[CANONICAL] Ignoring duplicate command: ${canonical}`);
+        return false;
+    }
+    // Record this command
+    recentCommands.push({
+        timestamp: now,
+        command: canonical,
+        seconds: seconds
+    });
+    addToDebugLog(`[CANONICAL] Accepted new command: ${canonical}`);
+    return true;
+}
+function userTimerComplete() {
+    addToDebugPriority(`[TIMER] *** TIMER COMPLETION STARTED *** - was active: ${userTimer.active}, remaining: ${userTimer.remainingSeconds}s`);
+    try {
+        userTimer.active = false;
+        timerAnnounced = false; // Reset announcement flag
+        addToDebugLog('[TIMER] Timer state reset to inactive');
+        clearCountdownDots();
+        addToDebugLog('[TIMER] Countdown dots cleared');
+        // Clear timer interval
+        if (userTimerInterval) {
+            clearInterval(userTimerInterval);
+            userTimerInterval = 0;
+        }
+        // Hide floating cancel button and countdown display
+        floatingCancelBtn.classList.add('hidden');
+        floatingCancelBtn.classList.remove('active');
+        timerCountdown.classList.remove('visible');
+        if (startTimerBtn)
+            startTimerBtn.disabled = false;
+        if (cancelTimerBtn)
+            cancelTimerBtn.disabled = true;
+        // Clear banner countdown interval if present
+        if (bannerCountdownInterval) {
+            clearInterval(bannerCountdownInterval);
+            bannerCountdownInterval = null;
+        }
+        // Update status to show completion
+        const status = dv('voice-status');
+        if (status)
+            status.textContent = 'Timer completed';
+        // Play timer sound
+        dv('timer-sound')?.play();
+        // Timer alerts always play audio regardless of silent mode
+        if ('speechSynthesis' in window) {
+            const utterance = new SpeechSynthesisUtterance('Timer complete!');
+            speechSynthesis.speak(utterance);
+            addToDebugLog('[SPEECH] Timer complete!');
+        }
+        // Resume wake word listening after timer completes
+        addToDebugLog('[TIMER] Attempting to resume voice controller...');
+        if (voice.controller && voice.enabled) {
+            voice.controller.startListening();
+            addToDebugLog('[TIMER] Voice controller resumed - listening for wake words');
+            setBannerState('waiting');
+            addToDebugLog('[TIMER] Banner state set to waiting');
+        }
+        else {
+            addToDebugWarn(`[TIMER] Cannot resume voice - controller: ${!!voice.controller}, enabled: ${voice.enabled}`);
+        }
+        addToDebugPriority('[TIMER] *** TIMER COMPLETION FINISHED SUCCESSFULLY ***');
+    }
+    catch (error) {
+        addToDebugPriority(`[TIMER] *** TIMER COMPLETION FAILED *** - Error: ${error.message}`);
+        addToDebugErr(`[TIMER] Error stack: ${error.stack}`);
+        // Ensure timer is marked as inactive even if completion fails
+        userTimer.active = false;
+        // Try to resume voice controller even if other things failed
+        try {
+            if (voice.controller && voice.enabled) {
+                voice.controller.startListening();
+                setBannerState('waiting');
+                addToDebugLog('[TIMER] Voice controller resumed after error');
+            }
+        }
+        catch (voiceError) {
+            addToDebugErr(`[TIMER] Failed to resume voice controller: ${voiceError.message}`);
+        }
+    }
+}
+async function initializeVoiceController() {
+    const voiceConfig = {
+        ...DEFAULT_VOICE_CONFIG,
+        // Remove accessKey - not part of VoiceConfig interface
+    };
+    const voiceEvents = {
+        // Fix: Use correct event name from VoiceEvents interface
+        wakeWordDetected: () => {
+            const timestamp = Date.now();
+            lastVoiceActivity = timestamp; // Track voice activity
+            const timeSinceInit = timestamp - performance.timeOrigin;
+            addToDebugLog(`[VOICE] Wake word detected at ${timeSinceInit.toFixed(0)}ms after page load - starting command recognition`);
+            handleWakeWordDetected();
+        },
+        listeningStarted: () => {
+            addToDebugLog('[VOICE] listeningStarted event fired');
+            // Don't call setBannerState here - handleWakeWordDetected already did it
+            // This prevents duplicate banner state changes that restart the progress bar
+            // NOTE: No safety timeout needed here - the listening timeout progress bar
+            // already handles timing out after the configured duration (default 15s).
+        },
+        listeningEnded: () => {
+            // Don't update lastVoiceActivity here - only on actual user interaction
+            addToDebugLog('[VOICE] Speech recognition ended');
+            setBannerState('waiting');
+        },
+        commandReceived: (transcript, confidence) => {
+            lastVoiceActivity = Date.now(); // Track actual user voice command
+            addToDebugLog(`[VOICE] Final result: "${transcript}" (confidence: ${confidence.toFixed(2)})`);
+            processVoiceCommand(transcript);
+        },
+        error: (error) => {
+            addToDebugLog(`[VOICE ERROR] ${error}`);
+            // Show network error state specifically
+            if (error.toLowerCase().includes('network')) {
+                setBannerState('network-error');
+                // Auto-recover to waiting state after 3 seconds
+                setTimeout(() => {
+                    if (microphoneState === 'network-error') {
+                        setBannerState('waiting');
+                    }
+                }, 3000);
+            }
+            else {
+                setBannerState('unavailable');
+            }
+        },
+        statusChanged: (status) => {
+            const now = Date.now();
+            const timeSinceLast = (now - lastVoiceActivity) / 1000;
+            addToDebugLog(`[VOICE STATUS] ${status} (last activity: ${timeSinceLast.toFixed(1)}s ago)`);
+            // Update voice activity timestamp to prevent false "dead" detection
+            // during normal Web Speech API auto-restarts
+            lastVoiceActivity = now;
+        }
+    };
+    try {
+        voice.controller = new VoiceController(voiceConfig, voiceEvents);
+        await voice.controller.initialize();
+        // Fix: Check if controller exists and initialized, not if actively listening
+        if (voice.controller) {
+            addToDebugLog(`[VOICE] Controller initialized successfully`);
+            // Start listening for wake words
+            await voice.controller.startListening();
+            addToDebugLog(`[VOICE] Started listening for wake words`);
+            // Only set banner state if not already waiting (prevents redundant state changes)
+            if (microphoneState !== 'waiting') {
+                setBannerState('waiting');
+            }
+            // Refresh microphone list now that we have permissions
+            await refreshMicrophoneList();
+        }
+        else {
+            addToDebugLog(`[VOICE] Controller initialization failed`);
+            setBannerState('unavailable');
+        }
+    }
+    catch (error) {
+        addToDebugErr(`[VOICE ERROR] Initialization failed: ${error.message}`);
+        setBannerState('unavailable');
+    }
+}
+async function shutdownVoiceController() {
+    if (voice.controller) {
+        // Fix: Use destroy() method instead of shutdown()
+        voice.controller.destroy();
+        voice.controller = undefined;
+        addToDebugLog('[VOICE] Voice controller shutdown complete');
+    }
+}
+function handleWakeWordDetected() {
+    addToDebugLog(`[WAKE WORD] Wake word detected! UI hidden: ${isUIHidden}, showOnWakeWord: ${INACTIVITY_POLICY.showOnWakeWord}`);
+    // Show UI when wake word detected if configured
+    if (INACTIVITY_POLICY.showOnWakeWord && isUIHidden) {
+        addToDebugLog('[WAKE WORD] Showing UI due to wake word detection');
+        showUI();
+        resetInactivityTimer();
+    }
+    // Show blue "Listening..." banner after wake word detection
+    setBannerState('listening');
+    if (voice.controller) {
+        voice.controller.startCommandListening();
+        addToDebugLog('[WAKE WORD] Started command listening');
+    }
+    else {
+        addToDebugWarn('[WAKE WORD] No voice controller available for command listening');
+    }
+}
+// Voice initialization is now handled by VoiceController module
+async function toggleVoiceControl() {
+    const button = dv('voice-toggle');
+    const status = dv('voice-status');
+    if (!button || !status)
+        return;
+    if (voice.enabled) {
+        voiceManuallyStopped = true;
+        await shutdownVoiceController();
+        voice.enabled = false;
+        button.textContent = 'Enable Voice Control';
+        button.classList.remove('enabled');
+        status.textContent = '';
+        setBannerState('disabled');
+        saveSettings();
+    }
+    else {
+        addToDebugLog('User requesting voice control activation');
+        try {
+            await initializeVoiceController();
+            voice.enabled = true;
+            button.textContent = 'Disable Voice Control';
+            button.classList.add('enabled');
+            status.textContent = 'Voice control active';
+            addToDebugLog('Voice control started successfully');
+            // Refresh microphone list after successful initialization
+            await refreshMicrophoneList();
+            saveSettings();
+        }
+        catch (error) {
+            addToDebugErr(`Voice control start failed: ${error.message}`);
+            status.textContent = `Voice control failed: ${error.message}. Check microphone and try again.`;
+            setBannerState('unavailable');
+        }
+    }
+}
+// Microphone management methods
+async function refreshMicrophoneList() {
+    addToDebugLog('[MIC] Refreshing microphone list...');
+    if (!voice.controller)
+        return;
+    try {
+        // Request microphone permission first to get device labels
+        const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+        stream.getTracks().forEach(track => track.stop());
+        const microphones = await voice.controller.getAvailableMicrophones();
+        const select = dv('microphone-select');
+        const currentValue = select.value;
+        // Clear existing options except default
+        select.innerHTML = '<option value="">Default</option>';
+        // Add microphone options
+        microphones.forEach(mic => {
+            const option = document.createElement('option');
+            option.value = mic.deviceId;
+            option.textContent = mic.label;
+            select.appendChild(option);
+        });
+        // Restore selection or set saved selection
+        const savedDeviceId = voice.controller.getSelectedMicrophoneId();
+        if (savedDeviceId) {
+            select.value = savedDeviceId;
+        }
+        else {
+            select.value = currentValue;
+        }
+        addToDebugLog(`[MIC] Refreshed microphone list: ${microphones.length} devices`);
+    }
+    catch (error) {
+        addToDebugErr(`[MIC] Failed to refresh microphones: ${error.message}`);
+    }
+}
+function handleMicrophoneChange() {
+    if (!voice.controller)
+        return;
+    const selectedDeviceId = dv('microphone-select').value;
+    voice.controller.setSelectedMicrophone(selectedDeviceId);
+    const deviceName = selectedDeviceId ?
+        dv('microphone-select').options[dv('microphone-select').selectedIndex].text :
+        'Default';
+    addToDebugLog(`[MIC] Selected microphone: ${deviceName}`);
+    // If voice control is active, restart it to use the new microphone
+    if (voice.enabled) {
+        addToDebugLog(`[MIC] Restarting voice control with new microphone...`);
+        restartVoiceControlWithNewMicrophone();
+    }
+}
+async function restartVoiceControlWithNewMicrophone() {
+    try {
+        await shutdownVoiceController();
+        await new Promise(resolve => setTimeout(resolve, 500)); // Brief delay
+        await initializeVoiceController();
+        voice.enabled = true;
+        // Update button state
+        const button = dv('voice-toggle');
+        if (button) {
+            button.textContent = 'Disable Voice Control';
+            button.classList.add('enabled');
+        }
+        addToDebugLog(`[MIC] Voice control restarted with new microphone`);
+    }
+    catch (error) {
+        addToDebugErr(`[MIC] Failed to restart voice control: ${error.message}`);
+    }
+}
+async function processVoiceCommand(transcript) {
+    const status = dv('voice-status');
+    if (!status)
+        return;
+    const now = Date.now();
+    // Enhanced duplicate command prevention
+    if (transcript === lastCommand && (now - lastCommandTime) < 5000) { // Increased to 5 seconds
+        addToDebugLog(`[VOICE DUP] Ignoring duplicate: "${transcript}" (${now - lastCommandTime}ms ago)`);
+        return;
+    }
+    lastCommand = transcript;
+    lastCommandTime = now;
+    // Debug: Show what was heard
+    addToDebugLog(`[VOICE CMD] Processing: "${transcript}"`);
+    status.textContent = `Processing: "${transcript}"`;
+    // Filter out wake words - don't process them as commands
+    const normalizedTranscript = transcript.toLowerCase().trim();
+    if (normalizedTranscript === 'hey timer' || normalizedTranscript === 'go timer' ||
+        normalizedTranscript === 'hey timer.' || normalizedTranscript === 'go timer.') {
+        addToDebugLog(`[VOICE CMD] Ignoring wake word: "${transcript}"`);
+        // Continue listening, don't treat as failed command
+        return;
+    }
+    // Try local parsing first
+    const localResult = parseVoiceCommandLocal(transcript);
+    addToDebugLog(`[LOCAL PARSE] Result: success=${localResult.success}, action=${localResult.action}, value=${localResult.value}, reason=${localResult.reason}`);
+    if (localResult.success) {
+        addToDebugLog(`[LOCAL PARSE] Success: ${JSON.stringify(localResult)}`);
+        executeCommand(localResult, transcript);
+        return;
+    }
+    addToDebugLog(`[LOCAL PARSE] Failed: ${localResult.reason}`);
+    // Try AI parsing if enabled and local parsing failed
+    if (aiParser.isAvailable()) {
+        try {
+            status.textContent = `Trying AI parsing...`;
+            const aiCommand = await aiParser.parseCommand(transcript);
+            if (aiCommand) {
+                addToDebugLog(`[AI PARSE] Success: "${aiCommand}"`);
+                const aiResult = parseVoiceCommandLocal(aiCommand);
+                if (aiResult.success) {
+                    aiResult.source = 'ai';
+                    executeCommand(aiResult, `${transcript} → ${aiCommand}`);
+                    return;
+                }
+                else {
+                    addToDebugLog(`[AI PARSE] AI result failed local parsing: ${aiResult.reason}`);
+                }
+            }
+            else {
+                addToDebugLog(`[AI PARSE] AI returned null (not a timer command)`);
+            }
+        }
+        catch (error) {
+            addToDebugErr(`[AI PARSE] Error: ${error.message}`);
+            status.textContent = `AI parsing failed, check API key`;
+        }
+    }
+    else {
+        const config = aiParser.getConfig();
+        addToDebugLog(`[AI PARSE] Not available - enabled: ${config.enabled}, hasApiKey: ${!!config.apiKey}, service: ${config.service}`);
+    }
+    // Both local and AI parsing failed - also stop listening here
+    if (voice.controller?.isActive()) {
+        addToDebugLog('[VOICE] Stopping speech recognition after failed command parsing');
+        voice.controller.stopListening();
+        // Resume wake word listening after failed parse
+        setTimeout(() => {
+            if (voice.controller && voice.enabled && !voice.controller.isActive()) {
+                try {
+                    voice.controller.startListening();
+                    addToDebugLog('[VOICE] Resumed wake word listening after failed parse');
+                    setBannerState('waiting');
+                }
+                catch (error) {
+                    addToDebugErr(`[VOICE] Failed to resume listening: ${error.message}`);
+                }
+            }
+            else if (voice.controller?.isActive()) {
+                addToDebugLog('[VOICE] Already listening, skipping restart after failed parse');
+                setBannerState('waiting');
+            }
+        }, 100);
+    }
+    status.textContent = `Command not recognized: "${transcript}"`;
+    addToDebugLog(`[PARSE FAILED] Both local and AI parsing failed`);
+}
+function parseVoiceCommandLocal(transcript) {
+    addToDebugLog(`[PARSE] Starting parse of: "${transcript}"`);
+    // Try pattern matching first - if it fails, LLM can handle complex phrases
+    // More flexible pattern matching
+    const timePatterns = [
+        /(\d+)\s*(?:minute|minutes|min)/,
+        /(\d+)\s*(?:second|seconds|sec)/,
+        /(\d+)\s*(?:hour|hours|hr)/
+    ];
+    const cancelMatch = /(?:cancel|stop|clear|reset|off)/.test(transcript);
+    const timerMatch = /(?:timer|alarm|countdown)/.test(transcript);
+    const showDigitalMatch = /(?:show|display).*(?:digital|time|24)/.test(transcript);
+    const hideDigitalMatch = /(?:hide|remove).*(?:digital|time)/.test(transcript);
+    const silentMatch = /(?:silent|quiet|mute)/.test(transcript);
+    const stopVoiceMatch = /(?:stop voice|disable voice|voice off)/.test(transcript);
+    const fullscreenMatch = /(?:full\s*screen|fullscreen|maximize)/.test(transcript);
+    const exitFullscreenMatch = /(?:exit|leave|minimize|normal)/.test(transcript);
+    const lightModeMatch = /(?:light mode|light theme|bright mode)/.test(transcript);
+    const darkModeMatch = /(?:dark mode|dark theme|night mode)/.test(transcript);
+    const systemThemeMatch = /(?:system theme|system mode|auto theme)/.test(transcript);
+    const helpMatch = /(?:help|commands|what can you do)/.test(transcript);
+    const stopMatch = /^stop$/i.test(transcript);
+    const whatTimeMatch = /(?:what time|time is it|current time)/.test(transcript);
+    const weatherMatch = /(?:weather|temperature|how hot|how cold|what's the temperature)/.test(transcript);
+    const showBannerMatch = /(?:show banner|show ui|show interface|display banner)/.test(transcript);
+    const hideBannerMatch = /(?:hide banner|hide ui|hide interface|remove banner)/.test(transcript);
+    // Handle cancel/stop
+    if (cancelMatch) {
+        return { action: 'cancel', success: true, source: 'local' };
+    }
+    // Handle digital time display
+    if (showDigitalMatch) {
+        return { action: 'show-digital', success: true, source: 'local' };
+    }
+    if (hideDigitalMatch) {
+        return { action: 'hide-digital', success: true, source: 'local' };
+    }
+    // Handle silent mode toggle
+    if (silentMatch) {
+        return { action: 'silent', success: true, source: 'local' };
+    }
+    // Handle stop voice command
+    if (stopVoiceMatch) {
+        return { action: 'stop-voice', success: true, source: 'local' };
+    }
+    // Handle fullscreen
+    if (fullscreenMatch) {
+        return { action: 'fullscreen', success: true, source: 'local' };
+    }
+    if (exitFullscreenMatch) {
+        return { action: 'exit-fullscreen', success: true, source: 'local' };
+    }
+    // Handle theme changes
+    if (lightModeMatch) {
+        return { action: 'light-mode', success: true, source: 'local' };
+    }
+    if (darkModeMatch) {
+        return { action: 'dark-mode', success: true, source: 'local' };
+    }
+    if (systemThemeMatch) {
+        return { action: 'system-theme', success: true, source: 'local' };
+    }
+    // Handle help command
+    if (helpMatch) {
+        return { action: 'help', success: true, source: 'local' };
+    }
+    // Handle stop command (for stopping help speech)
+    if (stopMatch && isSpeakingHelp) {
+        return { action: 'stop-speaking', success: true, source: 'local' };
+    }
+    // Handle cancel during help (should also stop help speech and close dialog)
+    if (cancelMatch && isSpeakingHelp) {
+        return { action: 'stop-speaking', success: true, source: 'local' };
+    }
+    // Handle what time is it
+    if (whatTimeMatch) {
+        return { action: 'what-time', success: true, source: 'local' };
+    }
+    // Handle weather/temperature requests
+    if (weatherMatch) {
+        return { action: 'weather', success: true, source: 'local' };
+    }
+    // Handle show/hide banner commands
+    if (showBannerMatch) {
+        return { action: 'show-banner', success: true, source: 'local' };
+    }
+    if (hideBannerMatch) {
+        return { action: 'hide-banner', success: true, source: 'local' };
+    }
+    // Handle "time till" or "time until" patterns
+    const timeTillMatch = transcript.match(/(?:time\s+)?(?:till|until)\s+([\d:]+)\s*(am|pm)?/i);
+    if (timeTillMatch) {
+        const timeStr = timeTillMatch[1];
+        const ampm = timeTillMatch[2];
+        try {
+            const targetTime = parseTimeString(timeStr, ampm);
+            if (targetTime) {
+                const now = new Date();
+                const diffMs = targetTime.getTime() - now.getTime();
+                if (diffMs > 0) {
+                    const diffSeconds = Math.floor(diffMs / 1000);
+                    return {
+                        action: 'timer',
+                        value: diffSeconds,
+                        unit: 'seconds',
+                        success: true,
+                        source: 'local'
+                    };
+                }
+            }
+        }
+        catch (error) {
+            addToDebugErr(`[LOCAL PARSE] Time parsing error: ${error.message}`);
+        }
+    }
+    // Handle timer setting
+    if (timerMatch || timePatterns.some(p => p.test(transcript))) {
+        addToDebugLog(`[PARSE] Timer command detected - timerMatch: ${timerMatch}, timePatterns match: ${timePatterns.some(p => p.test(transcript))}`);
+        const result = parseTimerCommand(transcript);
+        addToDebugLog(`[PARSE] parseTimerCommand result: ${result.totalSeconds} seconds`);
+        if (result.totalSeconds > 0) {
+            return {
+                action: 'timer',
+                value: result.totalSeconds,
+                unit: 'seconds',
+                success: true,
+                source: 'local'
+            };
+        }
+    }
+    return { action: '', success: false, reason: 'Command pattern not recognized', source: 'local' };
+}
+function parseTimerCommand(transcript) {
+    addToDebugLog(`[TIMER PARSE] Input: "${transcript}"`);
+    let totalSeconds = 0;
+    let foundTimeUnit = false;
+    // Enhanced word-to-number conversion including fractions
+    const wordToNumber = {
+        'one': '1', 'two': '2', 'three': '3', 'four': '4', 'five': '5',
+        'six': '6', 'seven': '7', 'eight': '8', 'nine': '9', 'ten': '10',
+        'eleven': '11', 'twelve': '12', 'thirteen': '13', 'fourteen': '14', 'fifteen': '15',
+        'twenty': '20', 'thirty': '30', 'forty': '40', 'fifty': '50'
+    };
+    let processedTranscript = transcript;
+    for (const [word, num] of Object.entries(wordToNumber)) {
+        processedTranscript = processedTranscript.replace(new RegExp(`\\b${word}\\b`, 'gi'), num);
+    }
+    addToDebugLog(`[TIMER PARSE] Original: "${transcript}" -> Processed: "${processedTranscript}"`);
+    // Handle special fractional expressions first
+    // Handle "X and a half" (e.g., "one and a half minutes")
+    const andHalfMatch = processedTranscript.match(/(\d+)\s+and\s+a\s+half\s+(minute|minutes|min|second|seconds|sec|hour|hours|hr)/i);
+    if (andHalfMatch) {
+        const baseNumber = parseInt(andHalfMatch[1]);
+        const unit = andHalfMatch[2].toLowerCase();
+        let multiplier = 60; // Default to minutes
+        if (unit.startsWith('sec'))
+            multiplier = 1;
+        if (unit.startsWith('hour') || unit.startsWith('hr'))
+            multiplier = 3600;
+        totalSeconds = (baseNumber + 0.5) * multiplier;
+        foundTimeUnit = true;
+        addToDebugLog(`Matched: "${andHalfMatch[0]}" -> Base: ${baseNumber}, Unit: ${unit}, Multiplier: ${multiplier}, Total: ${totalSeconds} seconds`);
+    }
+    // Handle "X and three quarters" (e.g., "one and three quarters minutes")
+    if (!foundTimeUnit) {
+        const andThreeQuartersMatch = processedTranscript.match(/(\d+)\s+and\s+three\s+quarters?\s+(minute|minutes|min|second|seconds|sec|hour|hours|hr)/i);
+        if (andThreeQuartersMatch) {
+            const baseNumber = parseInt(andThreeQuartersMatch[1]);
+            const unit = andThreeQuartersMatch[2].toLowerCase();
+            let multiplier = 60; // Default to minutes
+            if (unit.startsWith('sec'))
+                multiplier = 1;
+            if (unit.startsWith('hour') || unit.startsWith('hr'))
+                multiplier = 3600;
+            totalSeconds = (baseNumber + 0.75) * multiplier;
+            foundTimeUnit = true;
+            addToDebugLog(`Matched: "${andThreeQuartersMatch[0]}" -> Base: ${baseNumber}, Unit: ${unit}, Multiplier: ${multiplier}, Total: ${totalSeconds} seconds`);
+        }
+    }
+    // Handle "X 3/4" notation (e.g., "1 3/4 minutes")
+    if (!foundTimeUnit) {
+        const threeQuartersFractionMatch = processedTranscript.match(/(\d+)\s+3\/4\s+(minute|minutes|min|second|seconds|sec|hour|hours|hr)/i);
+        if (threeQuartersFractionMatch) {
+            const baseNumber = parseInt(threeQuartersFractionMatch[1]);
+            const unit = threeQuartersFractionMatch[2].toLowerCase();
+            let multiplier = 60; // Default to minutes
+            if (unit.startsWith('sec'))
+                multiplier = 1;
+            if (unit.startsWith('hour') || unit.startsWith('hr'))
+                multiplier = 3600;
+            totalSeconds = (baseNumber + 0.75) * multiplier;
+            foundTimeUnit = true;
+            addToDebugLog(`Matched fraction: "${threeQuartersFractionMatch[0]}" -> Base: ${baseNumber}, Unit: ${unit}, Multiplier: ${multiplier}, Total: ${totalSeconds} seconds`);
+        }
+    }
+    // Handle "X 1/2" notation (e.g., "1 1/2 minutes")
+    if (!foundTimeUnit) {
+        const fractionMatch = processedTranscript.match(/(\d+)\s+1\/2\s+(minute|minutes|min|second|seconds|sec|hour|hours|hr)/i);
+        if (fractionMatch) {
+            const baseNumber = parseInt(fractionMatch[1]);
+            const unit = fractionMatch[2].toLowerCase();
+            let multiplier = 60; // Default to minutes
+            if (unit.startsWith('sec'))
+                multiplier = 1;
+            if (unit.startsWith('hour') || unit.startsWith('hr'))
+                multiplier = 3600;
+            totalSeconds = (baseNumber + 0.5) * multiplier;
+            foundTimeUnit = true;
+            addToDebugLog(`Matched fraction: "${fractionMatch[0]}" -> Base: ${baseNumber}, Unit: ${unit}, Multiplier: ${multiplier}, Total: ${totalSeconds} seconds`);
+        }
+    }
+    // Handle "X point Y" (e.g., "one point five minutes")
+    if (!foundTimeUnit) {
+        const pointMatch = processedTranscript.match(/(\d+)\s+point\s+(\d+)\s+(minute|minutes|min|second|seconds|sec|hour|hours|hr)/i);
+        if (pointMatch) {
+            const wholeNumber = parseInt(pointMatch[1]);
+            const fractionalDigit = parseInt(pointMatch[2]);
+            const unit = pointMatch[3].toLowerCase();
+            let multiplier = 60; // Default to minutes
+            if (unit.startsWith('sec'))
+                multiplier = 1;
+            if (unit.startsWith('hour') || unit.startsWith('hr'))
+                multiplier = 3600;
+            const fractionalValue = wholeNumber + (fractionalDigit / 10);
+            totalSeconds = fractionalValue * multiplier;
+            foundTimeUnit = true;
+            addToDebugLog(`Parsed "${pointMatch[0]}" as ${totalSeconds} seconds`);
+        }
+    }
+    // Handle standard parsing if no special fraction found
+    if (!foundTimeUnit) {
+        // Check for multiple units in priority order, but allow combining
+        let hours = 0, minutes = 0, seconds = 0;
+        // Check for hours
+        const hourMatch = processedTranscript.match(/(\d+)\s*(?:hour|hours|hr)\b/);
+        if (hourMatch && !processedTranscript.includes('and a half') && !processedTranscript.includes('point')) {
+            hours = parseInt(hourMatch[1]);
+            foundTimeUnit = true;
+            addToDebugLog(`Standard hour parsing: ${hours} hours`);
+        }
+        // Check for minutes (can coexist with hours/seconds)
+        const minuteMatch = processedTranscript.match(/(\d+)\s*(?:minute|minutes|min)\b/);
+        if (minuteMatch) {
+            minutes = parseInt(minuteMatch[1]);
+            foundTimeUnit = true;
+            addToDebugLog(`Standard minute parsing: ${minutes} minutes`);
+        }
+        // Check for seconds (can coexist with hours/minutes)
+        const secondMatch = processedTranscript.match(/(\d+)\s*(?:second|seconds|sec)\b/);
+        if (secondMatch) {
+            seconds = parseInt(secondMatch[1]);
+            foundTimeUnit = true;
+            addToDebugLog(`Standard second parsing: ${seconds} seconds`);
+        }
+        // Calculate total seconds by combining all units
+        totalSeconds = hours * 3600 + minutes * 60 + seconds;
+        addToDebugLog(`Combined total: ${hours}h + ${minutes}m + ${seconds}s = ${totalSeconds} seconds`);
+    }
+    addToDebugLog(`[TIMER PARSE] Final result: ${totalSeconds} seconds (found time unit: ${foundTimeUnit})`);
+    return { totalSeconds };
+}
+function executeCommand(command, originalTranscript) {
+    const status = dv('voice-status');
+    if (!status)
+        return;
+    // Command understood - no need for separate accepted state
+    // Keep listening for additional commands instead of stopping
+    // The timeout will handle when to stop listening
+    addToDebugLog('[VOICE] Continuing to listen for additional commands');
+    switch (command.action) {
+        case 'cancel':
+            if (userTimer.active) {
+                addToDebugLog(`Cancel command detected, timer active: ${userTimer.active}`);
+                cancelUserTimer();
+                speak('Timer cancelled', true);
+                status.textContent = 'Timer cancelled';
+            }
+            else {
+                addToDebugLog(`Cancel command detected but timer not active: ${userTimer.active}`);
+                status.textContent = 'No timer to cancel';
+            }
+            break;
+        case 'show-digital':
+            setShowDigitalTime(true);
+            if (showDigitalCheckbox)
+                showDigitalCheckbox.checked = true;
+            if (dv('digital-time-overlay'))
+                dv('digital-time-overlay').style.display = 'block';
+            saveSettings();
+            speak('Showing digital time', false);
+            status.textContent = 'Digital time enabled';
+            break;
+        case 'hide-digital':
+            setShowDigitalTime(false);
+            if (showDigitalCheckbox)
+                showDigitalCheckbox.checked = false;
+            if (dv('digital-time-overlay'))
+                dv('digital-time-overlay').style.display = 'none';
+            saveSettings();
+            speak('Hiding digital time', false);
+            status.textContent = 'Digital time disabled';
+            break;
+        case 'silent':
+            setSilentMode(!getSilentMode());
+            if (silentModeCheckbox)
+                silentModeCheckbox.checked = getSilentMode();
+            saveSettings();
+            if (!getSilentMode()) {
+                speak('Silent mode off', false);
+            }
+            status.textContent = getSilentMode() ? 'Silent mode enabled' : 'Silent mode disabled';
+            break;
+        case 'stop-voice':
+            toggleVoiceControl();
+            status.textContent = 'Voice control disabled';
+            // This command should stop listening immediately
+            return;
+        case 'show-banner':
+        case 'show-ui':
+            showUI();
+            resetInactivityTimer();
+            speak('Banner shown', false);
+            status.textContent = 'UI shown';
+            break;
+        case 'hide-banner':
+        case 'hide-ui':
+            hideUI();
+            speak('Banner hidden', false);
+            status.textContent = 'UI hidden';
+            break;
+        case 'fullscreen':
+            if (!document.fullscreenElement) {
+                addToDebugLog('[FULLSCREEN] Voice command - attempting fullscreen');
+                const docEl = document.documentElement;
+                const requestFullscreen = docEl.requestFullscreen ||
+                    docEl.webkitRequestFullscreen ||
+                    docEl.mozRequestFullScreen ||
+                    docEl.msRequestFullscreen;
+                if (requestFullscreen) {
+                    const promise = requestFullscreen.call(docEl);
+                    if (promise && promise.then) {
+                        promise.then(() => {
+                            addToDebugLog('[FULLSCREEN] Successfully entered fullscreen');
+                            speak('Fullscreen mode active', false);
+                            status.textContent = 'Fullscreen mode';
+                        }).catch((error) => {
+                            addToDebugErr(`[FULLSCREEN] Voice command failed: ${error.name} - ${error.message}`);
+                            speak('Fullscreen not available via voice', false);
+                            status.textContent = 'Fullscreen blocked by browser';
+                        });
+                    }
+                    else {
+                        addToDebugLog('[FULLSCREEN] Fullscreen request sent (no promise)');
+                        status.textContent = 'Fullscreen requested';
+                    }
+                }
+                else {
+                    addToDebugErr('[FULLSCREEN] Fullscreen API not supported');
+                    speak('Fullscreen not supported', false);
+                    status.textContent = 'Fullscreen not supported';
+                }
+            }
+            else {
+                addToDebugLog('[FULLSCREEN] Already in fullscreen mode');
+                speak('Already in fullscreen', false);
+                status.textContent = 'Already in fullscreen';
+            }
+            break;
+        case 'exit-fullscreen':
+            if (document.fullscreenElement) {
+                document.exitFullscreen();
+                speak('Exiting fullscreen', false);
+                status.textContent = 'Normal mode';
+            }
+            break;
+        case 'light-mode':
+            addToDebugLog('[VOICE CMD] Light mode command matched');
+            setTheme('light');
+            if (themeSelect)
+                themeSelect.value = 'light';
+            applyTheme();
+            saveSettings();
+            speak('Light mode enabled', false);
+            status.textContent = 'Theme: Light mode';
+            break;
+        case 'dark-mode':
+            addToDebugLog('[VOICE CMD] Dark mode command matched');
+            setTheme('dark');
+            if (themeSelect)
+                themeSelect.value = 'dark';
+            applyTheme();
+            saveSettings();
+            speak('Dark mode enabled', false);
+            status.textContent = 'Theme: Dark mode';
+            break;
+        case 'system-theme':
+            addToDebugLog('[VOICE CMD] System theme command matched');
+            setTheme('system');
+            if (themeSelect)
+                themeSelect.value = 'system';
+            applyTheme();
+            saveSettings();
+            speak('System theme enabled', false);
+            status.textContent = 'Theme: System automatic';
+            break;
+        case 'help':
+            addToDebugLog('[VOICE CMD] Help command matched');
+            showHelpDialog();
+            speakHelp();
+            status.textContent = 'Showing help';
+            // Keep listening for commands during help (like "stop" or "cancel")
+            if (voice.controller) {
+                voice.controller.startCommandListening();
+                addToDebugLog('[VOICE] Keeping command listening active during help');
+            }
+            break;
+        case 'stop-speaking':
+            addToDebugLog('[VOICE CMD] Stop speaking command matched');
+            stopSpeaking();
+            status.textContent = '';
+            break;
+        case 'what-time':
+            addToDebugLog('[VOICE CMD] What time is it command matched');
+            const now = new Date();
+            const hours = now.getHours();
+            const minutes = now.getMinutes();
+            const ampm = hours >= 12 ? 'PM' : 'AM';
+            const displayHours = hours === 0 ? 12 : hours > 12 ? hours - 12 : hours;
+            const timeStr = `${displayHours}:${minutes.toString().padStart(2, '0')} ${ampm}`;
+            speak(`The time is ${timeStr}`, false);
+            status.textContent = `Time: ${timeStr}`;
+            break;
+        case 'timer':
+            if (command.value && command.value > 0) {
+                // Check for canonical command to prevent duplicates (e.g., "5 minutes" vs "300 seconds")
+                if (!isCanonicalCommand('timer', command.value)) {
+                    addToDebugLog(`[TIMER] Ignoring duplicate timer command: ${command.value} seconds`);
+                    status.textContent = `Duplicate timer command ignored`;
+                    break;
+                }
+                // Reset inactivity timer when user sets a timer via voice
+                resetInactivityTimer();
+                if (userTimer.active) {
+                    cancelUserTimer();
+                }
+                startUserTimer(command.value);
+                const minutes = Math.floor(command.value / 60);
+                const seconds = command.value % 60;
+                const timeStr = minutes > 0 ? `${minutes} minute${minutes !== 1 ? 's' : ''}` +
+                    (seconds > 0 ? ` ${seconds} second${seconds !== 1 ? 's' : ''}` : '') :
+                    `${seconds} second${seconds !== 1 ? 's' : ''}`;
+                speak(`Timer set for ${timeStr}`, true);
+                status.textContent = `Timer: ${timeStr} (${command.source} parsing)`;
+                addToDebugLog(`[TIMER START] ${command.value} seconds using ${command.source} parsing`);
+            }
+            else {
+                status.textContent = 'Invalid timer duration';
+            }
+            break;
+        case 'weather':
+            const temperature = getCurrentTemperature();
+            speak(`The current temperature is ${temperature}`, false);
+            status.textContent = `Weather: ${temperature}`;
+            addToDebugLog(`[WEATHER] Spoken: ${temperature}`);
+            break;
+        default:
+            status.textContent = `Unknown command: ${command.action}`;
+    }
+    // After command execution, keep the listening banner active and continue listening for more commands
+    // The listening timeout will handle returning to wake word listening
+    addToDebugLog('[VOICE] Continuing to listen for additional commands until timeout');
+    // Don't change banner state or restart wake word listening - let the timeout handle it
+}
+function speak(text, isTimerRelated = false) {
+    // Prevent duplicate speech announcements
+    const now = Date.now();
+    if (text === lastSpokenText && (now - lastSpokenTime) < 3000) {
+        addToDebugLog(`[SPEECH DUP] Ignoring duplicate speech: "${text}"`);
+        return;
+    }
+    lastSpokenText = text;
+    lastSpokenTime = now;
+    // Only speak if not in silent mode, or if it's timer-related
+    if (('speechSynthesis' in window) && (!getSilentMode() || isTimerRelated)) {
+        // CRITICAL: Stop listening before speaking to prevent echo loop
+        // The microphone will pick up our own speech and trigger commands
+        if (voice.controller && microphoneState === 'waiting') {
+            voice.controller.stopListening();
+            addToDebugLog('[SPEECH] Stopped listening to prevent echo');
+        }
+        const utterance = new SpeechSynthesisUtterance(text);
+        // Resume listening after speech completes
+        utterance.onend = () => {
+            if (voice.controller && voice.enabled) {
+                setTimeout(() => {
+                    if (!voice.controller.isActive()) {
+                        voice.controller?.startListening();
+                        setBannerState('waiting');
+                        addToDebugLog('[SPEECH] Resumed listening after speech');
+                    }
+                    else {
+                        addToDebugLog('[SPEECH] Already listening, skipping resume');
+                    }
+                }, 500); // Small delay to ensure clean state
+            }
+        };
+        speechSynthesis.speak(utterance);
+        addToDebugLog(`[SPEECH] Speaking: "${text}" (timer-related: ${isTimerRelated}, silent mode: ${getSilentMode()})`);
+    }
+    else {
+        addToDebugLog(`[SPEECH BLOCKED] Not speaking: "${text}" (speechSynthesis available: ${('speechSynthesis' in window)}, silent mode: ${getSilentMode()}, timer-related: ${isTimerRelated})`);
+        // Show orange banner when speech is blocked
+        setBannerState('speech-blocked');
+        // Hide the speech blocked banner after 3 seconds
+        setTimeout(() => {
+            if (microphoneState === 'speech-blocked') {
+                setBannerState('waiting');
+            }
+        }, 3000);
+    }
+}
+function parseTimeString(timeStr, ampm) {
+    try {
+        // Handle formats like "1:00", "13:00", "1", etc.
+        let hours;
+        let minutes = 0;
+        if (timeStr.includes(':')) {
+            const [hoursStr, minutesStr] = timeStr.split(':');
+            hours = parseInt(hoursStr);
+            minutes = parseInt(minutesStr) || 0;
+        }
+        else {
+            hours = parseInt(timeStr);
+        }
+        // Handle 12-hour format
+        if (ampm) {
+            if (ampm.toLowerCase() === 'pm' && hours !== 12) {
+                hours += 12;
+            }
+            else if (ampm.toLowerCase() === 'am' && hours === 12) {
+                hours = 0;
+            }
+        }
+        // Create target time
+        const now = new Date();
+        const target = new Date(now);
+        target.setHours(hours, minutes, 0, 0);
+        // If the target time is in the past today, assume it's for tomorrow
+        if (target.getTime() <= now.getTime()) {
+            target.setDate(target.getDate() + 1);
+        }
+        return target;
+    }
+    catch (error) {
+        return null;
+    }
+}
+// Browser compatibility checking is now handled by VoiceController module
+function showHelpDialog() {
+    const helpDialog = dv('help-dialog');
+    helpDialog.classList.remove('hidden');
+    // Auto-close help dialog after 30 seconds
+    if (helpTimeoutInterval) {
+        clearTimeout(helpTimeoutInterval);
+    }
+    helpTimeoutInterval = window.setTimeout(() => {
+        closeHelpDialog();
+        addToDebugLog('[HELP] Help dialog auto-closed after 30 seconds');
+    }, 30000);
+}
+function closeHelpDialog() {
+    const helpDialog = dv('help-dialog');
+    helpDialog.classList.add('hidden');
+    stopSpeaking();
+    // Clear the auto-close timeout
+    if (helpTimeoutInterval) {
+        clearTimeout(helpTimeoutInterval);
+        helpTimeoutInterval = undefined;
+    }
+}
+function speakHelp() {
+    if (!('speechSynthesis' in window))
+        return;
+    isSpeakingHelp = true;
+    const helpText = `Voice commands available.
+            Timer commands: Say timer 5 minutes, timer 30 seconds, or cancel userTimer.
+            Display commands: Say show digital time, hide digital time, fullscreen, or exit fullscreen.
+            Theme commands: Say light mode, dark mode, or system theme.
+            Other commands: Say silent to toggle silent mode, or stop voice to disable voice control.
+            Say stop at any time to stop this help.`;
+    const utterance = new SpeechSynthesisUtterance(helpText);
+    utterance.rate = 0.9; // Slightly slower for clarity
+    utterance.onend = () => {
+        isSpeakingHelp = false;
+        addToDebugLog('[SPEECH] Help speech completed');
+    };
+    speechSynthesis.speak(utterance);
+    addToDebugLog('[SPEECH] Speaking help commands');
+}
+function stopSpeaking() {
+    if ('speechSynthesis' in window) {
+        speechSynthesis.cancel();
+        isSpeakingHelp = false;
+        addToDebugLog('[SPEECH] Stopped speaking');
+    }
+    // Also close the help dialog when stopping speech
+    const helpDialog = dv('help-dialog');
+    if (!helpDialog.classList.contains('hidden')) {
+        closeHelpDialog();
+    }
+}
+// PWA Install Functions
+function handleInstallClick() {
+    if (deferredPrompt) {
+        deferredPrompt.prompt();
+        deferredPrompt.userChoice.then((choiceResult) => {
+            if (choiceResult.outcome === 'accepted') {
+                addToDebugLog('[PWA] User accepted the install prompt');
+            }
+            else {
+                addToDebugLog('[PWA] User dismissed the install prompt');
+            }
+            deferredPrompt = null;
+            updateInstallButtonVisibility();
+        });
+    }
+    else {
+        addToDebugLog('[PWA] Install not available - app may already be installed');
+    }
+}
+function enterFullscreen() {
+    if (!document.fullscreenElement) {
+        const docEl = document.documentElement;
+        const requestFullscreen = docEl.requestFullscreen ||
+            docEl.webkitRequestFullscreen ||
+            docEl.mozRequestFullScreen ||
+            docEl.msRequestFullscreen;
+        if (requestFullscreen) {
+            requestFullscreen.call(docEl).then(() => {
+                addToDebugLog('[FULLSCREEN] Successfully entered fullscreen mode');
+            }).catch((error) => {
+                addToDebugWarn(`[FULLSCREEN] Failed to enter fullscreen: ${error.message}`);
+            });
+        }
+        else {
+            addToDebugWarn('[FULLSCREEN] Fullscreen API not supported');
+        }
+    }
+}
+function updateInstallButtonVisibility() {
+    const installButton = dv('install-button');
+    if (installButton) {
+        // Check if app is running in standalone mode (already installed)
+        const isStandalone = window.matchMedia('(display-mode: standalone)').matches;
+        const isInWebApp = window.navigator.standalone === true; // iOS
+        if (deferredPrompt && !isStandalone && !isInWebApp) {
+            installButton.classList.remove('hidden');
+            addToDebugLog('[PWA] Install button shown - app can be installed');
+        }
+        else {
+            installButton.classList.add('hidden');
+            if (isStandalone || isInWebApp) {
+                addToDebugLog('[PWA] Install button hidden - app is already installed');
+            }
+            else {
+                addToDebugLog('[PWA] Install button hidden - install not available');
+            }
+        }
+        // Debug: Log current state
+        addToDebugLog(`[PWA] Button state: classes="${installButton.className}", hasPrompt=${!!deferredPrompt}`);
+    }
+}
+// PWA Event Listeners
+window.addEventListener('beforeinstallprompt', (e) => {
+    e.preventDefault();
+    deferredPrompt = e;
+    updateInstallButtonVisibility();
+    addToDebugLog('[PWA] Install prompt available');
+});
+window.addEventListener('appinstalled', () => {
+    deferredPrompt = null;
+    updateInstallButtonVisibility();
+    addToDebugLog('[PWA] App installed successfully');
+});
+document.addEventListener('DOMContentLoaded', async () => {
+    await init();
+});
+//# sourceMappingURL=clock.js.map