826661c refactor(logging): migrate log.Printf to logging package · dumber

M internal/app/api/scheme.go +11 -11

 import (
 	"embed"
 	"fmt"
-	"log"
 	"mime"
 	neturl "net/url"
 	"os"
 	"github.com/bnema/dumber/internal/app/constants"
 	"github.com/bnema/dumber/internal/config"
+	"github.com/bnema/dumber/internal/logging"
 	"github.com/bnema/dumber/internal/services"
 	webkit "github.com/diamondburned/gotk4-webkitgtk/pkg/webkit/v6"
 	"github.com/diamondburned/gotk4/pkg/gio/v2"
 // Handle processes dumb:// scheme requests using the new URISchemeRequest API
 func (s *SchemeHandler) Handle(req *webkit.URISchemeRequest) {
 	uri := req.URI()
-	log.Printf("[scheme] request: %s", uri)
+	logging.Debug(fmt.Sprintf("[scheme] request: %s", uri))
 	// Known forms:
 	// - dumb://homepage or dumb:homepage → index.html
 	// Special-case homepage favicon: map .ico request to embedded PNG file
 	if (u.Host == constants.HomepagePath || u.Opaque == constants.HomepagePath) && strings.EqualFold(rel, "favicon.ico") {
-		log.Printf("[scheme] asset: rel=%s (host=%s path=%s) → mapping to favicon.png", rel, u.Host, u.Path)
+		logging.Debug(fmt.Sprintf("[scheme] asset: rel=%s (host=%s path=%s) → mapping to favicon.png", rel, u.Host, u.Path))
 		data, rerr := s.assets.ReadFile(filepath.ToSlash(filepath.Join("assets", "gui", "favicon.png")))
 		if rerr == nil {
 			s.finishRequest(req, "image/png", data, "favicon.png")
 		}
 	}
-	log.Printf("[scheme] asset: rel=%s (host=%s path=%s)", rel, u.Host, u.Path)
+	logging.Debug(fmt.Sprintf("[scheme] asset: rel=%s (host=%s path=%s)", rel, u.Host, u.Path))
 	// Try to read the requested asset
 	data, rerr := s.assets.ReadFile(filepath.ToSlash(filepath.Join("assets", "gui", rel)))
 	if rerr != nil {
-		log.Printf("[scheme] not found: %s", rel)
+		logging.Debug(fmt.Sprintf("[scheme] not found: %s", rel))
 		req.FinishError(fmt.Errorf("asset not found: %s", rel))
 		return
 	}
 	mt := s.getMimeType(rel)
 	// Finish the request with the data
-	log.Printf("[scheme] serving %s with mime-type: %s", rel, mt)
+	logging.Debug(fmt.Sprintf("[scheme] serving %s with mime-type: %s", rel, mt))
 	s.finishRequest(req, mt, data, rel)
 }
 	stream := gio.NewMemoryInputStreamFromBytes(gbytes)
 	if stream == nil {
 		req.FinishError(fmt.Errorf("failed to create input stream for: %s", filename))
-		log.Printf("[scheme] failed to create stream for: %s", filename)
+		logging.Error(fmt.Sprintf("[scheme] failed to create stream for: %s", filename))
 		return
 	}
 	}
 	if filename == "" {
-		log.Printf("[scheme] favicon: empty filename")
+		logging.Debug(fmt.Sprintf("[scheme] favicon: empty filename"))
 		req.FinishError(fmt.Errorf("invalid favicon path"))
 		return
 	}
 	// Get the favicon cache directory path
 	dataDir, err := config.GetDataDir()
 	if err != nil {
-		log.Printf("[scheme] favicon: failed to get data directory: %v", err)
+		logging.Error(fmt.Sprintf("[scheme] favicon: failed to get data directory: %v", err))
 		req.FinishError(fmt.Errorf("failed to get data directory"))
 		return
 	}
 	// Read the favicon file
 	data, err := os.ReadFile(faviconPath)
 	if err != nil {
-		log.Printf("[scheme] favicon: file not found: %s", faviconPath)
+		logging.Debug(fmt.Sprintf("[scheme] favicon: file not found: %s", faviconPath))
 		req.FinishError(fmt.Errorf("favicon not found: %s", filename))
 		return
 	}
-	log.Printf("[scheme] favicon: serving %s (%d bytes)", filename, len(data))
+	logging.Debug(fmt.Sprintf("[scheme] favicon: serving %s (%d bytes)", filename, len(data)))
 	s.finishRequest(req, "image/png", data, filename)
 }

M internal/app/browser/browser.go +42 -43

 	"database/sql"
 	"embed"
 	"fmt"
-	"log"
 	"os"
 	"os/signal"
 	"runtime"
 	workspace  *WorkspaceManager
 	// Content filtering
-	filterManager           *filtering.FilterManager
+	filterManager          *filtering.FilterManager
-	contentBlockingService  *filtering.ContentBlockingService
+	contentBlockingService *filtering.ContentBlockingService
 	// Handlers
 	schemeHandler         *api.SchemeHandler
 // Run starts the browser application
 func Run(assets embed.FS, version, commit, buildDate string) {
 	startupStart := time.Now()
-	log.Printf("Starting GUI mode (webkit_cgo=%v)", webkit.IsNativeAvailable())
+	logging.Info(fmt.Sprintf("Starting GUI mode (webkit_cgo=%v)", webkit.IsNativeAvailable()))
 	app := &BrowserApp{
 		version:   version,
 	}
 	if err := app.Initialize(); err != nil {
-		log.Printf("Failed to initialize browser: %v", err)
+		logging.Error(fmt.Sprintf("Failed to initialize browser: %v", err))
 		if webkit.IsNativeAvailable() {
 			runtime.UnlockOSThread()
 		}
 	}
 	startupElapsed := time.Since(startupStart)
-	log.Printf("[startup] Application initialized in %v", startupElapsed)
+	logging.Info(fmt.Sprintf("[startup] Application initialized in %v", startupElapsed))
 	if startupElapsed > 500*time.Millisecond {
-		log.Printf("[startup] WARNING: Startup took %v (target: <500ms)", startupElapsed)
+		logging.Warn(fmt.Sprintf("[startup] WARNING: Startup took %v (target: <500ms)", startupElapsed))
 	}
 	app.Run()
 	// Setup output capture if configured
 	if err := app.setupOutputCapture(); err != nil {
-		log.Printf("Warning: failed to setup output capture: %v", err)
+		logging.Warn(fmt.Sprintf("Warning: failed to setup output capture: %v", err))
 	}
 	// Initialize WebKit log capture if configured
 	if app.config.Logging.CaptureCOutput {
 		if err := webkit.InitWebKitLogCapture(); err != nil {
-			log.Printf("Warning: failed to initialize WebKit log capture: %v", err)
+			logging.Warn(fmt.Sprintf("Warning: failed to initialize WebKit log capture: %v", err))
 		} else {
 			defer webkit.StopWebKitLogCapture()
 			webkit.StartWebKitOutputCapture()
 		}
 	}
-	log.Printf("Config initialized")
+	logging.Info(fmt.Sprintf("Config initialized"))
 	// Detect keyboard layout
 	environment.DetectAndSetKeyboardLocale()
 	}
 	app.database = database
 	app.queries = db.New(database)
-	log.Printf("Database opened at %s", app.config.Database.Path)
+	logging.Info(fmt.Sprintf("Database opened at %s", app.config.Database.Path))
 	// Cleanup expired certificate validations
 	if err := webkit.CleanupExpiredCertificateValidations(); err != nil {
-		log.Printf("Warning: failed to cleanup expired certificate validations: %v", err)
+		logging.Warn(fmt.Sprintf("Warning: failed to cleanup expired certificate validations: %v", err))
 	}
 	// Initialize services
 	// Load all caches in parallel for fast startup (target: <100ms)
 	if err := app.loadCachesParallel(context.Background()); err != nil {
-		log.Printf("Warning: failed to load caches: %v", err)
+		logging.Warn(fmt.Sprintf("Warning: failed to load caches: %v", err))
 		// Non-fatal - caches will fall back to defaults or DB queries
 	}
 	// Load zoom cache in parallel
 	g.Go(func() error {
 		if err := app.browserService.LoadZoomCacheFromDB(ctx); err != nil {
-			log.Printf("[cache] Failed to load zoom cache: %v", err)
+			logging.Error(fmt.Sprintf("[cache] Failed to load zoom cache: %v", err))
 			return err
 		}
 		return nil
 	// Load certificate validation cache in parallel
 	g.Go(func() error {
 		if err := app.browserService.LoadCertCacheFromDB(ctx); err != nil {
-			log.Printf("[cache] Failed to load cert cache: %v", err)
+			logging.Error(fmt.Sprintf("[cache] Failed to load cert cache: %v", err))
 			return err
 		}
 		return nil
 	// Load favorites cache in parallel
 	g.Go(func() error {
 		if err := app.browserService.LoadFavoritesCacheFromDB(ctx); err != nil {
-			log.Printf("[cache] Failed to load favorites cache: %v", err)
+			logging.Error(fmt.Sprintf("[cache] Failed to load favorites cache: %v", err))
 			return err
 		}
 		return nil
 	// Load fuzzy search cache in parallel for instant dmenu access
 	g.Go(func() error {
 		if err := app.browserService.LoadFuzzyCacheFromDB(ctx); err != nil {
-			log.Printf("[cache] Failed to load fuzzy cache: %v", err)
+			logging.Error(fmt.Sprintf("[cache] Failed to load fuzzy cache: %v", err))
 			return err
 		}
 		return nil
 	}
 	elapsed := time.Since(startTime)
-	log.Printf("[cache] All caches loaded in %v", elapsed)
+	logging.Info(fmt.Sprintf("[cache] All caches loaded in %v", elapsed))
 	// Warn if startup is slower than target
 	if elapsed > 100*time.Millisecond {
-		log.Printf("[cache] Warning: Cache loading took %v (target: <100ms)", elapsed)
+		logging.Warn(fmt.Sprintf("[cache] Warning: Cache loading took %v (target: <100ms)", elapsed))
 	}
 	return nil
 	// Initialize content blocking BEFORE creating WebViews so the service is ready
 	// to register WebViews as they are created (tabs, workspaces, popups)
 	if err := app.setupContentBlocking(); err != nil {
-		log.Printf("Warning: failed to setup content blocking: %v", err)
+		logging.Warn(fmt.Sprintf("Warning: failed to setup content blocking: %v", err))
 		// Continue without content blocking
 	}
 	// Create and setup WebView (this also creates TabManager which creates more WebViews)
 	if err := app.createWebView(); err != nil {
-		log.Printf("Warning: failed to create WebView: %v", err)
+		logging.Warn(fmt.Sprintf("Warning: failed to create WebView: %v", err))
 		return
 	}
 	// Apply URI scheme handlers after WebView creation
 	if err := webkit.ApplyURISchemeHandlers(app.webView.GetWebView()); err != nil {
-		log.Printf("Warning: failed to register URI scheme handlers: %v", err)
+		logging.Warn(fmt.Sprintf("Warning: failed to register URI scheme handlers: %v", err))
 	}
 	// Handle browse command if present (must use active tab's navigation controller)
 // cleanup handles cleanup on shutdown
 func (app *BrowserApp) cleanup() {
-	log.Printf("Starting browser cleanup...")
+	logging.Info(fmt.Sprintf("Starting browser cleanup..."))
 	// Cleanup window shortcuts first
 	if app.windowShortcutHandler != nil {
-		log.Printf("Cleaning up window shortcuts")
+		logging.Info(fmt.Sprintf("Cleaning up window shortcuts"))
 		app.windowShortcutHandler.Cleanup()
 		app.windowShortcutHandler = nil
 	}
 	// Cleanup tab manager (which cleans up all tabs and their workspaces)
 	if app.tabManager != nil {
-		log.Printf("Cleaning up tab manager")
+		logging.Info(fmt.Sprintf("Cleaning up tab manager"))
 		app.tabManager.Cleanup()
 		app.tabManager = nil
 	}
 	// Flush all caches to ensure pending writes complete before database closes
 	if app.browserService != nil {
-		log.Printf("Flushing all caches...")
+		logging.Info(fmt.Sprintf("Flushing all caches..."))
 		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 		defer cancel()
 		if err := app.browserService.FlushAllCaches(ctx); err != nil {
-			log.Printf("Warning: failed to flush caches: %v", err)
+			logging.Warn(fmt.Sprintf("Warning: failed to flush caches: %v", err))
 		}
 	}
 	// Close database with WAL checkpoint
 	if app.database != nil {
-		log.Printf("Performing WAL checkpoint and closing database...")
+		logging.Info(fmt.Sprintf("Performing WAL checkpoint and closing database..."))
 		// Run WAL checkpoint to commit all pending writes and truncate WAL file
 		if _, err := app.database.Exec("PRAGMA wal_checkpoint(TRUNCATE)"); err != nil {
-			log.Printf("Warning: WAL checkpoint failed: %v", err)
+			logging.Warn(fmt.Sprintf("Warning: WAL checkpoint failed: %v", err))
 		} else {
-			log.Printf("WAL checkpoint completed successfully")
+			logging.Info(fmt.Sprintf("WAL checkpoint completed successfully"))
 		}
 		// Close database connection
 		if closeErr := app.database.Close(); closeErr != nil {
-			log.Printf("Warning: failed to close database: %v", closeErr)
+			logging.Warn(fmt.Sprintf("Warning: failed to close database: %v", closeErr))
 		} else {
-			log.Printf("Database closed successfully")
+			logging.Info(fmt.Sprintf("Database closed successfully"))
 		}
 	}
-	log.Printf("Browser cleanup completed")
+	logging.Info(fmt.Sprintf("Browser cleanup completed"))
 }
 // setupOutputCapture initializes stdout/stderr capture if configured
 		// Capturing stdout/stderr works for non-GTK builds, but in native GTK mode
 		// it interferes with WebKit's own pipe management and crashes immediately.
 		if webkit.IsNativeAvailable() {
-			log.Printf("Warning: stdout/stderr capture is not supported in native GTK mode; skipping")
+			logging.Warn(fmt.Sprintf("Warning: stdout/stderr capture is not supported in native GTK mode; skipping"))
 			return nil
 		}
-		log.Printf("Warning: stdout/stderr capture is experimental and may interfere with normal operations")
+		logging.Warn(fmt.Sprintf("Warning: stdout/stderr capture is experimental and may interfere with normal operations"))
 		if logger := logging.GetLogger(); logger != nil {
 			outputCapture := logging.NewOutputCapture(logger)
 			if err := outputCapture.Start(); err != nil {
 	// Handle signals in a goroutine to quit the main loop
 	go func() {
 		sig := <-sigChan
-		log.Printf("Received signal %v - shutting down gracefully", sig)
+		logging.Info(fmt.Sprintf("Received signal %v - shutting down gracefully", sig))
 		webkit.QuitMainLoop()
 	}()
 }
 // runMainLoop starts the appropriate main loop based on WebKit availability
 func (app *BrowserApp) runMainLoop() {
 	if webkit.IsNativeAvailable() {
-		log.Printf("Entering GTK main loop…")
+		logging.Info(fmt.Sprintf("Entering GTK main loop…"))
 		webkit.RunMainLoop()
-		log.Printf("GTK main loop exited")
+		logging.Info(fmt.Sprintf("GTK main loop exited"))
 		// Flush pending history writes immediately after main loop exit
 		// This ensures database operations complete while GTK is still in a valid state
 		// MUST happen before cleanup() deferred call, which happens after this function returns
 		if app.browserService != nil {
-			log.Printf("Flushing pending history writes...")
+			logging.Info(fmt.Sprintf("Flushing pending history writes..."))
 			ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 			defer cancel()
 			if err := app.browserService.FlushHistoryQueue(ctx); err != nil {
-				log.Printf("Warning: history queue flush incomplete: %v", err)
+				logging.Warn(fmt.Sprintf("Warning: history queue flush incomplete: %v", err))
 			} else {
-				log.Printf("History queue flushed successfully")
+				logging.Info(fmt.Sprintf("History queue flushed successfully"))
 			}
 		}
 	} else {
-		log.Printf("Not entering GUI loop (non-CGO build)")
+		logging.Info(fmt.Sprintf("Not entering GUI loop (non-CGO build)"))
 		// In non-CGO mode, just wait for signals
 		sigChan := make(chan os.Signal, 1)
 		signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
 		sig := <-sigChan
-		log.Printf("Received signal %v - exiting", sig)
+		logging.Info(fmt.Sprintf("Received signal %v - exiting", sig))
 	}
 }

M internal/app/browser/focus_state_machine.go +40 -40

 import (
 	"container/heap"
 	"fmt"
-	"log"
 	"runtime/debug"
 	"sync"
 	"time"
+	"github.com/bnema/dumber/internal/logging"
 	"github.com/bnema/dumber/pkg/webkit"
 	"github.com/diamondburned/gotk4/pkg/gtk/v4"
 )
 	fsm.metricsEnabled = metricsEnabled
 	if focusDebug {
-		log.Printf("[FSM] Focus debug logging enabled")
+		logging.Info(fmt.Sprintf("[FSM] Focus debug logging enabled"))
 	}
 	if metricsEnabled {
-		log.Printf("[FSM] Focus metrics tracking enabled")
+		logging.Info(fmt.Sprintf("[FSM] Focus metrics tracking enabled"))
 	}
 }
 	fsm.mu.Lock()
 	defer fsm.mu.Unlock()
-	log.Printf("[FSM] Initializing focus state machine")
+	logging.Info(fmt.Sprintf("[FSM] Initializing focus state machine"))
 	fsm.currentState = StateInitializing
 	// Determine initial focus
 	leaves := fsm.wm.collectLeaves()
 	if len(leaves) == 0 {
-		log.Printf("[FSM] No panes found during initialization")
+		logging.Debug(fmt.Sprintf("[FSM] No panes found during initialization"))
 		fsm.currentState = StateIdle
 		return nil
 	}
 	initialPane := fsm.determineInitialFocus(leaves)
 	if initialPane == nil {
-		log.Printf("[FSM] Could not determine initial focus target")
+		logging.Warn(fmt.Sprintf("[FSM] Could not determine initial focus target"))
 		fsm.currentState = StateIdle
 		return nil
 	}
 	// Phase 3: Apply initial focus and CSS
 	if err := fsm.applyInitialFocus(initialPane); err != nil {
-		log.Printf("[FSM] Failed to apply initial focus: %v", err)
+		logging.Error(fmt.Sprintf("[FSM] Failed to apply initial focus: %v", err))
 		fsm.currentState = StateIdle
 		return err
 	}
 	// Phase 7: Transition to idle state
 	fsm.currentState = StateIdle
-	log.Printf("[FSM] Focus state machine initialized successfully with pane %p", initialPane)
+	logging.Info(fmt.Sprintf("[FSM] Focus state machine initialized successfully with pane %p", initialPane))
 	return nil
 }
 	fsm.mu.Lock()
 	defer fsm.mu.Unlock()
-	log.Printf("[FSM] Shutting down focus state machine")
+	logging.Info(fmt.Sprintf("[FSM] Shutting down focus state machine"))
 	// Signal shutdown
 	close(fsm.shutdownChan)
 		fsm.settlingTimer.Stop()
 	}
-	log.Printf("[FSM] Focus state machine shutdown complete")
+	logging.Info(fmt.Sprintf("[FSM] Focus state machine shutdown complete"))
 }
 // RequestFocus queues a focus change request with priority and deduplication
 			fsm.mu.Unlock()
 		}
 		if fsm.debugEnabled {
-			log.Printf("[FSM] Duplicate request ignored: %s -> %p", request.Source, request.TargetNode)
+			logging.Debug(fmt.Sprintf("[FSM] Duplicate request ignored: %s -> %p", request.Source, request.TargetNode))
 		}
 		return nil
 	}
 			fsm.mu.Unlock()
 		}
 		if fsm.debugEnabled {
-			log.Printf("[FSM] Request coalesced: %s -> %p", request.Source, request.TargetNode)
+			logging.Debug(fmt.Sprintf("[FSM] Request coalesced: %s -> %p", request.Source, request.TargetNode))
 		}
 		return nil
 	}
 		return
 	}
-	log.Printf("[FSM] Active pane invalidated: %p", node)
+	logging.Debug(fmt.Sprintf("[FSM] Active pane invalidated: %p", node))
 	fsm.activePane = nil
 	if fsm.wm != nil && fsm.wm.app != nil {
 		if leaf.pane != nil && leaf.pane.webView != nil {
 			url := leaf.pane.webView.GetCurrentURL()
 			if url != "" && url != "about:blank" {
-				log.Printf("[FSM] Selected pane with content as initial focus: %s", url)
+				logging.Debug(fmt.Sprintf("[FSM] Selected pane with content as initial focus: %s", url))
 				return leaf
 			}
 		}
 	// Priority 2: Top-left pane (geometrically)
 	if topLeft := fsm.findTopLeftPane(leaves); topLeft != nil {
-		log.Printf("[FSM] Selected top-left pane as initial focus")
+		logging.Debug(fmt.Sprintf("[FSM] Selected top-left pane as initial focus"))
 		return topLeft
 	}
 	// Priority 3: First pane in tree order
-	log.Printf("[FSM] Selected first pane as initial focus")
+	logging.Debug(fmt.Sprintf("[FSM] Selected first pane as initial focus"))
 	return leaves[0]
 }
 		return ErrInvalidTarget
 	}
-	log.Printf("[FSM] Applying initial focus to pane %p", node)
+	logging.Debug(fmt.Sprintf("[FSM] Applying initial focus to pane %p", node))
 	// Apply GTK focus
 	if err := fsm.applyGTKFocus(node); err != nil {
 func (fsm *FocusStateMachine) processQueue() {
 	defer fsm.queueProcessor.Done()
-	log.Printf("[FSM] Focus request queue processor started")
+	logging.Debug(fmt.Sprintf("[FSM] Focus request queue processor started"))
 	for {
 		select {
 			// Legacy channel for backward compatibility
 			fsm.handleFocusRequest(request)
 		case <-fsm.shutdownChan:
-			log.Printf("[FSM] Focus request queue processor shutting down")
+			logging.Debug(fmt.Sprintf("[FSM] Focus request queue processor shutting down"))
 			return
 		}
 	}
 		fsm.mu.Lock()
 		fsm.metrics.FailedRequests++
 		fsm.mu.Unlock()
-		log.Printf("[FSM] Invalid focus request %s: %v", request.ID, err)
+		logging.Error(fmt.Sprintf("[FSM] Invalid focus request %s: %v", request.ID, err))
 		return
 	}
 	fsm.mu.RUnlock()
 	if currentActive == request.TargetNode {
-		log.Printf("[FSM] Focus request %s: already focused on target", request.ID)
+		logging.Debug(fmt.Sprintf("[FSM] Focus request %s: already focused on target", request.ID))
 		fsm.recordProcessTime(time.Since(startTime))
 		return
 	}
-	log.Printf("[FSM] Processing focus request %s: %s -> %p",
+	logging.Debug(fmt.Sprintf("[FSM] Processing focus request %s: %s -> %p",
-		request.ID, request.Source, request.TargetNode)
+		request.ID, request.Source, request.TargetNode))
 	// GTK operations must run on main thread - always use IdleAdd for simplicity
 	var err error
 		fsm.mu.Lock()
 		fsm.metrics.FailedRequests++
 		fsm.mu.Unlock()
-		log.Printf("[FSM] Focus request %s failed: %v", request.ID, err)
+		logging.Error(fmt.Sprintf("[FSM] Focus request %s failed: %v", request.ID, err))
 	} else {
 		fsm.mu.Lock()
 		fsm.metrics.SuccessfulRequests++
 	// Start settling timer
 	fsm.startSettlingTimer()
-	log.Printf("[FSM] Focus change completed: %p -> %p", oldPane, newPane)
+	logging.Debug(fmt.Sprintf("[FSM] Focus change completed: %p -> %p", oldPane, newPane))
 	return nil
 }
 		}
 		if fsm.reconcileCount > fsm.maxReconcileAttempts {
-			log.Printf("[FSM] WARNING: Reconciliation loop detected, skipping (attempt %d)", fsm.reconcileCount)
+			logging.Warn(fmt.Sprintf("[FSM] WARNING: Reconciliation loop detected, skipping (attempt %d)", fsm.reconcileCount))
 			fsm.mu.Unlock()
 			return
 		}
 		fsm.mu.Unlock()
-		log.Printf("[FSM] CSS inconsistencies found: %v", issues)
+		logging.Debug(fmt.Sprintf("[FSM] CSS inconsistencies found: %v", issues))
-		log.Printf("[FSM] Triggering CSS reconciliation (attempt %d)", fsm.reconcileCount)
+		logging.Debug(fmt.Sprintf("[FSM] Triggering CSS reconciliation (attempt %d)", fsm.reconcileCount))
 		// Track reconciliation in metrics
 		fsm.mu.Lock()
 	for i := 0; i < fsm.priorityQueue.Len(); i++ {
 		pending := (*fsm.priorityQueue)[i]
 		if pending.TargetNode == request.TargetNode {
-			log.Printf("[FSM] Coalescing request to same target: %p", request.TargetNode)
+			logging.Debug(fmt.Sprintf("[FSM] Coalescing request to same target: %p", request.TargetNode))
 			return true
 		}
 	}
 	defer fsm.mu.Unlock()
 	heap.Push(fsm.priorityQueue, &request)
-	log.Printf("[FSM] Requeued request due to higher priority: %s", request.ID)
+	logging.Debug(fmt.Sprintf("[FSM] Requeued request due to higher priority: %s", request.ID))
 	// Signal that a request is pending
 	select {
 	}
 	if node.focusControllerToken != 0 {
-		log.Printf("[FSM] Controller already attached to pane %p", node)
+		logging.Debug(fmt.Sprintf("[FSM] Controller already attached to pane %p", node))
 		return
 	}
 		}
 		node.lastFocusEnterTime = now
-		log.Printf("[FSM] GTK focus enter: %p", node)
+		logging.Debug(fmt.Sprintf("[FSM] GTK focus enter: %p", node))
 		// Don't automatically change focus on GTK enter - let user interactions drive this
 		// This prevents infinite loops with our own focus changes
 	})
 		}
 		node.lastFocusLeaveTime = now
-		log.Printf("[FSM] GTK focus leave: %p", node)
+		logging.Debug(fmt.Sprintf("[FSM] GTK focus leave: %p", node))
 		// Similarly, don't react to GTK leave events automatically
 	})
 	// Store controller pointer as token for later removal
 	node.focusControllerToken = uintptr(controller.Native())
 	if node.focusControllerToken != 0 {
-		log.Printf("[FSM] Attached GTK focus controller to pane %p with token %d", node, node.focusControllerToken)
+		logging.Debug(fmt.Sprintf("[FSM] Attached GTK focus controller to pane %p with token %d", node, node.focusControllerToken))
 	}
 }
 	}
 	if node.focusControllerToken != token {
-		log.Printf("[FSM] Token mismatch, skipping detach for pane %p", node)
+		logging.Debug(fmt.Sprintf("[FSM] Token mismatch, skipping detach for pane %p", node))
 		return
 	}
 	// Note: In GTK4, controllers are automatically removed when widget is destroyed
 	// We just need to clear our token reference
-	log.Printf("[FSM] Detached GTK focus controller from pane %p", node)
+	logging.Debug(fmt.Sprintf("[FSM] Detached GTK focus controller from pane %p", node))
 }
 // attachGTKControllersToAllPanes attaches focus controllers to all existing panes
 		fsm.attachGTKController(leaf)
 	}
-	log.Printf("[FSM] Attached GTK focus controllers to %d panes", len(leaves))
+	logging.Debug(fmt.Sprintf("[FSM] Attached GTK focus controllers to %d panes", len(leaves)))
 }
 // FocusDebugInfo contains comprehensive debug information about the focus system
 // ForceValidation manually triggers CSS consistency check and validation
 func (fsm *FocusStateMachine) ForceValidation() []string {
-	log.Printf("[FSM] Force validation requested")
+	logging.Debug(fmt.Sprintf("[FSM] Force validation requested"))
 	// Trigger CSS verification
 	fsm.verifyCSSState()
 		}
 	}
-	log.Printf("[FSM] Force validation completed: %d issues found", len(issues))
+	logging.Debug(fmt.Sprintf("[FSM] Force validation completed: %d issues found", len(issues)))
 	return issues
 }
 	defer fsm.mu.Unlock()
 	fsm.historyRing = NewRingBuffer[FocusTransition](50)
-	log.Printf("[FSM] Focus transition history cleared")
+	logging.Debug(fmt.Sprintf("[FSM] Focus transition history cleared"))
 }
 // GetMetrics returns performance metrics for the focus system

M internal/app/browser/pane.go +6 -5

 package browser
 import (
-	"log"
+	"fmt"
 	"time"
 	"github.com/bnema/dumber/internal/app/control"
 	"github.com/bnema/dumber/internal/app/messaging"
+	"github.com/bnema/dumber/internal/logging"
 	"github.com/bnema/dumber/pkg/webkit"
 )
 	if p.shortcutHandler != nil {
 		p.shortcutHandler.Detach()
-		log.Printf("[pane-%s] Cleaned up shortcuts", p.id)
+		logging.Debug(fmt.Sprintf("[pane-%s] Cleaned up shortcuts", p.id))
 	}
 	if p.navigationController != nil {
 	// Destroy WebView to unregister from global registry and release resources
 	if p.webView != nil && !p.webView.IsDestroyed() {
 		if err := p.webView.Destroy(); err != nil {
-			log.Printf("[pane-%s] failed to destroy webview: %v", p.id, err)
+			logging.Error(fmt.Sprintf("[pane-%s] failed to destroy webview: %v", p.id, err))
 		} else {
-			log.Printf("[pane-%s] successfully destroyed webview", p.id)
+			logging.Debug(fmt.Sprintf("[pane-%s] successfully destroyed webview", p.id))
 		}
 	}
 	}); ok {
 		workspaceManager.removeFromMaps(p.webView)
 		workspaceManager.removeFromAppPanes(p)
-		log.Printf("[pane-%s] Cleaned up from workspace tracking", p.id)
+		logging.Debug(fmt.Sprintf("[pane-%s] Cleaned up from workspace tracking", p.id))
 	}
 }

M internal/app/browser/shortcuts.go +6 -6

 import (
 	"encoding/json"
 	"fmt"
-	"log"
 	"github.com/bnema/dumber/internal/app/control"
 	"github.com/bnema/dumber/internal/config"
+	"github.com/bnema/dumber/internal/logging"
 	"github.com/bnema/dumber/pkg/webkit"
 )
 		if !s.isActivePane() {
 			return
 		}
-		log.Printf("Shortcut: Reload page")
+		logging.Debug("Shortcut: Reload page")
 		_ = s.webView.Reload()
 	})
 		if !s.isActivePane() {
 			return
 		}
-		log.Printf("Shortcut: Hard reload page")
+		logging.Debug("Shortcut: Hard reload page")
 		_ = s.webView.ReloadBypassCache()
 	})
 		if !s.isActivePane() {
 			return
 		}
