diff --git a/package-lock.json b/package-lock.json
index 944e413..bad6efc 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
     "name": "pickle-glass",
-    "version": "0.2.2",
+    "version": "0.2.3",
     "lockfileVersion": 3,
     "requires": true,
     "packages": {
         "": {
             "name": "pickle-glass",
-            "version": "0.2.2",
+            "version": "0.2.3",
             "hasInstallScript": true,
             "license": "GPL-3.0",
             "dependencies": {
diff --git a/package.json b/package.json
index 84777a5..ea125a0 100644
--- a/package.json
+++ b/package.json
@@ -2,7 +2,7 @@
     "name": "pickle-glass",
     "productName": "Glass",
 
-    "version": "0.2.2",
+    "version": "0.2.3",
 
     "description": "Cl*ely for Free",
     "main": "src/index.js",
diff --git a/src/common/config/schema.js b/src/common/config/schema.js
index 19e0d8c..00b58f7 100644
--- a/src/common/config/schema.js
+++ b/src/common/config/schema.js
@@ -6,7 +6,8 @@ const LATEST_SCHEMA = {
             { name: 'email', type: 'TEXT NOT NULL' },
             { name: 'created_at', type: 'INTEGER' },
             { name: 'api_key', type: 'TEXT' },
-            { name: 'provider', type: 'TEXT DEFAULT \'openai\'' }
+            { name: 'provider', type: 'TEXT DEFAULT \'openai\'' },
+            { name: 'auto_update_enabled', type: 'INTEGER DEFAULT 1' }
         ]
     },
     sessions: {
diff --git a/src/common/services/authService.js b/src/common/services/authService.js
index a664ba1..fd4b9de 100644
--- a/src/common/services/authService.js
+++ b/src/common/services/authService.js
@@ -37,56 +37,64 @@ class AuthService {
         this.currentUserMode = 'local'; // 'local' or 'firebase'
         this.currentUser = null;
         this.isInitialized = false;
+        this.initializationPromise = null;
     }
 
     initialize() {
-        if (this.isInitialized) return;
+        if (this.isInitialized) return this.initializationPromise;
 
-        const auth = getFirebaseAuth();
-        onAuthStateChanged(auth, async (user) => {
-            const previousUser = this.currentUser;
+        this.initializationPromise = new Promise((resolve) => {
+            const auth = getFirebaseAuth();
+            onAuthStateChanged(auth, async (user) => {
+                const previousUser = this.currentUser;
 
-            if (user) {
-                // User signed IN
-                console.log(`[AuthService] Firebase user signed in:`, user.uid);
-                this.currentUser = user;
-                this.currentUserId = user.uid;
-                this.currentUserMode = 'firebase';
+                if (user) {
+                    // User signed IN
+                    console.log(`[AuthService] Firebase user signed in:`, user.uid);
+                    this.currentUser = user;
+                    this.currentUserId = user.uid;
+                    this.currentUserMode = 'firebase';
 
-                // Start background task to fetch and save virtual key
-                (async () => {
-                    try {
-                        const idToken = await user.getIdToken(true);
-                        const virtualKey = await getVirtualKeyByEmail(user.email, idToken);
+                    // Start background task to fetch and save virtual key
+                    (async () => {
+                        try {
+                            const idToken = await user.getIdToken(true);
+                            const virtualKey = await getVirtualKeyByEmail(user.email, idToken);
 
-                        if (global.modelStateService) {
-                            global.modelStateService.setFirebaseVirtualKey(virtualKey);
+                            if (global.modelStateService) {
+                                global.modelStateService.setFirebaseVirtualKey(virtualKey);
+                            }
+                            console.log(`[AuthService] BG: Virtual key for ${user.email} has been processed.`);
+
+                        } catch (error) {
+                            console.error('[AuthService] BG: Failed to fetch or save virtual key:', error);
                         }
-                        console.log(`[AuthService] BG: Virtual key for ${user.email} has been processed.`);
+                    })();
 
-                    } catch (error) {
-                        console.error('[AuthService] BG: Failed to fetch or save virtual key:', error);
-                    }
-                })();
-
-            } else {
-                // User signed OUT
-                console.log(`[AuthService] No Firebase user.`);
-                if (previousUser) {
-                    console.log(`[AuthService] Clearing API key for logged-out user: ${previousUser.uid}`);
-                    if (global.modelStateService) {
-                        global.modelStateService.setFirebaseVirtualKey(null);
+                } else {
+                    // User signed OUT
+                    console.log(`[AuthService] No Firebase user.`);
+                    if (previousUser) {
+                        console.log(`[AuthService] Clearing API key for logged-out user: ${previousUser.uid}`);
+                        if (global.modelStateService) {
+                            global.modelStateService.setFirebaseVirtualKey(null);
+                        }
                     }
+                    this.currentUser = null;
+                    this.currentUserId = 'default_user';
+                    this.currentUserMode = 'local';
                 }
-                this.currentUser = null;
-                this.currentUserId = 'default_user';
-                this.currentUserMode = 'local';
-            }
-            this.broadcastUserState();
+                this.broadcastUserState();
+                
+                if (!this.isInitialized) {
+                    this.isInitialized = true;
+                    console.log('[AuthService] Initialized and resolved initialization promise.');
+                    resolve();
+                }
+            });
         });
 
-        this.isInitialized = true;
-        console.log('[AuthService] Initialized and attached to Firebase Auth state.');
+        return this.initializationPromise;
     }
 
     async signInWithCustomToken(token) {
diff --git a/src/electron/smoothMovementManager.js b/src/electron/smoothMovementManager.js
index a676c82..d7ccfae 100644
--- a/src/electron/smoothMovementManager.js
+++ b/src/electron/smoothMovementManager.js
@@ -120,6 +120,11 @@ class SmoothMovementManager {
         let targetX = this.headerPosition.x;
         let targetY = this.headerPosition.y;
 
+        const windowSize = {
+            width: currentBounds.width,
+            height: currentBounds.height
+        };
+
         switch (direction) {
             case 'left': targetX -= this.stepSize; break;
             case 'right': targetX += this.stepSize; break;
@@ -130,22 +135,23 @@ class SmoothMovementManager {
 
         const displays = screen.getAllDisplays();
         let validPosition = displays.some(d => (
-            targetX >= d.workArea.x && targetX + currentBounds.width <= d.workArea.x + d.workArea.width &&
-            targetY >= d.workArea.y && targetY + currentBounds.height <= d.workArea.y + d.workArea.height
+            targetX >= d.workArea.x && targetX + windowSize.width <= d.workArea.x + d.workArea.width &&
+            targetY >= d.workArea.y && targetY + windowSize.height <= d.workArea.y + d.workArea.height
         ));
 
         if (!validPosition) {
             const nearestDisplay = screen.getDisplayNearestPoint({ x: targetX, y: targetY });
             const { x, y, width, height } = nearestDisplay.workArea;
-            targetX = Math.max(x, Math.min(x + width - currentBounds.width, targetX));
-            targetY = Math.max(y, Math.min(y + height - currentBounds.height, targetY));
+            targetX = Math.max(x, Math.min(x + width - windowSize.width, targetX));
+            targetY = Math.max(y, Math.min(y + height - windowSize.height, targetY));
         }
 
         if (targetX === this.headerPosition.x && targetY === this.headerPosition.y) return;
-        this.animateToPosition(header, targetX, targetY);
+
+        this.animateToPosition(header, targetX, targetY, windowSize);
     }
 
-    animateToPosition(header, targetX, targetY) {
+    animateToPosition(header, targetX, targetY, windowSize) {
         if (!this._isWindowValid(header)) return;
         
         this.isAnimating = true;
@@ -173,7 +179,13 @@ class SmoothMovementManager {
             }
 
             if (!this._isWindowValid(header)) return;
-            header.setPosition(Math.round(currentX), Math.round(currentY));
+            const { width, height } = windowSize || header.getBounds();
+            header.setBounds({
+                x: Math.round(currentX),
+                y: Math.round(currentY),
+                width,
+                height
+            });
 
             if (progress < 1) {
                 this.animationFrameId = setTimeout(animate, 8);
@@ -198,20 +210,40 @@ class SmoothMovementManager {
         const display = this.getCurrentDisplay(header);
         const { width, height } = display.workAreaSize;
         const { x: workAreaX, y: workAreaY } = display.workArea;
-        const headerBounds = header.getBounds();
         const currentBounds = header.getBounds();
+        
+        const windowSize = {
+            width: currentBounds.width,
+            height: currentBounds.height
+        };
+
         let targetX = currentBounds.x;
         let targetY = currentBounds.y;
 
         switch (direction) {
-            case 'left': targetX = workAreaX; break;
-            case 'right': targetX = workAreaX + width - headerBounds.width; break;
-            case 'up': targetY = workAreaY; break;
-            case 'down': targetY = workAreaY + height - headerBounds.height; break;
+            case 'left': 
+                targetX = workAreaX; 
+                break;
+            case 'right': 
+                targetX = workAreaX + width - windowSize.width; 
+                break;
+            case 'up': 
+                targetY = workAreaY; 
+                break;
+            case 'down': 
+                targetY = workAreaY + height - windowSize.height; 
+                break;
         }
 
-        this.headerPosition = { x: currentBounds.x, y: currentBounds.y };
-        this.animateToPosition(header, targetX, targetY);
+        header.setBounds({
+            x: Math.round(targetX),
+            y: Math.round(targetY),
+            width: windowSize.width,
+            height: windowSize.height
+        });
+
+        this.headerPosition = { x: targetX, y: targetY };
+        this.updateLayout();
     }
 
     destroy() {
@@ -224,4 +256,4 @@ class SmoothMovementManager {
     }
 }
 
-module.exports = SmoothMovementManager;
\ No newline at end of file
+module.exports = SmoothMovementManager;
diff --git a/src/features/settings/SettingsView.js b/src/features/settings/SettingsView.js
index 7dbd9f1..bd99937 100644
--- a/src/features/settings/SettingsView.js
+++ b/src/features/settings/SettingsView.js
@@ -456,6 +456,8 @@ export class SettingsView extends LitElement {
         presets: { type: Array, state: true },
         selectedPreset: { type: Object, state: true },
         showPresets: { type: Boolean, state: true },
+        autoUpdateEnabled: { type: Boolean, state: true },
+        autoUpdateLoading: { type: Boolean, state: true },
     };
     //////// after_modelStateService ////////
 
@@ -479,10 +481,48 @@ export class SettingsView extends LitElement {
         this.selectedPreset = null;
         this.showPresets = false;
         this.handleUsePicklesKey = this.handleUsePicklesKey.bind(this)
+        this.autoUpdateEnabled = true;
+        this.autoUpdateLoading = true;
         this.loadInitialData();
         //////// after_modelStateService ////////
     }
 
+    async loadAutoUpdateSetting() {
+        if (!window.require) return;
+        const { ipcRenderer } = window.require('electron');
+        this.autoUpdateLoading = true;
+        try {
+            const enabled = await ipcRenderer.invoke('settings:get-auto-update');
+            this.autoUpdateEnabled = enabled;
+            console.log('Auto-update setting loaded:', enabled);
+        } catch (e) {
+            console.error('Error loading auto-update setting:', e);
+            this.autoUpdateEnabled = true; // fallback
+        }
+        this.autoUpdateLoading = false;
+        this.requestUpdate();
+    }
+
+    async handleToggleAutoUpdate() {
+        if (!window.require || this.autoUpdateLoading) return;
+        const { ipcRenderer } = window.require('electron');
+        this.autoUpdateLoading = true;
+        this.requestUpdate();
+        try {
+            const newValue = !this.autoUpdateEnabled;
+            const result = await ipcRenderer.invoke('settings:set-auto-update', newValue);
+            if (result && result.success) {
+                this.autoUpdateEnabled = newValue;
+            } else {
+                console.error('Failed to update auto-update setting');
+            }
+        } catch (e) {
+            console.error('Error toggling auto-update:', e);
+        }
+        this.autoUpdateLoading = false;
+        this.requestUpdate();
+    }
+
     //////// after_modelStateService ////////
     async loadInitialData() {
         if (!window.require) return;
@@ -617,6 +657,7 @@ export class SettingsView extends LitElement {
         this.setupEventListeners();
         this.setupIpcListeners();
         this.setupWindowResize();
+        this.loadAutoUpdateSetting();
     }
 
     disconnectedCallback() {
@@ -648,6 +689,7 @@ export class SettingsView extends LitElement {
             } else {
                 this.firebaseUser = null;
             }
+            this.loadAutoUpdateSetting();
             this.requestUpdate();
         };
         
@@ -1161,6 +1203,9 @@ export class SettingsView extends LitElement {
                     <button class="settings-button full-width" @click=${this.handlePersonalize}>
                         <span>Personalize / Meeting Notes</span>
                     </button>
+                    <button class="settings-button full-width" @click=${this.handleToggleAutoUpdate} ?disabled=${this.autoUpdateLoading}>
+                        <span>Automatic Updates: ${this.autoUpdateEnabled ? 'On' : 'Off'}</span>
+                    </button>
                     
                     <div class="move-buttons">
                         <button class="settings-button half-width" @click=${this.handleMoveLeft}>
diff --git a/src/features/settings/repositories/index.js b/src/features/settings/repositories/index.js
index 508ebe5..973a149 100644
--- a/src/features/settings/repositories/index.js
+++ b/src/features/settings/repositories/index.js
@@ -18,4 +18,6 @@ module.exports = {
     createPreset: (...args) => getRepository().createPreset(...args),
     updatePreset: (...args) => getRepository().updatePreset(...args),
     deletePreset: (...args) => getRepository().deletePreset(...args),
+    getAutoUpdate: (...args) => getRepository().getAutoUpdate(...args),
+    setAutoUpdate: (...args) => getRepository().setAutoUpdate(...args),
 };
\ No newline at end of file
diff --git a/src/features/settings/repositories/sqlite.repository.js b/src/features/settings/repositories/sqlite.repository.js
index 6611346..86769d9 100644
--- a/src/features/settings/repositories/sqlite.repository.js
+++ b/src/features/settings/repositories/sqlite.repository.js
@@ -90,10 +90,57 @@ function deletePreset(id, uid) {
     }
 }
 
+function getAutoUpdate(uid) {
+    const db = sqliteClient.getDb();
+    const targetUid = uid;
+
+    try {
+        const row = db.prepare('SELECT auto_update_enabled FROM users WHERE uid = ?').get(targetUid);
+        
+        if (row) {
+            console.log('SQLite: Auto update setting found:', row.auto_update_enabled);
+            return row.auto_update_enabled !== 0;
+        } else {
+            // User doesn't exist, create them with default settings
+            const now = Math.floor(Date.now() / 1000);
+            const stmt = db.prepare(
+                'INSERT OR REPLACE INTO users (uid, display_name, email, created_at, auto_update_enabled) VALUES (?, ?, ?, ?, ?)');
+            stmt.run(targetUid, 'User', 'user@example.com', now, 1);
+            return true; // default to enabled
+        }
+    } catch (error) {
+        console.error('SQLite: Error getting auto_update_enabled setting:', error);
+        return true; // fallback to enabled
+    }
+}
+
+function setAutoUpdate(uid, isEnabled) {
+    const db = sqliteClient.getDb();
+    const targetUid = uid || sqliteClient.defaultUserId;
+    
+    try {
+        const result = db.prepare('UPDATE users SET auto_update_enabled = ? WHERE uid = ?').run(isEnabled ? 1 : 0, targetUid);
+        
+        // If no rows were updated, the user might not exist, so create them
+        if (result.changes === 0) {
+            const now = Math.floor(Date.now() / 1000);
+            const stmt = db.prepare('INSERT OR REPLACE INTO users (uid, display_name, email, created_at, auto_update_enabled) VALUES (?, ?, ?, ?, ?)');
+            stmt.run(targetUid, 'User', 'user@example.com', now, isEnabled ? 1 : 0);
+        }
+        
+        return { success: true };
+    } catch (error) {
+        console.error('SQLite: Error setting auto-update:', error);
+        throw error;
+    }
+}
+
 module.exports = {
     getPresets,
     getPresetTemplates,
     createPreset,
     updatePreset,
-    deletePreset
+    deletePreset,
+    getAutoUpdate,
+    setAutoUpdate
 };
\ No newline at end of file
diff --git a/src/features/settings/settingsService.js b/src/features/settings/settingsService.js
index 6360f36..76b0d1a 100644
--- a/src/features/settings/settingsService.js
+++ b/src/features/settings/settingsService.js
@@ -383,6 +383,29 @@ async function updateContentProtection(enabled) {
     }
 }
 
+async function getAutoUpdateSetting() {
+    try {
+        const uid = authService.getCurrentUserId();
+        // This can be awaited if the repository returns a promise.
+        // Assuming it's synchronous for now based on original structure.
+        return settingsRepository.getAutoUpdate(uid);
+    } catch (error) {
+        console.error('[SettingsService] Error getting auto update setting:', error);
+        return true; // Fallback to enabled
+    }
+}
+
+async function setAutoUpdateSetting(isEnabled) {
+    try {
+        const uid = authService.getCurrentUserId();
+        await settingsRepository.setAutoUpdate(uid, isEnabled);
+        return { success: true };
+    } catch (error) {
+        console.error('[SettingsService] Error setting auto update setting:', error);
+        return { success: false, error: error.message };
+    }
+}
+
 function initialize() {
     // cleanup 
     windowNotificationManager.cleanup();
@@ -428,6 +451,15 @@ function initialize() {
     ipcMain.handle('settings:updateContentProtection', async (event, enabled) => {
         return await updateContentProtection(enabled);
     });
+
+    ipcMain.handle('settings:get-auto-update', async () => {
+        return await getAutoUpdateSetting();
+    });
+
+    ipcMain.handle('settings:set-auto-update', async (event, isEnabled) => {
+        console.log('[SettingsService] Setting auto update setting:', isEnabled);
+        return await setAutoUpdateSetting(isEnabled);
+    });
     
     console.log('[SettingsService] Initialized and ready.');
 }
@@ -459,4 +491,5 @@ module.exports = {
     saveApiKey,
     removeApiKey,
     updateContentProtection,
+    getAutoUpdateSetting,
 };
\ No newline at end of file
diff --git a/src/index.js b/src/index.js
index 31ae822..6015c26 100644
--- a/src/index.js
+++ b/src/index.js
@@ -26,6 +26,7 @@ const askService = require('./features/ask/askService');
 const settingsService = require('./features/settings/settingsService');
 const sessionRepository = require('./common/repositories/session');
 const ModelStateService = require('./common/services/modelStateService');
+const sqliteClient = require('./common/services/sqliteClient');
 
 const eventBridge = new EventEmitter();
 let WEB_PORT = 3000;
@@ -189,7 +190,7 @@ app.whenReady().then(async () => {
         // Clean up zombie sessions from previous runs first
         sessionRepository.endAllActiveSessions();
 
-        authService.initialize();
+        await authService.initialize();
 
         //////// after_modelStateService ////////
         modelStateService.initialize();
@@ -215,6 +216,7 @@ app.whenReady().then(async () => {
         );
     }
 
+    // initAutoUpdater should be called after auth is initialized
     initAutoUpdater();
 
     // Process any pending deep link after everything is initialized
@@ -651,8 +653,13 @@ async function startWebStack() {
 }
 
 // Auto-update initialization
-function initAutoUpdater() {
+async function initAutoUpdater() {
     try {
+        const autoUpdateEnabled = await settingsService.getAutoUpdateSetting();
+        if (!autoUpdateEnabled) {
+            console.log('[AutoUpdater] Skipped because auto-updates are disabled in settings');
+            return;
+        }
         // Skip auto-updater in development mode
         if (!app.isPackaged) {
             console.log('[AutoUpdater] Skipped in development (app is not packaged)');