-		log.Printf("Shortcut: F5 reload")
+		logging.Debug("Shortcut: F5 reload")
 		_ = s.webView.Reload()
 	})
 	payload, err := json.Marshal(s.config.Workspace)
 	if err != nil {
-		log.Printf("Shortcut: failed to marshal workspace config: %v", err)
+		logging.Error(fmt.Sprintf("Shortcut: failed to marshal workspace config: %v", err))
 		return
 	}
 })();`, string(payload))
 	if err := s.webView.InjectScript(script); err != nil {
-		log.Printf("Shortcut: failed to expose workspace config: %v", err)
+		logging.Error(fmt.Sprintf("Shortcut: failed to expose workspace config: %v", err))
 	}
 }

M internal/app/browser/stacked_panes.go +34 -35

 import (
 	"errors"
 	"fmt"
-	"log"
 	"sync/atomic"
 	"time"
+	"github.com/bnema/dumber/internal/logging"
+	"github.com/bnema/dumber/pkg/webkit"
 	"github.com/diamondburned/gotk4/pkg/gdk/v4"
 	"github.com/diamondburned/gotk4/pkg/gtk/v4"
-	"github.com/bnema/dumber/pkg/webkit"
 )
 const (
 	// Insert the new pane right after the current pane
 	insertIndex := currentIndex + 1
-	log.Printf("[workspace] adding to existing stack: currentIndex=%d insertIndex=%d stackSize=%d",
+	logging.Debug(fmt.Sprintf("[workspace] adding to existing stack: currentIndex=%d insertIndex=%d stackSize=%d",
-		currentIndex, insertIndex, len(stackNode.stackedPanes))
+		currentIndex, insertIndex, len(stackNode.stackedPanes)))
 	// Set parent relationship
 	newLeaf.parent = stackNode
 		if box, ok := stackNode.stackWrapper.(*gtk.Box); ok && newLeaf.container != nil && newLeaf.titleBar != nil {
 			box.InsertChildAfter(newLeaf.container, newLeaf.titleBar)
 		}
-		log.Printf("[workspace] inserted widgets at position %d (after widget %p)", insertIndex, insertAfterWidget)
+		logging.Debug(fmt.Sprintf("[workspace] inserted widgets at position %d (after widget %p)", insertIndex, insertAfterWidget))
 	} else {
 		// Insert at the beginning (insertIndex = 0)
 		if box, ok := stackNode.stackWrapper.(*gtk.Box); ok && newLeaf.container != nil {
 		if box, ok := stackNode.stackWrapper.(*gtk.Box); ok && newLeaf.titleBar != nil {
 			box.Prepend(newLeaf.titleBar)
 		}
-		log.Printf("[workspace] prepended widgets at position 0")
+		logging.Debug("[workspace] prepended widgets at position 0")
 	}
 	return stackNode, insertIndex, nil
 // convertToStackedContainer converts a simple pane to a stacked container
 func (spm *StackedPaneManager) convertToStackedContainer(target, newLeaf *paneNode) (*paneNode, int, error) {
-	log.Printf("[workspace] converting pane to stacked: %p", target)
+	logging.Debug(fmt.Sprintf("[workspace] converting pane to stacked: %p", target))
 	// Create the wrapper container - this is what will be used by splitNode
 	stackWrapperContainer := gtk.NewBox(gtk.OrientationVertical, 0)
 	if newLeaf.container != nil {
 		parentWidget := webkit.WidgetGetParent(newLeaf.container)
 		if parentWidget != nil {
-			log.Printf("[workspace] unparenting new pane container %p from parent %p before stack append", newLeaf.container, parentWidget)
+			logging.Debug(fmt.Sprintf("[workspace] unparenting new pane container %p from parent %p before stack append", newLeaf.container, parentWidget))
 			webkit.WidgetUnparent(newLeaf.container)
 			// Verify unparent succeeded
 			if finalParent := webkit.WidgetGetParent(newLeaf.container); finalParent != nil {
-				log.Printf("[workspace] WARNING: container %p still has parent %p after unparent", newLeaf.container, finalParent)
+				logging.Warn(fmt.Sprintf("[workspace] container %p still has parent %p after unparent", newLeaf.container, finalParent))
 			}
 		}
 	}
 			currentTitle := currentlyActivePane.pane.webView.GetTitle()
 			if currentTitle != "" {
 				spm.updateTitleBarLabel(currentlyActivePane, currentTitle)
-				log.Printf("[workspace] updated title bar for pane becoming inactive during stack creation: %s", currentTitle)
+				logging.Debug(fmt.Sprintf("[workspace] updated title bar for pane becoming inactive during stack creation: %s", currentTitle))
 			}
 		}
 	}
 	// Set focus on the new pane synchronously
 	spm.wm.SetActivePane(newLeaf, SourceSplit)
-	log.Printf("[workspace] stacked new pane: stackNode=%p newLeaf=%p stackSize=%d activeIndex=%d insertIndex=%d",
+	logging.Debug(fmt.Sprintf("[workspace] stacked new pane: stackNode=%p newLeaf=%p stackSize=%d activeIndex=%d insertIndex=%d",
-		stackNode, newLeaf, len(stackNode.stackedPanes), stackNode.activeStackIndex, insertIndex)
+		stackNode, newLeaf, len(stackNode.stackedPanes), stackNode.activeStackIndex, insertIndex))
 	return newLeaf, nil
 }
 // UpdateStackVisibility updates the visibility of panes in a stack
 func (spm *StackedPaneManager) UpdateStackVisibility(stackNode *paneNode) {
-	log.Printf("[workspace] updateStackVisibility called: stackNode=%p", stackNode)
+	logging.Debug(fmt.Sprintf("[workspace] updateStackVisibility called: stackNode=%p", stackNode))
 	if stackNode == nil {
-		log.Printf("[workspace] updateStackVisibility aborted: stackNode is nil")
+		logging.Debug("[workspace] updateStackVisibility aborted: stackNode is nil")
 		return
 	}
 	if !stackNode.isStacked {
-		log.Printf("[workspace] updateStackVisibility aborted: stackNode.isStacked=%v", stackNode.isStacked)
+		logging.Debug(fmt.Sprintf("[workspace] updateStackVisibility aborted: stackNode.isStacked=%v", stackNode.isStacked))
 		return
 	}
 	if len(stackNode.stackedPanes) == 0 {
-		log.Printf("[workspace] updateStackVisibility aborted: stackedPanes empty, len=%d", len(stackNode.stackedPanes))
+		logging.Debug(fmt.Sprintf("[workspace] updateStackVisibility aborted: stackedPanes empty, len=%d", len(stackNode.stackedPanes)))
 		return
 	}
 	activeIndex := stackNode.activeStackIndex
 	if activeIndex < 0 || activeIndex >= len(stackNode.stackedPanes) {
-		log.Printf("[workspace] updateStackVisibility: correcting activeIndex from %d to 0", activeIndex)
+		logging.Debug(fmt.Sprintf("[workspace] updateStackVisibility: correcting activeIndex from %d to 0", activeIndex))
 		activeIndex = 0
 		stackNode.activeStackIndex = activeIndex
 	}
-	log.Printf("[workspace] updating stack visibility: activeIndex=%d stackSize=%d", activeIndex, len(stackNode.stackedPanes))
+	logging.Debug(fmt.Sprintf("[workspace] updating stack visibility: activeIndex=%d stackSize=%d", activeIndex, len(stackNode.stackedPanes)))
 	// CRITICAL: Process ALL panes in a single pass to prevent flickering
 	for i, pane := range stackNode.stackedPanes {
 			if pane.titleBar != nil {
 				webkit.WidgetSetVisible(pane.titleBar, false) // ABSOLUTE RULE: never visible for active pane
 			}
-			log.Printf("[workspace] active pane %d: container=visible, titleBar=HIDDEN", i)
+			logging.Debug(fmt.Sprintf("[workspace] active pane %d: container=visible, titleBar=HIDDEN", i))
 		} else {
 			// Inactive panes: hide container, show title bar
 			if pane.container != nil {
 	// This is more reliable than trying to match panes
 	currentIndex := stackNode.activeStackIndex
 	if currentIndex < 0 || currentIndex >= len(stackNode.stackedPanes) {
-		log.Printf("[workspace] navigateStack: invalid activeStackIndex=%d, resetting to 0", currentIndex)
+		logging.Debug(fmt.Sprintf("[workspace] navigateStack: invalid activeStackIndex=%d, resetting to 0", currentIndex))
 		currentIndex = 0
 		stackNode.activeStackIndex = 0
 	}
 		currentTitle := currentActivePane.pane.webView.GetTitle()
 		if currentTitle != "" {
 			spm.updateTitleBarLabel(currentActivePane, currentTitle)
-			log.Printf("[workspace] updated title bar for pane transitioning to INACTIVE: %s", currentTitle)
+			logging.Debug(fmt.Sprintf("[workspace] updated title bar for pane transitioning to INACTIVE: %s", currentTitle))
 		}
 	}
 	newActivePane := stackNode.stackedPanes[newIndex]
 	spm.wm.SetActivePane(newActivePane, SourceStackNav)
-	log.Printf("[workspace] navigated stack: direction=%s from=%d to=%d stackSize=%d",
+	logging.Debug(fmt.Sprintf("[workspace] navigated stack: direction=%s from=%d to=%d stackSize=%d",
-		direction, currentIndex, newIndex, len(stackNode.stackedPanes))
+		direction, currentIndex, newIndex, len(stackNode.stackedPanes)))
 	return true
 }
 		if paneIndex != -1 && paneIndex != activeIndex {
 			// This is an INACTIVE pane - safe to update title bar
 			spm.updateTitleBarLabel(node, title)
-			log.Printf("[workspace] updated title bar for INACTIVE WebView %d: %s", webView.ID(), title)
+			logging.Debug(fmt.Sprintf("[workspace] updated title bar for INACTIVE WebView %d: %s", webView.ID(), title))
 		} else {
 			// This is the ACTIVE pane - title bar should remain hidden
-			log.Printf("[workspace] skipped title bar update for ACTIVE WebView %d: %s", webView.ID(), title)
+			logging.Debug(fmt.Sprintf("[workspace] skipped title bar update for ACTIVE WebView %d: %s", webView.ID(), title))
 		}
 	}
 }
 	// Create new title bar with updated title and favicon
 	newTitleBar := spm.createTitleBarWithTitle(title, pageURL)
 	if newTitleBar == nil {
-		log.Printf("[workspace] failed to create new title bar")
+		logging.Error("[workspace] failed to create new title bar")
 		return
 	}
 			}
 		}
-		log.Printf("[workspace] replaced title bar for pane %d: %p", paneIndex, node)
+		logging.Debug(fmt.Sprintf("[workspace] replaced title bar for pane %d: %p", paneIndex, node))
 	}
 }
 	if pageURL != "" && spm.wm != nil && spm.wm.app != nil && spm.wm.app.faviconService != nil {
 		spm.wm.app.faviconService.GetFaviconTexture(pageURL, func(texture *gdk.Texture, err error) {
 			if err != nil {
-				log.Printf("[favicon] Failed to load favicon for title bar: %s - %v", pageURL, err)
+				logging.Warn(fmt.Sprintf("[favicon] Failed to load favicon for title bar: %s - %v", pageURL, err))
 				return
 			}
 		return errors.New("node not found in stack")
 	}
-	log.Printf("[workspace] closing stacked pane: index=%d stackSize=%d", nodeIndex, len(stackNode.stackedPanes))
+	logging.Debug(fmt.Sprintf("[workspace] closing stacked pane: index=%d stackSize=%d", nodeIndex, len(stackNode.stackedPanes)))
 	// Detach hover/focus controllers before tearing down widgets to avoid GTK
 	// callbacks referencing freed memory during destruction.
 		stackNode.stackWrapper = nil
 		stackNode.stackedPanes = nil
-		log.Printf("[workspace] converted stack back to regular pane")
+		logging.Debug("[workspace] converted stack back to regular pane")
 		return nil
 	default:
 		generation := spm.wm.nextCleanupGeneration()
 		spm.wm.cleanupPane(node, generation)
-		log.Printf("[workspace] closed pane from stack: remaining=%d activeIndex=%d",
+		logging.Debug(fmt.Sprintf("[workspace] closed pane from stack: remaining=%d activeIndex=%d",
-			len(stackNode.stackedPanes), stackNode.activeStackIndex)
+			len(stackNode.stackedPanes), stackNode.activeStackIndex))
 		return nil
 	}
 }
 		if p == pane {
 			// Only switch if it's not already active
 			if i != stackNode.activeStackIndex {
-				log.Printf("[workspace] title bar clicked: switching from pane %d to pane %d",
+				logging.Debug(fmt.Sprintf("[workspace] title bar clicked: switching from pane %d to pane %d",
-					stackNode.activeStackIndex, i)
+					stackNode.activeStackIndex, i))
 				// Update title bar for the pane transitioning from ACTIVE to INACTIVE
 				currentActivePane := stackNode.stackedPanes[stackNode.activeStackIndex]

M internal/app/browser/webview.go +41 -41

 	"context"
 	"encoding/json"
 	"fmt"
-	"log"
 	"os"
 	"path/filepath"
 	"time"
 	"github.com/bnema/dumber/internal/app/messaging"
 	"github.com/bnema/dumber/internal/config"
 	"github.com/bnema/dumber/internal/filtering"
+	"github.com/bnema/dumber/internal/logging"
 	"github.com/bnema/dumber/internal/services"
 	"github.com/bnema/dumber/pkg/webkit"
 )
 	// Build WebKit configuration with data directories for persistence
 	cfg := &webkit.Config{
-		UserAgent:                 buildUserAgent(app.config),
+		UserAgent:             buildUserAgent(app.config),
-		EnableJavaScript:          true,
+		EnableJavaScript:      true,
-		EnableWebGL:               true,
+		EnableWebGL:           true,
-		EnableMediaStream:         true,
+		EnableMediaStream:     true,
-		HardwareAcceleration:      true,
+		HardwareAcceleration:  true,
-		DefaultFontSize:           app.config.Appearance.DefaultFontSize,
+		DefaultFontSize:       app.config.Appearance.DefaultFontSize,
-		MinimumFontSize:           8,
+		MinimumFontSize:       8,
-		EnablePageCache:           true, // Instant back/forward navigation (bfcache)
+		EnablePageCache:       true, // Instant back/forward navigation (bfcache)
-		EnableSmoothScrolling:     true, // Smooth scrolling animations
+		EnableSmoothScrolling: true, // Smooth scrolling animations
-		DataDir:                   webkitData,
+		DataDir:               webkitData,
-		CacheDir:             webkitCache,
+		CacheDir:              webkitCache,
-		AppearanceConfigJSON: app.buildAppearanceConfigJSON(),
+		AppearanceConfigJSON:  app.buildAppearanceConfigJSON(),
-		CreateWindow:         true, // Default to creating a window for standalone WebViews
+		CreateWindow:          true, // Default to creating a window for standalone WebViews
 	}
 	return cfg, nil
 	payload, err := json.Marshal(paletteConfig)
 	if err != nil {
-		log.Printf("[webview] Failed to marshal palette config: %v", err)
+		logging.Error(fmt.Sprintf("[webview] Failed to marshal palette config: %v", err))
 		return ""
 	}
 	pane.initializeGUITracking()
 	// GUI manager will be loaded on-demand when needed
-	log.Printf("[webview] Created pane for webview: %d", view.ID())
+	logging.Debug(fmt.Sprintf("[webview] Created pane for webview: %d", view.ID()))
 	app.attachPaneHandlers(pane)
 	return pane, nil
 		go func(url, title string) {
 			ctx := context.Background()
 			if err := app.browserService.UpdatePageTitle(ctx, url, title); err != nil {
-				log.Printf("Warning: failed to update page title: %v", err)
+				logging.Warn(fmt.Sprintf("Warning: failed to update page title: %v", err))
 			}
 		}(url, title)
 		node := app.workspace.GetNodeForWebView(pane.webView)
 		if node != nil {
 			app.workspace.setupPopupHandling(pane.webView, node)
-			log.Printf("[webview] Setup native popup handling for WebView ID: %d", pane.webView.ID())
+			logging.Debug(fmt.Sprintf("[webview] Setup native popup handling for WebView ID: %d", pane.webView.ID()))
 		}
 	}
 }
 // createWebView creates and configures the WebView
 func (app *BrowserApp) createWebView() error {
-	log.Printf("Creating WebView (native backend expected: %v)", webkit.IsNativeAvailable())
+	logging.Info(fmt.Sprintf("Creating WebView (native backend expected: %v)", webkit.IsNativeAvailable()))
 	cfg, err := app.buildWebkitConfig()
 	if err != nil {
 		// Initialize tab system (creates root container with tab bar and first tab)
 		if err := app.tabManager.Initialize(initialURL); err != nil {
-			log.Printf("ERROR: failed to initialize tab manager: %v", err)
+			logging.Error(fmt.Sprintf("ERROR: failed to initialize tab manager: %v", err))
 			return err
 		}
 		rootContainer := app.tabManager.GetRootContainer()
 		if rootContainer != nil {
 			window.SetChild(rootContainer)
-			log.Printf("[tabs] Tab system initialized and set as window content")
+			logging.Info(fmt.Sprintf("[tabs] Tab system initialized and set as window content"))
 		} else {
-			log.Printf("ERROR: tab manager root container is nil")
+			logging.Error(fmt.Sprintf("ERROR: tab manager root container is nil"))
 			return fmt.Errorf("failed to get tab manager root container")
 		}
 	}
 	if window != nil {
 		app.windowShortcutHandler = NewWindowShortcutHandler(window, app)
 		if app.windowShortcutHandler != nil {
-			log.Printf("Window-level global shortcuts initialized")
+			logging.Info(fmt.Sprintf("Window-level global shortcuts initialized"))
 		} else {
-			log.Printf("Warning: failed to initialize window-level shortcuts")
+			logging.Warn(fmt.Sprintf("Warning: failed to initialize window-level shortcuts"))
 		}
 	}
 	// Initialize FaviconService after WebView is created
 	if err := app.initializeFaviconService(); err != nil {
-		log.Printf("Warning: failed to initialize favicon service: %v", err)
+		logging.Warn(fmt.Sprintf("Warning: failed to initialize favicon service: %v", err))
 		// Continue without favicon service - not critical
 	}
 	// Apply initial zoom and show window
 	app.zoomController.ApplyInitialZoom()
-	log.Printf("Showing WebView window…")
+	logging.Info(fmt.Sprintf("Showing WebView window…"))
 	if err := view.Show(); err != nil {
-		log.Printf("Warning: failed to show WebView: %v", err)
+		logging.Warn(fmt.Sprintf("Warning: failed to show WebView: %v", err))
 	} else if !webkit.IsNativeAvailable() {
-		log.Printf("Notice: running without webkit_cgo tag — no native window will be displayed.")
+		logging.Info(fmt.Sprintf("Notice: running without webkit_cgo tag — no native window will be displayed."))
 	}
 	return nil
 	}
 	app.faviconService = faviconService
-	log.Printf("[favicon] FaviconService initialized successfully")
+	logging.Info(fmt.Sprintf("[favicon] FaviconService initialized successfully"))
 	return nil
 }
 // setupContentBlocking initializes the content blocking system with proper timing
 func (app *BrowserApp) setupContentBlocking() error {
-	log.Printf("Initializing content blocking system...")
+	logging.Info(fmt.Sprintf("Initializing content blocking system..."))
 	// Enable WebKit debug logging if requested
 	webkit.SetupWebKitDebugLogging()
 	defer func() {
 		if r := recover(); r != nil {
-			log.Printf("Content blocking setup panic recovered: %v", r)
+			logging.Error(fmt.Sprintf("Content blocking setup panic recovered: %v", r))
 		}
 	}()
 	// Setup filter system
 	filterManager, err := filtering.SetupFilterSystem()
 	if err != nil {
-		log.Printf("Warning: Failed to setup filter system: %v", err)
+		logging.Warn(fmt.Sprintf("Warning: Failed to setup filter system: %v", err))
 		return nil // Don't fail browser startup, continue without filters
 	}
 	// Get data directory for content blocking service
 	dataDir, err := config.GetDataDir()
 	if err != nil {
-		log.Printf("Warning: Failed to get data dir for content blocking: %v", err)
+		logging.Warn(fmt.Sprintf("Warning: Failed to get data dir for content blocking: %v", err))
 		return nil
 	}
 	// Create content blocking service
 	cbService, err := filtering.NewContentBlockingService(dataDir+"/webkit", filterManager)
 	if err != nil {
-		log.Printf("Warning: Failed to create content blocking service: %v", err)
+		logging.Warn(fmt.Sprintf("Warning: Failed to create content blocking service: %v", err))
 		return nil
 	}
 	app.contentBlockingService = cbService
 	// Set up callback to apply network filters when they become ready
 	// This callback will be called from the async filter loading process
 	filterManager.SetFiltersReadyCallback(func() {
-		log.Printf("[filtering] Filters ready, distributing to all WebViews...")
+		logging.Info(fmt.Sprintf("[filtering] Filters ready, distributing to all WebViews..."))
 		// Get the WebKit JSON rules from filter manager
 		filterJSON, err := filterManager.GetNetworkFilters()
 		if err != nil {
-			log.Printf("[filtering] Failed to get network filters: %v", err)
+			logging.Error(fmt.Sprintf("[filtering] Failed to get network filters: %v", err))
 			return
 		}
 		if len(filterJSON) == 0 {
-			log.Printf("[filtering] No network filters to apply")
+			logging.Info(fmt.Sprintf("[filtering] No network filters to apply"))
 			return
 		}
-		log.Printf("[filtering] Got %d bytes of WebKit JSON rules", len(filterJSON))
+		logging.Debug(fmt.Sprintf("[filtering] Got %d bytes of WebKit JSON rules", len(filterJSON)))
 		// Signal the service that filters are ready - it will apply to all registered WebViews
 		cbService.SetFiltersReady(filterJSON)
-		log.Printf("[filtering] Content blocking enabled for all WebViews")
+		logging.Info(fmt.Sprintf("[filtering] Content blocking enabled for all WebViews"))
 	})
 	// Start async filter loading
 	// This allows filters to compile in the background while the browser starts
 	go func() {
 		if err := filtering.InitializeFiltersAsync(filterManager); err != nil {
-			log.Printf("Warning: failed to initialize filters asynchronously: %v", err)
+			logging.Warn(fmt.Sprintf("Warning: failed to initialize filters asynchronously: %v", err))
 		}
 	}()
-	log.Printf("Content blocking system initialization started")
+	logging.Info(fmt.Sprintf("Content blocking system initialization started"))
 	return nil
 }

M internal/app/browser/window_shortcuts.go +61 -61

 import (
 	"fmt"
-	"log"
 	"sync"
 	"time"
 	"github.com/bnema/dumber/internal/app/messaging"
+	"github.com/bnema/dumber/internal/logging"
 	"github.com/bnema/dumber/pkg/webkit"
 	"github.com/diamondburned/gotk4/pkg/gdk/v4"
 	"github.com/diamondburned/gotk4/pkg/gtk/v4"
 	}
 	if err := h.initialize(); err != nil {
-		log.Printf("[window-shortcuts] Failed to initialize: %v", err)
+		logging.Error(fmt.Sprintf("[window-shortcuts] Failed to initialize: %v", err))
 		return nil
 	}
 	// Register hardware keycode-based shortcuts (for AZERTY/international keyboards)
 	if err := h.registerKeycodeShortcuts(); err != nil {
-		log.Printf("[window-shortcuts] Failed to register keycode shortcuts: %v", err)
+		logging.Error(fmt.Sprintf("[window-shortcuts] Failed to register keycode shortcuts: %v", err))
 	}
 	return h.registerGlobalShortcuts()
 	for _, shortcut := range shortcuts {
 		h.shortcuts.RegisterShortcut(shortcut.key, shortcut.handler)
-		log.Printf("[window-shortcuts] Registered global shortcut: %s (%s)",
+		logging.Debug(fmt.Sprintf("[window-shortcuts] Registered global shortcut: %s (%s)",
-			shortcut.key, shortcut.desc)
+			shortcut.key, shortcut.desc))
 	}
 	// NOTE: Ctrl+P is NOT registered here - it's handled by WebView's keyboard bridge
 		// Handle Ctrl+Tab for next tab
 		if keyval == gdkKeyTab && state.Has(gdk.ControlMask) && !state.Has(gdk.ShiftMask) {
-			log.Printf("[window-shortcuts] Ctrl+Tab -> next tab")
+			logging.Debug(fmt.Sprintf("[window-shortcuts] Ctrl+Tab -> next tab"))
 			h.handleNextTab()
 			return true // Consume event to prevent focus cycling
 		}
 		// Handle Ctrl+Shift+Tab for previous tab
 		if keyval == gdkKeyTab && state.Has(gdk.ControlMask) && state.Has(gdk.ShiftMask) {
-			log.Printf("[window-shortcuts] Ctrl+Shift+Tab -> previous tab")
+			logging.Debug(fmt.Sprintf("[window-shortcuts] Ctrl+Shift+Tab -> previous tab"))
 			h.handlePrevTab()
 			return true // Consume event to prevent focus cycling
 		}
 		if state.Has(gdk.AltMask) && !state.Has(gdk.ControlMask) && !state.Has(gdk.ShiftMask) {
 			// Check if this is a number key
 			if tabIndex, ok := keycodeToTab[keycode]; ok {
-				log.Printf("[window-shortcuts] Hardware keycode shortcut: Alt+keycode(%d) -> tab %d", keycode, tabIndex)
+				logging.Debug(fmt.Sprintf("[window-shortcuts] Hardware keycode shortcut: Alt+keycode(%d) -> tab %d", keycode, tabIndex))
 				h.handleDirectTabSwitch(tabIndex)
 				return true // Handled
 			}
 			}
 			if handled {
-				log.Printf("[window-shortcuts] Tab mode action: %s", action)
+				logging.Debug(fmt.Sprintf("[window-shortcuts] Tab mode action: %s", action))
 				h.handleTabModeAction(action)
 				return true // Consume event
 			}
 	})
 	gtkWindow.AddController(keyController)
-	log.Printf("[window-shortcuts] Registered capture phase shortcuts: Ctrl+Tab, Alt+number")
+	logging.Debug(fmt.Sprintf("[window-shortcuts] Registered capture phase shortcuts: Ctrl+Tab, Alt+number"))
 	return nil
 }
 	h.lastCopyURL = time.Now()
 	if h.app.activePane == nil || h.app.activePane.webView == nil {
-		log.Printf("[window-shortcuts] No active pane for copy URL")
+		logging.Debug(fmt.Sprintf("[window-shortcuts] No active pane for copy URL"))
 		return
 	}
-	log.Printf("[window-shortcuts] Copy URL -> pane %p", h.app.activePane.webView)
+	logging.Debug(fmt.Sprintf("[window-shortcuts] Copy URL -> pane %p", h.app.activePane.webView))
 	// Execute copy URL script directly on active pane
 	script := `
 	`
 	if err := h.app.activePane.webView.InjectScript(script); err != nil {
-		log.Printf("[window-shortcuts] Failed to inject copy URL script: %v", err)
+		logging.Error(fmt.Sprintf("[window-shortcuts] Failed to inject copy URL script: %v", err))
 	}
 }
 	h.lastDevTools = time.Now()
 	if h.app.activePane == nil || h.app.activePane.webView == nil {
-		log.Printf("[window-shortcuts] No active pane for devtools")
+		logging.Debug(fmt.Sprintf("[window-shortcuts] No active pane for devtools"))
 		return
 	}
-	log.Printf("[window-shortcuts] DevTools -> pane %p", h.app.activePane.webView)
+	logging.Debug(fmt.Sprintf("[window-shortcuts] DevTools -> pane %p", h.app.activePane.webView))
 	if err := h.app.activePane.webView.ShowDevTools(); err != nil {
-		log.Printf("[window-shortcuts] Failed to show devtools: %v", err)
+		logging.Error(fmt.Sprintf("[window-shortcuts] Failed to show devtools: %v", err))
 	}
 }
 	h.lastPrint = time.Now()
 	if h.app.activePane == nil || h.app.activePane.webView == nil {
-		log.Printf("[window-shortcuts] No active pane for print")
+		logging.Debug(fmt.Sprintf("[window-shortcuts] No active pane for print"))
 		return
 	}
-	log.Printf("[window-shortcuts] Print -> pane %p", h.app.activePane.webView)
+	logging.Debug(fmt.Sprintf("[window-shortcuts] Print -> pane %p", h.app.activePane.webView))
 	if err := h.app.activePane.webView.ShowPrintDialog(); err != nil {
-		log.Printf("[window-shortcuts] Failed to show print dialog: %v", err)
+		logging.Error(fmt.Sprintf("[window-shortcuts] Failed to show print dialog: %v", err))
 	}
 }
 	defer h.mu.Unlock()
 	if h.app.activePane == nil || h.app.activePane.webView == nil {
-		log.Printf("[window-shortcuts] No active pane for reload")
+		logging.Debug(fmt.Sprintf("[window-shortcuts] No active pane for reload"))
 		return
 	}
-	log.Printf("[window-shortcuts] Reload page -> pane %p", h.app.activePane.webView)
+	logging.Debug(fmt.Sprintf("[window-shortcuts] Reload page -> pane %p", h.app.activePane.webView))
 	if err := h.app.activePane.webView.Reload(); err != nil {
-		log.Printf("[window-shortcuts] Failed to reload page: %v", err)
+		logging.Error(fmt.Sprintf("[window-shortcuts] Failed to reload page: %v", err))
 	}
 }
 	defer h.mu.Unlock()
 	if h.app.activePane == nil || h.app.activePane.webView == nil {
-		log.Printf("[window-shortcuts] No active pane for hard reload")
+		logging.Debug(fmt.Sprintf("[window-shortcuts] No active pane for hard reload"))
 		return
 	}
-	log.Printf("[window-shortcuts] Hard reload (bypass cache) -> pane %p", h.app.activePane.webView)
+	logging.Debug(fmt.Sprintf("[window-shortcuts] Hard reload (bypass cache) -> pane %p", h.app.activePane.webView))
 	if err := h.app.activePane.webView.ReloadBypassCache(); err != nil {
-		log.Printf("[window-shortcuts] Failed to hard reload page: %v", err)
+		logging.Error(fmt.Sprintf("[window-shortcuts] Failed to hard reload page: %v", err))
 	}
 }
 	defer h.mu.Unlock()
 	if h.app.activePane == nil || h.app.activePane.webView == nil {
-		log.Printf("[window-shortcuts] No active pane for zoom %s", action)
+		logging.Debug(fmt.Sprintf("[window-shortcuts] No active pane for zoom %s", action))
 		return
 	}
 	activeWebView := h.app.activePane.webView
-	log.Printf("[window-shortcuts] Zoom %s -> pane %p", action, activeWebView)
+	logging.Debug(fmt.Sprintf("[window-shortcuts] Zoom %s -> pane %p", action, activeWebView))
 	// Get current zoom level
 	currentZoom := activeWebView.GetZoom()
 		}
 	}
-	log.Printf("[window-shortcuts] Zoom %s: %.2f -> %.2f", action, currentZoom, newZoom)
+	logging.Debug(fmt.Sprintf("[window-shortcuts] Zoom %s: %.2f -> %.2f", action, currentZoom, newZoom))
 	// Apply zoom to active pane
 	if err := activeWebView.SetZoom(newZoom); err != nil {
-		log.Printf("[window-shortcuts] Failed to set zoom: %v", err)
+		logging.Error(fmt.Sprintf("[window-shortcuts] Failed to set zoom: %v", err))
 		return
 	}
 	`, newZoom)
 	if err := activeWebView.InjectScript(toastScript); err != nil {
-		log.Printf("[window-shortcuts] Failed to show zoom toast: %v", err)
+		logging.Error(fmt.Sprintf("[window-shortcuts] Failed to show zoom toast: %v", err))
 	}
 }
 	pane := h.app.activePane
 	if !pane.HasGUI() {
-		log.Printf("[window-shortcuts] Injecting GUI into pane %s for %s", pane.ID(), component)
+		logging.Debug(fmt.Sprintf("[window-shortcuts] Injecting GUI into pane %s for %s", pane.ID(), component))
 		if h.app.workspace != nil {
 			h.app.workspace.ensureGUIInPane(pane)
 		}
 	// Ensure specific component is available
 	if !pane.HasGUIComponent(component) {
-		log.Printf("[window-shortcuts] Ensuring %s component in pane %s", component, pane.ID())
+		logging.Debug(fmt.Sprintf("[window-shortcuts] Ensuring %s component in pane %s", component, pane.ID()))
 		pane.SetGUIComponent(component, true)
 	}
 }
 	defer h.mu.Unlock()
 	if time.Since(*lastToggle) < 50*time.Millisecond {
-		log.Printf("[window-shortcuts] %s toggle debounced", featureName)
+		logging.Debug(fmt.Sprintf("[window-shortcuts] %s toggle debounced", featureName))
 		return
 	}
 	*lastToggle = time.Now()
 	if h.app.activePane == nil || h.app.activePane.webView == nil {
-		log.Printf("[window-shortcuts] No active pane for %s", featureName)
+		logging.Debug(fmt.Sprintf("[window-shortcuts] No active pane for %s", featureName))
 		return
 	}
-	log.Printf("[window-shortcuts] %s toggle -> pane %p", featureName, h.app.activePane.webView)
+	logging.Debug(fmt.Sprintf("[window-shortcuts] %s toggle -> pane %p", featureName, h.app.activePane.webView))
 	h.ensureGUIInActivePane("omnibox")
 		"timestamp": time.Now().UnixMilli(),
 		"source":    "window-global",
 	}); err != nil {
-		log.Printf("[window-shortcuts] Failed to dispatch %s toggle: %v", featureName, err)
+		logging.Error(fmt.Sprintf("[window-shortcuts] Failed to dispatch %s toggle: %v", featureName, err))
 	}
 }
 func (h *WindowShortcutHandler) handleWorkspaceNavigation(direction string) {
 	if h.app == nil || h.app.workspace == nil {
-		log.Printf("[window-shortcuts] No workspace for navigation")
+		logging.Debug(fmt.Sprintf("[window-shortcuts] No workspace for navigation"))
 		return
 	}
-	log.Printf("[window-shortcuts] Workspace navigation: %s", direction)
+	logging.Debug(fmt.Sprintf("[window-shortcuts] Workspace navigation: %s", direction))
 	if h.app.workspace.FocusNeighbor(direction) {
-		log.Printf("[window-shortcuts] Workspace navigation %s successful", direction)
+		logging.Debug(fmt.Sprintf("[window-shortcuts] Workspace navigation %s successful", direction))
 	} else {
-		log.Printf("[window-shortcuts] Workspace navigation %s failed", direction)
+		logging.Debug(fmt.Sprintf("[window-shortcuts] Workspace navigation %s failed", direction))
 	}
 }
 func (h *WindowShortcutHandler) handleClosePane() {
 	if h.app == nil || h.app.workspace == nil {
-		log.Printf("[window-shortcuts] No workspace for close pane")
+		logging.Debug(fmt.Sprintf("[window-shortcuts] No workspace for close pane"))
 		return
 	}
 	// Find the currently active WebView
 	var activeWebView *webkit.WebView
-	log.Printf("[window-shortcuts] Searching for active WebView among %d WebViews", len(h.app.workspace.viewToNode))
+	logging.Debug(fmt.Sprintf("[window-shortcuts] Searching for active WebView among %d WebViews", len(h.app.workspace.viewToNode)))
 	for webView := range h.app.workspace.viewToNode {
 		if webView != nil {
 			isActive := webView.IsActive()
-			log.Printf("[window-shortcuts] WebView %d: IsActive=%t", webView.ID(), isActive)
+			logging.Debug(fmt.Sprintf("[window-shortcuts] WebView %d: IsActive=%t", webView.ID(), isActive))
 			if isActive {
 				activeWebView = webView
-				log.Printf("[window-shortcuts] Found active WebView: %d", webView.ID())
+				logging.Debug(fmt.Sprintf("[window-shortcuts] Found active WebView: %d", webView.ID()))
 				break
 			}
 		}
 	}
 	if activeWebView == nil {
-		log.Printf("[window-shortcuts] No active WebView found, using workspace closeCurrentPane")
+		logging.Debug(fmt.Sprintf("[window-shortcuts] No active WebView found, using workspace closeCurrentPane"))
 		h.app.workspace.closeCurrentPane()
 		return
 	}
 	// Check if the active WebView is a popup
 	node := h.app.workspace.viewToNode[activeWebView]
 	if node != nil && node.isPopup {
-		log.Printf("[window-shortcuts] Closing popup via OnWorkspaceMessage")
+		logging.Debug(fmt.Sprintf("[window-shortcuts] Closing popup via OnWorkspaceMessage"))
 		// Use the proper close-popup message for popups
 		msg := messaging.Message{
 			Event:     "close-popup",
 		}
 		h.app.workspace.OnWorkspaceMessage(activeWebView, msg)
 	} else {
-		log.Printf("[window-shortcuts] Closing regular pane via workspace closeCurrentPane")
+		logging.Debug(fmt.Sprintf("[window-shortcuts] Closing regular pane via workspace closeCurrentPane"))
 		// Use regular close for non-popup panes
 		h.app.workspace.closeCurrentPane()
 	}
 // handlePaneMode enters pane mode for modal pane management.
 func (h *WindowShortcutHandler) handlePaneMode() {
 	if h.app == nil || h.app.workspace == nil {
-		log.Printf("[window-shortcuts] Cannot enter pane mode: workspace not available")
+		logging.Debug(fmt.Sprintf("[window-shortcuts] Cannot enter pane mode: workspace not available"))
 		return
 	}
-	log.Printf("[window-shortcuts] Entering pane mode")
+	logging.Debug(fmt.Sprintf("[window-shortcuts] Entering pane mode"))
 	h.app.workspace.EnterPaneMode()
 }
 // handleTabMode enters tab mode for modal tab management.
 func (h *WindowShortcutHandler) handleTabMode() {
 	if h.app == nil || h.app.tabManager == nil {
-		log.Printf("[window-shortcuts] Cannot enter tab mode: tab manager not available")
+		logging.Debug(fmt.Sprintf("[window-shortcuts] Cannot enter tab mode: tab manager not available"))
 		return
 	}
-	log.Printf("[window-shortcuts] Entering tab mode")
+	logging.Debug(fmt.Sprintf("[window-shortcuts] Entering tab mode"))
 	h.app.tabManager.EnterTabMode()
 }
 // handleNextTab switches to the next tab.
 func (h *WindowShortcutHandler) handleNextTab() {
 	if h.app == nil || h.app.tabManager == nil {
-		log.Printf("[window-shortcuts] Cannot switch tab: tab manager not available")
+		logging.Debug(fmt.Sprintf("[window-shortcuts] Cannot switch tab: tab manager not available"))
 		return
 	}
-	log.Printf("[window-shortcuts] Switching to next tab")
+	logging.Debug(fmt.Sprintf("[window-shortcuts] Switching to next tab"))
 	if err := h.app.tabManager.NextTab(); err != nil {
-		log.Printf("[window-shortcuts] Failed to switch to next tab: %v", err)
+		logging.Error(fmt.Sprintf("[window-shortcuts] Failed to switch to next tab: %v", err))
 	}
 }
 // handlePrevTab switches to the previous tab.
 func (h *WindowShortcutHandler) handlePrevTab() {
 	if h.app == nil || h.app.tabManager == nil {
-		log.Printf("[window-shortcuts] Cannot switch tab: tab manager not available")
+		logging.Debug(fmt.Sprintf("[window-shortcuts] Cannot switch tab: tab manager not available"))
 		return
 	}
-	log.Printf("[window-shortcuts] Switching to previous tab")
+	logging.Debug(fmt.Sprintf("[window-shortcuts] Switching to previous tab"))
 	if err := h.app.tabManager.PreviousTab(); err != nil {
-		log.Printf("[window-shortcuts] Failed to switch to previous tab: %v", err)
+		logging.Error(fmt.Sprintf("[window-shortcuts] Failed to switch to previous tab: %v", err))
 	}
 }
 // handleDirectTabSwitch switches to a specific tab by index (0-based).
 func (h *WindowShortcutHandler) handleDirectTabSwitch(index int) {
 	if h.app == nil || h.app.tabManager == nil {
-		log.Printf("[window-shortcuts] Cannot switch tab: tab manager not available")
+		logging.Debug(fmt.Sprintf("[window-shortcuts] Cannot switch tab: tab manager not available"))
 		return
 	}
-	log.Printf("[window-shortcuts] Direct tab switch to index %d", index)
+	logging.Debug(fmt.Sprintf("[window-shortcuts] Direct tab switch to index %d", index))
 	if err := h.app.tabManager.SwitchToTab(index); err != nil {
-		log.Printf("[window-shortcuts] Failed to switch to tab %d: %v", index, err)
+		logging.Error(fmt.Sprintf("[window-shortcuts] Failed to switch to tab %d: %v", index, err))
 	}
 }
 	}
 	// Tab mode is active, handle the action
-	log.Printf("[window-shortcuts] Tab mode action: %s", action)
+	logging.Debug(fmt.Sprintf("[window-shortcuts] Tab mode action: %s", action))
 	h.app.tabManager.HandleTabAction(action)
 }

M internal/app/browser/workspace_css.go +9 -4


@@ -3,10 +3,10 @@ package browser
3			3
4		import (	4		import (
5		"fmt"	5		"fmt"
6	-	"log"
7		"strings"	6		"strings"
8			7
9		"github.com/bnema/dumber/internal/config"	8		"github.com/bnema/dumber/internal/config"
			9	+	"github.com/bnema/dumber/internal/logging"
10		"github.com/bnema/dumber/pkg/webkit"	10		"github.com/bnema/dumber/pkg/webkit"
11		)	11		)
12			12

@@ -393,12 +393,17 @@ func (wm *WorkspaceManager) ensureWorkspaceStyles() {
393		// Only apply CSS if it hasn't been applied globally or if content changed	393		// Only apply CSS if it hasn't been applied globally or if content changed
394		if !globalCSSInitialized \|\| globalCSSContent != workspaceCSS {	394		if !globalCSSInitialized \|\| globalCSSContent != workspaceCSS {
395		if err := webkit.AddCSSProvider(workspaceCSS); err != nil {	395		if err := webkit.AddCSSProvider(workspaceCSS); err != nil {
396	-	log.Printf("[workspace] WARNING: Failed to add CSS provider: %v", err)	396	+	logging.Error(fmt.Sprintf("[workspace] WARNING: Failed to add CSS provider: %v", err))
397		}	397		}
398		globalCSSInitialized = true	398		globalCSSInitialized = true
399		globalCSSContent = workspaceCSS	399		globalCSSContent = workspaceCSS
400	-	log.Printf("[workspace] Applied workspace CSS styles (%d bytes)", len(workspaceCSS))	400	+	logging.Info(fmt.Sprintf("[workspace] Applied workspace CSS styles (%d bytes)", len(workspaceCSS)))
401	-	log.Printf("[workspace] CSS preview: %s...", workspaceCSS[:min(200, len(workspaceCSS))])	401	+
			402	+	previewLen := 200
			403	+	if len(workspaceCSS) < previewLen {
			404	+	previewLen = len(workspaceCSS)
			405	+	}
			406	+	logging.Info(fmt.Sprintf("[workspace] CSS preview: %s...", workspaceCSS[:previewLen]))
402		}	407		}
403			408
404		wm.cssInitialized = true	409		wm.cssInitialized = true

M internal/app/browser/workspace_debug.go +6 -2

 package browser
-import "log"
+import (
+	"fmt"
+	"github.com/bnema/dumber/internal/logging"
+)
 func (wm *WorkspaceManager) paneCloseLogf(format string, args ...interface{}) {
 	if wm == nil || !wm.debugPaneClose {
 		return
 	}
-	log.Printf("[pane-close] "+format, args...)
+	logging.Info(fmt.Sprintf("[pane-close] "+format, args...))
 }
 func (wm *WorkspaceManager) dumpTreeState(label string) {

M internal/app/browser/workspace_diagnostics.go +3 -2

 import (
 	"fmt"
-	"log"
 	"strings"
 	"sync"
+	"github.com/bnema/dumber/internal/logging"
 )
 type TreeSnapshot struct {
 	d.snapshots = append(d.snapshots, snapshot)
 	d.mu.Unlock()
-	log.Printf("[pane-close] snapshot %s\n%s", snapshot.Label, strings.Join(snapshot.Lines, "\n"))
+	logging.Info(fmt.Sprintf("[pane-close] snapshot %s\n%s", snapshot.Label, strings.Join(snapshot.Lines, "\n")))
 	return snapshot
 }

M internal/app/browser/workspace_geometry_validator.go +4 -5


@@ -3,8 +3,7 @@ package browser
3			3
4		import (	4		import (
5		"fmt"	5		"fmt"
6	-	"log"	6	+	"github.com/bnema/dumber/internal/logging"
7	-
8		"github.com/bnema/dumber/pkg/webkit"	7		"github.com/bnema/dumber/pkg/webkit"
9		)	8		)
10			9

@@ -52,7 +51,7 @@ func (gv GeometryValidator) GetPaneGeometry(node paneNode) PaneGeometry {
52			51
53		if node == nil \|\| node.container == nil {	52		if node == nil \|\| node.container == nil {
54		if gv.debugMode {	53		if gv.debugMode {
55	-	log.Printf("[geometry] Invalid node or missing container")	54	+	logging.Error(fmt.Sprintf("[geometry] Invalid node or missing container"))
56		}	55		}
57		return geometry	56		return geometry
58		}	57		}

@@ -67,8 +66,8 @@ func (gv GeometryValidator) GetPaneGeometry(node paneNode) PaneGeometry {
67		geometry.IsValid = true	66		geometry.IsValid = true
68			67
69		if gv.debugMode {	68		if gv.debugMode {
70	-	log.Printf("[geometry] Pane geometry: %dx%d at (%d,%d)",	69	+	logging.Info(fmt.Sprintf("[geometry] Pane geometry: %dx%d at (%d,%d)",
71	-	geometry.Width, geometry.Height, geometry.X, geometry.Y)	70	+	geometry.Width, geometry.Height, geometry.X, geometry.Y))
72		}	71		}
73			72
74		return geometry	73		return geometry

M internal/app/browser/workspace_hover.go +6 -5

 package browser
 import (
-	"log"
+	"fmt"
+	"github.com/bnema/dumber/internal/logging"
 	"github.com/bnema/dumber/pkg/webkit"
 	"github.com/diamondburned/gotk4/pkg/glib/v2"
 )
 	if controller != nil {
 		node.hoverToken = controller
-		log.Printf("[workspace] Attached hover handler to pane %p (controller=%p)", node, controller)
+		logging.Debug(fmt.Sprintf("[workspace] Attached hover handler to pane %p (controller=%p)", node, controller))
 	} else {
-		log.Printf("[workspace] Failed to attach hover handler to pane %p", node)
+		logging.Error(fmt.Sprintf("[workspace] Failed to attach hover handler to pane %p", node))
 	}
 }
 	}
 	webkit.WidgetRemoveHoverHandler(node.container, node.hoverToken)
-	log.Printf("[workspace] Detached hover handler from pane %p (controller=%p)", node, node.hoverToken)
+	logging.Debug(fmt.Sprintf("[workspace] Detached hover handler from pane %p (controller=%p)", node, node.hoverToken))
 	node.hoverToken = nil
 }
 		wm.ensureHover(leaf)
 	}
-	log.Printf("[workspace] Attached hover handlers to %d panes", len(leaves))
+	logging.Debug(fmt.Sprintf("[workspace] Attached hover handlers to %d panes", len(leaves)))
 }

M internal/app/browser/workspace_manager.go +39 -39

 import (
 	"errors"
 	"fmt"
-	"log"
 	"strings"
 	"sync"
 	"sync/atomic"
 	"time"
 	"github.com/bnema/dumber/internal/app/messaging"
+	"github.com/bnema/dumber/internal/logging"
 	"github.com/bnema/dumber/pkg/webkit"
 	"github.com/diamondburned/gotk4/pkg/glib/v2"
 	"github.com/diamondburned/gotk4/pkg/gtk/v4"
 	// Initialize focus state machine after all setup is complete
 	if err := manager.focusStateMachine.Initialize(); err != nil {
-		log.Printf("[workspace] Failed to initialize focus state machine: %v", err)
+		logging.Error(fmt.Sprintf("[workspace] Failed to initialize focus state machine: %v", err))
 	}
 	// Ensure hover controllers are attached to all panes for mouse-driven focus changes
 func (wm *WorkspaceManager) shouldDebounce(source *webkit.WebView, threshold time.Duration) bool {
 	if last, ok := wm.lastSplitMsg[source]; ok {
 		if elapsed := time.Since(last); elapsed < threshold {
-			log.Printf("[workspace] operation debounced: %.0fms", elapsed.Seconds()*1000)
+			logging.Debug(fmt.Sprintf("[workspace] operation debounced: %.0fms", elapsed.Seconds()*1000))
 			return true
 		}
 	}
 // withSplitLock executes an operation with atomic splitting lock protection
 func (wm *WorkspaceManager) withSplitLock(operation string, fn func() error) error {
 	if !atomic.CompareAndSwapInt32(&wm.splitting, 0, 1) {
-		log.Printf("[workspace] %s ignored: operation in progress", operation)
+		logging.Debug(fmt.Sprintf("[workspace] %s ignored: operation in progress", operation))
 		return fmt.Errorf("operation in progress")
 	}
 	defer func() {
 		atomic.StoreInt32(&wm.splitting, 0)
 		if r := recover(); r != nil {
-			log.Printf("[workspace] %s panicked: %v", operation, r)
+			logging.Error(fmt.Sprintf("[workspace] %s panicked: %v", operation, r))
 			panic(r)
 		}
 	}()
 	`, parentWebViewID, requestID, requestID, requestID, requestID, webviewID)
 	if err := parentNode.pane.WebView().InjectScript(script); err != nil {
-		log.Printf("[workspace] localStorage cleanup failed: %v", err)
+		logging.Error(fmt.Sprintf("[workspace] localStorage cleanup failed: %v", err))
 	} else {
-		log.Printf("[workspace] Cleaned localStorage for popup requestId=%s webviewId=%s", requestID, webviewID)
+		logging.Debug(fmt.Sprintf("[workspace] Cleaned localStorage for popup requestId=%s webviewId=%s", requestID, webviewID))
 	}
 }
 	}
 	if node == nil {
-		log.Printf("[workspace] message from unknown webview: event=%s webviewId=%s", msg.Event, msg.WebViewID)
+		logging.Warn(fmt.Sprintf("[workspace] message from unknown webview: event=%s webviewId=%s", msg.Event, msg.WebViewID))
 		return
 	}
 		})
 		if err != nil {
-			log.Printf("[workspace] split failed: %v", err)
+			logging.Error(fmt.Sprintf("[workspace] split failed: %v", err))
 		}
 	case "pane-stack":
 		})
 		if err != nil {
-			log.Printf("[workspace] stack failed: %v", err)
+			logging.Error(fmt.Sprintf("[workspace] stack failed: %v", err))
 		}
 	case "close-popup":
 		if msg.WebViewID == "" {
-			log.Printf("[workspace] close-popup: empty webviewId, ignoring")
+			logging.Warn(fmt.Sprintf("[workspace] close-popup: empty webviewId, ignoring"))
 			return
 		}
 		}
 		if targetNode == nil {
-			log.Printf("[workspace] close-popup: webview not found: %s", msg.WebViewID)
+			logging.Warn(fmt.Sprintf("[workspace] close-popup: webview not found: %s", msg.WebViewID))
 			return
 		}
 		if !targetNode.isPopup {
-			log.Printf("[workspace] close-popup: target is not a popup: %s", msg.WebViewID)
+			logging.Warn(fmt.Sprintf("[workspace] close-popup: target is not a popup: %s", msg.WebViewID))
 			return
 		}
-		log.Printf("[workspace] Closing popup due to %s", msg.Reason)
+		logging.Info(fmt.Sprintf("[workspace] Closing popup due to %s", msg.Reason))
 		// Remove from parent's active popup list
 		if targetNode.parentPane != nil {
 			for i, childID := range parentNode.activePopupChildren {
 				if childID == msg.WebViewID {
 					parentNode.activePopupChildren = append(parentNode.activePopupChildren[:i], parentNode.activePopupChildren[i+1:]...)
-					log.Printf("[workspace] Removed popup from parent (remaining: %d)", len(parentNode.activePopupChildren))
+					logging.Debug(fmt.Sprintf("[workspace] Removed popup from parent (remaining: %d)", len(parentNode.activePopupChildren)))
 					break
 				}
 			}
 		}
 		if err := wm.ClosePane(targetNode); err != nil {
-			log.Printf("[workspace] Failed to close popup: %v", err)
+			logging.Error(fmt.Sprintf("[workspace] Failed to close popup: %v", err))
 		}
 	default:
-		log.Printf("[workspace] unhandled workspace event: %s", msg.Event)
+		logging.Warn(fmt.Sprintf("[workspace] unhandled workspace event: %s", msg.Event))
 	}
 }
 	wm.lastFocusTarget = node
 	if err := wm.focusStateMachine.RequestFocus(node, source); err != nil {
-		log.Printf("[workspace] Focus request failed: %v", err)
+		logging.Error(fmt.Sprintf("[workspace] Focus request failed: %v", err))
 	}
 }
 			return false
 		}
-		log.Printf("[workspace] Middle-click/Ctrl+click on link, opening in new pane: %s", linkURL)
+		logging.Info(fmt.Sprintf("[workspace] Middle-click/Ctrl+click on link, opening in new pane: %s", linkURL))
 		// Get the node for this webview
 		node := wm.GetNodeForWebView(webView)
 		if node == nil {
-			log.Printf("[workspace] Cannot find node for middle-clicked link")
+			logging.Error(fmt.Sprintf("[workspace] Cannot find node for middle-clicked link"))
 			return false
 		}
 		switch behavior {
 		case "stacked":
 			// Stack the current pane - this also creates a new pane in the stack
-			log.Printf("[workspace] Using stacked behavior for gesture link")
+			logging.Debug(fmt.Sprintf("[workspace] Using stacked behavior for gesture link"))
 			newNode, err = wm.stackedPaneManager.StackPane(node)
 			if err != nil {
-				log.Printf("[workspace] Failed to stack pane for gesture link: %v", err)
+				logging.Error(fmt.Sprintf("[workspace] Failed to stack pane for gesture link: %v", err))
 				return false
 			}
 			// newNode is the new pane that was added to the stack
-			log.Printf("[workspace] StackPane created new pane in stack: %p", newNode)
+			logging.Debug(fmt.Sprintf("[workspace] StackPane created new pane in stack: %p", newNode))
 		case "split":
 			// Regular split behavior
-			log.Printf("[workspace] Using split behavior for gesture link")
+			logging.Debug(fmt.Sprintf("[workspace] Using split behavior for gesture link"))
 			direction := "right"
 			if wm.app.config.Workspace.Popups.Placement != "" {
 				direction = strings.ToLower(wm.app.config.Workspace.Popups.Placement)
 		case "tabbed":
 			// Tabbed not yet implemented, fall back to split
-			log.Printf("[workspace] WARNING: Tabbed behavior not yet implemented for gesture links, falling back to split")
+			logging.Warn(fmt.Sprintf("[workspace] WARNING: Tabbed behavior not yet implemented for gesture links, falling back to split"))
 			direction := "right"
 			if wm.app.config.Workspace.Popups.Placement != "" {
 				direction = strings.ToLower(wm.app.config.Workspace.Popups.Placement)
 		default:
 			// Unknown behavior, fall back to split
-			log.Printf("[workspace] WARNING: Unknown behavior '%s' for gesture links, falling back to split", behavior)
+			logging.Warn(fmt.Sprintf("[workspace] WARNING: Unknown behavior '%s' for gesture links, falling back to split", behavior))
 			direction := "right"
 			if wm.app.config.Workspace.Popups.Placement != "" {
 				direction = strings.ToLower(wm.app.config.Workspace.Popups.Placement)
 		}
 		if err != nil {
-			log.Printf("[workspace] Failed to handle gesture link: %v", err)
+			logging.Error(fmt.Sprintf("[workspace] Failed to handle gesture link: %v", err))
 			return false
 		}
 		// Navigate the new pane to the URL
 		if newNode != nil && newNode.pane != nil && newNode.pane.WebView() != nil {
 			if err := newNode.pane.WebView().LoadURL(linkURL); err != nil {
-				log.Printf("[workspace] Failed to load URL in new pane: %v", err)
+				logging.Error(fmt.Sprintf("[workspace] Failed to load URL in new pane: %v", err))
 				return false
 			}
 		return true // Indicate we handled the click
 	})
-	log.Printf("[workspace] Registered navigation handler for webview: %d", webView.ID())
+	logging.Debug(fmt.Sprintf("[workspace] Registered navigation handler for webview: %d", webView.ID()))
 }
 // GetAllPanes returns all BrowserPanes in this workspace.
 // RestoreFocus restores focus to the active pane in this workspace.
 // Called when switching to a tab to ensure the correct pane has focus.
 func (wm *WorkspaceManager) RestoreFocus() {
-	log.Printf("[workspace] RestoreFocus: workspace %p", wm)
+	logging.Debug(fmt.Sprintf("[workspace] RestoreFocus: workspace %p", wm))
 	// Get the active pane and explicitly grab GTK focus
 	activeNode := wm.GetActiveNode()
 		// This ensures keyboard events go to the active tab's WebView
 		// Note: RestoreFocus is called from switchToTabInternal which is already on the main thread
 		webkit.WidgetGrabFocus(activeNode.pane.webView.AsWidget())
-		log.Printf("[workspace] Grabbed GTK focus for WebView in workspace %p", wm)
+		logging.Debug(fmt.Sprintf("[workspace] Grabbed GTK focus for WebView in workspace %p", wm))
 		// Also request focus via FSM
 		if wm.focusStateMachine != nil {
 	}
 	// The active workspace is the one currently assigned to app.workspace
 	isActive := wm.app.workspace == wm
-	log.Printf("[workspace] IsInActiveTab check: workspace %p, app.workspace %p, isActive=%v", wm, wm.app.workspace, isActive)
+	logging.Debug(fmt.Sprintf("[workspace] IsInActiveTab check: workspace %p, app.workspace %p, isActive=%v", wm, wm.app.workspace, isActive))
 	return isActive
 }
 // ClearFocus removes GTK focus from all panes in this workspace.
 // This prevents inactive tab's WebViews from catching keyboard events.
 func (wm *WorkspaceManager) ClearFocus() {
-	log.Printf("[workspace] ClearFocus: workspace %p", wm)
+	logging.Debug(fmt.Sprintf("[workspace] ClearFocus: workspace %p", wm))
 	// No state to clear - IsInActiveTab() checks dynamically
 }
 	}
 	if wm.app == nil || wm.app.tabManager == nil || wm.app.tabManager.ContentArea == nil {
-		log.Printf("[workspace] ERROR: Cannot set root - tab manager not initialized")
+		logging.Error(fmt.Sprintf("[workspace] ERROR: Cannot set root - tab manager not initialized"))
 		return
 	}
 	contentBox, ok := wm.app.tabManager.ContentArea.(*gtk.Box)
 	if !ok || contentBox == nil {
-		log.Printf("[workspace] ERROR: ContentArea is not a Box")
+		logging.Error(fmt.Sprintf("[workspace] ERROR: ContentArea is not a Box"))
 		return
 	}
 	contentBox.Append(container)
 	webkit.WidgetSetVisible(container, true)
-	log.Printf("[workspace] Attached root container %p to ContentArea", container)
+	logging.Debug(fmt.Sprintf("[workspace] Attached root container %p to ContentArea", container))
 }
 // clearRootContainer removes the current workspace root from TabManager.ContentArea.
 	}
 	if wm.app == nil || wm.app.tabManager == nil || wm.app.tabManager.ContentArea == nil {
-		log.Printf("[workspace] ERROR: Cannot clear root - tab manager not initialized")
+		logging.Error(fmt.Sprintf("[workspace] ERROR: Cannot clear root - tab manager not initialized"))
 		return
 	}
 	contentBox, ok := wm.app.tabManager.ContentArea.(*gtk.Box)
 	if !ok || contentBox == nil {
-		log.Printf("[workspace] ERROR: ContentArea is not a Box")
+		logging.Error(fmt.Sprintf("[workspace] ERROR: ContentArea is not a Box"))
 		return
 	}
 	contentBox.Remove(wm.root.container)
-	log.Printf("[workspace] Removed root container %p from ContentArea", wm.root.container)
+	logging.Debug(fmt.Sprintf("[workspace] Removed root container %p from ContentArea", wm.root.container))
 }

M internal/app/browser/workspace_navigation.go +30 -30

 import (
 	"fmt"
-	"log"
 	"math"
 	"strings"
 	"time"
+	"github.com/bnema/dumber/internal/logging"
 	"github.com/bnema/dumber/pkg/webkit"
 	"github.com/diamondburned/gotk4/pkg/gtk/v4"
 )
 	}
 	if err := node.pane.webView.DispatchCustomEvent("dumber:workspace-focus", detail); err != nil {
-		log.Printf("[workspace] failed to dispatch focus event: %v", err)
+		logging.Error(fmt.Sprintf("[workspace] failed to dispatch focus event: %v", err))
 	} else if wm.app.config != nil && wm.app.config.Debug.EnableWorkspaceDebug {
-		log.Printf("[workspace] dispatched focus event for webview %d (active=%v)", node.pane.webView.ID(), active)
+		logging.Debug(fmt.Sprintf("[workspace] dispatched focus event for webview %d (active=%v)", node.pane.webView.ID(), active))
 	}
 }
 			activePane := stack.stackedPanes[activeIndex]
 			if activePane != nil && activePane != node {
 				if reason != "" {
-					log.Printf("[workspace] %s: preserving active stacked pane index=%d", reason, activeIndex)
+					logging.Info(fmt.Sprintf("[workspace] %s: preserving active stacked pane index=%d", reason, activeIndex))
 				}
 				wm.SetActivePane(activePane, SourceKeyboard)
 				return
 	case DirectionLeft, DirectionRight:
 		return wm.focusAdjacent(strings.ToLower(direction))
 	default:
-		log.Printf("[workspace] invalid focus direction: %s (expected: up, down, left, right)", direction)
+		logging.Error(fmt.Sprintf("[workspace] invalid focus direction: %s (expected: up, down, left, right)", direction))
 		return false
 	}
 }
 	}
 	if currentIndex == -1 {
-		log.Printf("[workspace] navigateStack: current pane not found in stack")
+		logging.Error(fmt.Sprintf("[workspace] navigateStack: current pane not found in stack"))
 		return false
 	}
 	newActivePane := stackNode.stackedPanes[newIndex]
 	wm.SetActivePane(newActivePane, SourceStackNav)
-	log.Printf("[workspace] navigated stack: direction=%s from=%d to=%d stackSize=%d",
+	logging.Debug(fmt.Sprintf("[workspace] navigated stack: direction=%s from=%d to=%d stackSize=%d",
-		direction, currentIndex, newIndex, len(stackNode.stackedPanes))
+		direction, currentIndex, newIndex, len(stackNode.stackedPanes)))
 	return true
 }
 	}
 	if neighbor := wm.structuralNeighbor(currentFocused, direction); neighbor != nil {
-		log.Printf("[workspace] focusAdjacent: using structural neighbor for direction=%s", direction)
+		logging.Debug(fmt.Sprintf("[workspace] focusAdjacent: using structural neighbor for direction=%s", direction))
 		wm.SetActivePane(neighbor, SourceKeyboard)
 		return true
 	}
 	curX, curY, curWidth, curHeight := wm.getNavigationAllocation(currentFocused)
 	cx := float64(curX) + float64(curWidth)/2.0
 	cy := float64(curY) + float64(curHeight)/2.0
-	log.Printf("[workspace] focusAdjacent: current pane center=(%.0f, %.0f) direction=%s", cx, cy, direction)
+	logging.Debug(fmt.Sprintf("[workspace] focusAdjacent: current pane center=(%.0f, %.0f) direction=%s", cx, cy, direction))
 	leaves := wm.collectLeaves()
 	bestScore := math.MaxFloat64
 	if best != nil {
 		bx, by, _, _ := webkit.WidgetGetAllocation(best.container)
-		log.Printf("[workspace] focusAdjacent: found best candidate at pos=(%d,%d) for direction=%s", bx, by, direction)
+		logging.Debug(fmt.Sprintf("[workspace] focusAdjacent: found best candidate at pos=(%d,%d) for direction=%s", bx, by, direction))
 		wm.SetActivePane(best, SourceKeyboard)
 		return true
 	}
 	if len(debugCandidates) > 0 {
-		log.Printf("[workspace] focusAdjacent: NO candidate found for direction=%s current=%p center=(%.0f,%.0f) candidates=[%s]", direction, currentFocused.container, cx, cy, strings.Join(debugCandidates, "; "))
+		logging.Debug(fmt.Sprintf("[workspace] focusAdjacent: NO candidate found for direction=%s current=%p center=(%.0f,%.0f) candidates=[%s]", direction, currentFocused.container, cx, cy, strings.Join(debugCandidates, "; ")))
 	}
 	return false
 }
 	cy := float64(refY) + float64(refHeight)/2.0
 	axisVertical := direction == DirectionUp || direction == DirectionDown
-	log.Printf("[workspace] structuralNeighbor: node=%p pos=(%d,%d) direction=%s", node.container, refX, refY, direction)
+	logging.Debug(fmt.Sprintf("[workspace] structuralNeighbor: node=%p pos=(%d,%d) direction=%s", node.container, refX, refY, direction))
 	// Start from the node's parent, but skip stack containers for vertical navigation
 	// Stack containers are transparent to vertical navigation - we want to navigate
 	// from stack to external panes, not within the stack (that's handled by NavigateStack)
 	startParent := node.parent
 	if startParent != nil && startParent.isStacked && axisVertical {
-		log.Printf("[workspace] structuralNeighbor: skipping stack container parent, using stack's parent instead")
+		logging.Debug(fmt.Sprintf("[workspace] structuralNeighbor: skipping stack container parent, using stack's parent instead"))
 		node = startParent // Treat the stack container as the navigation node
 		startParent = startParent.parent
 	}
 	for parent := startParent; parent != nil; parent = parent.parent {
 		isLeft := parent.left == node
 		isRight := parent.right == node
-		log.Printf("[workspace] structuralNeighbor: checking parent orientation=%v isLeft=%v isRight=%v", parent.orientation, isLeft, isRight)
+		logging.Debug(fmt.Sprintf("[workspace] structuralNeighbor: checking parent orientation=%v isLeft=%v isRight=%v", parent.orientation, isLeft, isRight))
 		switch direction {
 		case DirectionUp:
 			if axisVertical && parent.orientation == gtk.OrientationVertical && parent.right == node {
-				log.Printf("[workspace] structuralNeighbor: DirectionUp - we are RIGHT child, looking in LEFT subtree")
+				logging.Info(fmt.Sprintf("[workspace] structuralNeighbor: DirectionUp - we are RIGHT child, looking in LEFT subtree"))
 				if leaf := wm.closestLeafFromSubtree(parent.left, cx, cy, direction); leaf != nil {
 					lx, ly, _, _ := webkit.WidgetGetAllocation(leaf.container)
-					log.Printf("[workspace] structuralNeighbor: found leaf at pos=(%d,%d)", lx, ly)
+					logging.Debug(fmt.Sprintf("[workspace] structuralNeighbor: found leaf at pos=(%d,%d)", lx, ly))
 					return leaf
 				}
 			}
 		case DirectionDown:
 			if axisVertical && parent.orientation == gtk.OrientationVertical && parent.left == node {
-				log.Printf("[workspace] structuralNeighbor: DirectionDown - we are LEFT child, looking in RIGHT subtree")
+				logging.Info(fmt.Sprintf("[workspace] structuralNeighbor: DirectionDown - we are LEFT child, looking in RIGHT subtree"))
 				if leaf := wm.closestLeafFromSubtree(parent.right, cx, cy, direction); leaf != nil {
 					lx, ly, _, _ := wm.getNavigationAllocation(leaf)
-					log.Printf("[workspace] structuralNeighbor: found leaf at pos=(%d,%d)", lx, ly)
+					logging.Debug(fmt.Sprintf("[workspace] structuralNeighbor: found leaf at pos=(%d,%d)", lx, ly))
 					return leaf
 				} else {
-					log.Printf("[workspace] structuralNeighbor: closestLeafFromSubtree returned nil for DirectionDown")
+					logging.Error(fmt.Sprintf("[workspace] structuralNeighbor: closestLeafFromSubtree returned nil for DirectionDown"))
 				}
 			}
 		case DirectionLeft:
 // closestLeafFromSubtree finds the closest leaf node in a subtree based on direction
 func (wm *WorkspaceManager) closestLeafFromSubtree(node *paneNode, cx, cy float64, direction string) *paneNode {
 	leaves := wm.collectLeavesFromWithDirection(node, direction)
-	log.Printf("[workspace] closestLeafFromSubtree: found %d leaves for direction=%s from cx=%.0f cy=%.0f", len(leaves), direction, cx, cy)
+	logging.Debug(fmt.Sprintf("[workspace] closestLeafFromSubtree: found %d leaves for direction=%s from cx=%.0f cy=%.0f", len(leaves), direction, cx, cy))
 	bestScore := math.MaxFloat64
 	var best *paneNode
 	for _, leaf := range leaves {
 		ty := float64(y) + float64(height)/2.0
 		dx := tx - cx
 		dy := ty - cy
-		log.Printf("[workspace] closestLeafFromSubtree: leaf=%p pos=(%d,%d) center=(%.0f,%.0f) dx=%.0f dy=%.0f", leaf.container, x, y, tx, ty, dx, dy)
+		logging.Info(fmt.Sprintf("[workspace] closestLeafFromSubtree: leaf=%p pos=(%d,%d) center=(%.0f,%.0f) dx=%.0f dy=%.0f", leaf.container, x, y, tx, ty, dx, dy))
 		var score float64
 		switch direction {
 		case DirectionLeft:
 			if dx >= -focusEpsilon {
-				log.Printf("[workspace] closestLeafFromSubtree: SKIPPED (dx=%.0f not left)", dx)
+				logging.Warn(fmt.Sprintf("[workspace] closestLeafFromSubtree: SKIPPED (dx=%.0f not left)", dx))
 				continue
 			}
 			score = math.Abs(dx)*1000 + math.Abs(dy)
 		case DirectionRight:
 			if dx <= focusEpsilon {
-				log.Printf("[workspace] closestLeafFromSubtree: SKIPPED (dx=%.0f not right)", dx)
+				logging.Warn(fmt.Sprintf("[workspace] closestLeafFromSubtree: SKIPPED (dx=%.0f not right)", dx))
 				continue
 			}
 			score = math.Abs(dx)*1000 + math.Abs(dy)
 		case DirectionUp:
 			if dy >= -focusEpsilon {
-				log.Printf("[workspace] closestLeafFromSubtree: SKIPPED (dy=%.0f not above)", dy)
+				logging.Warn(fmt.Sprintf("[workspace] closestLeafFromSubtree: SKIPPED (dy=%.0f not above)", dy))
 				continue
 			}
 			score = math.Abs(dy)*1000 + math.Abs(dx)
 		case DirectionDown:
 			if dy <= focusEpsilon {
-				log.Printf("[workspace] closestLeafFromSubtree: SKIPPED (dy=%.0f not below)", dy)
+				logging.Warn(fmt.Sprintf("[workspace] closestLeafFromSubtree: SKIPPED (dy=%.0f not below)", dy))
 				continue
 			}
 			score = math.Abs(dy)*1000 + math.Abs(dx)
 		default:
 			continue
 		}
-		log.Printf("[workspace] closestLeafFromSubtree: ACCEPTED with score=%.0f", score)
+		logging.Debug(fmt.Sprintf("[workspace] closestLeafFromSubtree: ACCEPTED with score=%.0f", score))
 		if score < bestScore {
 			bestScore = score
 			best = leaf
 		}
 	}
 	if best == nil {
-		log.Printf("[workspace] closestLeafFromSubtree: no match found, trying boundaryFallback")
+		logging.Warn(fmt.Sprintf("[workspace] closestLeafFromSubtree: no match found, trying boundaryFallback"))
 		return wm.boundaryFallback(node, direction)
 	}
-	log.Printf("[workspace] closestLeafFromSubtree: returning best=%p", best.container)
+	logging.Info(fmt.Sprintf("[workspace] closestLeafFromSubtree: returning best=%p", best.container))
 	return best
 }
 	// Prevent infinite recursion - max tree depth should be reasonable
 	const maxDepth = 50
 	if depth > maxDepth {
-		log.Printf("[workspace] boundaryFallback: max depth exceeded, possible tree corruption")
+		logging.Error(fmt.Sprintf("[workspace] boundaryFallback: max depth exceeded, possible tree corruption"))
 		return nil
 	}

M internal/app/browser/workspace_operations.go +39 -40


@@ -3,8 +3,7 @@ package browser
3			3
4		import (	4		import (
5		"fmt"	5		"fmt"
6	-	"log"	6	+	"github.com/bnema/dumber/internal/logging"
7	-
8		"github.com/bnema/dumber/pkg/webkit"	7		"github.com/bnema/dumber/pkg/webkit"
9		)	8		)
10			9

@@ -25,7 +24,7 @@ func (wm WorkspaceManager) SplitPane(target paneNode, direction string) (*pane
25		return nil, fmt.Errorf("invalid split direction '%s', expected one of: left, right, up, down", direction)	24		return nil, fmt.Errorf("invalid split direction '%s', expected one of: left, right, up, down", direction)
26		}	25		}
27			26
28	-	log.Printf("[workspace] Starting split operation: target=%p direction=%s", target, direction)	27	+	logging.Debug(fmt.Sprintf("[workspace] Starting split operation: target=%p direction=%s", target, direction))
29			28
30		// Step 1: Validate geometry constraints (only in DebugBasic+)	29		// Step 1: Validate geometry constraints (only in DebugBasic+)
31		if wm.debugLevel >= DebugBasic {	30		if wm.debugLevel >= DebugBasic {

@@ -34,12 +33,12 @@ func (wm WorkspaceManager) SplitPane(target paneNode, direction string) (*pane
34		if wm.debugLevel == DebugFull {	33		if wm.debugLevel == DebugFull {
35		return nil, fmt.Errorf("split validation failed: %s", validation.Reason)	34		return nil, fmt.Errorf("split validation failed: %s", validation.Reason)
36		}	35		}
37	-	log.Printf("[workspace] WARNING: Split validation failed but allowing operation: %s", validation.Reason)	36	+	logging.Error(fmt.Sprintf("[workspace] WARNING: Split validation failed but allowing operation: %s", validation.Reason))
38		}	37		}
39			38
40		// Log if re-validation will be needed due to pending widget allocation	39		// Log if re-validation will be needed due to pending widget allocation
41		if validation.RequiresRevalidation {	40		if validation.RequiresRevalidation {
42	-	log.Printf("[workspace] Split validation passed with pending allocation - operation will proceed")	41	+	logging.Info(fmt.Sprintf("[workspace] Split validation passed with pending allocation - operation will proceed"))
43		}	42		}
44			43
45		// Step 3: Validate tree invariants before operation	44		// Step 3: Validate tree invariants before operation

@@ -47,13 +46,13 @@ func (wm WorkspaceManager) SplitPane(target paneNode, direction string) (*pane
47		if wm.debugLevel == DebugFull {	46		if wm.debugLevel == DebugFull {
48		return nil, fmt.Errorf("tree validation failed before split: %w", err)	47		return nil, fmt.Errorf("tree validation failed before split: %w", err)
49		}	48		}
50	-	log.Printf("[workspace] WARNING: Tree validation failed before split but allowing operation: %v", err)	49	+	logging.Error(fmt.Sprintf("[workspace] WARNING: Tree validation failed before split but allowing operation: %v", err))
51		}	50		}
52		}	51		}
53			52
54		// Step 2: Execute directly if we're already on the GTK main thread	53		// Step 2: Execute directly if we're already on the GTK main thread
55		if webkit.IsMainThread() {	54		if webkit.IsMainThread() {
56	-	log.Printf("[workspace] Already on main thread, executing split directly")	55	+	logging.Info(fmt.Sprintf("[workspace] Already on main thread, executing split directly"))
57		newNode, err := wm.splitNode(target, direction, nil)	56		newNode, err := wm.splitNode(target, direction, nil)
58		if err != nil {	57		if err != nil {
59		return nil, err	58		return nil, err

@@ -61,18 +60,18 @@ func (wm WorkspaceManager) SplitPane(target paneNode, direction string) (*pane
61			60
62		if wm.debugLevel >= DebugBasic {	61		if wm.debugLevel >= DebugBasic {
63		if err := wm.treeValidator.ValidateTree(wm.root, "after_split"); err != nil {	62		if err := wm.treeValidator.ValidateTree(wm.root, "after_split"); err != nil {
64	-	log.Printf("[workspace] Tree validation failed after split: %v", err)	63	+	logging.Error(fmt.Sprintf("[workspace] Tree validation failed after split: %v", err))
65		}	64		}
66		}	65		}
67			66
68		// Tree rebalancing is only needed after close promotions. Splits have correct allocation from GTK.	67		// Tree rebalancing is only needed after close promotions. Splits have correct allocation from GTK.
69			68
70	-	log.Printf("[workspace] Split operation completed successfully (direct execution): newNode=%p", newNode)	69	+	logging.Info(fmt.Sprintf("[workspace] Split operation completed successfully (direct execution): newNode=%p", newNode))
71		return newNode, nil	70		return newNode, nil
72		}	71		}
73			72
74		// Step 3: Not on main thread, marshal via IdleAdd	73		// Step 3: Not on main thread, marshal via IdleAdd
75	-	log.Printf("[workspace] Not on main thread, marshalling split via IdleAdd")	74	+	logging.Info(fmt.Sprintf("[workspace] Not on main thread, marshalling split via IdleAdd"))
76		var newNode *paneNode	75		var newNode *paneNode
77		var splitErr error	76		var splitErr error
78		done := make(chan struct{})	77		done := make(chan struct{})

@@ -82,7 +81,7 @@ func (wm WorkspaceManager) SplitPane(target paneNode, direction string) (*pane
82		if splitErr == nil {	81		if splitErr == nil {
83		if wm.debugLevel >= DebugBasic {	82		if wm.debugLevel >= DebugBasic {
84		if verr := wm.treeValidator.ValidateTree(wm.root, "after_split"); verr != nil {	83		if verr := wm.treeValidator.ValidateTree(wm.root, "after_split"); verr != nil {
85	-	log.Printf("[workspace] Tree validation failed after split: %v", verr)	84	+	logging.Error(fmt.Sprintf("[workspace] Tree validation failed after split: %v", verr))
86		}	85		}
87		}	86		}
88		}	87		}

@@ -96,7 +95,7 @@ func (wm WorkspaceManager) SplitPane(target paneNode, direction string) (*pane
96		return nil, splitErr	95		return nil, splitErr
97		}	96		}
98			97
99	-	log.Printf("[workspace] Split operation completed successfully: newNode=%p", newNode)	98	+	logging.Info(fmt.Sprintf("[workspace] Split operation completed successfully: newNode=%p", newNode))
100		return newNode, nil	99		return newNode, nil
101		}	100		}
102			101

@@ -106,7 +105,7 @@ func (wm WorkspaceManager) ClosePane(node paneNode) error {
106		return fmt.Errorf("workspace manager is nil")	105		return fmt.Errorf("workspace manager is nil")
107		}	106		}
108			107
109	-	log.Printf("[workspace] Starting close operation: node=%p", node)	108	+	logging.Info(fmt.Sprintf("[workspace] Starting close operation: node=%p", node))
110		wm.paneCloseLogf("start bulletproof close node=%p", node)	109		wm.paneCloseLogf("start bulletproof close node=%p", node)
111		wm.dumpTreeState("before_close")	110		wm.dumpTreeState("before_close")
112			111

@@ -116,19 +115,19 @@ func (wm WorkspaceManager) ClosePane(node paneNode) error {
116		if wm.debugLevel == DebugFull {	115		if wm.debugLevel == DebugFull {
117		return fmt.Errorf("tree validation failed before close: %w", err)	116		return fmt.Errorf("tree validation failed before close: %w", err)
118		}	117		}
119	-	log.Printf("[workspace] WARNING: Tree validation failed before close but allowing operation: %v", err)	118	+	logging.Error(fmt.Sprintf("[workspace] WARNING: Tree validation failed before close but allowing operation: %v", err))
120		}	119		}
121		}	120		}
122			121
123		// Step 3: Check if this is a stacked pane and use enhanced lifecycle management	122		// Step 3: Check if this is a stacked pane and use enhanced lifecycle management
124		if node.parent != nil && node.parent.isStacked {	123		if node.parent != nil && node.parent.isStacked {
125	-	log.Printf("[workspace] Using enhanced stack lifecycle management for close")	124	+	logging.Debug(fmt.Sprintf("[workspace] Using enhanced stack lifecycle management for close"))
126		return wm.stackLifecycleManager.CloseStackedPaneWithLifecycle(node)	125		return wm.stackLifecycleManager.CloseStackedPaneWithLifecycle(node)
127		}	126		}
128			127
129		// Step 4: Execute directly when already on the GTK main thread	128		// Step 4: Execute directly when already on the GTK main thread
130		if webkit.IsMainThread() {	129		if webkit.IsMainThread() {
131	-	log.Printf("[workspace] Already on main thread, executing close directly")	130	+	logging.Info(fmt.Sprintf("[workspace] Already on main thread, executing close directly"))
132			131
133		wm.paneCloseLogf("invoking closePane node=%p", node)	132		wm.paneCloseLogf("invoking closePane node=%p", node)
134		promoted, err := wm.closePane(node)	133		promoted, err := wm.closePane(node)

@@ -140,7 +139,7 @@ func (wm WorkspaceManager) ClosePane(node paneNode) error {
140			139
141		if wm.debugLevel >= DebugBasic {	140		if wm.debugLevel >= DebugBasic {
142		if err := wm.treeValidator.ValidateTree(wm.root, "after_close"); err != nil {	141		if err := wm.treeValidator.ValidateTree(wm.root, "after_close"); err != nil {
143	-	log.Printf("[workspace] Tree validation failed after close: %v", err)	142	+	logging.Error(fmt.Sprintf("[workspace] Tree validation failed after close: %v", err))
144		}	143		}
145		}	144		}
146		wm.paneCloseLogf("closePane succeeded node=%p promoted=%p root=%p", node, promoted, wm.root)	145		wm.paneCloseLogf("closePane succeeded node=%p promoted=%p root=%p", node, promoted, wm.root)

@@ -148,16 +147,16 @@ func (wm WorkspaceManager) ClosePane(node paneNode) error {
148			147
149		if wm.treeRebalancer != nil {	148		if wm.treeRebalancer != nil {
150		if err := wm.treeRebalancer.RebalanceAfterClose(node, promoted); err != nil {	149		if err := wm.treeRebalancer.RebalanceAfterClose(node, promoted); err != nil {
151	-	log.Printf("[workspace] Tree rebalancing failed after close: %v", err)	150	+	logging.Error(fmt.Sprintf("[workspace] Tree rebalancing failed after close: %v", err))
152		}	151		}
153		}	152		}
154			153
155	-	log.Printf("[workspace] Close operation completed successfully (direct execution)")	154	+	logging.Info(fmt.Sprintf("[workspace] Close operation completed successfully (direct execution)"))
156		return nil	155		return nil
157		}	156		}
158			157
159		// Step 5: Not on main thread, marshal via IdleAdd	158		// Step 5: Not on main thread, marshal via IdleAdd
160	-	log.Printf("[workspace] Not on main thread, marshalling close via IdleAdd")	159	+	logging.Info(fmt.Sprintf("[workspace] Not on main thread, marshalling close via IdleAdd"))
161		var promoted *paneNode	160		var promoted *paneNode
162		var closeErr error	161		var closeErr error
163		done := make(chan struct{})	162		done := make(chan struct{})

@@ -171,7 +170,7 @@ func (wm WorkspaceManager) ClosePane(node paneNode) error {
171		} else {	170		} else {
172		if wm.debugLevel >= DebugBasic {	171		if wm.debugLevel >= DebugBasic {
173		if verr := wm.treeValidator.ValidateTree(wm.root, "after_close"); verr != nil {	172		if verr := wm.treeValidator.ValidateTree(wm.root, "after_close"); verr != nil {
174	-	log.Printf("[workspace] Tree validation failed after close: %v", verr)	173	+	logging.Error(fmt.Sprintf("[workspace] Tree validation failed after close: %v", verr))
175		}	174		}
176		}	175		}
177		wm.paneCloseLogf("closePane succeeded node=%p promoted=%p root=%p", node, promoted, wm.root)	176		wm.paneCloseLogf("closePane succeeded node=%p promoted=%p root=%p", node, promoted, wm.root)

@@ -179,7 +178,7 @@ func (wm WorkspaceManager) ClosePane(node paneNode) error {
179			178
180		if wm.treeRebalancer != nil {	179		if wm.treeRebalancer != nil {
181		if rerr := wm.treeRebalancer.RebalanceAfterClose(node, promoted); rerr != nil {	180		if rerr := wm.treeRebalancer.RebalanceAfterClose(node, promoted); rerr != nil {
182	-	log.Printf("[workspace] Tree rebalancing failed after close: %v", rerr)	181	+	logging.Error(fmt.Sprintf("[workspace] Tree rebalancing failed after close: %v", rerr))
183		}	182		}
184		}	183		}
185		}	184		}

@@ -193,7 +192,7 @@ func (wm WorkspaceManager) ClosePane(node paneNode) error {
193		return closeErr	192		return closeErr
194		}	193		}
195			194
196	-	log.Printf("[workspace] Close operation completed successfully")	195	+	logging.Info(fmt.Sprintf("[workspace] Close operation completed successfully"))
197		return nil	196		return nil
198		}	197		}
199			198

@@ -203,7 +202,7 @@ func (wm WorkspaceManager) StackPane(target paneNode) (*paneNode, error) {
203		return nil, fmt.Errorf("workspace manager is nil")	202		return nil, fmt.Errorf("workspace manager is nil")
204		}	203		}
205			204
206	-	log.Printf("[workspace] Starting stack operation: target=%p", target)	205	+	logging.Info(fmt.Sprintf("[workspace] Starting stack operation: target=%p", target))
207			206
208		// Step 1: Validate stack operation constraints (only in DebugBasic+)	207		// Step 1: Validate stack operation constraints (only in DebugBasic+)
209		if wm.debugLevel >= DebugBasic {	208		if wm.debugLevel >= DebugBasic {

@@ -212,12 +211,12 @@ func (wm WorkspaceManager) StackPane(target paneNode) (*paneNode, error) {
212		if wm.debugLevel == DebugFull {	211		if wm.debugLevel == DebugFull {
213		return nil, fmt.Errorf("stack validation failed: %s", validation.Reason)	212		return nil, fmt.Errorf("stack validation failed: %s", validation.Reason)
214		}	213		}
215	-	log.Printf("[workspace] WARNING: Stack validation failed but allowing operation: %s", validation.Reason)	214	+	logging.Error(fmt.Sprintf("[workspace] WARNING: Stack validation failed but allowing operation: %s", validation.Reason))
216		}	215		}
217			216
218		// Log if re-validation will be needed due to pending widget allocation	217		// Log if re-validation will be needed due to pending widget allocation
219		if validation.RequiresRevalidation {	218		if validation.RequiresRevalidation {
220	-	log.Printf("[workspace] Stack validation passed with pending allocation - operation will proceed")	219	+	logging.Info(fmt.Sprintf("[workspace] Stack validation passed with pending allocation - operation will proceed"))
221		}	220		}
222		}	221		}
223			222

@@ -227,13 +226,13 @@ func (wm WorkspaceManager) StackPane(target paneNode) (*paneNode, error) {
227		if wm.debugLevel == DebugFull {	226		if wm.debugLevel == DebugFull {
228		return nil, fmt.Errorf("tree validation failed before stack: %w", err)	227		return nil, fmt.Errorf("tree validation failed before stack: %w", err)
229		}	228		}
230	-	log.Printf("[workspace] WARNING: Tree validation failed before stack but allowing operation: %v", err)	229	+	logging.Error(fmt.Sprintf("[workspace] WARNING: Tree validation failed before stack but allowing operation: %v", err))
231		}	230		}
232		}	231		}
233			232
234		// Step 3: Execute directly if already on the GTK main thread	233		// Step 3: Execute directly if already on the GTK main thread
235		if webkit.IsMainThread() {	234		if webkit.IsMainThread() {
236	-	log.Printf("[workspace] Already on main thread, executing stack directly")	235	+	logging.Info(fmt.Sprintf("[workspace] Already on main thread, executing stack directly"))
237		newNode, err := wm.stackedPaneManager.StackPane(target)	236		newNode, err := wm.stackedPaneManager.StackPane(target)
238		if err != nil {	237		if err != nil {
239		return nil, err	238		return nil, err

@@ -241,16 +240,16 @@ func (wm WorkspaceManager) StackPane(target paneNode) (*paneNode, error) {
241			240
242		if wm.debugLevel >= DebugBasic {	241		if wm.debugLevel >= DebugBasic {
243		if err := wm.treeValidator.ValidateTree(wm.root, "after_stack"); err != nil {	242		if err := wm.treeValidator.ValidateTree(wm.root, "after_stack"); err != nil {
244	-	log.Printf("[workspace] Tree validation failed after stack: %v", err)	243	+	logging.Error(fmt.Sprintf("[workspace] Tree validation failed after stack: %v", err))
245		}	244		}
246		}	245		}
247			246
248	-	log.Printf("[workspace] Stack operation completed successfully (direct execution): newNode=%p", newNode)	247	+	logging.Info(fmt.Sprintf("[workspace] Stack operation completed successfully (direct execution): newNode=%p", newNode))
249		return newNode, nil	248		return newNode, nil
250		}	249		}
251			250
252		// Step 4: Not on main thread, marshal via IdleAdd	251		// Step 4: Not on main thread, marshal via IdleAdd
253	-	log.Printf("[workspace] Not on main thread, marshalling stack via IdleAdd")	252	+	logging.Info(fmt.Sprintf("[workspace] Not on main thread, marshalling stack via IdleAdd"))
254		var newNode *paneNode	253		var newNode *paneNode
255		var stackErr error	254		var stackErr error
256		done := make(chan struct{})	255		done := make(chan struct{})

@@ -260,7 +259,7 @@ func (wm WorkspaceManager) StackPane(target paneNode) (*paneNode, error) {
260		if stackErr == nil {	259		if stackErr == nil {
261		if wm.debugLevel >= DebugBasic {	260		if wm.debugLevel >= DebugBasic {
262		if verr := wm.treeValidator.ValidateTree(wm.root, "after_stack"); verr != nil {	261		if verr := wm.treeValidator.ValidateTree(wm.root, "after_stack"); verr != nil {
263	-	log.Printf("[workspace] Tree validation failed after stack: %v", verr)	262	+	logging.Error(fmt.Sprintf("[workspace] Tree validation failed after stack: %v", verr))
264		}	263		}
265		}	264		}
266		}	265		}

@@ -274,7 +273,7 @@ func (wm WorkspaceManager) StackPane(target paneNode) (*paneNode, error) {
274		return nil, stackErr	273		return nil, stackErr
275		}	274		}
276			275
277	-	log.Printf("[workspace] Stack operation completed successfully: newNode=%p", newNode)	276	+	logging.Info(fmt.Sprintf("[workspace] Stack operation completed successfully: newNode=%p", newNode))
278		return newNode, nil	277		return newNode, nil
279		}	278		}
280			279

@@ -286,7 +285,7 @@ func (wm *WorkspaceManager) EnableEnhancedMode() {
286		if wm.treeRebalancer != nil {	285		if wm.treeRebalancer != nil {
287		wm.treeRebalancer.Enable()	286		wm.treeRebalancer.Enable()
288		}	287		}
289	-	log.Printf("[workspace] Enhanced validation mode enabled")	288	+	logging.Info(fmt.Sprintf("[workspace] Enhanced validation mode enabled"))
290		}	289		}
291			290
292		// DisableEnhancedMode disables enhanced features for performance	291		// DisableEnhancedMode disables enhanced features for performance

@@ -297,7 +296,7 @@ func (wm *WorkspaceManager) DisableEnhancedMode() {
297		if wm.treeRebalancer != nil {	296		if wm.treeRebalancer != nil {
298		wm.treeRebalancer.Disable()	297		wm.treeRebalancer.Disable()
299		}	298		}
300	-	log.Printf("[workspace] Enhanced validation mode disabled")	299	+	logging.Info(fmt.Sprintf("[workspace] Enhanced validation mode disabled"))
301		}	300		}
302			301
303		// SetEnhancedDebugMode enables/disables debug mode for all enhanced validation components	302		// SetEnhancedDebugMode enables/disables debug mode for all enhanced validation components

@@ -308,7 +307,7 @@ func (wm *WorkspaceManager) SetEnhancedDebugMode(debug bool) {
308		if wm.geometryValidator != nil {	307		if wm.geometryValidator != nil {
309		wm.geometryValidator.SetDebugMode(debug)	308		wm.geometryValidator.SetDebugMode(debug)
310		}	309		}
311	-	log.Printf("[workspace] Enhanced debug mode set to: %v", debug)	310	+	logging.Debug(fmt.Sprintf("[workspace] Enhanced debug mode set to: %v", debug))
312		}	311		}
313			312
314		// GetEnhancedStats returns comprehensive statistics about all enhanced validation components	313		// GetEnhancedStats returns comprehensive statistics about all enhanced validation components

@@ -330,7 +329,7 @@ func (wm *WorkspaceManager) GetEnhancedStats() map[string]interface{} {
330			329
331		// ValidateWorkspaceIntegrity performs a comprehensive validation of the workspace	330		// ValidateWorkspaceIntegrity performs a comprehensive validation of the workspace
332		func (wm *WorkspaceManager) ValidateWorkspaceIntegrity() error {	331		func (wm *WorkspaceManager) ValidateWorkspaceIntegrity() error {
333	-	log.Printf("[workspace] Performing comprehensive workspace integrity check")	332	+	logging.Info(fmt.Sprintf("[workspace] Performing comprehensive workspace integrity check"))
334			333
335		// Tree structure validation	334		// Tree structure validation
336		if wm.treeValidator != nil {	335		if wm.treeValidator != nil {

@@ -341,14 +340,14 @@ func (wm *WorkspaceManager) ValidateWorkspaceIntegrity() error {
341			340
342		// Geometry validation simplified - ValidateWorkspaceLayout removed	341		// Geometry validation simplified - ValidateWorkspaceLayout removed
343			342
344	-	log.Printf("[workspace] Workspace integrity check completed successfully")	343	+	logging.Info(fmt.Sprintf("[workspace] Workspace integrity check completed successfully"))
345		return nil	344		return nil
346		}	345		}
347			346
348		// ShutdownEnhancedComponents gracefully shuts down all enhanced validation components	347		// ShutdownEnhancedComponents gracefully shuts down all enhanced validation components
349		func (wm *WorkspaceManager) ShutdownEnhancedComponents() {	348		func (wm *WorkspaceManager) ShutdownEnhancedComponents() {
350	-	log.Printf("[workspace] Shutting down enhanced validation components")	349	+	logging.Info(fmt.Sprintf("[workspace] Shutting down enhanced validation components"))
351			350
352		// Other components don't require explicit shutdown currently	351		// Other components don't require explicit shutdown currently
353	-	log.Printf("[workspace] Enhanced validation components shutdown complete")	352	+	logging.Info(fmt.Sprintf("[workspace] Enhanced validation components shutdown complete"))
354		}	353		}

M internal/app/browser/workspace_pane_mode.go +21 -19

 package browser
 import (
-	"log"
+	"fmt"
+	"github.com/bnema/dumber/internal/logging"
 )
 // EnterPaneMode activates pane mode on the currently focused pane
 	// Get the currently focused pane
 	activeNode := wm.GetActiveNode()
 	if activeNode == nil {
-		log.Printf("[pane-mode] Cannot enter pane mode: no active pane")
+		logging.Error(fmt.Sprintf("[pane-mode] Cannot enter pane mode: no active pane"))
 		return
 	}
 	// Already in pane mode on this pane?
 	if wm.paneModeActive && wm.paneModeActivePane == activeNode {
-		log.Printf("[pane-mode] Pane mode already active on this pane")
+		logging.Info(fmt.Sprintf("[pane-mode] Pane mode already active on this pane"))
 		return
 	}
-	log.Printf("[pane-mode] Entering pane mode on pane %p (workspace=%p)", activeNode, wm)
+	logging.Debug(fmt.Sprintf("[pane-mode] Entering pane mode on pane %p (workspace=%p)", activeNode, wm))
 	wm.paneModeActive = true
 	wm.paneModeActivePane = activeNode
 		return
 	}
-	log.Printf("[pane-mode] Exiting pane mode: %s", reason)
+	logging.Info(fmt.Sprintf("[pane-mode] Exiting pane mode: %s", reason))
 	wm.paneModeActive = false
 	wm.paneModeActivePane = nil
 	if !wm.paneModeActive {
 		wm.paneMutex.Unlock()
-		log.Printf("[pane-mode] Ignoring action '%s': pane mode not active", action)
+		logging.Info(fmt.Sprintf("[pane-mode] Ignoring action '%s': pane mode not active", action))
 		return
 	}
 	wm.paneMutex.Unlock()
 	if activePane == nil {
-		log.Printf("[pane-mode] Ignoring action '%s': no active pane", action)
+		logging.Info(fmt.Sprintf("[pane-mode] Ignoring action '%s': no active pane", action))
 		wm.ExitPaneMode("no-active-pane")
 		return
 	}
-	log.Printf("[pane-mode] Handling action '%s' on pane %p", action, activePane)
+	logging.Debug(fmt.Sprintf("[pane-mode] Handling action '%s' on pane %p", action, activePane))
 	switch action {
 	case "close":
 	case "stack":
 		wm.handlePaneStack(activePane)
 	default:
-		log.Printf("[pane-mode] Unknown action: %s", action)
+		logging.Warn(fmt.Sprintf("[pane-mode] Unknown action: %s", action))
 	}
 	// Exit pane mode after action
 		return
 	}
-	log.Printf("[pane-mode] Closing pane %p", node)
+	logging.Debug(fmt.Sprintf("[pane-mode] Closing pane %p", node))
 	// Notify JavaScript first so it can show toast
 	wm.dispatchPaneModeEvent("action", "close")
 	// Close the pane
 	if err := wm.ClosePane(node); err != nil {
-		log.Printf("[pane-mode] Failed to close pane: %v", err)
+		logging.Error(fmt.Sprintf("[pane-mode] Failed to close pane: %v", err))
 	}
 }
 	case "split-down":
 		direction = DirectionDown
 	default:
-		log.Printf("[pane-mode] Invalid split action: %s", action)
+		logging.Error(fmt.Sprintf("[pane-mode] Invalid split action: %s", action))
 		return
 	}
-	log.Printf("[pane-mode] Splitting pane %p in direction %s", node, direction)
+	logging.Debug(fmt.Sprintf("[pane-mode] Splitting pane %p in direction %s", node, direction))
 	// Notify JavaScript first so it can show toast
 	wm.dispatchPaneModeEvent("action", action)
 	// Perform the split (pass nil so it creates a fresh pane, not popup mode)
 	newNode, err := wm.splitNode(node, direction, nil)
 	if err != nil {
-		log.Printf("[pane-mode] Failed to split pane: %v", err)
+		logging.Error(fmt.Sprintf("[pane-mode] Failed to split pane: %v", err))
 		return
 	}
 	// Load initial URL in the new pane so scripts execute
 	wm.clonePaneState(node, newNode)
-	log.Printf("[pane-mode] Split successful: direction=%s", direction)
+	logging.Debug(fmt.Sprintf("[pane-mode] Split successful: direction=%s", direction))
 }
 // handlePaneStack creates a stacked pane
 		return
 	}
-	log.Printf("[pane-mode] Stacking pane %p", node)
+	logging.Debug(fmt.Sprintf("[pane-mode] Stacking pane %p", node))
 	// Notify JavaScript first so it can show toast
 	wm.dispatchPaneModeEvent("action", "stack")
 	// Perform the stack operation
 	newNode, err := wm.stackedPaneManager.StackPane(node)
 	if err != nil {
-		log.Printf("[pane-mode] Failed to stack pane: %v", err)
+		logging.Error(fmt.Sprintf("[pane-mode] Failed to stack pane: %v", err))
 		return
 	}
 	// Load initial URL in the new pane so scripts execute
 	wm.clonePaneState(node, newNode)
-	log.Printf("[pane-mode] Stack successful")
+	logging.Info(fmt.Sprintf("[pane-mode] Stack successful"))
 }
 // dispatchPaneModeEvent sends a pane mode event to JavaScript for UI updates
 	}
 	if err := view.DispatchCustomEvent("dumber:pane-mode", data); err != nil {
-		log.Printf("[pane-mode] Failed to dispatch event: %v", err)
+		logging.Error(fmt.Sprintf("[pane-mode] Failed to dispatch event: %v", err))
 	}
 }

M internal/app/browser/workspace_pane_ops.go +57 -57

 import (
 	"errors"
 	"fmt"
-	"log"
 	"github.com/diamondburned/gotk4/pkg/gdk/v4"
 	"github.com/diamondburned/gotk4/pkg/gtk/v4"
+	"github.com/bnema/dumber/internal/logging"
 	"github.com/bnema/dumber/pkg/webkit"
 )
 			return
 		}
 		if visited[n] {
-			log.Printf("[workspace] collectLeavesFromWithDirection: cycle detected in tree")
+			logging.Error(fmt.Sprintf("[workspace] collectLeavesFromWithDirection: cycle detected in tree"))
 			return
 		}
 		visited[n] = true
 			return
 		}
 		if visited[n] {
-			log.Printf("[workspace] collectLeavesFrom: cycle detected in tree")
+			logging.Error(fmt.Sprintf("[workspace] collectLeavesFrom: cycle detected in tree"))
 			return
 		}
 		visited[n] = true
 // clonePaneState sets up a new pane with cloned state from another pane
 func (wm *WorkspaceManager) clonePaneState(_ *paneNode, target *paneNode) {
 	if wm == nil || target == nil {
-		log.Printf("[workspace] clonePaneState: wm or target is nil")
+		logging.Debug(fmt.Sprintf("[workspace] clonePaneState: wm or target is nil"))
 		return
 	}
 	if target.pane == nil || target.pane.webView == nil {
-		log.Printf("[workspace] clonePaneState: target pane or webView is nil")
+		logging.Debug(fmt.Sprintf("[workspace] clonePaneState: target pane or webView is nil"))
 		return
 	}
 	// Load about:blank and auto-open omnibox
 	const blankURL = "about:blank"
-	log.Printf("[workspace] clonePaneState: loading %s in pane %p", blankURL, target.pane)
+	logging.Debug(fmt.Sprintf("[workspace] clonePaneState: loading %s in pane %p", blankURL, target.pane))
 	if err := target.pane.webView.LoadURL(blankURL); err != nil {
-		log.Printf("[workspace] failed to load blank page in new pane: %v", err)
+		logging.Error(fmt.Sprintf("[workspace] failed to load blank page in new pane: %v", err))
 	} else {
-		log.Printf("[workspace] successfully initiated load of %s", blankURL)
+		logging.Debug(fmt.Sprintf("[workspace] successfully initiated load of %s", blankURL))
 	}
 }
 		if target.hoverToken != nil {
 			target.pendingHoverReattach = true
 			target.hoverToken = nil // Clear reference, don't manually remove
-			log.Printf("[workspace] Marked hover controller for reattach on pane %p (GTK will auto-remove)", target)
+			logging.Debug(fmt.Sprintf("[workspace] Marked hover controller for reattach on pane %p (GTK will auto-remove)", target))
 		}
 		if target.focusControllerToken != 0 {
 			target.pendingFocusReattach = true
 			target.focusControllerToken = 0 // Clear reference, don't manually remove
-			log.Printf("[workspace] Marked focus controller for reattach on pane %p (GTK will auto-remove)", target)
+			logging.Debug(fmt.Sprintf("[workspace] Marked focus controller for reattach on pane %p (GTK will auto-remove)", target))
 		}
 	}
 		return
 	}
 	if err := wm.ClosePane(wm.GetActiveNode()); err != nil {
-		log.Printf("[workspace] close current pane failed: %v", err)
+		logging.Error(fmt.Sprintf("[workspace] close current pane failed: %v", err))
 	}
 }
 	delete(wm.viewToNode, webView)
 	delete(wm.lastSplitMsg, webView)
 	delete(wm.lastExitMsg, webView)
-	log.Printf("[workspace] removed webview %p from tracking maps", webView)
+	logging.Debug(fmt.Sprintf("[workspace] removed webview %p from tracking maps", webView))
 }
 // removeFromAppPanes removes a BrowserPane from the app.panes slice
 	for i, p := range wm.app.panes {
 		if p == pane {
 			wm.app.panes = append(wm.app.panes[:i], wm.app.panes[i+1:]...)
-			log.Printf("[workspace] removed pane from app.panes slice, remaining: %d", len(wm.app.panes))
+			logging.Debug(fmt.Sprintf("[workspace] removed pane from app.panes slice, remaining: %d", len(wm.app.panes)))
 			return
 		}
 	}
 	if target.parent != nil && target.parent.isStacked {
 		// Target is in a stack - we'll create the split around the entire stack
 		stackContainer = target.parent
-		log.Printf("[workspace] target is in stack, will split around the stack: originalTarget=%p stackContainer=%p", originalTarget, stackContainer)
+		logging.Debug(fmt.Sprintf("[workspace] target is in stack, will split around the stack: originalTarget=%p stackContainer=%p", originalTarget, stackContainer))
 	}
 	// Determine what we're actually splitting
 		// Case: splitting from inside a stack - we split around the entire stack
 		splitTarget = stackContainer
 		splitTargetContainer = stackContainer.container
-		log.Printf("[workspace] splitting around stack: stackContainer=%p", splitTarget)
+		logging.Debug(fmt.Sprintf("[workspace] splitting around stack: stackContainer=%p", splitTarget))
 	} else {
 		// Case: normal split from a simple pane
 		splitTarget = target
 		splitTargetContainer = target.container
-		log.Printf("[workspace] normal split from pane: target=%p", splitTarget)
+		logging.Info(fmt.Sprintf("[workspace] normal split from pane: target=%p", splitTarget))
 	}
 	// Use provided pane or create new one
 	if existingPane != nil {
 		// Reuse existing pane (for popup insertion)
 		newPane = existingPane
-		log.Printf("[workspace] Using existing pane for split: %p", newPane)
+		logging.Debug(fmt.Sprintf("[workspace] Using existing pane for split: %p", newPane))
 	} else {
 		// Create new WebView and pane (for normal splits)
 		newView, err := wm.createWebView()
 		if err != nil {
 			return nil, err
 		}
-		log.Printf("[workspace] Created new pane for split: %p", newPane)
+		logging.Info(fmt.Sprintf("[workspace] Created new pane for split: %p", newPane))
 	}
 	if handler := newPane.MessageHandler(); handler != nil {
 		if splitTargetContainer != nil {
 			webkit.WidgetSetHExpand(splitTargetContainer, true)
 			webkit.WidgetSetVExpand(splitTargetContainer, true)
-			log.Printf("[workspace] configured stack wrapper for split: %p", splitTargetContainer)
+			logging.Debug(fmt.Sprintf("[workspace] configured stack wrapper for split: %p", splitTargetContainer))
 		}
 	}
 	orientation, existingFirst := mapDirection(direction)
-	log.Printf("[workspace] splitting direction=%s orientation=%v existingFirst=%v splitTarget.parent=%p splitTarget.isStacked=%v isPopup=%v",
+	logging.Debug(fmt.Sprintf("[workspace] splitting direction=%s orientation=%v existingFirst=%v splitTarget.parent=%p splitTarget.isStacked=%v isPopup=%v",
-		direction, orientation, existingFirst, splitTarget.parent, splitTarget.isStacked, existingPane != nil)
+		direction, orientation, existingFirst, splitTarget.parent, splitTarget.isStacked, existingPane != nil))
 	paned := gtk.NewPaned(orientation)
 	if paned == nil {
 		// Remove active border class if present (prevents GTK bloom filter corruption during unparent)
 		if webkit.WidgetHasCSSClass(splitTargetContainer, activePaneClass) {
 			webkit.WidgetRemoveCSSClass(splitTargetContainer, activePaneClass)
-			log.Printf("[workspace] removed active class from split target (will transfer to new pane)")
+			logging.Debug(fmt.Sprintf("[workspace] removed active class from split target (will transfer to new pane)"))
 		}
 	}
 	// For non-root splits, unparent from parent paned
 	if parent != nil && parent.container != nil {
 		// Split target has a parent paned - remove it (automatically unparents in GTK4)
-		log.Printf("[workspace] unparenting split target container=%p from parent paned=%p", splitTargetContainer, parent.container)
+		logging.Debug(fmt.Sprintf("[workspace] unparenting split target container=%p from parent paned=%p", splitTargetContainer, parent.container))
 		if parentPaned, ok := parent.container.(*gtk.Paned); ok && parentPaned != nil {
 			if parent.left == splitTarget {
 				parentPaned.SetStartChild(nil)
 	if parent == nil {
 		// ROOT SPLIT: Manipulate TabManager.ContentArea
 		if wm.app == nil || wm.app.tabManager == nil || wm.app.tabManager.ContentArea == nil {
-			log.Printf("[workspace] ERROR: Cannot perform root split - tab manager not initialized")
+			logging.Error(fmt.Sprintf("[workspace] ERROR: Cannot perform root split - tab manager not initialized"))
 			return nil, fmt.Errorf("tab manager not initialized")
 		}
 		contentBox, ok := wm.app.tabManager.ContentArea.(*gtk.Box)
 		if !ok || contentBox == nil {
-			log.Printf("[workspace] ERROR: ContentArea is not a Box")
+			logging.Error(fmt.Sprintf("[workspace] ERROR: ContentArea is not a Box"))
 			return nil, fmt.Errorf("ContentArea is not a Box")
 		}
 		// Remove the old workspace root from ContentArea
 		contentBox.Remove(splitTargetContainer)
-		log.Printf("[workspace] ROOT SPLIT: removed old root %p from ContentArea", splitTargetContainer)
+		logging.Debug(fmt.Sprintf("[workspace] ROOT SPLIT: removed old root %p from ContentArea", splitTargetContainer))
 		// Attach the new paned to ContentArea FIRST
 		contentBox.Append(paned)
-		log.Printf("[workspace] ROOT SPLIT: attached paned %p to ContentArea", paned)
+		logging.Debug(fmt.Sprintf("[workspace] ROOT SPLIT: attached paned %p to ContentArea", paned))
 		// Now add children to the paned - GTK will handle reparenting automatically
 		if existingFirst {
 			paned.SetStartChild(splitTargetContainer)
 			paned.SetEndChild(newContainer)
-			log.Printf("[workspace] ROOT SPLIT: added splitTarget=%p (start), new=%p (end)", splitTargetContainer, newContainer)
+			logging.Debug(fmt.Sprintf("[workspace] ROOT SPLIT: added splitTarget=%p (start), new=%p (end)", splitTargetContainer, newContainer))
 		} else {
 			paned.SetStartChild(newContainer)
 			paned.SetEndChild(splitTargetContainer)
-			log.Printf("[workspace] ROOT SPLIT: added new=%p (start), splitTarget=%p (end)", newContainer, splitTargetContainer)
+			logging.Debug(fmt.Sprintf("[workspace] ROOT SPLIT: added new=%p (start), splitTarget=%p (end)", newContainer, splitTargetContainer))
 		}
 	} else {
 		// NON-ROOT SPLIT: Standard approach
 			if splitTargetContainer != nil {
 				paned.SetStartChild(splitTargetContainer)
 				paned.SetEndChild(newContainer)
-				log.Printf("[workspace] added splitTarget=%p as start child, new=%p as end child", splitTargetContainer, newContainer)
+				logging.Debug(fmt.Sprintf("[workspace] added splitTarget=%p as start child, new=%p as end child", splitTargetContainer, newContainer))
 			}
 		} else {
 			if splitTargetContainer != nil {
 				paned.SetStartChild(newContainer)
 				paned.SetEndChild(splitTargetContainer)
-				log.Printf("[workspace] added new=%p as start child, splitTarget=%p as end child", newContainer, splitTargetContainer)
+				logging.Debug(fmt.Sprintf("[workspace] added new=%p as start child, splitTarget=%p as end child", newContainer, splitTargetContainer))
 			}
 		}
 			}
 			webkit.WidgetQueueAllocate(parent.container)
 			paned.QueueAllocate()
-			log.Printf("[workspace] paned inserted into parent=%p", parent.container)
+			logging.Info(fmt.Sprintf("[workspace] paned inserted into parent=%p", parent.container))
 		}
 	}
 		wm.app.panes = append(wm.app.panes, newPane)
 	} else {
 		// For existing popup panes, they're already in app.panes from createPane() in handlePopupReadyToShow
-		log.Printf("[workspace] Skipping app.panes append for existing popup pane (already added)")
+		logging.Info(fmt.Sprintf("[workspace] Skipping app.panes append for existing popup pane (already added)"))
 	}
 	if newPane.zoomController != nil {
 			// so it has no GTK parent now.
 			if wm.app == nil || wm.app.tabManager == nil || wm.app.tabManager.ContentArea == nil {
-				log.Printf("[workspace] ERROR: Cannot promote sibling to root - tab manager not initialized")
+				logging.Error(fmt.Sprintf("[workspace] ERROR: Cannot promote sibling to root - tab manager not initialized"))
 				return
 			}
 			contentBox, ok := wm.app.tabManager.ContentArea.(*gtk.Box)
 			if !ok || contentBox == nil {
-				log.Printf("[workspace] ERROR: ContentArea is not a Box")
+				logging.Error(fmt.Sprintf("[workspace] ERROR: ContentArea is not a Box"))
 				return
 			}
 			// CRITICAL: Remove the old paned from ContentArea first
 			if parent != nil && parent.container != nil {
 				contentBox.Remove(parent.container)
-				log.Printf("[workspace] Removed old paned %p from ContentArea", parent.container)
+				logging.Debug(fmt.Sprintf("[workspace] Removed old paned %p from ContentArea", parent.container))
 			}
 			// Now add sibling to ContentArea as the new root
 			contentBox.Append(sibling.container)
 			webkit.WidgetSetVisible(sibling.container, true)
-			log.Printf("[workspace] Promoted sibling %p to root in ContentArea", sibling.container)
+			logging.Debug(fmt.Sprintf("[workspace] Promoted sibling %p to root in ContentArea", sibling.container))
 		}
 		return
 	}
 		// GTK4 PanedSetStartChild/EndChild auto-unparent from current parent
 		// Focus was already cleared before unparenting closed pane
 		if parent := webkit.WidgetGetParent(sibling.container); parent != nil && parent != grand.container {
-			log.Printf("[workspace] widget %p reparenting from %p to %p (GTK4 will auto-unparent)", sibling.container, parent, grand.container)
+			logging.Debug(fmt.Sprintf("[workspace] widget %p reparenting from %p to %p (GTK4 will auto-unparent)", sibling.container, parent, grand.container))
 		}
 		if grand.left == sibling {
 			grandPaned.SetStartChild(sibling.container)
-			log.Printf("[workspace] swapContainers: set widget %p as start child of paned %p", sibling.container, grand.container)
+			logging.Debug(fmt.Sprintf("[workspace] swapContainers: set widget %p as start child of paned %p", sibling.container, grand.container))
 		} else {
 			grandPaned.SetEndChild(sibling.container)
-			log.Printf("[workspace] swapContainers: set widget %p as end child of paned %p", sibling.container, grand.container)
+			logging.Debug(fmt.Sprintf("[workspace] swapContainers: set widget %p as end child of paned %p", sibling.container, grand.container))
 		}
 		webkit.WidgetQueueAllocate(grand.container)
 	}
 		return
 	}
-	log.Printf("[workspace] Cascading promotion: replacing paned %p with its only child %p", singleChildPaned, onlyChild)
+	logging.Info(fmt.Sprintf("[workspace] Cascading promotion: replacing paned %p with its only child %p", singleChildPaned, onlyChild))
 	greatGrandparent := singleChildPaned.parent
 	if greatGrandparent == nil {
 		// Single child becomes new root
 		wm.root = onlyChild
-		log.Printf("[workspace] Only child %p promoted to root", onlyChild)
+		logging.Debug(fmt.Sprintf("[workspace] Only child %p promoted to root", onlyChild))
 		// Attach to window
 		if onlyChild.container != nil {
 			greatGrandparent.right = onlyChild
 		}
-		log.Printf("[workspace] Only child %p attached to great-grandparent %p", onlyChild, greatGrandparent)
+		logging.Debug(fmt.Sprintf("[workspace] Only child %p attached to great-grandparent %p", onlyChild, greatGrandparent))
 		// Reparent widget in GTK
 		if greatGrandPaned, ok := greatGrandparent.container.(*gtk.Paned); ok && greatGrandPaned != nil && onlyChild.container != nil {
 		// Check if great-grandparent now also has only one child (recursive case)
 		if greatGrandparent != nil && ((greatGrandparent.left == nil) != (greatGrandparent.right == nil)) {
-			log.Printf("[workspace] Great-grandparent %p also has only one child, continuing cascade", greatGrandparent)
+			logging.Info(fmt.Sprintf("[workspace] Great-grandparent %p also has only one child, continuing cascade", greatGrandparent))
 			wm.cascadePromotion(greatGrandparent)
 		}
 	}
 	// Detach from previous container (paned, stack, etc.) before attaching to ContentArea
 	// While GTK4 auto-unparents for paned operations, Box.Append requires manual unparent
 	if parent := webkit.WidgetGetParent(root.container); parent != nil {
-		log.Printf("[workspace] unparenting widget %p from parent %p before root attach", root.container, parent)
+		logging.Debug(fmt.Sprintf("[workspace] unparenting widget %p from parent %p before root attach", root.container, parent))
 		webkit.WidgetUnparent(root.container)
 		// Note: In gotk4, the Go object reference remains valid after unparent
 		// Only the GTK parent relationship is cleared
 	// Add to ContentArea (the old root will be orphaned and garbage collected)
 	if wm.app == nil || wm.app.tabManager == nil || wm.app.tabManager.ContentArea == nil {
-		log.Printf("[workspace] ERROR: Cannot attach root - tab manager not initialized")
+		logging.Error(fmt.Sprintf("[workspace] ERROR: Cannot attach root - tab manager not initialized"))
 		return
 	}
 	contentBox, ok := wm.app.tabManager.ContentArea.(*gtk.Box)
 	if !ok || contentBox == nil {
-		log.Printf("[workspace] ERROR: ContentArea is not a Box")
+		logging.Error(fmt.Sprintf("[workspace] ERROR: ContentArea is not a Box"))
 		return
 	}
 	// Verify attachment succeeded
 	if finalParent := webkit.WidgetGetParent(root.container); finalParent == nil {
-		log.Printf("[workspace] WARNING: widget %p has no parent after SetChild", root.container)
+		logging.Warn(fmt.Sprintf("[workspace] WARNING: widget %p has no parent after SetChild", root.container))
 	} else {
-		log.Printf("[workspace] attachRoot successful: widget %p now child of %p", root.container, finalParent)
+		logging.Debug(fmt.Sprintf("[workspace] attachRoot successful: widget %p now child of %p", root.container, finalParent))
 	}
 }
 		pane.Cleanup()
 		pane.CleanupFromWorkspace(wm)
 		if pane.webView != nil {
-			log.Printf("[workspace] releasing WebView reference: %p", pane.webView)
+			logging.Debug(fmt.Sprintf("[workspace] releasing WebView reference: %p", pane.webView))
 			pane.webView = nil
 		}
 		node.pane = nil
 	if !parent.isLeaf && parent.container != nil {
 		// In gotk4, we don't need to manually destroy - GTK handles this when unparented
 		// Just mark it for cleanup
-		log.Printf("[workspace] marked paned widget for cleanup: %p", parent.container)
+		logging.Debug(fmt.Sprintf("[workspace] marked paned widget for cleanup: %p", parent.container))
 	}
 	wm.cleanupPane(parent, generation)
 // cleanupAndExit handles the final pane cleanup and application exit
 func (wm *WorkspaceManager) cleanupAndExit(node *paneNode) (*paneNode, error) {
-	log.Printf("[workspace] closing final pane; exiting browser")
+	logging.Info(fmt.Sprintf("[workspace] closing final pane; exiting browser"))
 	wm.cleanupPane(node, wm.nextCleanupGeneration())
 	wm.detachHover(node)
 				} else if parent.right == node {
 					parentPaned.SetEndChild(nil)
 				}
-				log.Printf("[workspace] unparented closed pane container: %p", node.container)
+				logging.Debug(fmt.Sprintf("[workspace] unparented closed pane container: %p", node.container))
 			}
 		}
 	}
 			} else if parent.right == sibling {
 				parentPaned.SetEndChild(nil)
 			}
-			log.Printf("[workspace] unparented sibling container %p from parent paned %p", sibling.container, parent.container)
+			logging.Debug(fmt.Sprintf("[workspace] unparented sibling container %p from parent paned %p", sibling.container, parent.container))
 		}
 	}
 	// STEP 8: Check if grandparent now has only one child (cascade promotion needed)
 	if grandparent != nil && ((grandparent.left == nil) != (grandparent.right == nil)) {
 		// Grandparent has exactly one child - it should be promoted too
-		log.Printf("[workspace] Grandparent %p now has only one child, cascading promotion", grandparent)
+		logging.Info(fmt.Sprintf("[workspace] Grandparent %p now has only one child, cascading promotion", grandparent))
 		wm.cascadePromotion(grandparent)
 	}
 		}
 		paned.SetPosition(pos)
-		log.Printf("[workspace] Set paned position to 50%%: %d (orientation=%d, size=%dx%d)", pos, orientation, alloc.Width(), alloc.Height())
+		logging.Debug(fmt.Sprintf("[workspace] Set paned position to 50%%: %d (orientation=%d, size=%dx%d)", pos, orientation, alloc.Width(), alloc.Height()))
 		return true
 	}
 		if frames >= maxFrames {
 			alloc := paned.Allocation()
-			log.Printf("[workspace] Unable to stabilize paned position after %d frames (size=%dx%d)", frames, alloc.Width(), alloc.Height())
+			logging.Error(fmt.Sprintf("[workspace] Unable to stabilize paned position after %d frames (size=%dx%d)", frames, alloc.Width(), alloc.Height()))
 			return false
 		}

M internal/app/browser/workspace_popup.go +73 -72

 package browser
 import (
-	"log"
+	"fmt"
 	"strings"
 	"time"
 	"github.com/bnema/dumber/internal/config"
+	"github.com/bnema/dumber/internal/logging"
 	"github.com/bnema/dumber/pkg/webkit"
 	webkitgtk "github.com/diamondburned/gotk4-webkitgtk/pkg/webkit/v6"
 )
 // registerOAuthAutoClose sets up OAuth auto-close functionality for popups
 // Note: OAuth detection is now handled by the main-world.js injection script
 func (wm *WorkspaceManager) registerOAuthAutoClose(view *webkit.WebView, url string) {
-	log.Printf("[workspace] OAuth auto-close enabled for popup with URL: %s", url)
+	logging.Info(fmt.Sprintf("[workspace] OAuth auto-close enabled for popup with URL: %s", url))
-	log.Printf("[workspace] OAuth detection will be handled by main-world.js injection script")
+	logging.Info(fmt.Sprintf("[workspace] OAuth detection will be handled by main-world.js injection script"))
 }
 // insertIndependentPane inserts a new independent pane next to the source
 	related := webView
 	newPane, err := wm.createPane(related)
 	if err != nil {
-		log.Printf("[workspace] failed to create related popup pane: %v", err)
+		logging.Error(fmt.Sprintf("[workspace] failed to create related popup pane: %v", err))
 		return
 	}
 	direction := strings.ToLower(wm.app.config.Workspace.Popups.Placement)
 	}
 	// Use splitNode with existing pane instead of insertPopupPane
 	if _, err := wm.splitNode(sourceNode, direction, newPane); err != nil {
-		log.Printf("[workspace] failed to insert related popup pane: %v", err)
+		logging.Error(fmt.Sprintf("[workspace] failed to insert related popup pane: %v", err))
 		return
 	}
 	node := wm.viewToNode[related]
 			sourceNode.activePopupChildren = make([]string, 0)
 		}
 		sourceNode.activePopupChildren = append(sourceNode.activePopupChildren, popupWebViewID)
-		log.Printf("[workspace] Added popup %s to parent's activePopupChildren (count: %d)", popupWebViewID, len(sourceNode.activePopupChildren))
+		logging.Debug(fmt.Sprintf("[workspace] Added popup %s to parent's activePopupChildren (count: %d)", popupWebViewID, len(sourceNode.activePopupChildren)))
 		// Register navigation policy handler for parent to block script-initiated navigations
 		// when it has active popup children (prevents OAuth from hijacking parent pane)
 				// Block script-initiated navigations if this pane has active popup children
 				if len(sourceNode.activePopupChildren) > 0 {
-					log.Printf("[workspace] BLOCKED script-initiated navigation in parent pane (has %d active popups): %s", len(sourceNode.activePopupChildren), url)
+					logging.Info(fmt.Sprintf("[workspace] BLOCKED script-initiated navigation in parent pane (has %d active popups): %s", len(sourceNode.activePopupChildren), url))
 					return false
 				}
 				// Allow if no active popups
 				return true
 			})
-			log.Printf("[workspace] Registered navigation policy handler for parent pane")
+			logging.Debug(fmt.Sprintf("[workspace] Registered navigation policy handler for parent pane"))
 		}
 	}
 	// Pipe into existing auto-close flow only for popups (confirmed by detection)
 	related.RegisterCloseHandler(func() {
-		log.Printf("[workspace] Popup requesting close via window.close()")
+		logging.Info(fmt.Sprintf("[workspace] Popup requesting close via window.close()"))
 		// Remove this popup from parent's activePopupChildren
 		if sourceNode != nil && popupWebViewID != "" {
 			for i, childID := range sourceNode.activePopupChildren {
 				if childID == popupWebViewID {
 					sourceNode.activePopupChildren = append(sourceNode.activePopupChildren[:i], sourceNode.activePopupChildren[i+1:]...)
-					log.Printf("[workspace] Removed popup %s from parent's activePopupChildren (remaining: %d)", popupWebViewID, len(sourceNode.activePopupChildren))
+					logging.Debug(fmt.Sprintf("[workspace] Removed popup %s from parent's activePopupChildren (remaining: %d)", popupWebViewID, len(sourceNode.activePopupChildren)))
 					break
 				}
 			}
 						return false
 					}
 					if err := wm.ClosePane(n); err != nil {
-						log.Printf("[workspace] Failed to close popup pane: %v", err)
+						logging.Error(fmt.Sprintf("[workspace] Failed to close popup pane: %v", err))
 					}
 					return false
 				}, n)
 	if container := view.RootWidget(); container != nil {
 		webkit.WidgetSetSizeRequest(container, minWidth, minHeight)
 		webkit.WidgetQueueResize(container)
-		log.Printf("[workspace] Applied minimum size %dx%d to popup container=%p", minWidth, minHeight, container)
+		logging.Debug(fmt.Sprintf("[workspace] Applied minimum size %dx%d to popup container=%p", minWidth, minHeight, container))
 	}
 	// Apply to WebView widget
 	if webViewWidget := view.Widget(); webViewWidget != nil {
 		webkit.WidgetSetSizeRequest(webViewWidget, minWidth, minHeight)
 		webkit.WidgetQueueResize(webViewWidget)
-		log.Printf("[workspace] Applied minimum size %dx%d to popup webview=%p", minWidth, minHeight, webViewWidget)
+		logging.Debug(fmt.Sprintf("[workspace] Applied minimum size %dx%d to popup webview=%p", minWidth, minHeight, webViewWidget))
 	}
 }
 // shouldAutoClose checks simple OAuth-like URL patterns and config flag
 func (wm *WorkspaceManager) shouldAutoClose(url string) bool {
-	log.Printf("[workspace] shouldAutoClose called for URL: %s", url)
+	logging.Info(fmt.Sprintf("[workspace] shouldAutoClose called for URL: %s", url))
 	if wm == nil || wm.app == nil || wm.app.config == nil {
-		log.Printf("[workspace] shouldAutoClose: missing config, returning true")
+		logging.Error(fmt.Sprintf("[workspace] shouldAutoClose: missing config, returning true"))
 		return true
 	}
 	if !wm.app.config.Workspace.Popups.OAuthAutoClose {
-		log.Printf("[workspace] shouldAutoClose: OAuthAutoClose disabled in config, returning false")
+		logging.Info(fmt.Sprintf("[workspace] shouldAutoClose: OAuthAutoClose disabled in config, returning false"))
 		return false
 	}
 	u := strings.ToLower(url)
-	log.Printf("[workspace] shouldAutoClose: checking lowercase URL: %s", u)
+	logging.Debug(fmt.Sprintf("[workspace] shouldAutoClose: checking lowercase URL: %s", u))
 	// RFC 6749 compliant OAuth 2.0 URL patterns
 	oauthPatterns := []string{
 	// Check for OAuth patterns in URL
 	for _, pattern := range oauthPatterns {
 		if strings.Contains(u, pattern) {
-			log.Printf("[workspace] shouldAutoClose: MATCHED pattern '%s' in URL, returning true", pattern)
+			logging.Info(fmt.Sprintf("[workspace] shouldAutoClose: MATCHED pattern '%s' in URL, returning true", pattern))
 			return true
 		}
 	}
-	log.Printf("[workspace] shouldAutoClose: no OAuth patterns matched, returning false")
+	logging.Info(fmt.Sprintf("[workspace] shouldAutoClose: no OAuth patterns matched, returning false"))
 	return false
 }
 		return // Already placed
 	}
-	log.Printf("[workspace] Smart detection result: type=%d url=%s", windowType, url)
+	logging.Info(fmt.Sprintf("[workspace] Smart detection result: type=%d url=%s", windowType, url))
 	switch windowType {
 	case webkit.WindowTypeTab:
 		// For tabs, create a NEW independent WebView (can't use the related one)
 		webkitCfg, err := wm.app.buildWebkitConfig()
 		if err != nil {
-			log.Printf("[workspace] failed to build webkit config for tab: %v", err)
+			logging.Error(fmt.Sprintf("[workspace] failed to build webkit config for tab: %v", err))
 			return
 		}
 		// Tabs are embedded in workspace paned containers - no separate window needed
 		// Create independent WebView matching our standard tab insertion path
 		independentView, err := webkit.NewWebView(webkitCfg)
 		if err != nil {
-			log.Printf("[workspace] failed to create independent tab WebView: %v", err)
+			logging.Error(fmt.Sprintf("[workspace] failed to create independent tab WebView: %v", err))
 			return
 		}
 		// The related webView was just for detection - we don't use it for tabs
 		// Insert the new independent view as a tab
 		if err := wm.insertIndependentPane(sourceNode, independentView, url); err != nil {
-			log.Printf("[workspace] Failed to insert independent pane: %v", err)
+			logging.Error(fmt.Sprintf("[workspace] Failed to insert independent pane: %v", err))
 		}
 	case webkit.WindowTypePopup:
 		// Get URL from navigation action
 		req := navAction.Request()
 		if req == nil {
-			log.Printf("[workspace] create signal: no request in navigation action")
+			logging.Info(fmt.Sprintf("[workspace] create signal: no request in navigation action"))
 			return nil
 		}
 		url := req.URI()
-		log.Printf("[workspace] create signal received for URL: %s", url)
+		logging.Info(fmt.Sprintf("[workspace] create signal received for URL: %s", url))
 		// Check if popups are enabled in config
 		if wm.app.config != nil && !wm.app.config.Workspace.Popups.OpenInNewPane {
-			log.Printf("[workspace] Popup creation disabled in config - blocking popup")
+			logging.Info(fmt.Sprintf("[workspace] Popup creation disabled in config - blocking popup"))
 			return nil
 		}
 		// WebKit requires the related-view property to be set during construction for proper lifecycle
 		// This ensures session/cookie sharing and proper WindowFeatures initialization
 		// All initialization (wrapping, container, scripts) happens in ready-to-show
-		log.Printf("[workspace] Step 1: Creating bare gotk4 WebView with related-view property")
+		logging.Debug(fmt.Sprintf("[workspace] Step 1: Creating bare gotk4 WebView with related-view property"))
 		barePopupView := webkit.NewBareRelatedWebView(webView.GtkWebView())
 		if barePopupView == nil {
-			log.Printf("[workspace] Failed to create bare related popup WebView - blocking popup")
+			logging.Error(fmt.Sprintf("[workspace] Failed to create bare related popup WebView - blocking popup"))
 			return nil
 		}
-		log.Printf("[workspace] Step 1 complete: bare related gotk4 WebView created=%p (parent=%p)", barePopupView, webView.GtkWebView())
+		logging.Debug(fmt.Sprintf("[workspace] Step 1 complete: bare related gotk4 WebView created=%p (parent=%p)", barePopupView, webView.GtkWebView()))
 		// Wrap the bare view immediately to get a proper ID
 		// BUT don't initialize it yet - that happens in ready-to-show
-		log.Printf("[workspace] Step 2: Wrapping bare view (no initialization)")
+		logging.Info(fmt.Sprintf("[workspace] Step 2: Wrapping bare view (no initialization)"))
 		wrappedView := webkit.WrapBareWebView(barePopupView)
 		if wrappedView == nil {
-			log.Printf("[workspace] Failed to wrap bare popup WebView - blocking popup")
+			logging.Error(fmt.Sprintf("[workspace] Failed to wrap bare popup WebView - blocking popup"))
 			return nil
 		}
 		// Use the wrapper's ID for tracking
 		popupID := wrappedView.ID()
-		log.Printf("[workspace] Step 2 complete: wrapped view created with ID=%d", popupID)
+		logging.Debug(fmt.Sprintf("[workspace] Step 2 complete: wrapped view created with ID=%d", popupID))
 		// Store wrapped view (not initialized) for initialization in ready-to-show
-		log.Printf("[workspace] Step 3: Storing in pendingPopups map")
+		logging.Info(fmt.Sprintf("[workspace] Step 3: Storing in pendingPopups map"))
 		wm.pendingPopups[popupID] = &pendingPopup{
 			wrappedView: wrappedView,
 			parentView:  webView,
 			parentNode:  parentNode,
 			url:         url,
 		}
-		log.Printf("[workspace] Step 3 complete: stored in pendingPopups")
+		logging.Info(fmt.Sprintf("[workspace] Step 3 complete: stored in pendingPopups"))
 		// Connect signals immediately BEFORE returning to WebKit
 		// This is safe because we're only connecting signal handlers, not accessing properties
 		// WebKit will configure WindowFeatures AFTER this callback returns, which is fine
-		log.Printf("[workspace] Step 4: Connecting signals immediately before returning to WebKit")
+		logging.Info(fmt.Sprintf("[workspace] Step 4: Connecting signals immediately before returning to WebKit"))
 		// Connect ready-to-show signal
 		barePopupView.ConnectReadyToShow(func() {
-			log.Printf("[workspace] ready-to-show signal received for popup ID=%d", popupID)
+			logging.Info(fmt.Sprintf("[workspace] ready-to-show signal received for popup ID=%d", popupID))
 			wm.handlePopupReadyToShow(popupID)
 		})
-		log.Printf("[workspace] Connected ready-to-show signal for popup ID=%d", popupID)
+		logging.Debug(fmt.Sprintf("[workspace] Connected ready-to-show signal for popup ID=%d", popupID))
 		// Connect close handler
 		barePopupView.ConnectClose(func() {
-			log.Printf("[workspace] close signal received for popup ID=%d", popupID)
+			logging.Info(fmt.Sprintf("[workspace] close signal received for popup ID=%d", popupID))
 			wm.handlePopupClose(popupID)
 		})
-		log.Printf("[workspace] Connected close signal for popup ID=%d", popupID)
+		logging.Debug(fmt.Sprintf("[workspace] Connected close signal for popup ID=%d", popupID))
-		log.Printf("[workspace] Step 4 complete: signals connected")
+		logging.Debug(fmt.Sprintf("[workspace] Step 4 complete: signals connected"))
-		log.Printf("[workspace] Step 5: Returning wrapped view to WebKit (will extract bare view in ConnectCreate)")
+		logging.Debug(fmt.Sprintf("[workspace] Step 5: Returning wrapped view to WebKit (will extract bare view in ConnectCreate)"))
 		// Return the wrapped view - WebKit will extract the underlying gotk4 view and configure it
 		return wrappedView
 func (wm *WorkspaceManager) handlePopupReadyToShow(popupID uint64) {
 	info, ok := wm.pendingPopups[popupID]
 	if !ok {
-		log.Printf("[workspace] ready-to-show for unknown popup ID: %d", popupID)
+		logging.Warn(fmt.Sprintf("[workspace] ready-to-show for unknown popup ID: %d", popupID))
 		return
 	}
 	delete(wm.pendingPopups, popupID)
-	log.Printf("[workspace] ready-to-show received for popup ID=%d, starting full initialization", popupID)
+	logging.Info(fmt.Sprintf("[workspace] ready-to-show received for popup ID=%d, starting full initialization", popupID))
 	// NOW it's safe to initialize (WebKit has configured WindowProperties)
 	// We already have the wrapped view from setupPopupHandling
 	// Build webkit config for initialization
 	webkitCfg, err := wm.app.buildWebkitConfig()
 	if err != nil {
-		log.Printf("[workspace] Failed to build webkit config for popup initialization: %v", err)
+		logging.Error(fmt.Sprintf("[workspace] Failed to build webkit config for popup initialization: %v", err))
 		return
 	}
 	webkitCfg.CreateWindow = false // Embedded in workspace
 	// Initialize the wrapped view with full configuration
 	if err := wrappedView.InitializeFromBare(webkitCfg); err != nil {
-		log.Printf("[workspace] Failed to initialize popup WebView: %v", err)
+		logging.Error(fmt.Sprintf("[workspace] Failed to initialize popup WebView: %v", err))
 		return
 	}
 	// Register with content blocking service for network/cosmetic filtering
 	wm.app.RegisterWebViewForFiltering(wrappedView)
-	log.Printf("[workspace] Successfully initialized popup WebView ID %d", wrappedView.ID())
+	logging.Debug(fmt.Sprintf("[workspace] Successfully initialized popup WebView ID %d", wrappedView.ID()))
 	// Create pane for the fully initialized WebView
 	popupPane, err := wm.createPane(wrappedView)
 	if err != nil {
-		log.Printf("[workspace] Failed to create popup pane: %v", err)
+		logging.Error(fmt.Sprintf("[workspace] Failed to create popup pane: %v", err))
 		return
 	}
-	log.Printf("[workspace] Created popup pane, now inserting into workspace")
+	logging.Info(fmt.Sprintf("[workspace] Created popup pane, now inserting into workspace"))
 	// Determine window type from node (set during setupPopupHandling)
 	node := wm.viewToNode[wrappedView]
 	var behaviorStr string
 	if windowType == webkit.WindowTypeTab {
 		behaviorStr = wm.app.config.Workspace.Popups.BlankTargetBehavior
-		log.Printf("[workspace] WindowTypeTab (_blank link) detected, using BlankTargetBehavior: %s", behaviorStr)
+		logging.Debug(fmt.Sprintf("[workspace] WindowTypeTab (_blank link) detected, using BlankTargetBehavior: %s", behaviorStr))
 	} else {
 		behaviorStr = string(wm.app.config.Workspace.Popups.Behavior)
-		log.Printf("[workspace] WindowTypePopup detected, using Behavior: %s", behaviorStr)
+		logging.Debug(fmt.Sprintf("[workspace] WindowTypePopup detected, using Behavior: %s", behaviorStr))
 	}
 	// Map string to PopupBehavior enum
 		behavior = config.PopupBehaviorSplit // Fallback
 	}
-	log.Printf("[workspace] Final behavior: %s", behavior)
+	logging.Info(fmt.Sprintf("[workspace] Final behavior: %s", behavior))
 	switch behavior {
 	case config.PopupBehaviorSplit:
 			direction = DirectionRight
 		}
 		if _, err := wm.splitNode(info.parentNode, direction, popupPane); err != nil {
-			log.Printf("[workspace] Failed to insert split popup pane: %v", err)
+			logging.Error(fmt.Sprintf("[workspace] Failed to insert split popup pane: %v", err))
 			return
 		}
 		// Stacked pane behavior
 		_, err := wm.stackedPaneManager.StackPane(info.parentNode)
 		if err != nil {
-			log.Printf("[workspace] Failed to stack existing pane: %v", err)
+			logging.Error(fmt.Sprintf("[workspace] Failed to stack existing pane: %v", err))
 			return
 		}
 		// Insert the popup pane in the same container - use splitNode with existing popup pane
 			direction = DirectionRight
 		}
 		if _, err := wm.splitNode(info.parentNode, direction, popupPane); err != nil {
-			log.Printf("[workspace] Failed to insert stacked popup pane: %v", err)
+			logging.Error(fmt.Sprintf("[workspace] Failed to insert stacked popup pane: %v", err))
 			return
 		}
 	case config.PopupBehaviorTabbed:
 		// Tabbed behavior - TODO: implement proper tabbed interface
-		log.Printf("[workspace] WARNING: Tabbed popup behavior not yet implemented, falling back to split")
+		logging.Warn(fmt.Sprintf("[workspace] WARNING: Tabbed popup behavior not yet implemented, falling back to split"))
 		direction := strings.ToLower(wm.app.config.Workspace.Popups.Placement)
 		if direction == "" {
 			direction = DirectionRight
 		}
 		if _, err := wm.splitNode(info.parentNode, direction, popupPane); err != nil {
-			log.Printf("[workspace] Failed to insert tabbed popup pane: %v", err)
+			logging.Error(fmt.Sprintf("[workspace] Failed to insert tabbed popup pane: %v", err))
 			return
 		}
 	case config.PopupBehaviorWindowed:
 		// Windowed behavior - opens in new workspace/window
 		// TODO: implement new window creation with GTK
-		log.Printf("[workspace] WARNING: Windowed popup behavior not yet implemented, falling back to split")
+		logging.Warn(fmt.Sprintf("[workspace] WARNING: Windowed popup behavior not yet implemented, falling back to split"))
 		direction := strings.ToLower(wm.app.config.Workspace.Popups.Placement)
 		if direction == "" {
 			direction = DirectionRight
 		}
 		if _, err := wm.splitNode(info.parentNode, direction, popupPane); err != nil {
-			log.Printf("[workspace] Failed to insert windowed popup pane: %v", err)
+			logging.Error(fmt.Sprintf("[workspace] Failed to insert windowed popup pane: %v", err))
 			return
 		}
 	default:
 		// Fallback to split if unknown behavior
-		log.Printf("[workspace] Unknown popup behavior '%s', falling back to split", behavior)
+		logging.Warn(fmt.Sprintf("[workspace] Unknown popup behavior '%s', falling back to split", behavior))
 		direction := strings.ToLower(wm.app.config.Workspace.Popups.Placement)
 		if direction == "" {
 			direction = DirectionRight
 		}
 		if _, err := wm.splitNode(info.parentNode, direction, popupPane); err != nil {
-			log.Printf("[workspace] Failed to insert popup pane: %v", err)
+			logging.Error(fmt.Sprintf("[workspace] Failed to insert popup pane: %v", err))
 			return
 		}
 	}
 				info.parentNode.activePopupChildren = make([]string, 0)
 			}
 			info.parentNode.activePopupChildren = append(info.parentNode.activePopupChildren, popupWebViewID)
-			log.Printf("[workspace] Added popup %s to parent's activePopupChildren (count: %d)",
+			logging.Debug(fmt.Sprintf("[workspace] Added popup %s to parent's activePopupChildren (count: %d)",
-				popupWebViewID, len(info.parentNode.activePopupChildren))
+				popupWebViewID, len(info.parentNode.activePopupChildren)))
 			// Register navigation policy handler for parent
 			if info.parentNode.pane != nil && info.parentNode.pane.WebView() != nil {
 						return true
 					}
 					if len(info.parentNode.activePopupChildren) > 0 {
-						log.Printf("[workspace] BLOCKED script-initiated navigation in parent pane (has %d active popups): %s",
+						logging.Info(fmt.Sprintf("[workspace] BLOCKED script-initiated navigation in parent pane (has %d active popups): %s",
-							len(info.parentNode.activePopupChildren), url)
+							len(info.parentNode.activePopupChildren), url))
 						return false
 					}
 					return true
 	// Widgets are already shown by splitNode - no need to show again
 	// GTK4 handles visibility automatically during reparenting
-	log.Printf("[workspace] Popup pane inserted and visible for URL: %s", info.url)
+	logging.Info(fmt.Sprintf("[workspace] Popup pane inserted and visible for URL: %s", info.url))
 }
 // handlePopupClose responds to WebKit's close signal
 func (wm *WorkspaceManager) handlePopupClose(popupID uint64) {
-	log.Printf("[workspace] close signal received for popup native=%d", popupID)
+	logging.Info(fmt.Sprintf("[workspace] close signal received for popup native=%d", popupID))
 	// Check if it's in pending (not yet shown)
 	if info, ok := wm.pendingPopups[popupID]; ok {
 		delete(wm.pendingPopups, popupID)
-		log.Printf("[workspace] Popup closed before ready-to-show, cleaning up")
+		logging.Info(fmt.Sprintf("[workspace] Popup closed before ready-to-show, cleaning up"))
 		// Just remove from pending, WebKit will handle cleanup
 		_ = info // avoid unused variable
 		return
 	}
 	if targetNode == nil {
-		log.Printf("[workspace] close signal for unknown popup ID=%d, already closed?", popupID)
+		logging.Warn(fmt.Sprintf("[workspace] close signal for unknown popup ID=%d, already closed?", popupID))
 		return
 	}
 				targetNode.parentPane.activePopupChildren = append(
 					targetNode.parentPane.activePopupChildren[:i],
 					targetNode.parentPane.activePopupChildren[i+1:]...)
-				log.Printf("[workspace] Removed popup from parent's activePopupChildren (remaining: %d)",
+				logging.Debug(fmt.Sprintf("[workspace] Removed popup from parent's activePopupChildren (remaining: %d)",
-					len(targetNode.parentPane.activePopupChildren))
+					len(targetNode.parentPane.activePopupChildren)))
 				break
 			}
 		}
 	}
 	// Clean close via existing ClosePane (WebKit already stopped)
-	log.Printf("[workspace] Closing popup pane via ClosePane")
+	logging.Info(fmt.Sprintf("[workspace] Closing popup pane via ClosePane"))
 	if err := wm.ClosePane(targetNode); err != nil {
-		log.Printf("[workspace] Error closing popup pane: %v", err)
+		logging.Error(fmt.Sprintf("[workspace] Error closing popup pane: %v", err))
 	}
 }

M internal/app/browser/workspace_stack_lifecycle.go +6 -6


@@ -4,7 +4,7 @@ package browser
4		import (	4		import (
5		"errors"	5		"errors"
6		"fmt"	6		"fmt"
7	-	"log"	7	+	"github.com/bnema/dumber/internal/logging"
8		)	8		)
9			9
10		// StackLifecycleManager manages the lifecycle hooks around stacked pane operations.	10		// StackLifecycleManager manages the lifecycle hooks around stacked pane operations.

@@ -34,8 +34,8 @@ func (slm StackLifecycleManager) CloseStackedPaneWithLifecycle(node paneNode)
34		return errors.New("node is not part of a stacked pane")	34		return errors.New("node is not part of a stacked pane")
35		}	35		}
36			36
37	-	log.Printf("[stack-lifecycle] Closing stacked pane: node=%p stack=%p stackSize=%d",	37	+	logging.Info(fmt.Sprintf("[stack-lifecycle] Closing stacked pane: node=%p stack=%p stackSize=%d",
38	-	node, stackNode, len(stackNode.stackedPanes))	38	+	node, stackNode, len(stackNode.stackedPanes)))
39			39
40		if err := slm.validateStackState(stackNode, "before close"); err != nil {	40		if err := slm.validateStackState(stackNode, "before close"); err != nil {
41		return fmt.Errorf("invalid stack state before close: %w", err)	41		return fmt.Errorf("invalid stack state before close: %w", err)

@@ -51,7 +51,7 @@ func (slm StackLifecycleManager) CloseStackedPaneWithLifecycle(node paneNode)
51			51
52		if slm.treeValidator != nil {	52		if slm.treeValidator != nil {
53		if err := slm.treeValidator.ValidateTree(slm.wm.root, "after stack close"); err != nil {	53		if err := slm.treeValidator.ValidateTree(slm.wm.root, "after stack close"); err != nil {
54	-	log.Printf("[stack-lifecycle] Tree validation failed after stack close: %v", err)	54	+	logging.Error(fmt.Sprintf("[stack-lifecycle] Tree validation failed after stack close: %v", err))
55		}	55		}
56		}	56		}
57			57

@@ -86,7 +86,7 @@ func (slm StackLifecycleManager) validateStackState(stackNode paneNode, operat
86		}	86		}
87		}	87		}
88			88
89	-	log.Printf("[stack-lifecycle] Stack state valid for operation '%s': size=%d activeIndex=%d",	89	+	logging.Info(fmt.Sprintf("[stack-lifecycle] Stack state valid for operation '%s': size=%d activeIndex=%d",
90	-	operation, len(stackNode.stackedPanes), stackNode.activeStackIndex)	90	+	operation, len(stackNode.stackedPanes), stackNode.activeStackIndex))
91		return nil	91		return nil
92		}	92		}

M internal/app/browser/workspace_utils.go +3 -4


@@ -3,8 +3,7 @@ package browser
3			3
4		import (	4		import (
5		"fmt"	5		"fmt"
6	-	"log"	6	+	"github.com/bnema/dumber/internal/logging"
7	-
8		"github.com/bnema/dumber/pkg/webkit"	7		"github.com/bnema/dumber/pkg/webkit"
9		"github.com/diamondburned/gotk4/pkg/glib/v2"	8		"github.com/diamondburned/gotk4/pkg/glib/v2"
10		"github.com/diamondburned/gotk4/pkg/gtk/v4"	9		"github.com/diamondburned/gotk4/pkg/gtk/v4"

@@ -182,7 +181,7 @@ func (wm WorkspaceManager) applyActivePaneBorder(node paneNode) {
182		}	181		}
183			182
184		webkit.WidgetSetVisible(node.borderOverlay, true)	183		webkit.WidgetSetVisible(node.borderOverlay, true)
185	-	log.Printf("[workspace] Showing border overlay for pane %p", node)	184	+	logging.Debug(fmt.Sprintf("[workspace] Showing border overlay for pane %p", node))
186		}	185		}
187			186
188		// removeActivePaneBorder hides the border overlay for a pane.	187		// removeActivePaneBorder hides the border overlay for a pane.

@@ -192,7 +191,7 @@ func (wm WorkspaceManager) removeActivePaneBorder(node paneNode) {
192		}	191		}
193			192
194		webkit.WidgetSetVisible(node.borderOverlay, false)	193		webkit.WidgetSetVisible(node.borderOverlay, false)
195	-	log.Printf("[workspace] Hiding border overlay for pane %p", node)	194	+	logging.Debug(fmt.Sprintf("[workspace] Hiding border overlay for pane %p", node))
196		}	195		}
197			196
198		// Widget cleanup utilities	197		// Widget cleanup utilities

M internal/app/control/clipboard.go +7 -6

 package control
 import (
-	"log"
+	"fmt"
+	"github.com/bnema/dumber/internal/logging"
 	"github.com/bnema/dumber/pkg/clipboard"
 	"github.com/bnema/dumber/pkg/webkit"
 )
 // CopyCurrentURL copies the current WebView URL to the clipboard
 func (c *ClipboardController) CopyCurrentURL() {
-	log.Printf("Shortcut: Copy URL")
+	logging.Debug(fmt.Sprintf("Shortcut: Copy URL"))
 	currentURL := c.webView.GetCurrentURL()
 	if currentURL == "" {
-		log.Printf("No URL to copy")
+		logging.Warn(fmt.Sprintf("No URL to copy"))
 		c.showToast("No URL to copy", "error")
 		return
 	}
 	if err := clipboard.CopyToClipboard(currentURL); err != nil {
-		log.Printf("Failed to copy URL to clipboard: %v", err)
+		logging.Error(fmt.Sprintf("Failed to copy URL to clipboard: %v", err))
 		c.showToast("Failed to copy URL", "error")
 	} else {
-		log.Printf("URL copied to clipboard: %s", currentURL)
+		logging.Debug(fmt.Sprintf("URL copied to clipboard: %s", currentURL))
 		c.showToast("URL copied to clipboard", "success")
 	}
 }
 	}
 	if err := c.webView.DispatchCustomEvent("dumber:toast", detail); err != nil {
-		log.Printf("Failed to dispatch toast event: %v", err)
+		logging.Error(fmt.Sprintf("Failed to dispatch toast event: %v", err))
 	}
 }

M internal/app/control/navigation.go +14 -13

 import (
 	"context"
-	"log"
+	"fmt"
 	"os"
+	"github.com/bnema/dumber/internal/logging"
 	"github.com/bnema/dumber/internal/services"
 	"github.com/bnema/dumber/pkg/webkit"
 )
 	// Record navigation in browser service
 	if _, navErr := n.browserService.Navigate(ctx, result.URL); navErr != nil {
-		log.Printf("Warning: failed to navigate to %s: %v", result.URL, navErr)
+		logging.Warn(fmt.Sprintf("Warning: failed to navigate to %s: %v", result.URL, navErr))
 	}
 	var (
 			if n.webView != nil {
 				if n.webView.UsesDomZoom() {
 					if err := n.webView.SeedDomZoom(zoomLevel); err != nil {
-						log.Printf("Warning: failed to seed DOM zoom for %s: %v", result.URL, err)
+						logging.Warn(fmt.Sprintf("Warning: failed to seed DOM zoom for %s: %v", result.URL, err))
 					}
 				} else {
 					n.webView.RunOnMainThread(func() {
 						if err := n.webView.SetZoom(zoomLevel); err != nil {
-							log.Printf("Warning: failed to prime native zoom for %s: %v", result.URL, err)
+							logging.Warn(fmt.Sprintf("Warning: failed to prime native zoom for %s: %v", result.URL, err))
 						}
 					})
 				}
 			}
 		} else {
-			log.Printf("Warning: failed to lookup zoom for %s: %v", result.URL, err)
+			logging.Warn(fmt.Sprintf("Warning: failed to lookup zoom for %s: %v", result.URL, err))
 		}
 	}
 // HandleBrowseCommand processes the browse command line argument
 func (n *NavigationController) HandleBrowseCommand() {
 	if len(os.Args) >= 3 && os.Args[1] == "browse" {
-		log.Printf("Browse command detected: %s", os.Args[2])
+		logging.Debug(fmt.Sprintf("Browse command detected: %s", os.Args[2]))
 		ctx := context.Background()
 		result, err := n.parserService.ParseInput(ctx, os.Args[2])
 		if err == nil {
-			log.Printf("Parsed input → URL: %s", result.URL)
+			logging.Debug(fmt.Sprintf("Parsed input → URL: %s", result.URL))
 			if _, navErr := n.browserService.Navigate(ctx, result.URL); navErr != nil {
-				log.Printf("Warning: failed to navigate to %s: %v", result.URL, navErr)
+				logging.Warn(fmt.Sprintf("Warning: failed to navigate to %s: %v", result.URL, navErr))
 			}
 			if n.webView != nil {
-				log.Printf("Loading URL in WebView: %s", result.URL)
+				logging.Debug(fmt.Sprintf("Loading URL in WebView: %s", result.URL))
 				var (
 					zoomLevel float64
 					haveZoom  bool
 						haveZoom = true
 						if n.webView.UsesDomZoom() {
 							if err := n.webView.SeedDomZoom(zoomLevel); err != nil {
-								log.Printf("Warning: failed to seed DOM zoom for %s: %v", result.URL, err)
+								logging.Warn(fmt.Sprintf("Warning: failed to seed DOM zoom for %s: %v", result.URL, err))
 							}
 						} else {
 							n.webView.RunOnMainThread(func() {
 								if err := n.webView.SetZoom(zoomLevel); err != nil {
-									log.Printf("Warning: failed to prime native zoom for %s: %v", result.URL, err)
+									logging.Warn(fmt.Sprintf("Warning: failed to prime native zoom for %s: %v", result.URL, err))
 								}
 							})
 						}
 					} else {
-						log.Printf("Warning: failed to lookup zoom for %s: %v", result.URL, err)
+						logging.Warn(fmt.Sprintf("Warning: failed to lookup zoom for %s: %v", result.URL, err))
 					}
 				}
 				if err := n.webView.LoadURL(result.URL); err != nil {
-					log.Printf("Warning: failed to load URL: %v", err)
+					logging.Warn(fmt.Sprintf("Warning: failed to load URL: %v", err))
 				}
 				if n.zoomController != nil {
 					if haveZoom {

M internal/app/control/zoom.go +9 -8

 import (
 	"context"
-	"log"
+	"fmt"
 	"time"
+	"github.com/bnema/dumber/internal/logging"
 	"github.com/bnema/dumber/internal/services"
 	"github.com/bnema/dumber/pkg/webkit"
 )
 	go func(url string, level float64) {
 		ctx := context.Background()
 		if err := z.browserService.SetZoomLevel(ctx, url, level); err != nil {
-			log.Printf("[zoom] failed to save level %.2f for %s: %v", level, url, err)
+			logging.Error(fmt.Sprintf("[zoom] failed to save level %.2f for %s: %v", level, url, err))
 			return
 		}
 		key := services.ZoomKeyForLog(url)
-		log.Printf("[zoom] saved %.2f for %s", level, key)
+		logging.Debug(fmt.Sprintf("[zoom] saved %.2f for %s", level, key))
 	}(url, level)
 	// Only show toast for user-initiated zoom changes, not during init or programmatic changes
 // showZoomToast displays a zoom level notification using TypeScript toast system
 func (z *ZoomController) showZoomToast(level float64) {
-	log.Printf("[zoom] Attempting to show zoom toast for level %.2f", level)
+	logging.Debug(fmt.Sprintf("[zoom] Attempting to show zoom toast for level %.2f", level))
 	if z.webView == nil {
-		log.Printf("[zoom] webview unavailable for zoom toast")
+		logging.Debug(fmt.Sprintf("[zoom] webview unavailable for zoom toast"))
 		return
 	}
 	if err := z.webView.DispatchCustomEvent("dumber:toast:zoom", map[string]any{"level": level}); err != nil {
-		log.Printf("[zoom] failed to dispatch zoom toast: %v", err)
+		logging.Error(fmt.Sprintf("[zoom] failed to dispatch zoom toast: %v", err))
 	}
 }
 		})
 		if err := z.webView.SetZoom(zoomLevel); err != nil {
-			log.Printf("Warning: failed to set zoom: %v", err)
+			logging.Warn(fmt.Sprintf("Warning: failed to set zoom: %v", err))
 			return
 		}
-		log.Printf("[zoom] loaded %.2f for %s", zoomLevel, domain)
+		logging.Debug(fmt.Sprintf("[zoom] loaded %.2f for %s", zoomLevel, domain))
 		if allowToast && domain != z.lastZoomDomain && z.lastZoomDomain != "" {
 			z.showZoomToast(zoomLevel)
 		}

M internal/app/environment/codec.go +17 -16

 package environment
 import (
-	"log"
+	"fmt"
 	"os"
 	"strconv"
 	"strings"
 	"github.com/bnema/dumber/internal/config"
+	"github.com/bnema/dumber/internal/logging"
 )
 // ApplyCodecConfiguration applies codec preferences to environment variables and GStreamer settings
 func ApplyCodecConfiguration(codecPrefs config.CodecConfig) {
-	log.Printf("[codec] Applying codec preferences: preferred=%s, force_av1=%t, block_vp9=%t",
+	logging.Info(fmt.Sprintf("[codec] Applying codec preferences: preferred=%s, force_av1=%t, block_vp9=%t",
-		codecPrefs.PreferredCodecs, codecPrefs.ForceAV1, codecPrefs.BlockVP9)
+		codecPrefs.PreferredCodecs, codecPrefs.ForceAV1, codecPrefs.BlockVP9))
 	// Build comprehensive GStreamer plugin rankings
 	var rankSettings []string
 			"avdec_av1:256", // libav AV1 decoder
 		}
 		rankSettings = append(rankSettings, av1Ranks...)
-		log.Printf("[codec] Promoted AV1 decoders for maximum priority")
+		logging.Info(fmt.Sprintf("[codec] Promoted AV1 decoders for maximum priority"))
 	}
 	// H.264 decoder management
 			vp9Demotions = append(vp9Demotions, "vp9dec:64", "avdec_vp9:64")
 		}
 		rankSettings = append(rankSettings, vp9Demotions...)
-		log.Printf("[codec] Demoted/blocked VP9 decoders")
+		logging.Info(fmt.Sprintf("[codec] Demoted/blocked VP9 decoders"))
 	}
 	// VP8 decoder blocking
 			"avdec_vp8:0",
 		}
 		rankSettings = append(rankSettings, vp8Demotions...)
-		log.Printf("[codec] Blocked VP8 decoders")
+		logging.Info(fmt.Sprintf("[codec] Blocked VP8 decoders"))
 	}
 	// Apply the complete ranking system
 	if len(rankSettings) > 0 {
 		finalRank := strings.Join(rankSettings, ",")
 		if err := os.Setenv("GST_PLUGIN_FEATURE_RANK", finalRank); err != nil {
-			log.Printf("[codec] Warning: failed to set GST_PLUGIN_FEATURE_RANK: %v", err)
+			logging.Warn(fmt.Sprintf("[codec] Warning: failed to set GST_PLUGIN_FEATURE_RANK: %v", err))
 		} else {
-			log.Printf("[codec] Set comprehensive GST_PLUGIN_FEATURE_RANK: %s", finalRank)
+			logging.Info(fmt.Sprintf("[codec] Set comprehensive GST_PLUGIN_FEATURE_RANK: %s", finalRank))
 		}
 	}
 		bufferSize := strconv.Itoa(codecPrefs.VideoBufferSizeMB * 1024 * 1024)
 		if err := os.Setenv("GST_BUFFER_SIZE", bufferSize); err != nil {
-			log.Printf("[codec] Warning: failed to set GST_BUFFER_SIZE: %v", err)
+			logging.Warn(fmt.Sprintf("[codec] Warning: failed to set GST_BUFFER_SIZE: %v", err))
 		}
 		if err := os.Setenv("GST_QUEUE2_MAX_SIZE_BYTES", bufferSize); err != nil {
-			log.Printf("[codec] Warning: failed to set GST_QUEUE2_MAX_SIZE_BYTES: %v", err)
+			logging.Warn(fmt.Sprintf("[codec] Warning: failed to set GST_QUEUE2_MAX_SIZE_BYTES: %v", err))
 		}
-		log.Printf("[codec] Set video buffer size to %dMB", codecPrefs.VideoBufferSizeMB)
+		logging.Info(fmt.Sprintf("[codec] Set video buffer size to %dMB", codecPrefs.VideoBufferSizeMB))
 	}
 	// Set queue buffer time if specified
 		bufferTime := strconv.Itoa(codecPrefs.QueueBufferTimeSec * 1000000000)
 		if err := os.Setenv("GST_QUEUE2_MAX_SIZE_TIME", bufferTime); err != nil {
-			log.Printf("[codec] Warning: failed to set GST_QUEUE2_MAX_SIZE_TIME: %v", err)
+			logging.Warn(fmt.Sprintf("[codec] Warning: failed to set GST_QUEUE2_MAX_SIZE_TIME: %v", err))
 		} else {
-			log.Printf("[codec] Set queue buffer time to %ds", codecPrefs.QueueBufferTimeSec)
+			logging.Info(fmt.Sprintf("[codec] Set queue buffer time to %ds", codecPrefs.QueueBufferTimeSec))
 		}
 	}
 	if codecPrefs.ForceAV1 {
 		// Enable AV1 hardware decoding if available
 		if err := os.Setenv("GST_AV1_DECODER_ENABLE_HW", "1"); err != nil {
-			log.Printf("[codec] Warning: failed to set GST_AV1_DECODER_ENABLE_HW: %v", err)
+			logging.Warn(fmt.Sprintf("[codec] Warning: failed to set GST_AV1_DECODER_ENABLE_HW: %v", err))
 		}
 	}
 	// Disable video post-processing to avoid VA-API issues
 	if err := os.Setenv("GST_VAAPI_DISABLE_VPP", "1"); err != nil {
-		log.Printf("[codec] Warning: failed to set GST_VAAPI_DISABLE_VPP: %v", err)
+		logging.Warn(fmt.Sprintf("[codec] Warning: failed to set GST_VAAPI_DISABLE_VPP: %v", err))
 	}
-	log.Printf("[codec] Codec configuration applied successfully")
+	logging.Info(fmt.Sprintf("[codec] Codec configuration applied successfully"))
 }
 // BuildBlockedCodecsList converts config codec blocking preferences to a string slice

M internal/app/environment/locale.go +8 -6

 package environment
 import (
-	"log"
+	"fmt"
 	"os"
 	"os/exec"
 	"strings"
+	"github.com/bnema/dumber/internal/logging"
 )
 // DetectAndSetKeyboardLocale attempts to determine the current keyboard layout
 						cand := strings.TrimSpace(parts[1])
 						if cand != "" {
 							locale = cand
-							log.Printf("[locale] keyboard layout from localectl: %s", locale)
+							logging.Debug(fmt.Sprintf("[locale] keyboard layout from localectl: %s", locale))
 						}
 					}
 					break
 						cand := strings.TrimSpace(parts[1])
 						if cand != "" {
 							locale = cand
-							log.Printf("[locale] keyboard layout from setxkbmap: %s", locale)
+							logging.Debug(fmt.Sprintf("[locale] keyboard layout from setxkbmap: %s", locale))
 						}
 					}
 					break
 		if i := strings.IndexByte(locale, '_'); i > 0 {
 			locale = locale[:i]
 		}
-		log.Printf("[locale] keyboard layout from system locale: %s", locale)
+		logging.Debug(fmt.Sprintf("[locale] keyboard layout from system locale: %s", locale))
 	}
 	if locale == "" {
 		locale = "en"
-		log.Printf("[locale] keyboard layout defaulted to: %s", locale)
+		logging.Debug(fmt.Sprintf("[locale] keyboard layout defaulted to: %s", locale))
 	}
-	log.Printf("[locale] keyboard locale detected: %s", locale)
+	logging.Info(fmt.Sprintf("[locale] keyboard locale detected: %s", locale))
 }

M internal/app/environment/media.go +6 -4

 package environment
 import (
-	"log"
+	"fmt"
 	"os"
+	"github.com/bnema/dumber/internal/logging"
 )
 // SetupMediaPipeline proactively hardens media pipeline to avoid WebProcess crashes from buggy VAAPI/plugins.
 		// Demote VAAPI-related elements so they won't be auto-picked
 		if os.Getenv("GST_PLUGIN_FEATURE_RANK") == "" {
 			if err := os.Setenv("GST_PLUGIN_FEATURE_RANK", "vaapisink:0,vaapidecodebin:0,vaapih264dec:0,vaapivideoconvert:0"); err != nil {
-				log.Printf("Warning: failed to set GST_PLUGIN_FEATURE_RANK: %v", err)
+				logging.Warn(fmt.Sprintf("Warning: failed to set GST_PLUGIN_FEATURE_RANK: %v", err))
 			}
 		}
 		// Optionally disable media stream features that can engage complex pipelines (webcam/mic)
 		if os.Getenv("WEBKIT_DISABLE_MEDIA_STREAM") == "" {
 			if err := os.Setenv("WEBKIT_DISABLE_MEDIA_STREAM", "1"); err != nil {
-				log.Printf("Warning: failed to set WEBKIT_DISABLE_MEDIA_STREAM: %v", err)
+				logging.Warn(fmt.Sprintf("Warning: failed to set WEBKIT_DISABLE_MEDIA_STREAM: %v", err))
 			}
 		}
-		log.Printf("[media] Safe mode enabled: VAAPI demoted, webcam/mic disabled (override with DUMBER_MEDIA_SAFE=0)")
+		logging.Info(fmt.Sprintf("[media] Safe mode enabled: VAAPI demoted, webcam/mic disabled (override with DUMBER_MEDIA_SAFE=0)"))
 	}
 }

M internal/app/messaging/handler.go +55 -56

 	"context"
 	"encoding/json"
 	"fmt"
-	"log"
 	"strconv"
 	"time"
 func (h *Handler) Handle(payload string) {
 	msg, err := parseIncomingMessage(payload)
 	if err != nil {
-		log.Printf("[ERROR] Failed to unmarshal message: %v", err)
+		logging.Error(fmt.Sprintf("[ERROR] Failed to unmarshal message: %v", err))
 		return
 	}
 func (h *Handler) handleNavigation(msg Message) {
 	if h.navigationController != nil {
 		if err := h.navigationController.NavigateToURL(msg.URL); err != nil {
-			log.Printf("[messaging] Navigation controller failed for input %q: %v", msg.URL, err)
+			logging.Error(fmt.Sprintf("[messaging] Navigation controller failed for input %q: %v", msg.URL, err))
 			h.legacyNavigate(msg)
 		}
 		return
 	ctx := context.Background()
 	res, err := h.parserService.ParseInput(ctx, msg.URL)
 	if err != nil {
-		log.Printf("[messaging] Legacy navigation parse failed for %q: %v", msg.URL, err)
+		logging.Error(fmt.Sprintf("[messaging] Legacy navigation parse failed for %q: %v", msg.URL, err))
 		return
 	}
 	if _, navErr := h.browserService.Navigate(ctx, res.URL); navErr != nil {
-		log.Printf("Warning: failed to navigate to %s: %v", res.URL, navErr)
+		logging.Warn(fmt.Sprintf("Warning: failed to navigate to %s: %v", res.URL, navErr))
 	}
 	if h.webView == nil {
 	}
 	if err := h.webView.LoadURL(res.URL); err != nil {
-		log.Printf("[messaging] Legacy LoadURL failed for %s: %v", res.URL, err)
+		logging.Error(fmt.Sprintf("[messaging] Legacy LoadURL failed for %s: %v", res.URL, err))
 	}
 	if z, zerr := h.browserService.GetZoomLevel(ctx, res.URL); zerr == nil {
 		if err := h.webView.SetZoom(z); err != nil {
-			log.Printf("[messaging] Legacy SetZoom failed for %s: %v", res.URL, err)
+			logging.Error(fmt.Sprintf("[messaging] Legacy SetZoom failed for %s: %v", res.URL, err))
 		}
 	}
 }
 // handleQuery computes omnibox suggestions natively and returns them to the GUI without fetch
 func (h *Handler) handleWorkspace(msg Message) {
 	if h.workspaceObserver == nil {
-		log.Printf("[workspace] Received workspace event %q but no observer registered", msg.Event)
+		logging.Warn(fmt.Sprintf("[workspace] Received workspace event %q but no observer registered", msg.Event))
 		return
 	}
 	if h.webView == nil {
-		log.Printf("[workspace] Ignoring workspace event %q: webview not attached", msg.Event)
+		logging.Debug(fmt.Sprintf("[workspace] Ignoring workspace event %q: webview not attached", msg.Event))
 		return
 	}
-	log.Printf("[workspace] Forwarding workspace event: event=%s direction=%s action=%s webviewId=%s", msg.Event, msg.Direction, msg.Action, msg.WebViewID)
+	logging.Debug(fmt.Sprintf("[workspace] Forwarding workspace event: event=%s direction=%s action=%s webviewId=%s", msg.Event, msg.Direction, msg.Action, msg.WebViewID))
 	h.workspaceObserver.OnWorkspaceMessage(h.webView, msg)
 }
 func (h *Handler) handleClosePopup(msg Message) {
-	log.Printf("[messaging] Received close-popup request: webviewId=%s reason=%s", msg.WebViewID, msg.Reason)
+	logging.Debug(fmt.Sprintf("[messaging] Received close-popup request: webviewId=%s reason=%s", msg.WebViewID, msg.Reason))
 	if h.workspaceObserver == nil {
-		log.Printf("[messaging] No workspace observer registered for close-popup request")
+		logging.Warn(fmt.Sprintf("[messaging] No workspace observer registered for close-popup request"))
 		return
 	}
 	if h.webView == nil {
-		log.Printf("[messaging] No webview attached for close-popup request")
+		logging.Debug(fmt.Sprintf("[messaging] No webview attached for close-popup request"))
 		return
 	}
 		Reason:    msg.Reason,
 	}
-	log.Printf("[messaging] Forwarding close-popup to workspace: webviewId=%s reason=%s", msg.WebViewID, msg.Reason)
+	logging.Debug(fmt.Sprintf("[messaging] Forwarding close-popup to workspace: webviewId=%s reason=%s", msg.WebViewID, msg.Reason))
 	h.workspaceObserver.OnWorkspaceMessage(h.webView, closeMsg)
 }
 		// Prefer unified page-world API; fallback to legacy global function
 		script := "(window.__dumber?.omnibox?.suggestions ? window.__dumber.omnibox.suggestions(" + string(b) + ") : (window.__dumber_omnibox_suggestions && window.__dumber_omnibox_suggestions(" + string(b) + ")))"
 		if err := h.webView.InjectScript(script); err != nil {
-			log.Printf("[ERROR] Failed to inject omnibox suggestions: %v", err)
+			logging.Error(fmt.Sprintf("[ERROR] Failed to inject omnibox suggestions: %v", err))
 		}
 	}
 }
 	// Get config to determine behavior
 	cfg, err := h.browserService.GetConfig(ctx)
 	if err != nil {
-		log.Printf("[ERROR] Failed to get config: %v", err)
+		logging.Error(fmt.Sprintf("[ERROR] Failed to get config: %v", err))
 		return
 	}
 	behavior := cfg.Omnibox.InitialBehavior
 	}
 	if err != nil {
-		log.Printf("[ERROR] Failed to fetch initial history: %v", err)
+		logging.Error(fmt.Sprintf("[ERROR] Failed to fetch initial history: %v", err))
 		return
 	}
 	if b, err := json.Marshal(results); err == nil {
 		script := "(window.__dumber?.omnibox?.suggestions ? window.__dumber.omnibox.suggestions(" + string(b) + ") : (window.__dumber_omnibox_suggestions && window.__dumber_omnibox_suggestions(" + string(b) + ")))"
 		if err := h.webView.InjectScript(script); err != nil {
-			log.Printf("[ERROR] Failed to inject initial history: %v", err)
+			logging.Error(fmt.Sprintf("[ERROR] Failed to inject initial history: %v", err))
 		}
 	}
 }
 // handleTheme processes theme-related messages
 func (h *Handler) handleTheme(msg Message) {
 	if msg.Value != "" && msg.Value != h.lastTheme {
-		log.Printf("[theme] color-scheme changed: %s", msg.Value)
+		logging.Debug(fmt.Sprintf("[theme] color-scheme changed: %s", msg.Value))
 		h.lastTheme = msg.Value
 	}
 }
 	}
 	if err != nil {
-		log.Printf("[messaging] Failed to get recent history: %v", err)
+		logging.Error(fmt.Sprintf("[messaging] Failed to get recent history: %v", err))
 		requestIdParam := ""
 		if msg.RequestID != "" {
 			requestIdParam = ", '" + msg.RequestID + "'"
 	ctx := context.Background()
 	stats, err := h.browserService.GetHistoryStats(ctx)
 	if err != nil {
-		log.Printf("[messaging] Failed to get history stats: %v", err)
+		logging.Error(fmt.Sprintf("[messaging] Failed to get history stats: %v", err))
 		_ = h.webView.InjectScript("window.__dumber_history_error && window.__dumber_history_error('Failed to load history stats')")
 		return
 	}
 	entries, err := h.browserService.SearchHistory(ctx, query, limit)
 	if err != nil {
-		log.Printf("[messaging] Failed to search history: %v", err)
+		logging.Error(fmt.Sprintf("[messaging] Failed to search history: %v", err))
 		_ = h.webView.InjectScript("window.__dumber_history_error && window.__dumber_history_error('Failed to search history')")
 		return
 	}
 	}
 	if msg.HistoryID == "" {
-		log.Printf("[messaging] History delete: missing historyId")
+		logging.Warn(fmt.Sprintf("[messaging] History delete: missing historyId"))
 		_ = h.webView.InjectScript("window.__dumber_history_error && window.__dumber_history_error('Missing history ID')")
 		return
 	}
 	// Convert string ID to int64
 	id, err := strconv.ParseInt(msg.HistoryID, 10, 64)
 	if err != nil {
-		log.Printf("[messaging] History delete: invalid ID format: %v", err)
+		logging.Error(fmt.Sprintf("[messaging] History delete: invalid ID format: %v", err))
 		_ = h.webView.InjectScript("window.__dumber_history_error && window.__dumber_history_error('Invalid history ID format')")
 		return
 	}
 	ctx := context.Background()
 	err = h.browserService.DeleteHistoryEntry(ctx, id)
 	if err != nil {
-		log.Printf("[messaging] Failed to delete history entry: %v", err)
+		logging.Error(fmt.Sprintf("[messaging] Failed to delete history entry: %v", err))
 		_ = h.webView.InjectScript("window.__dumber_history_error && window.__dumber_history_error('Failed to delete history entry')")
 		return
 	}
 	}
 	if err := json.Unmarshal(msg.Payload, &consolePayload); err != nil {
-		log.Printf("[messaging] Failed to unmarshal console-message: %v", err)
+		logging.Error(fmt.Sprintf("[messaging] Failed to unmarshal console-message: %v", err))
 		return
 	}
 // handleWebViewIDRequest responds to JavaScript requests for the webview ID
 func (h *Handler) handleWebViewIDRequest(msg Message) {
 	if h.webView == nil {
-		log.Printf("[messaging] Cannot provide webview ID - no webview available")
+		logging.Warn(fmt.Sprintf("[messaging] Cannot provide webview ID - no webview available"))
 		return
 	}
 	// Check if WebView is destroyed before attempting any operations
 	if h.webView.IsDestroyed() {
-		log.Printf("[messaging] Cannot provide webview ID - webview is destroyed")
+		logging.Warn(fmt.Sprintf("[messaging] Cannot provide webview ID - webview is destroyed"))
 		return
 	}
 	webViewID := h.webView.ID()
-	log.Printf("[messaging] Sending webview ID %d to JavaScript", webViewID)
+	logging.Debug(fmt.Sprintf("[messaging] Sending webview ID %d to JavaScript", webViewID))
 	// Send the webview ID back to JavaScript via custom event
 	if err := h.webView.DispatchCustomEvent("dumber:webview-id", map[string]any{
 		"webviewId": webViewID,
 		"timestamp": time.Now().UnixMilli(),
 	}); err != nil {
-		log.Printf("[messaging] Failed to send webview ID: %v", err)
+		logging.Error(fmt.Sprintf("[messaging] Failed to send webview ID: %v", err))
 	}
 }
 // handleGetSearchShortcuts sends search shortcuts configuration to JavaScript
 func (h *Handler) handleGetSearchShortcuts(msg Message) {
 	if h.webView == nil {
-		log.Printf("[messaging] Cannot provide search shortcuts - no webview available")
+		logging.Warn(fmt.Sprintf("[messaging] Cannot provide search shortcuts - no webview available"))
 		return
 	}
 	if h.webView.IsDestroyed() {
-		log.Printf("[messaging] Cannot provide search shortcuts - webview is destroyed")
+		logging.Warn(fmt.Sprintf("[messaging] Cannot provide search shortcuts - webview is destroyed"))
 		return
 	}
 	// Get search shortcuts from browser service config
 	shortcuts, err := h.browserService.GetSearchShortcuts(context.Background())
 	if err != nil {
-		log.Printf("[messaging] Failed to get search shortcuts: %v", err)
+		logging.Error(fmt.Sprintf("[messaging] Failed to get search shortcuts: %v", err))
 		_ = h.webView.InjectScript("window.__dumber_search_shortcuts_error && window.__dumber_search_shortcuts_error('Failed to get search shortcuts')")
 		return
 	}
 	// Marshal to JSON
 	b, err := json.Marshal(shortcuts)
 	if err != nil {
-		log.Printf("[messaging] Failed to marshal search shortcuts: %v", err)
+		logging.Error(fmt.Sprintf("[messaging] Failed to marshal search shortcuts: %v", err))
 		_ = h.webView.InjectScript("window.__dumber_search_shortcuts_error && window.__dumber_search_shortcuts_error('Failed to load search shortcuts')")
 		return
 	}
 	// Inject the search shortcuts into the page
-	log.Printf("[messaging] Sending search shortcuts to JavaScript")
+	logging.Debug(fmt.Sprintf("[messaging] Sending search shortcuts to JavaScript"))
 	_ = h.webView.InjectScript("window.__dumber_search_shortcuts && window.__dumber_search_shortcuts(" + string(b) + ")")
 }
 // handleGetColorPalettes sends color palettes configuration to JavaScript
 func (h *Handler) handleGetColorPalettes(msg Message) {
 	if h.webView == nil {
-		log.Printf("[messaging] Cannot provide color palettes - no webview available")
+		logging.Warn(fmt.Sprintf("[messaging] Cannot provide color palettes - no webview available"))
 		return
 	}
 	if h.webView.IsDestroyed() {
-		log.Printf("[messaging] Cannot provide color palettes - webview is destroyed")
+		logging.Warn(fmt.Sprintf("[messaging] Cannot provide color palettes - webview is destroyed"))
 		return
 	}
 	// Marshal to JSON
 	b, err := json.Marshal(palettes)
 	if err != nil {
-		log.Printf("[messaging] Failed to marshal color palettes: %v", err)
+		logging.Error(fmt.Sprintf("[messaging] Failed to marshal color palettes: %v", err))
 		_ = h.webView.InjectScript("window.__dumber_color_palettes_error && window.__dumber_color_palettes_error('Failed to load color palettes')")
 		return
 	}
 	// Inject the color palettes into the page
-	log.Printf("[messaging] Sending color palettes to JavaScript")
+	logging.Debug(fmt.Sprintf("[messaging] Sending color palettes to JavaScript"))
 	_ = h.webView.InjectScript("window.__dumber_color_palettes && window.__dumber_color_palettes(" + string(b) + ")")
 }
 // handleGetFavorites sends all favorites to JavaScript
 func (h *Handler) handleGetFavorites(msg Message) {
 	if h.webView == nil {
-		log.Printf("[messaging] Cannot provide favorites - no webview available")
+		logging.Warn(fmt.Sprintf("[messaging] Cannot provide favorites - no webview available"))
 		return
 	}
 	if h.webView.IsDestroyed() {
-		log.Printf("[messaging] Cannot provide favorites - webview is destroyed")
+		logging.Warn(fmt.Sprintf("[messaging] Cannot provide favorites - webview is destroyed"))
 		return
 	}
 	// Get favorites from browser service
 	favorites, err := h.browserService.GetFavorites(context.Background())
 	if err != nil {
-		log.Printf("[messaging] Failed to get favorites: %v", err)
+		logging.Error(fmt.Sprintf("[messaging] Failed to get favorites: %v", err))
 		_ = h.webView.InjectScript("window.__dumber_favorites_error && window.__dumber_favorites_error('Failed to get favorites')")
 		return
 	}
 	// Marshal to JSON
 	b, err := json.Marshal(favorites)
 	if err != nil {
-		log.Printf("[messaging] Failed to marshal favorites: %v", err)
+		logging.Error(fmt.Sprintf("[messaging] Failed to marshal favorites: %v", err))
 		_ = h.webView.InjectScript("window.__dumber_favorites_error && window.__dumber_favorites_error('Failed to load favorites')")
 		return
 	}
 	// Inject the favorites into the page
-	log.Printf("[messaging] Sending %d favorites to JavaScript", len(favorites))
+	logging.Debug(fmt.Sprintf("[messaging] Sending %d favorites to JavaScript", len(favorites)))
 	_ = h.webView.InjectScript("window.__dumber_favorites && window.__dumber_favorites(" + string(b) + ")")
 }
 // handleToggleFavorite adds or removes a URL from favorites
 func (h *Handler) handleToggleFavorite(msg Message) {
 	if h.webView == nil {
-		log.Printf("[messaging] Cannot toggle favorite - no webview available")
+		logging.Warn(fmt.Sprintf("[messaging] Cannot toggle favorite - no webview available"))
 		return
 	}
 	if h.webView.IsDestroyed() {
-		log.Printf("[messaging] Cannot toggle favorite - webview is destroyed")
+		logging.Warn(fmt.Sprintf("[messaging] Cannot toggle favorite - webview is destroyed"))
 		return
 	}
 	if msg.URL == "" {
-		log.Printf("[messaging] Cannot toggle favorite - URL is empty")
+		logging.Warn(fmt.Sprintf("[messaging] Cannot toggle favorite - URL is empty"))
 		return
 	}
 	// Toggle the favorite
 	added, err := h.browserService.ToggleFavorite(context.Background(), msg.URL, msg.Title, msg.FaviconURL)
 	if err != nil {
-		log.Printf("[messaging] Failed to toggle favorite for %s: %v", msg.URL, err)
+		logging.Error(fmt.Sprintf("[messaging] Failed to toggle favorite for %s: %v", msg.URL, err))
 		_ = h.webView.InjectScript("window.__dumber_favorite_toggled_error && window.__dumber_favorite_toggled_error('Failed to toggle favorite')")
 		return
 	}
 	}
 	b, err := json.Marshal(result)
 	if err != nil {
-		log.Printf("[messaging] Failed to marshal toggle result: %v", err)
+		logging.Error(fmt.Sprintf("[messaging] Failed to marshal toggle result: %v", err))
 		return
 	}
-	log.Printf("[messaging] Favorite toggled for %s (added: %v)", msg.URL, added)
+	logging.Debug(fmt.Sprintf("[messaging] Favorite toggled for %s (added: %v)", msg.URL, added))
 	_ = h.webView.InjectScript("window.__dumber_favorite_toggled && window.__dumber_favorite_toggled(" + string(b) + ")")
 }
 // handleIsFavorite checks if a URL is favorited
 func (h *Handler) handleIsFavorite(msg Message) {
 	if h.webView == nil {
-		log.Printf("[messaging] Cannot check favorite - no webview available")
+		logging.Warn(fmt.Sprintf("[messaging] Cannot check favorite - no webview available"))
 		return
 	}
 	if h.webView.IsDestroyed() {
-		log.Printf("[messaging] Cannot check favorite - webview is destroyed")
+		logging.Warn(fmt.Sprintf("[messaging] Cannot check favorite - webview is destroyed"))
 		return
 	}
 	if msg.URL == "" {
-		log.Printf("[messaging] Cannot check favorite - URL is empty")
+		logging.Warn(fmt.Sprintf("[messaging] Cannot check favorite - URL is empty"))
 		return
 	}
 	// Check if the URL is favorited
 	isFavorite, err := h.browserService.IsFavorite(context.Background(), msg.URL)
 	if err != nil {
-		log.Printf("[messaging] Failed to check if favorite for %s: %v", msg.URL, err)
+		logging.Error(fmt.Sprintf("[messaging] Failed to check if favorite for %s: %v", msg.URL, err))
 		return
 	}
 	}
 	b, err := json.Marshal(result)
 	if err != nil {
-		log.Printf("[messaging] Failed to marshal is_favorite result: %v", err)
+		logging.Error(fmt.Sprintf("[messaging] Failed to marshal is_favorite result: %v", err))
 		return
 	}
 	}
 	if err := h.webView.InjectScript(script); err != nil {
-		log.Printf("[ERROR] Failed to inject keyboard blocking script: %v", err)
+		logging.Error(fmt.Sprintf("[ERROR] Failed to inject keyboard blocking script: %v", err))
 	}
 }

M internal/cache/binary_format.go +2 -3

 import (
 	"encoding/binary"
 	"fmt"
-	"log"
 	"os"
 	"syscall"
 	"unsafe"
 		logging.Warn(fmt.Sprintf("too many entries for binary format: %d, truncating", len(c.entries)))
 	}
 	if indexOffset < 0 {
-		log.Printf("Warning: negative index offset: %d, using 0", indexOffset)
+		logging.Warn(fmt.Sprintf("Warning: negative index offset: %d, using 0", indexOffset))
 		indexOffset = 0
 	}
 	}
 	defer func() {
 		if closeErr := file.Close(); closeErr != nil {
-			log.Printf("Warning: failed to close cache validation file: %v", closeErr)
+			logging.Warn(fmt.Sprintf("Warning: failed to close cache validation file: %v", closeErr))
 		}
 	}()

M internal/cache/filter_cache.go +3 -4

 	"encoding/binary"
 	"fmt"
 	"io"
-	"log"
 	"os"
 	"syscall"
 	"time"
 	header, err := fc.parseHeader()
 	if err != nil {
 		if unmapErr := fc.Unmap(); unmapErr != nil {
-			log.Printf("[filter-cache] failed to unmap after header parse error: %v", unmapErr)
+			logging.Warn(fmt.Sprintf("[filter-cache] failed to unmap after header parse error: %v", unmapErr))
 		}
 		return nil, fmt.Errorf("invalid cache header: %w", err)
 	}
 	// Validate magic and version
 	if header.Magic != cacheMagic {
 		if unmapErr := fc.Unmap(); unmapErr != nil {
-			log.Printf("[filter-cache] failed to unmap after magic validation: %v", unmapErr)
+			logging.Warn(fmt.Sprintf("[filter-cache] failed to unmap after magic validation: %v", unmapErr))
 		}
 		return nil, fmt.Errorf("invalid cache magic bytes")
 	}
 	if header.Version != cacheFormatVersion {
 		if unmapErr := fc.Unmap(); unmapErr != nil {
-			log.Printf("[filter-cache] failed to unmap after version validation: %v", unmapErr)
+			logging.Warn(fmt.Sprintf("[filter-cache] failed to unmap after version validation: %v", unmapErr))
 		}
 		return nil, fmt.Errorf("unsupported cache version: %d", header.Version)
 	}

M internal/cache/generic/cache.go +5 -3

 import (
 	"context"
-	"log"
+	"fmt"
 	"sync"
+	"github.com/bnema/dumber/internal/logging"
 )
 // Cache provides a generic interface for caching any type of data.
 		ctx := context.Background()
 		if err := c.dbOps.Persist(ctx, key, value); err != nil {
-			log.Printf("Warning: async persist failed for key %v: %v", key, err)
+			logging.Warn(fmt.Sprintf("Warning: async persist failed for key %v: %v", key, err))
 		}
 	}()
 		ctx := context.Background()
 		if err := c.dbOps.Delete(ctx, key); err != nil {
-			log.Printf("Warning: async delete failed for key %v: %v", key, err)
+			logging.Warn(fmt.Sprintf("Warning: async delete failed for key %v: %v", key, err))
 		}
 	}()

M internal/db/init.go +5 -5

 import (
 	"database/sql"
 	"fmt"
-	"log"
 	"os"
 	"path/filepath"
+	"github.com/bnema/dumber/internal/logging"
 	"github.com/bnema/dumber/internal/migrations"
 	_ "github.com/ncruces/go-sqlite3/driver" // SQLite driver
 	_ "github.com/ncruces/go-sqlite3/embed"  // Embed SQLite
 	// Test the connection
 	if err := database.Ping(); err != nil {
 		if err := database.Close(); err != nil {
-			log.Printf("Warning: failed to close database: %v", err)
+			logging.Warn(fmt.Sprintf("Warning: failed to close database: %v", err))
 		}
 		return nil, fmt.Errorf("failed to connect to database: %w", err)
 	}
 	for _, pragma := range pragmas {
 		if _, err := database.Exec(pragma); err != nil {
 			if err := database.Close(); err != nil {
-				log.Printf("Warning: failed to close database: %v", err)
+				logging.Warn(fmt.Sprintf("Warning: failed to close database: %v", err))
 			}
 			return nil, fmt.Errorf("failed to set pragma %q: %w", pragma, err)
 		}
 	}
-	log.Printf("SQLite configured with WAL mode and performance optimizations")
+	logging.Info(fmt.Sprintf("SQLite configured with WAL mode and performance optimizations"))
 	// Run embedded migrations - single source of truth for schema initialization
 	// RunEmbeddedMigrations is idempotent and checks if migrations are already applied
 	if err := migrations.RunEmbeddedMigrations(database); err != nil {
 		if err := database.Close(); err != nil {
-			log.Printf("Warning: failed to close database: %v", err)
+			logging.Warn(fmt.Sprintf("Warning: failed to close database: %v", err))
 		}
 		return nil, fmt.Errorf("failed to run database migrations: %w", err)
 	}

M internal/filtering/updater.go +2 -3

 	"context"
 	"crypto/sha256"
 	"fmt"
-	"log"
 	"net/http"
 	"strings"
 	"sync"
 	}
 	defer func() {
 		if err := resp.Body.Close(); err != nil {
-			log.Printf("warning: failed to close response body: %v", err)
+			logging.Warn(fmt.Sprintf("warning: failed to close response body: %v", err))
 		}
 	}()
 	}
 	defer func() {
 		if err := resp.Body.Close(); err != nil {
-			log.Printf("warning: failed to close response body: %v", err)
+			logging.Warn(fmt.Sprintf("warning: failed to close response body: %v", err))
 		}
 	}()

M internal/migrations/migrations.go +11 -10

 	"database/sql"
 	"embed"
 	"fmt"
-	"log"
 	"sort"
 	"strconv"
 	"strings"
+	"github.com/bnema/dumber/internal/logging"
 )
 //go:embed *.sql
 		// Parse version from filename (e.g., "001_initial.sql" -> version 1)
 		parts := strings.SplitN(entry.Name(), "_", 2)
 		if len(parts) != 2 {
-			log.Printf("Warning: skipping migration file with invalid name format: %s", entry.Name())
+			logging.Warn(fmt.Sprintf("Warning: skipping migration file with invalid name format: %s", entry.Name()))
 			continue
 		}
 		versionStr := parts[0]
 		version, err := strconv.Atoi(versionStr)
 		if err != nil {
-			log.Printf("Warning: skipping migration file with invalid version: %s", entry.Name())
+			logging.Warn(fmt.Sprintf("Warning: skipping migration file with invalid version: %s", entry.Name()))
 			continue
 		}
 		return nil
 	}
-	log.Printf("Applying migration %03d: %s", migration.Version, migration.Name)
+	logging.Info(fmt.Sprintf("Applying migration %03d: %s", migration.Version, migration.Name))
 	// Use transaction for safety
 	tx, err := db.Begin()
 	defer func() {
 		if err != nil {
 			if rollbackErr := tx.Rollback(); rollbackErr != nil {
-				log.Printf("failed to rollback migration transaction: %v", rollbackErr)
+				logging.Error(fmt.Sprintf("failed to rollback migration transaction: %v", rollbackErr))
 			}
 		}
 	}()
 		return fmt.Errorf("failed to commit migration transaction: %w", err)
 	}
-	log.Printf("Successfully applied migration %03d: %s", migration.Version, migration.Name)
+	logging.Info(fmt.Sprintf("Successfully applied migration %03d: %s", migration.Version, migration.Name))
 	return nil
 }
 	}
 	defer func() {
 		if err := rows.Close(); err != nil {
-			log.Printf("failed to close migration query rows: %v", err)
+			logging.Warn(fmt.Sprintf("failed to close migration query rows: %v", err))
 		}
 	}()
 	// Report results
 	if len(missingMigrations) > 0 {
-		log.Printf("WARNING: %d migrations are not applied:", len(missingMigrations))
+		logging.Warn(fmt.Sprintf("WARNING: %d migrations are not applied:", len(missingMigrations)))
 		for _, migration := range missingMigrations {
-			log.Printf("  - Migration %03d: %s", migration.Version, migration.Name)
+			logging.Warn(fmt.Sprintf("  - Migration %03d: %s", migration.Version, migration.Name))
 		}
 		return fmt.Errorf("%d migrations are not applied", len(missingMigrations))
 	}
-	log.Printf("Migration verification: All %d migrations are applied", len(allMigrations))
+	logging.Info(fmt.Sprintf("Migration verification: All %d migrations are applied", len(allMigrations)))
 	return nil
 }

M internal/services/browser.go +19 -19

 	"database/sql"
 	"embed"
 	"fmt"
-	"log"
 	"math"
 	neturl "net/url"
 	"sync"
 	"github.com/bnema/dumber/internal/cache"
 	"github.com/bnema/dumber/internal/config"
 	"github.com/bnema/dumber/internal/db"
+	"github.com/bnema/dumber/internal/logging"
 	"github.com/bnema/dumber/internal/parser"
 	"github.com/bnema/dumber/pkg/webkit"
 )
 // LoadGUIBundle loads the unified GUI bundle from assets
 func (s *BrowserService) LoadGUIBundle(assets embed.FS) error {
-	log.Printf("[browser] Attempting to load GUI bundle from assets/gui/gui.min.js")
+	logging.Debug(fmt.Sprintf("[browser] Attempting to load GUI bundle from assets/gui/gui.min.js"))
 	bundleBytes, err := assets.ReadFile("assets/gui/gui.min.js")
 	if err != nil {
-		log.Printf("[browser] ERROR: Failed to load GUI bundle: %v", err)
+		logging.Error(fmt.Sprintf("[browser] ERROR: Failed to load GUI bundle: %v", err))
 		return fmt.Errorf("failed to load GUI bundle: %w", err)
 	}
 	s.guiBundle = string(bundleBytes)
-	log.Printf("[browser] GUI bundle loaded successfully into browser service, size: %d bytes", len(bundleBytes))
+	logging.Info(fmt.Sprintf("[browser] GUI bundle loaded successfully into browser service, size: %d bytes", len(bundleBytes)))
 	return nil
 }
 		return nil
 	default:
 		// Queue full, write directly (fallback)
-		log.Printf("Warning: history queue full, writing directly")
+		logging.Warn(fmt.Sprintf("Warning: history queue full, writing directly"))
 		return s.dbQueries.AddOrUpdateHistory(ctx, normalizedURL, titleNull)
 	}
 }
 		// but we can still batch the operations to reduce overhead
 		for _, update := range batch {
 			if err := s.dbQueries.AddOrUpdateHistory(ctx, update.url, update.title); err != nil {
-				log.Printf("Warning: failed to write history for %s: %v", update.url, err)
+				logging.Warn(fmt.Sprintf("Warning: failed to write history for %s: %v", update.url, err))
 			}
 		}
-		log.Printf("Flushed %d history updates to database", len(batch))
+		logging.Debug(fmt.Sprintf("Flushed %d history updates to database", len(batch)))
 		// Track history entries for fuzzy cache refresh
 		batchSize := len(batch)
 		timeSinceRefresh := time.Since(s.lastCacheRefresh)
 		if s.historySinceRefresh >= minEntries && timeSinceRefresh >= minInterval {
-			log.Printf("[cache] Triggering async fuzzy cache refresh (%d new entries, %v since last refresh)",
+			logging.Debug(fmt.Sprintf("[cache] Triggering async fuzzy cache refresh (%d new entries, %v since last refresh)",
-				s.historySinceRefresh, timeSinceRefresh)
+				s.historySinceRefresh, timeSinceRefresh))
 			// Async refresh in background (non-blocking)
 			s.fuzzyCache.InvalidateAndRefresh(ctx)
 		// Wait for completion with context cancellation support
 		select {
 		case <-s.historyFlushDone:
-			log.Printf("History queue flushed and closed")
+			logging.Info(fmt.Sprintf("History queue flushed and closed"))
 		case <-ctx.Done():
 			flushErr = fmt.Errorf("history queue flush cancelled: %w", ctx.Err())
-			log.Printf("Warning: %v", flushErr)
+			logging.Warn(fmt.Sprintf("Warning: %v", flushErr))
 		}
 	})
 	return flushErr
 	}
 	loadedCount := len(s.zoomCache.List())
-	log.Printf("Loaded %d zoom levels into cache", loadedCount)
+	logging.Info(fmt.Sprintf("Loaded %d zoom levels into cache", loadedCount))
 	return nil
 }
 	}
 	loadedCount := len(s.certCache.List())
-	log.Printf("Loaded %d certificate validations into cache", loadedCount)
+	logging.Info(fmt.Sprintf("Loaded %d certificate validations into cache", loadedCount))
 	return nil
 }
 	}
 	stats := s.fuzzyCache.Stats()
-	log.Printf("Loaded fuzzy cache: %d entries, %d trigrams",
+	logging.Info(fmt.Sprintf("Loaded fuzzy cache: %d entries, %d trigrams",
-		stats.EntryCount, stats.TrigramCount)
+		stats.EntryCount, stats.TrigramCount))
 	return nil
 }
 	}
 	loadedCount := len(s.favoritesCache.List())
-	log.Printf("Loaded %d favorites into cache", loadedCount)
+	logging.Info(fmt.Sprintf("Loaded %d favorites into cache", loadedCount))
 	return nil
 }
 		if err := s.favoritesCache.Delete(url); err != nil {
 			return false, fmt.Errorf("failed to remove favorite: %w", err)
 		}
-		log.Printf("Removed favorite: %s", url)
+		logging.Info(fmt.Sprintf("Removed favorite: %s", url))
 		return false, nil
 	}
 		return false, fmt.Errorf("failed to add favorite: %w", err)
 	}
-	log.Printf("Added favorite: %s", url)
+	logging.Info(fmt.Sprintf("Added favorite: %s", url))
 	return true, nil
 }
 		return fmt.Errorf("failed to flush history queue: %w", err)
 	}
-	log.Printf("All caches flushed successfully")
+	logging.Info(fmt.Sprintf("All caches flushed successfully"))
 	return nil
 }

M internal/services/favicon_service.go +13 -13

 	"database/sql"
 	"errors"
 	"fmt"
-	"log"
 	"os"
 	"path/filepath"
 	"sync"
 	"time"
 	"github.com/bnema/dumber/internal/db"
+	"github.com/bnema/dumber/internal/logging"
 	"github.com/bnema/dumber/internal/parser"
 	"github.com/bnema/dumber/pkg/webkit"
 	"github.com/diamondburned/gotk4/pkg/gdk/v4"
 	// The FaviconDatabase is shared across all WebViews (at NetworkSession level)
 	faviconDB.ConnectFaviconChanged(func(pageURI, faviconURI string) {
 		if err := fs.OnFaviconChanged(pageURI, faviconURI); err != nil {
-			log.Printf("[favicon] Handler error for %s: %v", pageURI, err)
+			logging.Error(fmt.Sprintf("[favicon] Handler error for %s: %v", pageURI, err))
 		}
 	})
-	log.Printf("[favicon] Registered single shared favicon handler at FaviconService level")
+	logging.Info(fmt.Sprintf("[favicon] Registered single shared favicon handler at FaviconService level"))
 	return fs, nil
 }
 	}
 	// NEW favicon detected (first time or actual change)
-	log.Printf("[favicon] Favicon changed for %s: %s", pageURL, faviconURI)
+	logging.Info(fmt.Sprintf("[favicon] Favicon changed for %s: %s", pageURL, faviconURI))
 	ctx := context.Background()
 	// Update our history database with the favicon URI
 	nullString := sql.NullString{String: faviconURI, Valid: faviconURI != ""}
 	if err := fs.dbQueries.UpdateHistoryFavicon(ctx, nullString, canonicalURL); err != nil {
-		log.Printf("[favicon] Failed to update favicon URI in database for %s: %v", pageURL, err)
+		logging.Error(fmt.Sprintf("[favicon] Failed to update favicon URI in database for %s: %v", pageURL, err))
 		return fmt.Errorf("failed to update favicon in database: %w", err)
 	}
 	domainPattern := sql.NullString{String: "%://" + parsedURL.Host + "%", Valid: true}
 	entries, err := fs.dbQueries.SearchHistory(ctx, domainPattern, sql.NullString{}, 1000)
 	if err != nil {
-		log.Printf("[favicon] Failed to search history for domain %s: %v", parsedURL.Host, err)
+		logging.Error(fmt.Sprintf("[favicon] Failed to search history for domain %s: %v", parsedURL.Host, err))
 		return
 	}
 	for _, entry := range entries {
 		if entry.FaviconUrl.String == "" {
 			if err := fs.dbQueries.UpdateHistoryFavicon(ctx, faviconNull, entry.Url); err != nil {
-				log.Printf("[favicon] Failed to propagate favicon to %s: %v", entry.Url, err)
+				logging.Error(fmt.Sprintf("[favicon] Failed to propagate favicon to %s: %v", entry.Url, err))
 			} else {
-				log.Printf("[favicon] Propagated favicon to %s", entry.Url)
+				logging.Debug(fmt.Sprintf("[favicon] Propagated favicon to %s", entry.Url))
 			}
 		}
 	}
 	texture, err := fs.renderFaviconTexture(ctx, pageURL, faviconURI)
 	if err != nil {
-		log.Printf("[favicon] Preload failed for %s: %v", pageURL, err)
+		logging.Warn(fmt.Sprintf("[favicon] Preload failed for %s: %v", pageURL, err))
 		return
 	}
 	fs.maybeExportTexture(canonicalURL, texture)
-	log.Printf("[favicon] Preloaded and exported favicon for %s", pageURL)
+	logging.Debug(fmt.Sprintf("[favicon] Preloaded and exported favicon for %s", pageURL))
 }
 // GetFaviconTexture loads a favicon texture asynchronously and calls the callback with the result.
 			continue
 		}
 		if !errors.Is(err, sql.ErrNoRows) {
-			log.Printf("[favicon] failed to query history entry for %s: %v", candidate, err)
+			logging.Error(fmt.Sprintf("[favicon] failed to query history entry for %s: %v", candidate, err))
 		}
 	}
 	_ = webkit.IdleAdd(func() bool {
 		if err := webkit.SaveTextureAsPNG(texture, exportPath, fs.targetSize); err != nil {
-			log.Printf("[favicon] Failed to export favicon PNG for %s: %v", pageURL, err)
+			logging.Error(fmt.Sprintf("[favicon] Failed to export favicon PNG for %s: %v", pageURL, err))
 		}
 		return false
 	})
 func (fs *FaviconService) shouldProcessURL(pageURL string) bool {
 	parsedURL, err := webkit.ParseURL(pageURL)
 	if err != nil {
-		log.Printf("[favicon] Invalid page URL: %s", pageURL)
+		logging.Warn(fmt.Sprintf("[favicon] Invalid page URL: %s", pageURL))
 		return false
 	}

M main.go +6 -4

 import (
 	"embed"
-	"log"
+	"fmt"
 	"os"
 	"runtime"
 	// Load config file first, then initialize logging with actual config
 	if err := config.Init(); err != nil {
-		log.Printf("Warning: failed to load config: %v, using defaults", err)
+		// Use fmt.Printf for early errors before logging is initialized
+		fmt.Printf("Warning: failed to load config: %v, using defaults\n", err)
 	}
 	cfg := config.Get()
 		cfg.Logging.MaxAge,
 		cfg.Logging.Compress,
 	); err != nil {
-		log.Printf("Warning: failed to initialize logging: %v", err)
+		// Use fmt.Printf for early errors before logging is initialized
+		fmt.Printf("Warning: failed to initialize logging: %v\n", err)
 	}
-	log.Printf("Starting dumber browser v%s (commit: %s, built: %s)", version, commit, buildDate)
+	logging.Info(fmt.Sprintf("Starting dumber browser v%s (commit: %s, built: %s)", version, commit, buildDate))
 	// GTK requires all UI calls to run on the main OS thread
 	if webkit.IsNativeAvailable() {

M pkg/webkit/content_blocking.go +12 -12

 import (
 	"context"
 	"fmt"
-	"log"
 	"path/filepath"
 	"sync"
+	"github.com/bnema/dumber/internal/logging"
 	webkit "github.com/diamondburned/gotk4-webkitgtk/pkg/webkit/v6"
 	"github.com/diamondburned/gotk4/pkg/gio/v2"
 	"github.com/diamondburned/gotk4/pkg/glib/v2"
 		return nil, fmt.Errorf("failed to create UserContentFilterStore")
 	}
-	log.Printf("[webkit] Created UserContentFilterStore at: %s", storagePath)
+	logging.Debug(fmt.Sprintf("[webkit] Created UserContentFilterStore at: %s", storagePath))
 	return &ContentBlockingManager{
 		filterStore: filterStore,
 		return
 	}
-	log.Printf("[webkit] Compiling content filters (identifier: %s, rules size: %d bytes)", identifier, len(jsonRules))
+	logging.Debug(fmt.Sprintf("[webkit] Compiling content filters (identifier: %s, rules size: %d bytes)", identifier, len(jsonRules)))
 	// Store identifier for later use
 	cbm.mu.Lock()
 	cbm.filterStore.Save(ctx, identifier, gBytes, func(result gio.AsyncResulter) {
 		filter, err := cbm.filterStore.SaveFinish(result)
 		if err != nil {
-			log.Printf("[webkit] Failed to compile content filter: %v", err)
+			logging.Error(fmt.Sprintf("[webkit] Failed to compile content filter: %v", err))
 			if onComplete != nil {
 				onComplete(fmt.Errorf("failed to compile filter: %w", err))
 			}
 		}
 		if filter == nil {
-			log.Printf("[webkit] Filter compilation returned nil")
+			logging.Error(fmt.Sprintf("[webkit] Filter compilation returned nil"))
 			if onComplete != nil {
 				onComplete(fmt.Errorf("filter compilation returned nil"))
 			}
 		cbm.compiledFilter = filter
 		cbm.mu.Unlock()
-		log.Printf("[webkit] Filter compilation complete: %s", identifier)
+		logging.Debug(fmt.Sprintf("[webkit] Filter compilation complete: %s", identifier))
 		if onComplete != nil {
 			onComplete(nil)
 		}
 		filter := cbm.compiledFilter
 		cbm.mu.RUnlock()
 		ucm.AddFilter(filter)
-		log.Printf("[webkit] Applied cached content filter to UCM")
+		logging.Debug(fmt.Sprintf("[webkit] Applied cached content filter to UCM"))
 		return nil
 	}
 	cbm.mu.RUnlock()
 		return fmt.Errorf("empty filter rules")
 	}
-	log.Printf("[webkit] Applying content filters (identifier: %s, rules size: %d bytes)", identifier, len(jsonRules))
+	logging.Debug(fmt.Sprintf("[webkit] Applying content filters (identifier: %s, rules size: %d bytes)", identifier, len(jsonRules)))
 	// Convert []byte to *glib.Bytes for WebKit API
 	gBytes := glib.NewBytesWithGo(jsonRules)
 	cbm.filterStore.Save(ctx, identifier, gBytes, func(result gio.AsyncResulter) {
 		filter, err := cbm.filterStore.SaveFinish(result)
 		if err != nil {
-			log.Printf("[webkit] Failed to compile content filter: %v", err)
+			logging.Error(fmt.Sprintf("[webkit] Failed to compile content filter: %v", err))
 			done <- fmt.Errorf("failed to compile filter: %w", err)
 			return
 		}
 		if filter == nil {
-			log.Printf("[webkit] Filter compilation returned nil")
+			logging.Error(fmt.Sprintf("[webkit] Filter compilation returned nil"))
 			done <- fmt.Errorf("filter compilation returned nil")
 			return
 		}
 		RunOnMainThread(func() {
 			ucm.AddFilter(filter)
-			log.Printf("[webkit] Successfully added content filter: %s", identifier)
+			logging.Debug(fmt.Sprintf("[webkit] Successfully added content filter: %s", identifier))
 			done <- nil
 		})
 	})
 func (cbm *ContentBlockingManager) RemoveAllFilters(ucm *webkit.UserContentManager) {
 	if ucm != nil {
 		ucm.RemoveAllFilters()
-		log.Printf("[webkit] Removed all content filters")
+		logging.Debug(fmt.Sprintf("[webkit] Removed all content filters"))
 	}
 }

M pkg/webkit/keyboard_bridge.go +10 -10

 import (
 	"encoding/json"
 	"fmt"
-	"log"
+	"github.com/bnema/dumber/internal/logging"
 	"github.com/diamondburned/gotk4/pkg/gdk/v4"
 	"github.com/diamondburned/gotk4/pkg/gtk/v4"
 )
 				handler := w.onPaneModeShortcut
 				w.mu.RUnlock()
 				if handler != nil && handler(actionEnter) {
-					log.Printf("[keyboard-bridge] Pane mode: enter")
+					logging.Debug(fmt.Sprintf("[keyboard-bridge] Pane mode: enter"))
 					return true
 				}
 				return true // Block even if no handler
 				handler := w.onPaneModeShortcut
 				w.mu.RUnlock()
 				if handler != nil && handler(actionExit) {
-					log.Printf("[keyboard-bridge] Escape: exited mode")
+					logging.Debug(fmt.Sprintf("[keyboard-bridge] Escape: exited mode"))
 					return true
 				}
 				return false // Pass through to DOM if no active mode
 					handler := w.onWorkspaceNavigation
 					w.mu.RUnlock()
 					if handler != nil && handler(action) {
-						log.Printf("[keyboard-bridge] Navigation: %s", action)
+						logging.Debug(fmt.Sprintf("[keyboard-bridge] Navigation: %s", action))
 						return true
 					}
 					return true // Block anyway to prevent scrolling
 				handler := w.onPaneModeShortcut
 				w.mu.RUnlock()
 				if handler != nil && handler(action) {
-					log.Printf("[keyboard-bridge] Pane mode action: %s", action)
+					logging.Debug(fmt.Sprintf("[keyboard-bridge] Pane mode action: %s", action))
 					return true
 				}
 				return false // Not in pane mode, pass through
 			// Pane mode active: block all other shortcuts
 			if isPaneModeActive {
-				log.Printf("[keyboard-bridge] Blocking '%s' during pane mode", shortcut)
+				logging.Debug(fmt.Sprintf("[keyboard-bridge] Blocking '%s' during pane mode", shortcut))
 				return true
 			}
 			// Forward to JavaScript using proper JSON marshaling to prevent any potential injection
 			shortcutJSON, err := json.Marshal(shortcut)
 			if err != nil {
-				log.Printf("[keyboard-bridge] Failed to marshal shortcut: %v", err)
+				logging.Error(fmt.Sprintf("[keyboard-bridge] Failed to marshal shortcut: %v", err))
 				return false
 			}
 			script := fmt.Sprintf(`document.dispatchEvent(new CustomEvent('dumber:key',{detail:{shortcut:%s}}));`, shortcutJSON)
 			if err := w.InjectScript(script); err != nil {
-				log.Printf("[keyboard-bridge] Failed to dispatch: %v", err)
+				logging.Error(fmt.Sprintf("[keyboard-bridge] Failed to dispatch: %v", err))
 			}
 			return false // Allow WebKit to handle
 		}
 		// Pane mode active: block ALL non-shortcut keys
 		if isPaneModeActive {
-			log.Printf("[keyboard-bridge] Blocking key during pane mode: keyval=%d", keyval)
+			logging.Debug(fmt.Sprintf("[keyboard-bridge] Blocking key during pane mode: keyval=%d", keyval))
 			return true // Block all other keys
 		}
 	// Attach controller to WebView
 	w.view.AddController(keyController)
-	log.Printf("[keyboard-bridge] EventControllerKey attached to WebView ID %d", w.id)
+	logging.Debug(fmt.Sprintf("[keyboard-bridge] EventControllerKey attached to WebView ID %d", w.id))
 }

M pkg/webkit/mouse_gestures.go +8 -7

 package webkit
 import (
-	"log"
+	"fmt"
+	"github.com/bnema/dumber/internal/logging"
 	"github.com/diamondburned/gotk4/pkg/gtk/v4"
 )
 // This enables hardware mouse button navigation (back/forward buttons)
 func (w *WebView) AttachMouseGestures() {
 	if w.view == nil {
-		log.Printf("[mouse-gestures] Cannot attach: WebView is nil")
+		logging.Error(fmt.Sprintf("[mouse-gestures] Cannot attach: WebView is nil"))
 		return
 	}
 		switch button {
 		case mouseButtonBack:
 			if w.view.CanGoBack() {
-				log.Printf("[mouse-gestures] Back button clicked - navigating backward")
+				logging.Debug(fmt.Sprintf("[mouse-gestures] Back button clicked - navigating backward"))
 				w.view.GoBack()
 			} else {
-				log.Printf("[mouse-gestures] Back button clicked but cannot go back")
+				logging.Debug(fmt.Sprintf("[mouse-gestures] Back button clicked but cannot go back"))
 			}
 		case mouseButtonForward:
 			if w.view.CanGoForward() {
-				log.Printf("[mouse-gestures] Forward button clicked - navigating forward")
+				logging.Debug(fmt.Sprintf("[mouse-gestures] Forward button clicked - navigating forward"))
 				w.view.GoForward()
 			} else {
-				log.Printf("[mouse-gestures] Forward button clicked but cannot go forward")
+				logging.Debug(fmt.Sprintf("[mouse-gestures] Forward button clicked but cannot go forward"))
 			}
 		}
 	})
 	// Attach controller to WebView
 	w.view.AddController(gestureClick)
-	log.Printf("[mouse-gestures] Mouse gesture controller attached to WebView ID %d", w.id)
+	logging.Debug(fmt.Sprintf("[mouse-gestures] Mouse gesture controller attached to WebView ID %d", w.id))
 }

M pkg/webkit/network_session.go +7 -7

 import (
 	"fmt"
-	"log"
+	"github.com/bnema/dumber/internal/logging"
 	webkit "github.com/diamondburned/gotk4-webkitgtk/pkg/webkit/v6"
 )
 	// If session already exists, return success (idempotent)
 	// This ensures we only create ONE session for the entire application
 	if globalNetworkSession != nil {
-		log.Printf("[webkit] Using existing persistent network session")
+		logging.Debug(fmt.Sprintf("[webkit] Using existing persistent network session"))
 		return nil
 	}
 	// This is CRITICAL - if the session is GC'd, WebKit falls back to ephemeral storage
 	globalNetworkSession = session
-	log.Printf("[webkit] Persistent network session created: data=%s, cache=%s", dataDir, cacheDir)
+	logging.Debug(fmt.Sprintf("[webkit] Persistent network session created: data=%s, cache=%s", dataDir, cacheDir))
 	// Verify the session is not ephemeral
 	if session.IsEphemeral() {
 	if websiteDataManager.IsEphemeral() {
 		return fmt.Errorf("website data manager is ephemeral despite providing data directories")
 	}
-	log.Printf("[webkit] WebsiteDataManager verified as non-ephemeral")
+	logging.Debug(fmt.Sprintf("[webkit] WebsiteDataManager verified as non-ephemeral"))
 	// Configure CookieManager for persistent cookie storage
 	// This is REQUIRED - without this, cookies are not persisted to disk
 	// Set cookie accept policy to no third-party (default)
 	cookieManager.SetAcceptPolicy(webkit.CookiePolicyAcceptNoThirdParty)
-	log.Printf("[webkit] Cookie manager configured: storage=%s, policy=no-third-party", cookiePath)
+	logging.Debug(fmt.Sprintf("[webkit] Cookie manager configured: storage=%s, policy=no-third-party", cookiePath))
 	// Enable persistent credential storage (HTTP auth, etc.)
 	session.SetPersistentCredentialStorageEnabled(true)
 	// Configure TLS errors to emit signals instead of failing silently
 	// This enables the load-failed-with-tls-errors signal
 	session.SetTLSErrorsPolicy(webkit.TLSErrorsPolicyFail)
-	log.Printf("[webkit] TLS errors policy set to FAIL (signals enabled)")
+	logging.Debug(fmt.Sprintf("[webkit] TLS errors policy set to FAIL (signals enabled)"))
 	// Verify this is indeed the default session now
 	defaultSession := webkit.NetworkSessionGetDefault()
 		return fmt.Errorf("default network session is ephemeral after creating persistent session")
 	}
-	log.Printf("[webkit] Network session verified as persistent and set as default")
+	logging.Debug(fmt.Sprintf("[webkit] Network session verified as persistent and set as default"))
 	return nil
 }

M pkg/webkit/shortcuts.go +6 -5

 package webkit
 import (
-	"log"
+	"fmt"
 	"strings"
+	"github.com/bnema/dumber/internal/logging"
 	"github.com/diamondburned/gotk4/pkg/gdk/v4"
 	"github.com/diamondburned/gotk4/pkg/glib/v2"
 	"github.com/diamondburned/gotk4/pkg/gtk/v4"
 	// Convert to GTK format (e.g., "ctrl+plus" -> "<Control>plus")
 	gtkFormat := convertToGtkFormat(accelerator)
 	if gtkFormat == "" {
-		log.Printf("[shortcuts] Invalid key format: %s", accelerator)
+		logging.Warn(fmt.Sprintf("[shortcuts] Invalid key format: %s", accelerator))
 		return
 	}
 	// ShortcutFunc signature: func(widget Widgetter, args *glib.Variant) (ok bool)
 	action := gtk.NewCallbackAction(func(widget gtk.Widgetter, args *glib.Variant) bool {
 		if handler != nil {
-			log.Printf("[shortcuts] Shortcut triggered: %s", accelerator)
+			logging.Debug(fmt.Sprintf("[shortcuts] Shortcut triggered: %s", accelerator))
 			handler()
 		}
 		// Return false to allow event propagation to WebView
 	// GTK4 uses gtk.ShortcutTrigger for key combinations
 	trigger := gtk.NewShortcutTriggerParseString(gtkFormat)
 	if trigger == nil {
-		log.Printf("[shortcuts] Failed to parse trigger: %s", gtkFormat)
+		logging.Error(fmt.Sprintf("[shortcuts] Failed to parse trigger: %s", gtkFormat))
 		return
 	}
 	// Store the shortcut for potential cleanup
 	ws.shortcuts[accelerator] = shortcut
-	log.Printf("[shortcuts] Registered: %s -> %s", accelerator, gtkFormat)
+	logging.Debug(fmt.Sprintf("[shortcuts] Registered: %s -> %s", accelerator, gtkFormat))
 }
 // convertToGtkFormat converts common key formats to GTK shortcut format

M pkg/webkit/tls_handler.go +29 -29

 	"database/sql"
 	"errors"
 	"fmt"
-	"log"
 	"net/url"
 	"strings"
 	"time"
 	"github.com/bnema/dumber/internal/config"
 	"github.com/bnema/dumber/internal/db"
+	"github.com/bnema/dumber/internal/logging"
 	"github.com/diamondburned/gotk4/pkg/gio/v2"
 	"github.com/diamondburned/gotk4/pkg/gtk/v4"
 )
 // setupTLSErrorHandler sets up the TLS error handler for the WebView
 func (wv *WebView) setupTLSErrorHandler() {
 	wv.view.ConnectLoadFailedWithTLSErrors(func(failingUri string, certificate gio.TLSCertificater, errors gio.TLSCertificateFlags) bool {
-		log.Printf("[tls] Load failed with TLS errors for: %s, errors: %v", failingUri, errors)
+		logging.Warn(fmt.Sprintf("[tls] Load failed with TLS errors for: %s, errors: %v", failingUri, errors))
 		// Extract hostname from URI
 		hostname := extractHostname(failingUri)
 		if hostname == "" {
-			log.Printf("[tls] Failed to extract hostname from URI: %s", failingUri)
+			logging.Error(fmt.Sprintf("[tls] Failed to extract hostname from URI: %s", failingUri))
 			return false // Let WebKit handle it
 		}
 		decision, exists := checkStoredCertificateDecision(hostname)
 		if exists {
 			if decision == "accepted" {
-				log.Printf("[tls] Certificate previously accepted for %s, allowing", hostname)
+				logging.Debug(fmt.Sprintf("[tls] Certificate previously accepted for %s, allowing", hostname))
 				wv.allowCertificateAndReload(certificate, hostname, failingUri)
 				return true // Signal handled
 			} else {
-				log.Printf("[tls] Certificate previously rejected for %s, blocking", hostname)
+				logging.Debug(fmt.Sprintf("[tls] Certificate previously rejected for %s, blocking", hostname))
 				return false // Let WebKit show error
 			}
 		}
 		// No stored decision - show dialog to user
-		log.Printf("[tls] No stored decision for %s, showing dialog", hostname)
+		logging.Debug(fmt.Sprintf("[tls] No stored decision for %s, showing dialog", hostname))
 		wv.showTLSErrorDialog(failingUri, hostname, certificate, errors)
 		return true // Signal handled - we're managing the error
 func checkStoredCertificateDecision(hostname string) (string, bool) {
 	cfg := config.Get()
 	if cfg == nil {
-		log.Printf("[tls] Config not available, cannot check stored decisions")
+		logging.Error(fmt.Sprintf("[tls] Config not available, cannot check stored decisions"))
 		return "", false
 	}
 	dbPath := cfg.Database.Path
 	if dbPath == "" {
-		log.Printf("[tls] Database path not configured")
+		logging.Error(fmt.Sprintf("[tls] Database path not configured"))
 		return "", false
 	}
 	database, err := sql.Open("sqlite3", dbPath)
 	if err != nil {
-		log.Printf("[tls] Failed to open database: %v", err)
+		logging.Error(fmt.Sprintf("[tls] Failed to open database: %v", err))
 		return "", false
 	}
 	defer func() {
 		if err := database.Close(); err != nil {
-			log.Printf("[tls] warning: failed to close database: %v", err)
+			logging.Warn(fmt.Sprintf("[tls] warning: failed to close database: %v", err))
 		}
 	}()
 		if errors.Is(err, sql.ErrNoRows) {
 			return "", false
 		}
-		log.Printf("[tls] Error checking certificate validation: %v", err)
+		logging.Error(fmt.Sprintf("[tls] Error checking certificate validation: %v", err))
 		return "", false
 	}
 	}
 	defer func() {
 		if err := database.Close(); err != nil {
-			log.Printf("[tls] warning: failed to close database: %v", err)
+			logging.Warn(fmt.Sprintf("[tls] warning: failed to close database: %v", err))
 		}
 	}()
 	queries := db.New(database)
 	ctx := context.Background()
-	log.Printf("[tls] Saving certificate decision to database: hostname=%s, decision=%s, expiresAt=%v",
+	logging.Debug(fmt.Sprintf("[tls] Saving certificate decision to database: hostname=%s, decision=%s, expiresAt=%v",
-		hostname, decision, expiresAt)
+		hostname, decision, expiresAt))
 	// Use empty string for cert hash since we're doing hostname-only matching
 	if err := queries.StoreCertificateValidation(ctx, hostname, "", decision, expiresAt); err != nil {
-		log.Printf("[tls] Failed to save certificate decision to database: %v", err)
+		logging.Error(fmt.Sprintf("[tls] Failed to save certificate decision to database: %v", err))
 		return err
 	}
-	log.Printf("[tls] Certificate decision saved successfully in database")
+	logging.Debug(fmt.Sprintf("[tls] Certificate decision saved successfully in database"))
 	return nil
 }
 		// Create AlertDialog using CGO wrapper
 		dialog := newAlertDialog(fmt.Sprintf("Certificate Error for %s", hostname))
 		if dialog == nil {
-			log.Printf("[tls] Failed to create alert dialog")
+			logging.Error(fmt.Sprintf("[tls] Failed to create alert dialog"))
 			return
 		}
 		dialog.Choose(context.Background(), parentWindow, func(result gio.AsyncResulter) {
 			buttonIndex, err := dialog.ChooseFinish(result)
 			if err != nil {
-				log.Printf("[tls] Dialog error: %v", err)
+				logging.Error(fmt.Sprintf("[tls] Dialog error: %v", err))
 				return
 			}
-			log.Printf("[tls] User chose button %d for %s", buttonIndex, hostname)
+			logging.Debug(fmt.Sprintf("[tls] User chose button %d for %s", buttonIndex, hostname))
 			switch buttonIndex {
 			case 0: // Go Back
-				log.Printf("[tls] User chose to go back")
+				logging.Debug(fmt.Sprintf("[tls] User chose to go back"))
 				// Do nothing - let the load fail
 			case 1: // Proceed Once
-				log.Printf("[tls] User chose to proceed once")
+				logging.Debug(fmt.Sprintf("[tls] User chose to proceed once"))
 				wv.allowCertificateAndReload(certificate, hostname, failingUri)
 			case 2: // Always Accept This Site
-				log.Printf("[tls] User chose to always accept for %s", hostname)
+				logging.Debug(fmt.Sprintf("[tls] User chose to always accept for %s", hostname))
 				// Store decision in database (expires in 30 days)
 				expiresAt := sql.NullTime{
 					Time:  time.Now().Add(30 * 24 * time.Hour),
 					Valid: true,
 				}
 				if err := storeCertificateDecision(hostname, "accepted", expiresAt); err != nil {
-					log.Printf("[tls] Failed to store certificate decision: %v", err)
+					logging.Error(fmt.Sprintf("[tls] Failed to store certificate decision: %v", err))
 				} else {
-					log.Printf("[tls] Stored certificate acceptance for %s (expires in 30 days)", hostname)
+					logging.Debug(fmt.Sprintf("[tls] Stored certificate acceptance for %s (expires in 30 days)", hostname))
 				}
 				wv.allowCertificateAndReload(certificate, hostname, failingUri)
 			}
 		// Get the network session
 		session := wv.view.NetworkSession()
 		if session == nil {
-			log.Printf("[tls] Failed to get network session")
+			logging.Error(fmt.Sprintf("[tls] Failed to get network session"))
 			return
 		}
 		// Allow the certificate for this host
 		session.AllowTLSCertificateForHost(certificate, hostname)
-		log.Printf("[tls] Certificate exception added for host: %s", hostname)
+		logging.Debug(fmt.Sprintf("[tls] Certificate exception added for host: %s", hostname))
 		// Reload the page
 		wv.view.LoadURI(uri)
-		log.Printf("[tls] Reloading %s with certificate exception", uri)
+		logging.Debug(fmt.Sprintf("[tls] Reloading %s with certificate exception", uri))
 	})
 }
 	}
 	defer func() {
 		if err := database.Close(); err != nil {
-			log.Printf("[tls] warning: failed to close database: %v", err)
+			logging.Warn(fmt.Sprintf("[tls] warning: failed to close database: %v", err))
 		}
 	}()
 		return fmt.Errorf("failed to delete expired validations: %w", err)
 	}
-	log.Printf("[tls] Cleaned up expired certificate validations")
+	logging.Debug(fmt.Sprintf("[tls] Cleaned up expired certificate validations"))
 	return nil
 }

M pkg/webkit/touchpad_gestures.go +10 -9

 package webkit
 import (
-	"log"
+	"fmt"
 	"math"
+	"github.com/bnema/dumber/internal/logging"
 	"github.com/diamondburned/gotk4/pkg/gtk/v4"
 )
 // This enables two-finger swipe navigation (left/right for back/forward)
 func (w *WebView) AttachTouchpadGestures() {
 	if w.view == nil {
-		log.Printf("[touchpad-gestures] Cannot attach: WebView is nil")
+		logging.Error(fmt.Sprintf("[touchpad-gestures] Cannot attach: WebView is nil"))
 		return
 	}
 		// Require horizontal velocity to be dominant
 		if absVelocityY > absVelocityX {
-			log.Printf("[touchpad-gestures] Swipe is more vertical (X:%.1f Y:%.1f), ignoring", velocityX, velocityY)
+			logging.Debug(fmt.Sprintf("[touchpad-gestures] Swipe is more vertical (X:%.1f Y:%.1f), ignoring", velocityX, velocityY))
 			return
 		}
 		// Check if swipe velocity meets threshold
 		if absVelocityX < swipeVelocityThreshold {
-			log.Printf("[touchpad-gestures] Swipe velocity too low (%.1f < %.1f), ignoring", absVelocityX, swipeVelocityThreshold)
+			logging.Debug(fmt.Sprintf("[touchpad-gestures] Swipe velocity too low (%.1f < %.1f), ignoring", absVelocityX, swipeVelocityThreshold))
 			return
 		}
 		if velocityX > 0 {
 			// Swipe right (positive velocity) - go back
 			if w.view.CanGoBack() {
-				log.Printf("[touchpad-gestures] Swipe right detected (velocity: %.1f) - navigating backward", velocityX)
+				logging.Debug(fmt.Sprintf("[touchpad-gestures] Swipe right detected (velocity: %.1f) - navigating backward", velocityX))
 				w.view.GoBack()
 			} else {
-				log.Printf("[touchpad-gestures] Swipe right detected but cannot go back")
+				logging.Debug(fmt.Sprintf("[touchpad-gestures] Swipe right detected but cannot go back"))
 			}
 		} else {
 			// Swipe left (negative velocity) - go forward
 			if w.view.CanGoForward() {
-				log.Printf("[touchpad-gestures] Swipe left detected (velocity: %.1f) - navigating forward", velocityX)
+				logging.Debug(fmt.Sprintf("[touchpad-gestures] Swipe left detected (velocity: %.1f) - navigating forward", velocityX))
 				w.view.GoForward()
 			} else {
-				log.Printf("[touchpad-gestures] Swipe left detected but cannot go forward")
+				logging.Debug(fmt.Sprintf("[touchpad-gestures] Swipe left detected but cannot go forward"))
 			}
 		}
 	})
 	// Attach controller to WebView
 	w.view.AddController(gestureSwipe)
-	log.Printf("[touchpad-gestures] Touchpad gesture controller attached to WebView ID %d", w.id)
+	logging.Debug(fmt.Sprintf("[touchpad-gestures] Touchpad gesture controller attached to WebView ID %d", w.id))
 }

M pkg/webkit/types.go +7 -7


@@ -70,13 +70,13 @@ type Config struct {
70		// GetDefaultConfig returns a Config with sensible defaults	70		// GetDefaultConfig returns a Config with sensible defaults
71		func GetDefaultConfig() *Config {	71		func GetDefaultConfig() *Config {
72		return &Config{	72		return &Config{
73	-	UserAgent: "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Safari/605.1.15", // WebKitGTK default (same as Epiphany)	73	+	UserAgent: "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Safari/605.1.15", // WebKitGTK default (same as Epiphany)
74	-	EnableJavaScript: true,	74	+	EnableJavaScript: true,
75	-	EnableWebGL: true,	75	+	EnableWebGL: true,
76	-	EnableMediaStream: true,	76	+	EnableMediaStream: true,
77	-	HardwareAcceleration: true,	77	+	HardwareAcceleration: true,
78	-	DefaultFontSize: 16,	78	+	DefaultFontSize: 16,
79	-	MinimumFontSize: 8,	79	+	MinimumFontSize: 8,
80		EnablePageCache: true, // Instant back/forward navigation	80		EnablePageCache: true, // Instant back/forward navigation
81		EnableSmoothScrolling: true, // Better UX	81		EnableSmoothScrolling: true, // Better UX
82		CreateWindow: true, // Default to standalone window	82		CreateWindow: true, // Default to standalone window

M pkg/webkit/uri_scheme.go +3 -3

 import (
 	"fmt"
-	"log"
+	"github.com/bnema/dumber/internal/logging"
 	webkit "github.com/diamondburned/gotk4-webkitgtk/pkg/webkit/v6"
 )
 // In WebKitGTK 6.0, this must be called BEFORE creating any WebViews
 // The actual registration happens in InitPersistentSession
 func RegisterURIScheme(scheme string, callback URISchemeRequestCallback) {
-	log.Printf("[webkit] Registering URI scheme handler for: %s", scheme)
+	logging.Debug(fmt.Sprintf("[webkit] Registering URI scheme handler for: %s", scheme))
 	pendingURISchemeHandlers = append(pendingURISchemeHandlers, &URISchemeHandler{
 		scheme:   scheme,
 		callback: callback,
 	}
 	for _, handler := range pendingURISchemeHandlers {
-		log.Printf("[webkit] Registering URI scheme on WebContext: %s", handler.scheme)
+		logging.Debug(fmt.Sprintf("[webkit] Registering URI scheme on WebContext: %s", handler.scheme))
 		// Capture handler in closure
 		callback := handler.callback

M pkg/webkit/user_content.go +14 -14

 import (
 	"fmt"
-	"log"
 	"github.com/bnema/dumber/assets"
 	"github.com/bnema/dumber/internal/config"
+	"github.com/bnema/dumber/internal/logging"
 	webkit "github.com/diamondburned/gotk4-webkitgtk/pkg/webkit/v6"
 )
 	// Get the UserContentManager from the WebView
 	ucm := view.UserContentManager()
 	if ucm == nil {
-		log.Printf("[webkit] UserContentManager is nil, skipping script injection")
+		logging.Warn(fmt.Sprintf("[webkit] UserContentManager is nil, skipping script injection"))
 		return nil
 	}
 		nil,
 		nil,
 	))
-	log.Printf("[webkit] Injected webview ID script for ID: %d (main + isolated world)", webviewID)
+	logging.Debug(fmt.Sprintf("[webkit] Injected webview ID script for ID: %d (main + isolated world)", webviewID))
 	// Inject GTK theme detection in BOTH worlds
 	// The color-scheme.ts expects window.__dumber_gtk_prefers_dark to be set
 	switch cfg.Appearance.ColorScheme {
 	case "prefer-dark":
 		prefersDark = true
-		log.Printf("[webkit] Using config-forced dark theme (color_scheme: prefer-dark)")
+		logging.Debug(fmt.Sprintf("[webkit] Using config-forced dark theme (color_scheme: prefer-dark)"))
 	case "prefer-light":
 		prefersDark = false
-		log.Printf("[webkit] Using config-forced light theme (color_scheme: prefer-light)")
+		logging.Debug(fmt.Sprintf("[webkit] Using config-forced light theme (color_scheme: prefer-light)"))
 	default:
 		// "default" or empty - follow system GTK preference
 		prefersDark = PrefersDarkTheme()
-		log.Printf("[webkit] Using system GTK theme preference (color_scheme: %s)", cfg.Appearance.ColorScheme)
+		logging.Debug(fmt.Sprintf("[webkit] Using system GTK theme preference (color_scheme: %s)", cfg.Appearance.ColorScheme))
 	}
 	gtkThemeScript := fmt.Sprintf(`window.__dumber_gtk_prefers_dark = %t;`, prefersDark)
 		nil,
 		nil,
 	))
-	log.Printf("[webkit] Injected theme preference: prefersDark=%t (main + isolated world)", prefersDark)
+	logging.Debug(fmt.Sprintf("[webkit] Injected theme preference: prefersDark=%t (main + isolated world)", prefersDark))
 	// Inject palette config in BOTH worlds
 	// The GUI expects window.__dumber_palette = { "light": {...}, "dark": {...} }
 			nil,
 			nil,
 		))
-		log.Printf("[webkit] Injected palette config (%d bytes, main + isolated world)", len(paletteScript))
+		logging.Debug(fmt.Sprintf("[webkit] Injected palette config (%d bytes, main + isolated world)", len(paletteScript)))
 	}
 	// Inject color-scheme script in BOTH worlds
 			nil,
 			nil,
 		))
-		log.Printf("[webkit] Injected color-scheme script (%d bytes, main + isolated world)", len(assets.ColorSchemeScript))
+		logging.Debug(fmt.Sprintf("[webkit] Injected color-scheme script (%d bytes, main + isolated world)", len(assets.ColorSchemeScript)))
 	}
 	// Inject main-world script in MAIN world
 			nil,
 			nil,
 		))
-		log.Printf("[webkit] Injected main-world script (%d bytes, main world)", len(assets.MainWorldScript))
+		logging.Debug(fmt.Sprintf("[webkit] Injected main-world script (%d bytes, main world)", len(assets.MainWorldScript)))
 	}
 	// Inject GUI controls script in ISOLATED world at document-start
 			nil,
 			nil,
 		))
-		log.Printf("[webkit] Injected GUI controls script (%d bytes, isolated world, document-start)", len(assets.GUIScript))
+		logging.Debug(fmt.Sprintf("[webkit] Injected GUI controls script (%d bytes, isolated world, document-start)", len(assets.GUIScript)))
 	}
 	// Inject component CSS styles as a JavaScript variable in ISOLATED world at document-start
 			nil,
 			nil,
 		))
-		log.Printf("[webkit] Injected component styles string (%d bytes, isolated world, document-start)", len(assets.ComponentStyles))
+		logging.Debug(fmt.Sprintf("[webkit] Injected component styles string (%d bytes, isolated world, document-start)", len(assets.ComponentStyles)))
 	}
 	// Register script message handler "dumber" in the MAIN world
 	// Isolated world GUI scripts dispatch CustomEvents to main world, which forwards to this handler
 	// This architecture is required because webkit.messageHandlers is only available in main world
 	if !ucm.RegisterScriptMessageHandler("dumber", "") {
-		log.Printf("[webkit] Warning: failed to register 'dumber' script message handler in main world")
+		logging.Warn(fmt.Sprintf("[webkit] Warning: failed to register 'dumber' script message handler in main world"))
 	} else {
-		log.Printf("[webkit] Registered 'dumber' script message handler in main world (default)")
+		logging.Debug(fmt.Sprintf("[webkit] Registered 'dumber' script message handler in main world (default)"))
 	}
 	return nil

M pkg/webkit/webview.go +21 -21

 import (
 	"encoding/json"
 	"fmt"
-	"log"
 	"strconv"
 	"sync"
 	"sync/atomic"
+	"github.com/bnema/dumber/internal/logging"
 	webkit "github.com/diamondburned/gotk4-webkitgtk/pkg/webkit/v6"
 	"github.com/diamondburned/gotk4/pkg/gdk/v4"
 	"github.com/diamondburned/gotk4/pkg/gtk/v4"
 	// Generate unique ID immediately
 	id := atomic.AddUint64(&viewIDCounter, 1)
-	log.Printf("[webkit] Generated WebView ID: %d (CreateWindow=%v)", id, cfg.CreateWindow)
+	logging.Debug(fmt.Sprintf("[webkit] Generated WebView ID: %d (CreateWindow=%v)", id, cfg.CreateWindow))
 	InitMainThread()
 		wv.window = window
 		// Add container as child of window
 		window.SetChild(container)
-		log.Printf("[webkit] Created standalone window for WebView ID %d", id)
+		logging.Debug(fmt.Sprintf("[webkit] Created standalone window for WebView ID %d", id))
 	} else {
-		log.Printf("[webkit] Created WebView ID %d without window (for workspace embedding)", id)
+		logging.Debug(fmt.Sprintf("[webkit] Created WebView ID %d without window (for workspace embedding)", id))
 	}
 	// Register in global registry
 	// Create signal - for popup lifecycle management
 	w.view.ConnectCreate(func(navigationAction *webkit.NavigationAction) gtk.Widgetter {
-		log.Printf("[webkit] ConnectCreate callback fired for parent WebView ID=%d", w.id)
+		logging.Debug(fmt.Sprintf("[webkit] ConnectCreate callback fired for parent WebView ID=%d", w.id))
 		if w.onPopupCreate != nil {
-			log.Printf("[webkit] Calling onPopupCreate handler")
+			logging.Debug(fmt.Sprintf("[webkit] Calling onPopupCreate handler"))
 			newWebView := w.onPopupCreate(navigationAction)
 			if newWebView != nil {
-				log.Printf("[webkit] onPopupCreate returned WebView wrapper ID=%d", newWebView.id)
+				logging.Debug(fmt.Sprintf("[webkit] onPopupCreate returned WebView wrapper ID=%d", newWebView.id))
-				log.Printf("[webkit] Extracting underlying gotk4 WebView from wrapper")
+				logging.Debug(fmt.Sprintf("[webkit] Extracting underlying gotk4 WebView from wrapper"))
 				underlyingView := newWebView.view
-				log.Printf("[webkit] Extracted gotk4 WebView=%p, about to return to WebKit", underlyingView)
+				logging.Debug(fmt.Sprintf("[webkit] Extracted gotk4 WebView=%p, about to return to WebKit", underlyingView))
 				// Return the underlying WebView widget to WebKit
 				return underlyingView
 			}
-			log.Printf("[webkit] onPopupCreate returned nil, blocking popup")
+			logging.Debug(fmt.Sprintf("[webkit] onPopupCreate returned nil, blocking popup"))
 		}
 		// Return nil to cancel popup creation
-		log.Printf("[webkit] No onPopupCreate handler, blocking popup")
+		logging.Debug(fmt.Sprintf("[webkit] No onPopupCreate handler, blocking popup"))
 		return nil
 	})
 		if isCtrlClick {
 			clickType = "Ctrl+click"
 		}
-		log.Printf("[navigation-policy] Detected %s on link: %s", clickType, linkURL)
+		logging.Debug(fmt.Sprintf("[navigation-policy] Detected %s on link: %s", clickType, linkURL))
 		// Call the registered handler
 		w.mu.RLock()
 		if handler != nil {
 			handled := handler(linkURL)
 			if handled {
-				log.Printf("[navigation-policy] %s handled by workspace, blocking navigation", clickType)
+				logging.Debug(fmt.Sprintf("[navigation-policy] %s handled by workspace, blocking navigation", clickType))
 				// Block the navigation by calling Ignore()
 				navDecision.Ignore()
 				return true // Prevent default behavior
 		return false // Let WebKit handle if not handled
 	})
-	log.Printf("[webkit] Navigation policy handler attached to WebView ID %d", w.id)
+	logging.Debug(fmt.Sprintf("[webkit] Navigation policy handler attached to WebView ID %d", w.id))
 }
 // LoadURL loads the given URL in the WebView
 		return fmt.Errorf("failed to marshal event data: %w", err)
 	}
-	log.Printf("[webkit] Dispatching event '%s' to WebView ID %d with data: %s", eventName, w.id, string(jsonData))
+	logging.Debug(fmt.Sprintf("[webkit] Dispatching event '%s' to WebView ID %d with data: %s", eventName, w.id, string(jsonData)))
 	// Use document.dispatchEvent (not window) so events cross JavaScript world boundaries
 	// The GUI scripts run in an isolated world but share the same Document object
 	// Note: Content filtering is handled via InitializeContentBlocking()
 	// This method is kept for backward compatibility but is deprecated
-	log.Printf("[webkit] UpdateContentFilters called but is deprecated - use InitializeContentBlocking instead")
+	logging.Warn(fmt.Sprintf("[webkit] UpdateContentFilters called but is deprecated - use InitializeContentBlocking instead"))
 	return nil
 }
 	// Get the NetworkSession from the WebView
 	session := w.view.NetworkSession()
 	if session == nil {
-		log.Printf("[webkit] Warning: No NetworkSession available for favicon handling")
+		logging.Warn(fmt.Sprintf("[webkit] Warning: No NetworkSession available for favicon handling"))
 		return
 	}
 	// Get the WebsiteDataManager from the NetworkSession
 	dataManager := session.WebsiteDataManager()
 	if dataManager == nil {
-		log.Printf("[webkit] Warning: No WebsiteDataManager available for favicon handling")
+		logging.Warn(fmt.Sprintf("[webkit] Warning: No WebsiteDataManager available for favicon handling"))
 		return
 	}
 	// Enable favicons if not already enabled
 	if !dataManager.FaviconsEnabled() {
 		dataManager.SetFaviconsEnabled(true)
-		log.Printf("[webkit] Enabled favicons for WebView ID %d", w.id)
+		logging.Debug(fmt.Sprintf("[webkit] Enabled favicons for WebView ID %d", w.id))
 	}
 }
 	// Generate unique ID
 	id := atomic.AddUint64(&viewIDCounter, 1)
-	log.Printf("[webkit] Created minimal wrapper for bare WebView (ID: %d)", id)
+	logging.Debug(fmt.Sprintf("[webkit] Created minimal wrapper for bare WebView (ID: %d)", id))
 	// Create minimal wrapper - NO initialization yet
 	wv := &WebView{
 	// Attach touchpad gesture controls
 	w.AttachTouchpadGestures()
-	log.Printf("[webkit] Completed initialization for WebView ID %d", w.id)
+	logging.Debug(fmt.Sprintf("[webkit] Completed initialization for WebView ID %d", w.id))
 	return nil
 }

M pkg/webkit/webview_related.go +18 -17

 */
 import "C"
 import (
-	"log"
+	"fmt"
 	"runtime"
 	"unsafe"
+	"github.com/bnema/dumber/internal/logging"
 	webkit "github.com/diamondburned/gotk4-webkitgtk/pkg/webkit/v6"
 	coreglib "github.com/diamondburned/gotk4/pkg/core/glib"
 	"github.com/diamondburned/gotk4/pkg/glib/v2"
 // we manually construct the WebView struct hierarchy using CGO.
 func NewBareRelatedWebView(parentView *webkit.WebView) *webkit.WebView {
 	if parentView == nil {
-		log.Printf("[webkit] NewBareRelatedWebView: parent is nil, creating unrelated WebView")
+		logging.Warn(fmt.Sprintf("[webkit] NewBareRelatedWebView: parent is nil, creating unrelated WebView"))
 		return webkit.NewWebView()
 	}
 	// Get the native C pointer from the gotk4 WebView
 	parentObj := glib.BaseObject(parentView)
 	if parentObj == nil {
-		log.Printf("[webkit] NewBareRelatedWebView: failed to get parent object, creating unrelated WebView")
+		logging.Error(fmt.Sprintf("[webkit] NewBareRelatedWebView: failed to get parent object, creating unrelated WebView"))
 		return webkit.NewWebView()
 	}
 	parentNative := (*C.WebKitWebView)(unsafe.Pointer(parentObj.Native()))
 	if parentNative == nil {
-		log.Printf("[webkit] NewBareRelatedWebView: parent native pointer is nil, creating unrelated WebView")
+		logging.Error(fmt.Sprintf("[webkit] NewBareRelatedWebView: parent native pointer is nil, creating unrelated WebView"))
 		return webkit.NewWebView()
 	}
-	log.Printf("[webkit] Creating bare WebView with related-view property (parent=%p)", parentNative)
+	logging.Debug(fmt.Sprintf("[webkit] Creating bare WebView with related-view property (parent=%p)", parentNative))
 	// Create related WebView using CGO helper with g_object_new
-	log.Printf("[webkit] Step 3: About to call C.create_related_web_view")
+	logging.Debug(fmt.Sprintf("[webkit] Step 3: About to call C.create_related_web_view"))
 	webViewNative := C.create_related_web_view(parentNative)
-	log.Printf("[webkit] Step 4: C.create_related_web_view returned: %p", webViewNative)
+	logging.Debug(fmt.Sprintf("[webkit] Step 4: C.create_related_web_view returned: %p", webViewNative))
 	if webViewNative == nil {
-		log.Printf("[webkit] NewBareRelatedWebView: C.create_related_web_view returned nil")
+		logging.Error(fmt.Sprintf("[webkit] NewBareRelatedWebView: C.create_related_web_view returned nil"))
 		return nil
 	}
 	// Wrap the C object in a coreglib.Object
 	// This takes ownership of the floating reference
-	log.Printf("[webkit] Step 5: About to call coreglib.Take")
+	logging.Debug(fmt.Sprintf("[webkit] Step 5: About to call coreglib.Take"))
 	obj := coreglib.Take(unsafe.Pointer(webViewNative))
-	log.Printf("[webkit] Step 6: coreglib.Take succeeded, obj=%p", obj)
+	logging.Debug(fmt.Sprintf("[webkit] Step 6: coreglib.Take succeeded, obj=%p", obj))
 	// Manually construct the WebView struct hierarchy
 	// WebView -> WebViewBase -> gtk.Widget -> coreglib.InitiallyUnowned -> coreglib.Object
 	// manually construct the full struct hierarchy using the same pattern
 	// that gotk4 uses internally.
-	log.Printf("[webkit] Step 7: About to create gtk.Widget base")
+	logging.Debug(fmt.Sprintf("[webkit] Step 7: About to create gtk.Widget base"))
 	// Create the gtk.Widget base
 	widget := gtk.Widget{
 		InitiallyUnowned: coreglib.InitiallyUnowned{
 			Object: obj,
 		},
 	}
-	log.Printf("[webkit] Step 8: Created gtk.Widget base")
+	logging.Debug(fmt.Sprintf("[webkit] Step 8: Created gtk.Widget base"))
 	// Create the WebViewBase
-	log.Printf("[webkit] Step 9: About to create WebViewBase")
+	logging.Debug(fmt.Sprintf("[webkit] Step 9: About to create WebViewBase"))
 	webViewBase := webkit.WebViewBase{
 		Widget: widget,
 	}
-	log.Printf("[webkit] Step 10: Created WebViewBase")
+	logging.Debug(fmt.Sprintf("[webkit] Step 10: Created WebViewBase"))
 	// Create the final WebView
-	log.Printf("[webkit] Step 11: About to create final WebView")
+	logging.Debug(fmt.Sprintf("[webkit] Step 11: About to create final WebView"))
 	relatedView := &webkit.WebView{
 		WebViewBase: webViewBase,
 	}
-	log.Printf("[webkit] Step 12: Created final WebView: %p", relatedView)
+	logging.Debug(fmt.Sprintf("[webkit] Step 12: Created final WebView: %p", relatedView))
 	// Ensure parentView is kept alive until after the CGO call completes
 	runtime.KeepAlive(parentView)
-	log.Printf("[webkit] Created bare related WebView (parent=%p)", parentNative)
+	logging.Debug(fmt.Sprintf("[webkit] Created bare related WebView (parent=%p)", parentNative))
 	return relatedView
 }

M pkg/webkit/window.go +3 -2

 package webkit
 import (
-	"log"
+	"fmt"
+	"github.com/bnema/dumber/internal/logging"
 	"github.com/diamondburned/gotk4/pkg/gtk/v4"
 )
 	// Connect close-request signal to handle Cmd+Q and window close button
 	// Returning true prevents the default close behavior and allows graceful shutdown
 	win.ConnectCloseRequest(func() bool {
-		log.Printf("[window] Close request received (Cmd+Q or close button) - initiating graceful shutdown")
+		logging.Info(fmt.Sprintf("[window] Close request received (Cmd+Q or close button) - initiating graceful shutdown"))
 		// Quit the main loop gracefully, which will trigger cleanup
 		QuitMainLoop()
 		// Return true to prevent GTK from destroying the window immediately