0bdd398 chore(lint): address linting warnings · dumber

M .golangci.yml +56 -17

     - goconst
     - gocritic
     - gocyclo
-    - godox
+    # - godox # TODOs/FIXMEs are intentional markers
     - mnd
     - goprintffuncname
     - gosec
   settings:
     dupl:
-      threshold: 100
+      threshold: 150
     funlen:
       lines: -1
       statements: 50
         - ifElseChain
         - octalLiteral
         - whyNoLint
+        - unnamedResult
+        - hugeParam
+        - singleCaseSwitch
     gocyclo:
-      min-complexity: 15
+      min-complexity: 20
-    godox:
-      keywords:
-        - FIXME
-        - TODO
-        - BUG
     mnd:
       checks:
         - argument
         - '1'
         - '2'
         - '3'
+        - '4'
+        - '5'
+        - '10'
+        - '16'
+        - '32'
+        - '64'
+        - '100'
+        - '1000'
       ignored-functions:
         - strings.SplitN
+        - make
+        - time.Sleep
+        - time.Duration
+        - strconv.ParseInt
+        - strconv.ParseUint
+        - strconv.ParseFloat
     govet:
       enable:
         - nilness
     errorlint:
       asserts: false
     lll:
-      line-length: 120
+      line-length: 140
     misspell:
       locale: US
     nolintlint:
     paths:
       - vendor
     rules:
-      - text: "Error return value of `resp.Body.Close` is not checked"
+      # Test files get relaxed rules
-        linters:
-          - errcheck
-      - text: "Error return value of `os.Remove` is not checked"
-        linters:
-          - errcheck
       - path: _test\.go
         linters:
           - dupl
           - mnd
           - lll
           - funlen
+          - goconst
+          - errcheck
+          - gosec
+      # Generated SQL code
       - path: internal/db/.*\.sql\.go
         linters:
           - all
       - path: internal/db/models\.go
         linters:
           - unused
-      - path: internal/db/
+      # gosec false positives
+      - text: "G115:"
         linters:
-          - lll
+          - gosec
+      - text: "G404:"
+        linters:
+          - gosec
+      - text: "G301:"
+        linters:
+          - gosec
+      - text: "G302:"
+        linters:
+          - gosec
+      - text: "G306:"
+        linters:
+          - gosec
+      - text: "G204:"
+        linters:
+          - gosec
+      - text: "G304:"
+        linters:
+          - gosec
+      # GTK callbacks require unused parameters
+      - path: internal/ui/
+        text: "unused-parameter"
+        linters:
+          - revive
+      - path: internal/ui/
+        text: "unused-receiver"
+        linters:
+          - revive
 run:
   timeout: 20m

M assets/webui_embed.go +0 -1


@@ -2,7 +2,6 @@ package assets
2			2
3		import (	3	import (
4		"embed"	4	"embed"
5	-	_ "embed"
6		)	5	)
7			6
8		// WebUIAssets contains the embedded webui build output (homepage, error, and config pages).	7	// WebUIAssets contains the embedded webui build output (homepage, error, and config pages).

M cmd/dumber/main.go +178 -145


@@ -2,15 +2,18 @@ package main
2			2
3		import (	3		import (
4		"context"	4		"context"
			5	+	"database/sql"
5		"fmt"	6		"fmt"
6		"os"	7		"os"
7		"path/filepath"	8		"path/filepath"
8		"runtime"	9		"runtime"
9			10
10	-	"github.com/bnema/dumber/assets"	11	+	"github.com/bnema/dumber/internal/application/port"
11		"github.com/bnema/dumber/internal/application/usecase"	12		"github.com/bnema/dumber/internal/application/usecase"
			13	+	"github.com/bnema/dumber/internal/bootstrap"
12		"github.com/bnema/dumber/internal/cli/cmd"	14		"github.com/bnema/dumber/internal/cli/cmd"
13		"github.com/bnema/dumber/internal/domain/build"	15		"github.com/bnema/dumber/internal/domain/build"
			16	+	"github.com/bnema/dumber/internal/domain/repository"
14		"github.com/bnema/dumber/internal/infrastructure/clipboard"	17		"github.com/bnema/dumber/internal/infrastructure/clipboard"
15		"github.com/bnema/dumber/internal/infrastructure/config"	18		"github.com/bnema/dumber/internal/infrastructure/config"
16		"github.com/bnema/dumber/internal/infrastructure/deps"	19		"github.com/bnema/dumber/internal/infrastructure/deps"

@@ -22,6 +25,7 @@ import (
22		"github.com/bnema/dumber/internal/logging"	25		"github.com/bnema/dumber/internal/logging"
23		"github.com/bnema/dumber/internal/ui"	26		"github.com/bnema/dumber/internal/ui"
24		"github.com/bnema/dumber/internal/ui/theme"	27		"github.com/bnema/dumber/internal/ui/theme"
			28	+	"github.com/rs/zerolog"
25		)	29		)
26			30
27		// Build-time variables (set via ldflags)	31		// Build-time variables (set via ldflags)

@@ -43,7 +47,7 @@ func main() {
43		}	47		}
44		// Strip "browse" and URL from args so GTK doesn't see them	48		// Strip "browse" and URL from args so GTK doesn't see them
45		os.Args = os.Args[:1]	49		os.Args = os.Args[:1]
46	-	runGUI()	50	+	os.Exit(runGUI())
47		return	51		return
48		}	52		}
49			53

@@ -59,17 +63,11 @@ func main() {
59		cmd.Execute()	63		cmd.Execute()
60		}	64		}
61			65
62	-	func runGUI() {	66	+	func runGUI() int {
63		// GTK requires all GTK calls to be made from the main thread	67		// GTK requires all GTK calls to be made from the main thread
64		runtime.LockOSThread()	68		runtime.LockOSThread()
65			69
66	-	// Initialize configuration	70	+	cfg := initConfig()
67	-	if err := config.Init(); err != nil {
68	-	fmt.Fprintf(os.Stderr, "Failed to initialize configuration: %v\n", err)
69	-	os.Exit(1)
70	-	}
71	-
72	-	cfg := config.Get()
73			71
74		// Apply optional /opt-style runtime prefix overrides (if configured)	72		// Apply optional /opt-style runtime prefix overrides (if configured)
75		deps.ApplyPrefixEnv(cfg.Runtime.Prefix)	73		deps.ApplyPrefixEnv(cfg.Runtime.Prefix)

@@ -77,7 +75,101 @@ func runGUI() {
77		// Generate session ID for this browser run	75		// Generate session ID for this browser run
78		sessionID := logging.GenerateSessionID()	76		sessionID := logging.GenerateSessionID()
79			77
80	-	// Initialize logger with session file output	78	+	logger, logCleanup := initLogger(cfg, sessionID)
			79	+	if logCleanup != nil {
			80	+	defer logCleanup()
			81	+	}
			82	+
			83	+	logger.Info().
			84	+	Str("version", version).
			85	+	Str("commit", commit).
			86	+	Str("build_date", buildDate).
			87	+	Msg("starting dumber")
			88	+
			89	+	// Create root context with logger
			90	+	ctx := logging.WithContext(context.Background(), logger)
			91	+
			92	+	checkRuntimeRequirements(ctx, cfg, logger)
			93	+
			94	+	checkMediaRequirements(ctx, cfg, logger)
			95	+
			96	+	dataDir, cacheDir := resolveWebKitDirs(logger)
			97	+
			98	+	db, dbCleanup := openDatabase(ctx, logger, dataDir)
			99	+	if dbCleanup != nil {
			100	+	defer dbCleanup()
			101	+	}
			102	+
			103	+	// Create repositories
			104	+	historyRepo := sqlite.NewHistoryRepository(db)
			105	+	favoriteRepo := sqlite.NewFavoriteRepository(db)
			106	+	folderRepo := sqlite.NewFolderRepository(db)
			107	+	tagRepo := sqlite.NewTagRepository(db)
			108	+	zoomRepo := sqlite.NewZoomRepository(db)
			109	+
			110	+	// Theme management
			111	+	themeManager := theme.NewManager(ctx, cfg)
			112	+
			113	+	stack := bootstrap.BuildWebKitStack(ctx, cfg, dataDir, cacheDir, themeManager, logger)
			114	+
			115	+	// Create use cases
			116	+	const idAlphabetSize = 26
			117	+	idCounter := uint64(0)
			118	+	idGenerator := func() string {
			119	+	idCounter++
			120	+	return fmt.Sprintf("%c%d", 'a'+rune(idCounter%idAlphabetSize), idCounter/idAlphabetSize)
			121	+	}
			122	+	tabsUC := usecase.NewManageTabsUseCase(idGenerator)
			123	+	panesUC := usecase.NewManagePanesUseCase(idGenerator)
			124	+	historyUC := usecase.NewSearchHistoryUseCase(historyRepo)
			125	+	favoritesUC := usecase.NewManageFavoritesUseCase(favoriteRepo, folderRepo, tagRepo)
			126	+	zoomUC := usecase.NewManageZoomUseCase(zoomRepo, cfg.DefaultWebpageZoom)
			127	+	navigateUC := usecase.NewNavigateUseCase(historyRepo, zoomRepo, cfg.DefaultWebpageZoom)
			128	+	clipboardAdapter := clipboard.New()
			129	+	copyURLUC := usecase.NewCopyURLUseCase(clipboardAdapter)
			130	+
			131	+	// Create favicon service
			132	+	faviconCacheDir, _ := config.GetFaviconCacheDir()
			133	+	faviconService := favicon.NewService(faviconCacheDir)
			134	+
			135	+	uiDeps := buildUIDependencies(
			136	+	ctx,
			137	+	cfg,
			138	+	themeManager,
			139	+	stack.Context,
			140	+	stack.Pool,
			141	+	stack.Settings,
			142	+	stack.Injector,
			143	+	stack.MessageRouter,
			144	+	stack.FilterManager,
			145	+	historyRepo,
			146	+	favoriteRepo,
			147	+	zoomRepo,
			148	+	tabsUC,
			149	+	panesUC,
			150	+	historyUC,
			151	+	favoritesUC,
			152	+	zoomUC,
			153	+	navigateUC,
			154	+	copyURLUC,
			155	+	clipboardAdapter,
			156	+	faviconService,
			157	+	)
			158	+
			159	+	// Run the application
			160	+	exitCode := ui.RunWithArgs(ctx, uiDeps)
			161	+	return exitCode
			162	+	}
			163	+
			164	+	func initConfig() *config.Config {
			165	+	if err := config.Init(); err != nil {
			166	+	fmt.Fprintf(os.Stderr, "Failed to initialize configuration: %v\n", err)
			167	+	os.Exit(1)
			168	+	}
			169	+	return config.Get()
			170	+	}
			171	+
			172	+	func initLogger(cfg *config.Config, sessionID string) (zerolog.Logger, func()) {
81		logger, logCleanup, err := logging.NewWithFile(	173		logger, logCleanup, err := logging.NewWithFile(
82		logging.Config{	174		logging.Config{
83		Level: logging.ParseLevel(cfg.Logging.Level),	175		Level: logging.ParseLevel(cfg.Logging.Level),

@@ -92,23 +184,14 @@ func runGUI() {
92		},	184		},
93		)	185		)
94		if err != nil {	186		if err != nil {
95	-	// Fall back to stderr-only logger
96		logger = logging.NewFromConfigValues(cfg.Logging.Level, cfg.Logging.Format)	187		logger = logging.NewFromConfigValues(cfg.Logging.Level, cfg.Logging.Format)
97		fmt.Fprintf(os.Stderr, "Warning: failed to create session log file: %v\n", err)	188		fmt.Fprintf(os.Stderr, "Warning: failed to create session log file: %v\n", err)
98	-	} else {	189	+	return logger, nil
99	-	defer logCleanup()
100		}	190		}
			191	+	return logger, logCleanup
			192	+	}
101			193
102	-	logger.Info().	194	+	func checkRuntimeRequirements(ctx context.Context, cfg *config.Config, logger zerolog.Logger) {
103	-	Str("version", version).
104	-	Str("commit", commit).
105	-	Str("build_date", buildDate).
106	-	Msg("starting dumber")
107	-
108	-	// Create root context with logger
109	-	ctx := logging.WithContext(context.Background(), logger)
110	-
111	-	// Verify runtime requirements (GTK4/WebKitGTK) before creating any WebKit objects
112		probe := deps.NewPkgConfigProbe()	195		probe := deps.NewPkgConfigProbe()
113		checkRuntimeUC := usecase.NewCheckRuntimeDependenciesUseCase(probe)	196		checkRuntimeUC := usecase.NewCheckRuntimeDependenciesUseCase(probe)
114		runtimeOut, err := checkRuntimeUC.Execute(ctx, usecase.CheckRuntimeDependenciesInput{	197		runtimeOut, err := checkRuntimeUC.Execute(ctx, usecase.CheckRuntimeDependenciesInput{

@@ -117,37 +200,41 @@ func runGUI() {
117		if err != nil {	200		if err != nil {
118		logger.Fatal().Err(err).Msg("runtime requirements check failed")	201		logger.Fatal().Err(err).Msg("runtime requirements check failed")
119		}	202		}
120	-	if !runtimeOut.OK {	203	+	if runtimeOut.OK {
121	-	for _, c := range runtimeOut.Checks {	204	+	return
122	-	if c.Installed {	205	+	}
123	-	logger.Error().	206	+	for _, c := range runtimeOut.Checks {
124	-	Str("dependency", c.PkgConfigName).	207	+	if c.Installed {
125	-	Str("have", c.Version).	208	+	logger.Error().
126	-	Str("need", c.RequiredVersion).	209	+	Str("dependency", c.PkgConfigName).
127	-	Bool("ok", c.MeetsRequirement).	210	+	Str("have", c.Version).
128	-	Msg("runtime dependency")	211	+	Str("need", c.RequiredVersion).
129	-	} else {	212	+	Bool("ok", c.MeetsRequirement).
130	-	logger.Error().	213	+	Msg("runtime dependency")
131	-	Str("dependency", c.PkgConfigName).	214	+	} else {
132	-	Str("need", c.RequiredVersion).	215	+	logger.Error().
133	-	Msg("runtime dependency missing")	216	+	Str("dependency", c.PkgConfigName).
134	-	}	217	+	Str("need", c.RequiredVersion).
			218	+	Msg("runtime dependency missing")
135		}	219		}
136	-	logger.Fatal().
137	-	Str("hint", "Run: dumber doctor (and set runtime.prefix for /opt installs)").
138	-	Msg("runtime requirements not met")
139		}	220		}
			221	+	logger.Fatal().
			222	+	Str("hint", "Run: dumber doctor (and set runtime.prefix for /opt installs)").
			223	+	Msg("runtime requirements not met")
			224	+	}
140			225
141	-	// Check media playback requirements (GStreamer/VA-API)	226	+	func checkMediaRequirements(ctx context.Context, cfg *config.Config, logger zerolog.Logger) {
142		mediaDiagAdapter := media.New()	227		mediaDiagAdapter := media.New()
143		checkMediaUC := usecase.NewCheckMediaUseCase(mediaDiagAdapter)	228		checkMediaUC := usecase.NewCheckMediaUseCase(mediaDiagAdapter)
144	-	if _, err := checkMediaUC.Execute(ctx, usecase.CheckMediaInput{	229	+	if _, mediaErr := checkMediaUC.Execute(ctx, usecase.CheckMediaInput{
145		ShowDiagnostics: cfg.Media.ShowDiagnosticsOnStartup,	230		ShowDiagnostics: cfg.Media.ShowDiagnosticsOnStartup,
146	-	}); err != nil {	231	+	}); mediaErr != nil {
147	-	logger.Fatal().Err(err).Msg("media requirements check failed")	232	+	logger.Fatal().Err(mediaErr).Msg("media requirements check failed")
148		}	233		}
			234	+	}
149			235
150	-	// Resolve data/cache directories for WebKit	236	+	func resolveWebKitDirs(logger zerolog.Logger) (string, string) {
			237	+	const cacheDirPerm = 0o755
151		dataDir, err := config.GetDataDir()	238		dataDir, err := config.GetDataDir()
152		if err != nil {	239		if err != nil {
153		logger.Fatal().Err(err).Msg("failed to resolve data directory")	240		logger.Fatal().Err(err).Msg("failed to resolve data directory")

@@ -157,97 +244,50 @@ func runGUI() {
157		logger.Fatal().Err(err).Msg("failed to resolve state directory")	244		logger.Fatal().Err(err).Msg("failed to resolve state directory")
158		}	245		}
159		cacheDir := filepath.Join(stateDir, "webkit-cache")	246		cacheDir := filepath.Join(stateDir, "webkit-cache")
160	-	if mkErr := os.MkdirAll(cacheDir, 0o755); mkErr != nil {	247	+	if mkErr := os.MkdirAll(cacheDir, cacheDirPerm); mkErr != nil {
161		logger.Fatal().Err(mkErr).Str("path", cacheDir).Msg("failed to create cache directory")	248		logger.Fatal().Err(mkErr).Str("path", cacheDir).Msg("failed to create cache directory")
162		}	249		}
			250	+	return dataDir, cacheDir
			251	+	}
163			252
164	-	// Initialize SQLite database (in data dir per XDG spec - user data)	253	+	func openDatabase(ctx context.Context, logger zerolog.Logger, dataDir string) (*sql.DB, func()) {
165		dbPath := filepath.Join(dataDir, "dumber.db")	254		dbPath := filepath.Join(dataDir, "dumber.db")
166		db, err := sqlite.NewConnection(ctx, dbPath)	255		db, err := sqlite.NewConnection(ctx, dbPath)
167		if err != nil {	256		if err != nil {
168		logger.Fatal().Err(err).Str("path", dbPath).Msg("failed to initialize database")	257		logger.Fatal().Err(err).Str("path", dbPath).Msg("failed to initialize database")
169		}	258		}
170	-	defer sqlite.Close(db)	259	+	cleanup := func() {
171	-		260	+	if err := sqlite.Close(db); err != nil {
172	-	// Create repositories	261	+	logger.Error().Err(err).Msg("failed to close database")
173	-	historyRepo := sqlite.NewHistoryRepository(db)
174	-	favoriteRepo := sqlite.NewFavoriteRepository(db)
175	-	folderRepo := sqlite.NewFolderRepository(db)
176	-	tagRepo := sqlite.NewTagRepository(db)
177	-	zoomRepo := sqlite.NewZoomRepository(db)
178	-
179	-	// Theme management
180	-	themeManager := theme.NewManager(ctx, cfg)
181	-
182	-	// WebKit plumbing
183	-	wkCtx, err := webkit.NewWebKitContext(ctx, dataDir, cacheDir)
184	-	if err != nil {
185	-	logger.Fatal().Err(err).Msg("failed to initialize WebKit context")
186	-	}
187	-
188	-	// Content filtering (ad blocking)
189	-	filterStoreDir := filepath.Join(dataDir, "filters", "store")
190	-	filterJSONDir := filepath.Join(dataDir, "filters", "json")
191	-	filterManager, err := filtering.NewManager(filtering.ManagerConfig{
192	-	StoreDir: filterStoreDir,
193	-	JSONDir: filterJSONDir,
194	-	Enabled: cfg.ContentFiltering.Enabled,
195	-	AutoUpdate: cfg.ContentFiltering.AutoUpdate,
196	-	})
197	-	if err != nil {
198	-	logger.Warn().Err(err).Msg("failed to create filter manager, continuing without content filtering")
199	-	} else {
200	-	// Fast init: load compiled filters if cached
201	-	if err := filterManager.Initialize(ctx); err != nil {
202	-	logger.Warn().Err(err).Msg("failed to initialize filters, will load async")
203		}	262		}
204		}	263		}
			264	+	return db, cleanup
			265	+	}
205			266
206	-	// Register dumb:// scheme handler for serving embedded webui	267	+	func buildUIDependencies(
207	-	schemeHandler := webkit.NewDumbSchemeHandler(ctx)	268	+	ctx context.Context,
208	-	schemeHandler.SetAssets(assets.WebUIAssets)	269	+	cfg *config.Config,
209	-	schemeHandler.RegisterWithContext(wkCtx)	270	+	themeManager *theme.Manager,
210	-		271	+	wkCtx *webkit.WebKitContext,
211	-	settings := webkit.NewSettingsManager(ctx, cfg)	272	+	pool *webkit.WebViewPool,
212	-	injector := webkit.NewContentInjector(themeManager.PrefersDark())	273	+	settings *webkit.SettingsManager,
213	-		274	+	injector *webkit.ContentInjector,
214	-	// Prepare theme CSS for WebUI pages (dumb://*)	275	+	messageRouter *webkit.MessageRouter,
215	-	prepareThemeUC := usecase.NewPrepareWebUIThemeUseCase(injector)	276	+	filterManager *filtering.Manager,
216	-	themeCSSText := themeManager.GetWebUIThemeCSS()	277	+	historyRepo repository.HistoryRepository,
217	-	if err := prepareThemeUC.Execute(ctx, usecase.PrepareWebUIThemeInput{CSSVars: themeCSSText}); err != nil {	278	+	favoriteRepo repository.FavoriteRepository,
218	-	logger.Warn().Err(err).Msg("failed to prepare WebUI theme CSS")	279	+	zoomRepo repository.ZoomRepository,
219	-	}	280	+	tabsUC *usecase.ManageTabsUseCase,
220	-		281	+	panesUC *usecase.ManagePanesUseCase,
221	-	messageRouter := webkit.NewMessageRouter(ctx)	282	+	historyUC *usecase.SearchHistoryUseCase,
222	-	poolCfg := webkit.DefaultPoolConfig()	283	+	favoritesUC *usecase.ManageFavoritesUseCase,
223	-	pool := webkit.NewWebViewPool(ctx, wkCtx, settings, poolCfg, injector, messageRouter)	284	+	zoomUC *usecase.ManageZoomUseCase,
224	-		285	+	navigateUC *usecase.NavigateUseCase,
225	-	// Set filter applier on the pool if filtering is enabled	286	+	copyURLUC *usecase.CopyURLUseCase,
226	-	if filterManager != nil {	287	+	clipboardAdapter port.Clipboard,
227	-	pool.SetFilterApplier(filterManager)	288	+	faviconService *favicon.Service,
228	-	}	289	+	) *ui.Dependencies {
229	-		290	+	return &ui.Dependencies{
230	-	// Create use cases
231	-	idCounter := uint64(0)
232	-	idGenerator := func() string {
233	-	idCounter++
234	-	return fmt.Sprintf("%c%d", 'a'+rune(idCounter%26), idCounter/26)
235	-	}
236	-	tabsUC := usecase.NewManageTabsUseCase(idGenerator)
237	-	panesUC := usecase.NewManagePanesUseCase(idGenerator)
238	-	historyUC := usecase.NewSearchHistoryUseCase(historyRepo)
239	-	favoritesUC := usecase.NewManageFavoritesUseCase(favoriteRepo, folderRepo, tagRepo)
240	-	zoomUC := usecase.NewManageZoomUseCase(zoomRepo, cfg.DefaultWebpageZoom)
241	-	navigateUC := usecase.NewNavigateUseCase(historyRepo, zoomRepo, cfg.DefaultWebpageZoom)
242	-	clipboardAdapter := clipboard.New()
243	-	copyURLUC := usecase.NewCopyURLUseCase(clipboardAdapter)
244	-
245	-	// Create favicon service
246	-	faviconCacheDir, _ := config.GetFaviconCacheDir()
247	-	faviconService := favicon.NewService(faviconCacheDir)
248	-
249	-	// Build dependencies
250	-	deps := &ui.Dependencies{
251		Ctx: ctx,	291		Ctx: ctx,
252		Config: cfg,	292		Config: cfg,
253		InitialURL: initialURL,	293		InitialURL: initialURL,

@@ -257,25 +297,18 @@ func runGUI() {
257		Settings: settings,	297		Settings: settings,
258		Injector: injector,	298		Injector: injector,
259		MessageRouter: messageRouter,	299		MessageRouter: messageRouter,
260	-	// Repositories	300	+	HistoryRepo: historyRepo,
261	-	HistoryRepo: historyRepo,	301	+	FavoriteRepo: favoriteRepo,
262	-	FavoriteRepo: favoriteRepo,	302	+	ZoomRepo: zoomRepo,
263	-	ZoomRepo: zoomRepo,	303	+	TabsUC: tabsUC,
264	-	// Use Cases	304	+	PanesUC: panesUC,
265	-	TabsUC: tabsUC,	305	+	HistoryUC: historyUC,
266	-	PanesUC: panesUC,	306	+	FavoritesUC: favoritesUC,
267	-	HistoryUC: historyUC,	307	+	ZoomUC: zoomUC,
268	-	FavoritesUC: favoritesUC,	308	+	NavigateUC: navigateUC,
269	-	ZoomUC: zoomUC,	309	+	CopyURLUC: copyURLUC,
270	-	NavigateUC: navigateUC,	310	+	Clipboard: clipboardAdapter,
271	-	CopyURLUC: copyURLUC,
272	-	// Infrastructure Adapters
273	-	Clipboard: clipboardAdapter,
274		FaviconService: faviconService,	311		FaviconService: faviconService,
275		FilterManager: filterManager,	312		FilterManager: filterManager,
276		}	313		}
277	-
278	-	// Run the application
279	-	exitCode := ui.RunWithArgs(ctx, deps)
280	-	os.Exit(exitCode)
281		}	314		}

M internal/application/usecase/check_media.go +4 -1

 	// GStreamer is required - fail early if not installed
 	if !result.GStreamerAvailable {
-		return nil, fmt.Errorf("GStreamer not installed - video playback requires GStreamer. Install: gst-plugins-base gst-plugins-good gst-plugins-bad gst-plugins-ugly gst-libav")
+		return nil, fmt.Errorf(
+			"GStreamer not installed - video playback requires GStreamer. Install: %s",
+			"gst-plugins-base gst-plugins-good gst-plugins-bad gst-plugins-ugly gst-libav",
+		)
 	}
 	// Log warnings if requested

M internal/application/usecase/check_runtime_dependencies.go +8 -5

 }
 // Execute checks WebKitGTK and GTK runtime versions.
-func (uc *CheckRuntimeDependenciesUseCase) Execute(ctx context.Context, input CheckRuntimeDependenciesInput) (*CheckRuntimeDependenciesOutput, error) {
+func (uc *CheckRuntimeDependenciesUseCase) Execute(
+	ctx context.Context,
+	input CheckRuntimeDependenciesInput,
+) (*CheckRuntimeDependenciesOutput, error) {
 	log := logging.FromContext(ctx).With().Str("component", "runtime-check").Logger()
 	minGTK := input.MinGTK4Version
 		return 0, false
 	}
-	max := len(av)
+	maxLen := len(av)
-	if len(bv) > max {
+	if len(bv) > maxLen {
-		max = len(bv)
+		maxLen = len(bv)
 	}
-	for i := 0; i < max; i++ {
+	for i := 0; i < maxLen; i++ {
 		x := 0
 		if i < len(av) {
 			x = av[i]

M internal/application/usecase/find_in_page.go +12 -10


@@ -95,15 +95,17 @@ func (uc *FindInPageUseCase) Bind(controller port.FindController) {
95		return	95		return
96		}	96		}
97			97
98	-	uc.signalIDs = append(uc.signalIDs, controller.OnFoundText(func(matchCount uint) {	98	+	uc.signalIDs = append(uc.signalIDs,
99	-	uc.onFoundText(matchCount)	99	+	controller.OnFoundText(func(matchCount uint) {
100	-	}))	100	+	uc.onFoundText(matchCount)
101	-	uc.signalIDs = append(uc.signalIDs, controller.OnFailedToFindText(func() {	101	+	}),
102	-	uc.onFailedToFind()	102	+	controller.OnFailedToFindText(func() {
103	-	}))	103	+	uc.onFailedToFind()
104	-	uc.signalIDs = append(uc.signalIDs, controller.OnCountedMatches(func(matchCount uint) {	104	+	}),
105	-	uc.onCountedMatches(matchCount)	105	+	controller.OnCountedMatches(func(matchCount uint) {
106	-	}))	106	+	uc.onCountedMatches(matchCount)
			107	+	}),
			108	+	)
107			109
108		log.Debug().Int("signalCount", len(uc.signalIDs)).Msg("controller bound")	110		log.Debug().Int("signalCount", len(uc.signalIDs)).Msg("controller bound")
109		}	111		}

@@ -387,7 +389,7 @@ func (uc *FindInPageUseCase) finishSearch() {
387		}	389		}
388			390
389		func (uc *FindInPageUseCase) buildOptionsLocked(text string) port.FindOptions {	391		func (uc *FindInPageUseCase) buildOptionsLocked(text string) port.FindOptions {
390	-	caseInsensitive := true	392	+	var caseInsensitive bool
391		if uc.caseMode == caseModeManual {	393		if uc.caseMode == caseModeManual {
392		caseInsensitive = !uc.caseSensitive	394		caseInsensitive = !uc.caseSensitive
393		} else {	395		} else {

M internal/application/usecase/manage_favorites.go +2 -2


@@ -281,10 +281,10 @@ func (uc *ManageFavoritesUseCase) DeleteFolder(ctx context.Context, id entity.Fo
281			281
282		// Move favorites to parent folder (or root)	282		// Move favorites to parent folder (or root)
283		for _, fav := range favorites {	283		for _, fav := range favorites {
284	-	if err := uc.favoriteRepo.SetFolder(ctx, fav.ID, folder.ParentID); err != nil {	284	+	if setErr := uc.favoriteRepo.SetFolder(ctx, fav.ID, folder.ParentID); setErr != nil {
285		log.Warn().	285		log.Warn().
286		Int64("favorite_id", int64(fav.ID)).	286		Int64("favorite_id", int64(fav.ID)).
287	-	Err(err).	287	+	Err(setErr).
288		Msg("failed to move favorite from deleted folder")	288		Msg("failed to move favorite from deleted folder")
289		}	289		}
290		}	290		}

M internal/application/usecase/manage_panes.go +35 -5

 // Returns the sibling node that was promoted, or nil if this was the last pane.
 func (uc *ManagePanesUseCase) Close(ctx context.Context, ws *entity.Workspace, paneNode *entity.PaneNode) (*entity.PaneNode, error) {
 	log := logging.FromContext(ctx)
+	if uc == nil {
+		return nil, fmt.Errorf("manage panes use case is nil")
+	}
 	log.Debug().Str("pane_id", paneNode.ID).Msg("closing pane")
 	if ws == nil {
 // Focus sets the active pane in the workspace.
 func (uc *ManagePanesUseCase) Focus(ctx context.Context, ws *entity.Workspace, paneID entity.PaneID) error {
 	log := logging.FromContext(ctx)
+	if uc == nil {
+		return fmt.Errorf("manage panes use case is nil")
+	}
 	log.Debug().Str("pane_id", string(paneID)).Msg("focusing pane")
 	if ws == nil {
 // NavigateFocus moves focus to an adjacent pane.
 // Returns the newly focused pane, or nil if navigation not possible.
-func (uc *ManagePanesUseCase) NavigateFocus(ctx context.Context, ws *entity.Workspace, direction NavigateDirection) (*entity.PaneNode, error) {
+func (uc *ManagePanesUseCase) NavigateFocus(
+	ctx context.Context,
+	ws *entity.Workspace,
+	direction NavigateDirection,
+) (*entity.PaneNode, error) {
 	log := logging.FromContext(ctx)
 	log.Debug().Str("direction", string(direction)).Msg("navigating focus")
 	input GeometricNavigationInput,
 ) (*GeometricNavigationOutput, error) {
 	log := logging.FromContext(ctx)
+	if uc == nil {
+		return nil, fmt.Errorf("manage panes use case is nil")
+	}
 	log.Debug().
 		Str("direction", string(input.Direction)).
 		Str("active", string(input.ActivePaneID)).
 			}
 			// Check if we can move in the desired direction
-			targetIndex := childIndex
+			var targetIndex int
 			if isForward {
 				targetIndex = childIndex + 1
 			} else {
 //
 // The targetNode keeps its ID but becomes a stack container.
 // This allows the UI layer to update widget mappings incrementally.
-func (uc *ManagePanesUseCase) CreateStack(ctx context.Context, ws *entity.Workspace, paneNode *entity.PaneNode) (*CreateStackOutput, error) {
+func (uc *ManagePanesUseCase) CreateStack(
+	ctx context.Context,
+	ws *entity.Workspace,
+	paneNode *entity.PaneNode,
+) (*CreateStackOutput, error) {
 	log := logging.FromContext(ctx)
 	log.Debug().Str("pane_id", paneNode.ID).Msg("creating stack from pane")
 // AddToStack adds a new pane to an existing stack.
 // Optionally pass a pre-created pane, or nil to create a new one.
-func (uc *ManagePanesUseCase) AddToStack(ctx context.Context, ws *entity.Workspace, stackNode *entity.PaneNode, pane *entity.Pane) (*AddToStackOutput, error) {
+func (uc *ManagePanesUseCase) AddToStack(
+	ctx context.Context,
+	ws *entity.Workspace,
+	stackNode *entity.PaneNode,
+	pane *entity.Pane,
+) (*AddToStackOutput, error) {
 	log := logging.FromContext(ctx)
 	if ws == nil {
 // NavigateStack cycles through stacked panes.
 // direction: NavUp for previous, NavDown for next.
-func (uc *ManagePanesUseCase) NavigateStack(ctx context.Context, stackNode *entity.PaneNode, direction NavigateDirection) (*entity.Pane, error) {
+//nolint:revive // receiver required for interface consistency
+func (uc *ManagePanesUseCase) NavigateStack(
+	ctx context.Context,
+	stackNode *entity.PaneNode,
+	direction NavigateDirection,
+) (*entity.Pane, error) {
 	log := logging.FromContext(ctx)
 	if stackNode == nil {
 // RemoveFromStack removes a pane from a stack.
 // If only one pane remains, the stack is dissolved.
+//nolint:revive // receiver required for interface consistency
 func (uc *ManagePanesUseCase) RemoveFromStack(ctx context.Context, stackNode *entity.PaneNode, paneID entity.PaneID) error {
 	log := logging.FromContext(ctx)
 }
 // GetAllPanes returns all leaf panes in a workspace.
+//nolint:revive // receiver required for interface consistency
 func (uc *ManagePanesUseCase) GetAllPanes(ws *entity.Workspace) []*entity.Pane {
 	if ws == nil || ws.Root == nil {
 		return nil
 }
 // CountPanes returns the number of panes in a workspace.
+//nolint:revive // receiver required for interface consistency
 func (uc *ManagePanesUseCase) CountPanes(ws *entity.Workspace) int {
 	if ws == nil {
 		return 0

M internal/application/usecase/manage_tabs.go +13 -2

 // Close removes a tab from the list.
 // Returns true if this was the last tab (caller should handle app exit).
 func (uc *ManageTabsUseCase) Close(ctx context.Context, tabs *entity.TabList, tabID entity.TabID) (wasLast bool, err error) {
-	log := logging.FromContext(ctx)
 	ctx = logging.WithTabID(ctx, string(tabID))
-	log = logging.FromContext(ctx)
+	log := logging.FromContext(ctx)
+	if uc == nil {
+		return false, fmt.Errorf("manage tabs use case is nil")
+	}
 	log.Debug().Msg("closing tab")
 // Switch changes the active tab.
 func (uc *ManageTabsUseCase) Switch(ctx context.Context, tabs *entity.TabList, tabID entity.TabID) error {
 	log := logging.FromContext(ctx)
+	if uc == nil {
+		return fmt.Errorf("manage tabs use case is nil")
+	}
 	log.Debug().Str("tab_id", string(tabID)).Msg("switching to tab")
 	if tabs == nil {
 // Move repositions a tab within the tab bar.
 func (uc *ManageTabsUseCase) Move(ctx context.Context, tabs *entity.TabList, tabID entity.TabID, newPosition int) error {
 	log := logging.FromContext(ctx)
+	if uc == nil {
+		return fmt.Errorf("manage tabs use case is nil")
+	}
 	log.Debug().
 		Str("tab_id", string(tabID)).
 		Int("new_position", newPosition).
 }
 // Rename changes a tab's custom name.
+//nolint:revive // receiver required for interface consistency
 func (uc *ManageTabsUseCase) Rename(ctx context.Context, tabs *entity.TabList, tabID entity.TabID, name string) error {
 	log := logging.FromContext(ctx)
 	log.Debug().
 // GetNext returns the next tab ID in the given direction.
 // direction: 1 for next, -1 for previous.
+//nolint:revive // receiver required for interface consistency
 func (uc *ManageTabsUseCase) GetNext(tabs *entity.TabList, direction int) entity.TabID {
 	if tabs == nil || tabs.Count() == 0 {
 		return ""
 }
 // Pin toggles the pinned state of a tab.
+//nolint:revive // receiver required for interface consistency
 func (uc *ManageTabsUseCase) Pin(ctx context.Context, tabs *entity.TabList, tabID entity.TabID, pinned bool) error {
 	log := logging.FromContext(ctx)
 	log.Debug().

M internal/application/usecase/navigate.go +4 -4


@@ -150,7 +150,7 @@ func (uc *NavigateUseCase) UpdateHistoryTitle(ctx context.Context, url, title st
150			150
151		// Reload reloads the current page.	151		// Reload reloads the current page.
152		func (uc *NavigateUseCase) Reload(ctx context.Context, webview port.WebView, bypassCache bool) error {	152		func (uc *NavigateUseCase) Reload(ctx context.Context, webview port.WebView, bypassCache bool) error {
153	-	log := logging.FromContext(ctx)	153	+	log := logging.FromContext(ctx).With().Float64("default_zoom", uc.defaultZoom).Logger()
154		log.Debug().Bool("bypass_cache", bypassCache).Msg("reloading page")	154		log.Debug().Bool("bypass_cache", bypassCache).Msg("reloading page")
155			155
156		if bypassCache {	156		if bypassCache {

@@ -161,7 +161,7 @@ func (uc *NavigateUseCase) Reload(ctx context.Context, webview port.WebView, byp
161			161
162		// GoBack navigates back in history.	162		// GoBack navigates back in history.
163		func (uc *NavigateUseCase) GoBack(ctx context.Context, webview port.WebView) error {	163		func (uc *NavigateUseCase) GoBack(ctx context.Context, webview port.WebView) error {
164	-	log := logging.FromContext(ctx)	164	+	log := logging.FromContext(ctx).With().Float64("default_zoom", uc.defaultZoom).Logger()
165			165
166		if !webview.CanGoBack() {	166		if !webview.CanGoBack() {
167		log.Debug().Msg("cannot go back - no history")	167		log.Debug().Msg("cannot go back - no history")

@@ -174,7 +174,7 @@ func (uc *NavigateUseCase) GoBack(ctx context.Context, webview port.WebView) err
174			174
175		// GoForward navigates forward in history.	175		// GoForward navigates forward in history.
176		func (uc *NavigateUseCase) GoForward(ctx context.Context, webview port.WebView) error {	176		func (uc *NavigateUseCase) GoForward(ctx context.Context, webview port.WebView) error {
177	-	log := logging.FromContext(ctx)	177	+	log := logging.FromContext(ctx).With().Float64("default_zoom", uc.defaultZoom).Logger()
178			178
179		if !webview.CanGoForward() {	179		if !webview.CanGoForward() {
180		log.Debug().Msg("cannot go forward - no history")	180		log.Debug().Msg("cannot go forward - no history")

@@ -187,7 +187,7 @@ func (uc *NavigateUseCase) GoForward(ctx context.Context, webview port.WebView)
187			187
188		// Stop stops the current page load.	188		// Stop stops the current page load.
189		func (uc *NavigateUseCase) Stop(ctx context.Context, webview port.WebView) error {	189		func (uc *NavigateUseCase) Stop(ctx context.Context, webview port.WebView) error {
190	-	log := logging.FromContext(ctx)	190	+	log := logging.FromContext(ctx).With().Float64("default_zoom", uc.defaultZoom).Logger()
191		log.Debug().Msg("stopping page load")	191		log.Debug().Msg("stopping page load")
192		return webview.Stop(ctx)	192		return webview.Stop(ctx)
193		}	193		}

M internal/application/usecase/save_webui_config.go +4 -1

 	case "default", "prefer-dark", "prefer-light":
 		// ok
 	default:
-		errs = append(errs, fmt.Sprintf("appearance.color_scheme must be one of: prefer-dark, prefer-light, default (got: %s)", cfg.Appearance.ColorScheme))
+		errs = append(errs, fmt.Sprintf(
+			"appearance.color_scheme must be one of: prefer-dark, prefer-light, default (got: %s)",
+			cfg.Appearance.ColorScheme,
+		))
 	}
 	errs = append(errs, validation.ValidatePaletteHex(

M internal/application/usecase/setup_desktop.go +3 -1


@@ -148,7 +148,9 @@ func (uc RemoveDesktopUseCase) Execute(ctx context.Context) (RemoveDesktopOutp
148			148
149		// Unset as default browser first (if applicable)	149		// Unset as default browser first (if applicable)
150		if status.IsDefaultBrowser {	150		if status.IsDefaultBrowser {
151	-	_ = uc.desktop.UnsetAsDefaultBrowser(ctx)	151	+	if err := uc.desktop.UnsetAsDefaultBrowser(ctx); err != nil {
			152	+	log.Warn().Err(err).Msg("failed to unset default browser")
			153	+	}
152		}	154		}
153			155
154		// Remove desktop file	156		// Remove desktop file

A internal/bootstrap/webkit_stack.go +83 -0

@@ -0,0 +1,83 @@
	1	+	package bootstrap
	2	+
	3	+	import (
	4	+	"context"
	5	+	"path/filepath"
	6	+
	7	+	"github.com/bnema/dumber/assets"
	8	+	"github.com/bnema/dumber/internal/application/usecase"
	9	+	"github.com/bnema/dumber/internal/infrastructure/config"
	10	+	"github.com/bnema/dumber/internal/infrastructure/filtering"
	11	+	"github.com/bnema/dumber/internal/infrastructure/webkit"
	12	+	"github.com/bnema/dumber/internal/ui/theme"
	13	+	"github.com/rs/zerolog"
	14	+	)
	15	+
	16	+	type WebKitStack struct {
	17	+	Context *webkit.WebKitContext
	18	+	Settings *webkit.SettingsManager
	19	+	Injector *webkit.ContentInjector
	20	+	MessageRouter *webkit.MessageRouter
	21	+	Pool *webkit.WebViewPool
	22	+	FilterManager *filtering.Manager
	23	+	}
	24	+
	25	+	func BuildWebKitStack(
	26	+	ctx context.Context,
	27	+	cfg *config.Config,
	28	+	dataDir string,
	29	+	cacheDir string,
	30	+	themeManager *theme.Manager,
	31	+	logger zerolog.Logger,
	32	+	) WebKitStack {
	33	+	wkCtx, err := webkit.NewWebKitContext(ctx, dataDir, cacheDir)
	34	+	if err != nil {
	35	+	logger.Fatal().Err(err).Msg("failed to initialize WebKit context")
	36	+	}
	37	+
	38	+	filterStoreDir := filepath.Join(dataDir, "filters", "store")
	39	+	filterJSONDir := filepath.Join(dataDir, "filters", "json")
	40	+	filterManager, err := filtering.NewManager(filtering.ManagerConfig{
	41	+	StoreDir: filterStoreDir,
	42	+	JSONDir: filterJSONDir,
	43	+	Enabled: cfg.ContentFiltering.Enabled,
	44	+	AutoUpdate: cfg.ContentFiltering.AutoUpdate,
	45	+	})
	46	+	if err != nil {
	47	+	logger.Warn().Err(err).Msg("failed to create filter manager, continuing without content filtering")
	48	+	} else {
	49	+	if err := filterManager.Initialize(ctx); err != nil {
	50	+	logger.Warn().Err(err).Msg("failed to initialize filters, will load async")
	51	+	}
	52	+	}
	53	+
	54	+	schemeHandler := webkit.NewDumbSchemeHandler(ctx)
	55	+	schemeHandler.SetAssets(assets.WebUIAssets)
	56	+	schemeHandler.RegisterWithContext(wkCtx)
	57	+
	58	+	settings := webkit.NewSettingsManager(ctx, cfg)
	59	+	injector := webkit.NewContentInjector(themeManager.PrefersDark())
	60	+
	61	+	prepareThemeUC := usecase.NewPrepareWebUIThemeUseCase(injector)
	62	+	themeCSSText := themeManager.GetWebUIThemeCSS()
	63	+	if err := prepareThemeUC.Execute(ctx, usecase.PrepareWebUIThemeInput{CSSVars: themeCSSText}); err != nil {
	64	+	logger.Warn().Err(err).Msg("failed to prepare WebUI theme CSS")
	65	+	}
	66	+
	67	+	messageRouter := webkit.NewMessageRouter(ctx)
	68	+	poolCfg := webkit.DefaultPoolConfig()
	69	+	pool := webkit.NewWebViewPool(ctx, wkCtx, settings, poolCfg, injector, messageRouter)
	70	+
	71	+	if filterManager != nil {
	72	+	pool.SetFilterApplier(filterManager)
	73	+	}
	74	+
	75	+	return WebKitStack{
	76	+	Context: wkCtx,
	77	+	Settings: settings,
	78	+	Injector: injector,
	79	+	MessageRouter: messageRouter,
	80	+	Pool: pool,
	81	+	FilterManager: filterManager,
	82	+	}
	83	+	}

M internal/cli/app.go +7 -9

 // NewApp creates a new CLI application with all dependencies.
 func NewApp() (*App, error) {
+	const dataDirPerm = 0o755
 	// Load config
-	cfg, err := loadConfig()
+	cfg := loadConfig()
-	if err != nil {
-		return nil, fmt.Errorf("load config: %w", err)
-	}
 	// Create theme from config
 	theme := styles.NewTheme(cfg)
 	dbPath := filepath.Dir(dbFile)
 	// Ensure data directory exists
-	if err := os.MkdirAll(dbPath, 0755); err != nil {
+	if err = os.MkdirAll(dbPath, dataDirPerm); err != nil {
 		return nil, fmt.Errorf("create data dir: %w", err)
 	}
 }
 // loadConfig loads configuration from standard locations.
-func loadConfig() (*config.Config, error) {
+func loadConfig() *config.Config {
 	mgr, err := config.NewManager()
 	if err != nil {
 		// Return default config if manager fails
-		return config.DefaultConfig(), nil
+		return config.DefaultConfig()
 	}
 	if err := mgr.Load(); err != nil {
 		// Return default config if loading fails
-		return config.DefaultConfig(), nil
+		return config.DefaultConfig()
 	}
-	return mgr.Get(), nil
+	return mgr.Get()
 }

M internal/cli/cmd/about.go +1 -1


@@ -19,7 +19,7 @@ func init() {
19		rootCmd.AddCommand(aboutCmd)	19		rootCmd.AddCommand(aboutCmd)
20		}	20		}
21			21
22	-	func runAbout(cmd *cobra.Command, args []string) error {	22	+	func runAbout(_ *cobra.Command, _ []string) error {
23		app := GetApp()	23		app := GetApp()
24		if app == nil {	24		if app == nil {
25		return fmt.Errorf("app not initialized")	25		return fmt.Errorf("app not initialized")

M internal/cli/cmd/dmenu.go +1 -1


@@ -44,7 +44,7 @@ func init() {
44		dmenuCmd.Flags().IntVar(&dmenuMax, "max", 0, "maximum entries to output (default from config)")	44		dmenuCmd.Flags().IntVar(&dmenuMax, "max", 0, "maximum entries to output (default from config)")
45		}	45		}
46			46
47	-	func runDmenu(cmd *cobra.Command, args []string) error {	47	+	func runDmenu(_ *cobra.Command, _ []string) error {
48		app := GetApp()	48		app := GetApp()
49		if app == nil {	49		if app == nil {
50		return fmt.Errorf("app not initialized")	50		return fmt.Errorf("app not initialized")

M internal/cli/cmd/doctor.go +3 -9

 	doctorCmd.Flags().BoolVar(&doctorOnlyRuntime, "runtime", false, "Only run runtime checks (GTK4/WebKitGTK)")
 	doctorCmd.Flags().BoolVar(&doctorOnlyMedia, "media", false, "Only run media checks (GStreamer/VA-API)")
 }
-func runDoctor(cmd *cobra.Command, args []string) error {
+func runDoctor(_ *cobra.Command, _ []string) error {
 	app := GetApp()
 	if app == nil {
 		return fmt.Errorf("app not initialized")
 		return fmt.Errorf("--runtime and --media are mutually exclusive")
 	}
-	runRuntime := true
+	runRuntime := !doctorOnlyMedia
-	runMedia := true
+	runMedia := !doctorOnlyRuntime
-	if doctorOnlyRuntime {
-		runMedia = false
-	}
-	if doctorOnlyMedia {
-		runRuntime = false
-	}
 	report := styles.DoctorReport{OverallOK: true}

M internal/cli/cmd/history.go +6 -4

 	historyMax  int
 )
+const defaultHistoryMax = 50
 var historyCmd = &cobra.Command{
 	Use:   "history",
 	Short: "Browse and manage history",
 	rootCmd.AddCommand(historyCmd)
 	historyCmd.Flags().BoolVar(&historyJSON, "json", false, "output as JSON")
-	historyCmd.Flags().IntVar(&historyMax, "max", 50, "maximum entries to show (for --json)")
+	historyCmd.Flags().IntVar(&historyMax, "max", defaultHistoryMax, "maximum entries to show (for --json)")
 }
-func runHistory(cmd *cobra.Command, args []string) error {
+func runHistory(_ *cobra.Command, _ []string) error {
 	app := GetApp()
 	if app == nil {
 		return fmt.Errorf("app not initialized")
 	historyCmd.AddCommand(statsCmd)
 }
-func runStats(cmd *cobra.Command, args []string) error {
+func runStats(_ *cobra.Command, _ []string) error {
 	app := GetApp()
 	if app == nil {
 		return fmt.Errorf("app not initialized")
 	historyCmd.AddCommand(clearCmd)
 }
-func runClear(cmd *cobra.Command, args []string) error {
+func runClear(_ *cobra.Command, _ []string) error {
 	app := GetApp()
 	if app == nil {
 		return fmt.Errorf("app not initialized")

M internal/cli/cmd/logs.go +15 -9

 	logsClearAll bool
 )
+const defaultLogsLines = 50
 var logsCmd = &cobra.Command{
 	Use:   "logs [session]",
 	Short: "View application logs",
 	rootCmd.AddCommand(logsCmd)
 	logsCmd.Flags().BoolVarP(&logsFollow, "follow", "f", false, "follow log output in real-time")
-	logsCmd.Flags().IntVarP(&logsLines, "lines", "n", 50, "number of lines to show")
+	logsCmd.Flags().IntVarP(&logsLines, "lines", "n", defaultLogsLines, "number of lines to show")
 }
 // SessionInfo holds metadata about a log session.
 	ModTime   time.Time
 }
-func runLogs(cmd *cobra.Command, args []string) error {
+func runLogs(_ *cobra.Command, args []string) error {
 	app := GetApp()
 	if app == nil {
 		return fmt.Errorf("app not initialized")
 		return nil, fmt.Errorf("no sessions found")
 	}
-	query = strings.ToLower(query)
+	queryLower := strings.ToLower(query)
 	// Try exact short ID match first
 	for _, s := range sessions {
-		if strings.ToLower(s.ShortID) == query {
+		if strings.EqualFold(s.ShortID, queryLower) {
 			return &s, nil
 		}
 	}
 	// Try partial match on full session ID
 	var matches []SessionInfo
 	for _, s := range sessions {
-		if strings.Contains(strings.ToLower(s.SessionID), query) {
+		if strings.Contains(strings.ToLower(s.SessionID), queryLower) {
 			matches = append(matches, s)
 		}
 	}
 }
 // showSession displays the last N lines of a session log.
-func showSession(logPath string, lines int, theme *styles.Theme) error {
+func showSession(logPath string, lines int, theme *styles.Theme) (retErr error) {
 	file, err := os.Open(logPath)
 	if err != nil {
 		return fmt.Errorf("open log file: %w", err)
 	}
-	defer file.Close()
+	defer func() {
+		if closeErr := file.Close(); closeErr != nil && retErr == nil {
+			retErr = fmt.Errorf("close log file: %w", closeErr)
+		}
+	}()
 	// Read all lines
 	var allLines []string
 	if err != nil {
 		return fmt.Errorf("open log file: %w", err)
 	}
-	defer file.Close()
+	defer func() { _ = file.Close() }()
 	// Seek to end
 	_, _ = file.Seek(0, io.SeekEnd)
 	logsClearCmd.Flags().BoolVar(&logsClearAll, "all", false, "remove all session logs")
 }
-func runLogsClear(cmd *cobra.Command, args []string) error {
+func runLogsClear(_ *cobra.Command, _ []string) error {
 	app := GetApp()
 	if app == nil {
 		return fmt.Errorf("app not initialized")

M internal/cli/cmd/purge.go +123 -96


@@ -21,6 +21,27 @@ var (
21		purgeFilters bool	21		purgeFilters bool
22		)	22		)
23			23
			24	+	const dumberAppName = "dumber"
			25	+
			26	+	type purgeDir struct {
			27	+	path string
			28	+	desc string
			29	+	}
			30	+
			31	+	type purgeDirWithSize struct {
			32	+	path string
			33	+	desc string
			34	+	size int64
			35	+	}
			36	+
			37	+	type purgeDesktopStatus struct {
			38	+	desktopInstalled bool
			39	+	iconInstalled bool
			40	+	isDefault bool
			41	+	desktopPath string
			42	+	iconPath string
			43	+	}
			44	+
24		var purgeCmd = &cobra.Command{	45		var purgeCmd = &cobra.Command{
25		Use: "purge",	46		Use: "purge",
26		Short: "Remove all dumber data and configuration",	47		Short: "Remove all dumber data and configuration",

@@ -46,7 +67,7 @@ func init() {
46		purgeCmd.Flags().BoolVar(&purgeFilters, "filters", false, "only remove content filter cache")	67		purgeCmd.Flags().BoolVar(&purgeFilters, "filters", false, "only remove content filter cache")
47		}	68		}
48			69
49	-	func runPurge(cmd *cobra.Command, args []string) error {	70	+	func runPurge(_ *cobra.Command, _ []string) error {
50		home, err := os.UserHomeDir()	71		home, err := os.UserHomeDir()
51		if err != nil {	72		if err != nil {
52		return fmt.Errorf("get home dir: %w", err)	73		return fmt.Errorf("get home dir: %w", err)

@@ -57,70 +78,90 @@ func runPurge(cmd *cobra.Command, args []string) error {
57		return runPurgeFilters(home)	78		return runPurgeFilters(home)
58		}	79		}
59			80
60	-	// Build list of directories to remove	81	+	dirs := purgeDirList(home)
61	-	dirs := []struct {	82	+	existing := collectExistingDirs(dirs)
62	-	path string	83	+
63	-	desc string	84	+	var desktopStatus *purgeDesktopStatus
64	-	}{	85	+	// Check desktop integration status if --desktop flag is set
65	-	{getXDGPath("XDG_CONFIG_HOME", home, ".config", "dumber"), "config"},	86	+	if purgeDesktop {
66	-	{getXDGPath("XDG_DATA_HOME", home, ".local/share", "dumber"), "data"},	87	+	desktopStatus = getDesktopStatus()
67	-	{getXDGPath("XDG_STATE_HOME", home, ".local/state", "dumber"), "state"},
68	-	{getXDGPath("XDG_CACHE_HOME", home, ".cache", "dumber"), "cache"},
69		}	88		}
70			89
71	-	// Check which directories exist	90	+	// Check if there's anything to remove
72	-	var existing []struct {	91	+	if len(existing) == 0 && desktopStatus == nil {
73	-	path string	92	+	fmt.Println("No dumber directories found.")
74	-	desc string	93	+	return nil
75	-	size int64
76		}	94		}
77			95
78	-	for _, d := range dirs {	96	+	describePurgeTargets(existing, desktopStatus)
79	-	if info, err := os.Stat(d.path); err == nil && info.IsDir() {	97	+
80	-	size := getDirSize(d.path)	98	+	// Confirm unless --force
81	-	existing = append(existing, struct {	99	+	if !confirmPurge() {
82	-	path string	100	+	fmt.Println("Aborted.")
83	-	desc string	101	+	return nil
84	-	size int64	102	+	}
85	-	}{d.path, d.desc, size})	103	+
			104	+	// Remove directories
			105	+	errors := removeDirs(existing)
			106	+
			107	+	// Remove desktop integration
			108	+	if desktopStatus != nil {
			109	+	errors = removeDesktopIntegration(errors)
			110	+	}
			111	+
			112	+	if len(errors) > 0 {
			113	+	fmt.Println()
			114	+	fmt.Println("Errors:")
			115	+	for _, e := range errors {
			116	+	fmt.Printf(" \u2717 %s\n", e)
86		}	117		}
			118	+	return fmt.Errorf("failed to remove some items")
87		}	119		}
88			120
89	-	// Check desktop integration status if --desktop flag is set	121	+	fmt.Println()
90	-	var desktopStatus *struct {	122	+	fmt.Println("Purge complete.")
91	-	desktopInstalled bool	123	+	return nil
92	-	iconInstalled bool	124	+	}
93	-	isDefault bool	125	+
94	-	desktopPath string	126	+	func purgeDirList(home string) []purgeDir {
95	-	iconPath string	127	+	return []purgeDir{
			128	+	{getXDGPath("XDG_CONFIG_HOME", home, ".config"), "config"},
			129	+	{getXDGPath("XDG_DATA_HOME", home, ".local/share"), "data"},
			130	+	{getXDGPath("XDG_STATE_HOME", home, ".local/state"), "state"},
			131	+	{getXDGPath("XDG_CACHE_HOME", home, ".cache"), "cache"},
96		}	132		}
97	-	if purgeDesktop {	133	+	}
98	-	adapter := desktop.New()	134	+
99	-	status, err := adapter.GetStatus(context.Background())	135	+	func collectExistingDirs(dirs []purgeDir) []purgeDirWithSize {
100	-	if err == nil && (status.DesktopFileInstalled \|\| status.IconInstalled) {	136	+	var existing []purgeDirWithSize
101	-	desktopStatus = &struct {	137	+	for _, d := range dirs {
102	-	desktopInstalled bool	138	+	if info, err := os.Stat(d.path); err == nil && info.IsDir() {
103	-	iconInstalled bool	139	+	existing = append(existing, purgeDirWithSize{
104	-	isDefault bool	140	+	path: d.path,
105	-	desktopPath string	141	+	desc: d.desc,
106	-	iconPath string	142	+	size: getDirSize(d.path),
107	-	}{	143	+	})
108	-	desktopInstalled: status.DesktopFileInstalled,
109	-	iconInstalled: status.IconInstalled,
110	-	isDefault: status.IsDefaultBrowser,
111	-	desktopPath: status.DesktopFilePath,
112	-	iconPath: status.IconFilePath,
113	-	}
114		}	144		}
115		}	145		}
			146	+	return existing
			147	+	}
116			148
117	-	// Check if there's anything to remove	149	+	func getDesktopStatus() *purgeDesktopStatus {
118	-	if len(existing) == 0 && desktopStatus == nil {	150	+	adapter := desktop.New()
119	-	fmt.Println("No dumber directories found.")	151	+	status, err := adapter.GetStatus(context.Background())
			152	+	if err != nil \|\| (!status.DesktopFileInstalled && !status.IconInstalled) {
120		return nil	153		return nil
121		}	154		}
			155	+	return &purgeDesktopStatus{
			156	+	desktopInstalled: status.DesktopFileInstalled,
			157	+	iconInstalled: status.IconInstalled,
			158	+	isDefault: status.IsDefaultBrowser,
			159	+	desktopPath: status.DesktopFilePath,
			160	+	iconPath: status.IconFilePath,
			161	+	}
			162	+	}
122			163
123	-	// Show what will be deleted	164	+	func describePurgeTargets(existing []purgeDirWithSize, desktopStatus *purgeDesktopStatus) {
124		fmt.Println("The following will be removed:")	165		fmt.Println("The following will be removed:")
125		fmt.Println()	166		fmt.Println()
126		for _, d := range existing {	167		for _, d := range existing {

@@ -138,21 +179,20 @@ func runPurge(cmd *cobra.Command, args []string) error {
138		}	179		}
139		}	180		}
140		fmt.Println()	181		fmt.Println()
			182	+	}
141			183
142	-	// Confirm unless --force	184	+	func confirmPurge() bool {
143	-	if !purgeForce {	185	+	if purgeForce {
144	-	fmt.Print("Are you sure? [y/N]: ")	186	+	return true
145	-	reader := bufio.NewReader(os.Stdin)
146	-	response, _ := reader.ReadString('\n')
147	-	response = strings.TrimSpace(strings.ToLower(response))
148	-
149	-	if response != "y" && response != "yes" {
150	-	fmt.Println("Aborted.")
151	-	return nil
152	-	}
153		}	187		}
			188	+	fmt.Print("Are you sure? [y/N]: ")
			189	+	reader := bufio.NewReader(os.Stdin)
			190	+	response, _ := reader.ReadString('\n')
			191	+	response = strings.TrimSpace(strings.ToLower(response))
			192	+	return response == "y" \|\| response == "yes"
			193	+	}
154			194
155	-	// Remove directories	195	+	func removeDirs(existing []purgeDirWithSize) []string {
156		var errors []string	196		var errors []string
157		for _, d := range existing {	197		for _, d := range existing {
158		if err := os.RemoveAll(d.path); err != nil {	198		if err := os.RemoveAll(d.path); err != nil {

@@ -161,48 +201,35 @@ func runPurge(cmd *cobra.Command, args []string) error {
161		fmt.Printf("\u2713 Removed %s\n", d.path)	201		fmt.Printf("\u2713 Removed %s\n", d.path)
162		}	202		}
163		}	203		}
			204	+	return errors
			205	+	}
164			206
165	-	// Remove desktop integration	207	+	func removeDesktopIntegration(errors []string) []string {
166	-	if desktopStatus != nil {	208	+	adapter := desktop.New()
167	-	adapter := desktop.New()	209	+	uc := usecase.NewRemoveDesktopUseCase(adapter)
168	-	uc := usecase.NewRemoveDesktopUseCase(adapter)	210	+	result, err := uc.Execute(context.Background())
169	-	result, err := uc.Execute(context.Background())	211	+	if err != nil {
170	-	if err != nil {	212	+	return append(errors, fmt.Sprintf("desktop integration: %v", err))
171	-	errors = append(errors, fmt.Sprintf("desktop integration: %v", err))
172	-	} else {
173	-	if result.WasDesktopInstalled {
174	-	fmt.Printf("\u2713 Removed %s\n", result.RemovedDesktopPath)
175	-	}
176	-	if result.WasIconInstalled {
177	-	fmt.Printf("\u2713 Removed %s\n", result.RemovedIconPath)
178	-	}
179	-	if result.WasDefault {
180	-	fmt.Println(" \u26a0 Was default browser - please set a new default")
181	-	}
182	-	}
183		}	213		}
184	-		214	+	if result.WasDesktopInstalled {
185	-	if len(errors) > 0 {	215	+	fmt.Printf("\u2713 Removed %s\n", result.RemovedDesktopPath)
186	-	fmt.Println()
187	-	fmt.Println("Errors:")
188	-	for _, e := range errors {
189	-	fmt.Printf(" \u2717 %s\n", e)
190	-	}
191	-	return fmt.Errorf("failed to remove some items")
192		}	216		}
193	-		217	+	if result.WasIconInstalled {
194	-	fmt.Println()	218	+	fmt.Printf("\u2713 Removed %s\n", result.RemovedIconPath)
195	-	fmt.Println("Purge complete.")	219	+	}
196	-	return nil	220	+	if result.WasDefault {
			221	+	fmt.Println(" \u26a0 Was default browser - please set a new default")
			222	+	}
			223	+	return errors
197		}	224		}
198			225
199		// getXDGPath returns the XDG path for dumber.	226		// getXDGPath returns the XDG path for dumber.
200	-	func getXDGPath(envVar, home, defaultSuffix, appName string) string {	227	+	func getXDGPath(envVar, home, defaultSuffix string) string {
201		base := os.Getenv(envVar)	228		base := os.Getenv(envVar)
202		if base == "" {	229		if base == "" {
203		base = filepath.Join(home, defaultSuffix)	230		base = filepath.Join(home, defaultSuffix)
204		}	231		}
205	-	return filepath.Join(base, appName)	232	+	return filepath.Join(base, dumberAppName)
206		}	233		}
207			234
208		// getDirSize calculates the total size of a directory.	235		// getDirSize calculates the total size of a directory.

@@ -236,7 +263,7 @@ func formatSize(bytes int64) string {
236			263
237		// runPurgeFilters removes only the content filter cache.	264		// runPurgeFilters removes only the content filter cache.
238		func runPurgeFilters(home string) error {	265		func runPurgeFilters(home string) error {
239	-	dataDir := getXDGPath("XDG_DATA_HOME", home, ".local/share", "dumber")	266	+	dataDir := getXDGPath("XDG_DATA_HOME", home, ".local/share")
240		filterDirs := []struct {	267		filterDirs := []struct {
241		path string	268		path string
242		desc string	269		desc string

M internal/cli/cmd/root.go +3 -3


@@ -18,7 +18,7 @@ var (
18		Use: "dumber",	18		Use: "dumber",
19		Short: "A minimal web browser",	19		Short: "A minimal web browser",
20		Long: `Dumber is a minimal, keyboard-driven web browser built with GTK4 and WebKitGTK.`,	20		Long: `Dumber is a minimal, keyboard-driven web browser built with GTK4 and WebKitGTK.`,
21	-	PersistentPreRunE: func(cmd *cobra.Command, args []string) error {	21	+	PersistentPreRunE: func(cmd *cobra.Command, _ []string) error {
22		// Skip initialization for help commands	22		// Skip initialization for help commands
23		if cmd.Name() == "help" \|\| cmd.Name() == "completion" {	23		if cmd.Name() == "help" \|\| cmd.Name() == "completion" {
24		return nil	24		return nil

@@ -33,7 +33,7 @@ var (
33		app.BuildInfo = buildInfo	33		app.BuildInfo = buildInfo
34		return nil	34		return nil
35		},	35		},
36	-	PersistentPostRun: func(cmd *cobra.Command, args []string) {	36	+	PersistentPostRun: func(_ *cobra.Command, _ []string) {
37		if app != nil {	37		if app != nil {
38		_ = app.Close()	38		_ = app.Close()
39		}	39		}

@@ -65,7 +65,7 @@ If a URL is provided, navigate to it. Otherwise, open the homepage.
65		Examples:	65		Examples:
66		dumber browse # Open browser to homepage	66		dumber browse # Open browser to homepage
67		dumber browse example.com # Open browser to URL`,	67		dumber browse example.com # Open browser to URL`,
68	-	Run: func(cmd *cobra.Command, args []string) {	68	+	Run: func(_ *cobra.Command, _ []string) {
69		// This is handled by main.go before cobra runs	69		// This is handled by main.go before cobra runs
70		},	70		},
71		}	71		}

M internal/cli/cmd/setup.go +2 -2


@@ -55,7 +55,7 @@ func init() {
55		setupCmd.AddCommand(setupDefaultCmd)	55		setupCmd.AddCommand(setupDefaultCmd)
56		}	56		}
57			57
58	-	func runSetupInstall(cmd *cobra.Command, args []string) error {	58	+	func runSetupInstall(_ *cobra.Command, _ []string) error {
59		app := GetApp()	59		app := GetApp()
60		if app == nil {	60		if app == nil {
61		return fmt.Errorf("app not initialized")	61		return fmt.Errorf("app not initialized")

@@ -105,7 +105,7 @@ func runSetupInstall(cmd *cobra.Command, args []string) error {
105		return nil	105		return nil
106		}	106		}
107			107
108	-	func runSetupDefault(cmd *cobra.Command, args []string) error {	108	+	func runSetupDefault(_ *cobra.Command, _ []string) error {
109		app := GetApp()	109		app := GetApp()
110		if app == nil {	110		if app == nil {
111		return fmt.Errorf("app not initialized")	111		return fmt.Errorf("app not initialized")

M internal/cli/model/cleanup.go +4 -1

 // Init implements tea.Model.
 func (m CleanupModel) Init() tea.Cmd {
+	if m.theme == nil {
+		return nil
+	}
 	return nil
 }
 	m.cleanup = cleanup
 	if m.cleanup.Done() {
-		if m.cleanup.Cancelled {
+		if m.cleanup.Canceled {
 			return m, tea.Quit
 		}
 		if m.cleanup.Confirmed {

M internal/cli/model/dmenu.go +3 -1

 	err   error
 }
+const defaultDmenuHistoryLimit = 500
 // Init implements tea.Model.
 func (m DmenuModel) Init() tea.Cmd {
 	return tea.Batch(
 func (m DmenuModel) loadEntries() tea.Msg {
 	ctx := context.Background()
-	entries, err := m.historyUC.GetRecent(ctx, 500, 0)
+	entries, err := m.historyUC.GetRecent(ctx, defaultDmenuHistoryLimit, 0)
 	if err != nil {
 		return dmenuLoadedMsg{err: err}
 	}

M internal/cli/model/history.go +195 -151

 // Update implements tea.Model.
 func (m HistoryModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
-	var cmds []tea.Cmd
-	// Handle cleanup modal
 	if m.cleanup != nil {
-		cleanup, cmd := m.cleanup.Update(msg)
+		return m.handleCleanupModal(msg)
-		m.cleanup = &cleanup
-		if m.cleanup.Done() {
-			if m.cleanup.Confirmed {
-				// Perform cleanup
-				cmds = append(cmds, m.performCleanup(m.cleanup.SelectedRange()))
-			}
-			m.cleanup = nil
-		}
-		return m, cmd
 	}
-	// Handle confirm dialog
 	if m.confirm != nil {
-		confirm, cmd := m.confirm.Update(msg)
+		return m.handleConfirmModal(msg)
-		m.confirm = &confirm
-		if m.confirm.Done() {
-			if m.confirm.Result() {
-				// Perform the confirmed action (delete current entry)
-				cmds = append(cmds, m.deleteCurrentEntry())
-			}
-			m.confirm = nil
-		}
-		return m, cmd
 	}
 	switch msg := msg.(type) {
 	case tea.WindowSizeMsg:
-		m.width = msg.Width
+		return m.handleWindowSize(msg)
-		m.height = msg.Height
-		m.help.Width = msg.Width
-		m.updateList()
 	case tea.KeyMsg:
-		// Search mode handling
+		return m.handleKeyMsg(msg)
-		if m.searchMode {
-			switch msg.String() {
-			case "esc":
-				m.searchMode = false
-				m.search.Blur()
-				return m, nil
-			case "enter":
-				m.searchMode = false
-				m.search.Blur()
-				// Perform search
-				return m, m.performSearch(m.search.Value())
-			default:
-				var cmd tea.Cmd
-				m.search, cmd = m.search.Update(msg)
-				return m, cmd
-			}
-		}
-		// Normal mode handling
+	case historyLoadedMsg:
-		switch {
+		return m.handleHistoryLoaded(msg)
-		case key.Matches(msg, m.keys.Quit):
-			return m, tea.Quit
-		case key.Matches(msg, m.keys.Help):
-			m.showHelp = !m.showHelp
-		case key.Matches(msg, m.keys.Search):
-			m.searchMode = true
-			m.search.Focus()
-			return m, textinput.Blink
-		case key.Matches(msg, m.keys.Tab1):
-			m.tabs.SetActive(0)
-			m.updateList()
-		case key.Matches(msg, m.keys.Tab2):
-			m.tabs.SetActive(1)
-			m.updateList()
-		case key.Matches(msg, m.keys.Tab3):
-			m.tabs.SetActive(2)
-			m.updateList()
-		case key.Matches(msg, m.keys.Tab4):
-			m.tabs.SetActive(3)
-			m.updateList()
-		case key.Matches(msg, m.keys.NextTab):
-			// Cycle to next tab (wraps around)
-			next := (m.tabs.Active + 1) % 4
-			m.tabs.SetActive(next)
-			m.updateList()
-		case key.Matches(msg, m.keys.PrevTab):
-			// Cycle to previous tab (wraps around)
-			prev := (m.tabs.Active + 3) % 4 // +3 is same as -1 mod 4
-			m.tabs.SetActive(prev)
-			m.updateList()
-		case key.Matches(msg, m.keys.Open):
-			// Open selected URL in browser
-			if item := m.list.SelectedItem(); item != nil {
-				if hi, ok := item.(styles.HistoryItem); ok {
-					cmds = append(cmds, m.openURL(hi.URL))
-				}
-			}
-		case key.Matches(msg, m.keys.Delete):
+	case domainStatsMsg:
-			// Show delete confirmation
+		return m.handleDomainStats(msg)
-			if item := m.list.SelectedItem(); item != nil {
-				confirm := styles.NewConfirm(m.theme, "Delete this entry?")
-				m.confirm = &confirm
-			}
-		case key.Matches(msg, m.keys.DeleteDomain):
+	case historyDeletedMsg:
-			// Delete all from domain
+		return m.handleHistoryDeleted(msg)
-			if item := m.list.SelectedItem(); item != nil {
-				if hi, ok := item.(styles.HistoryItem); ok {
-					confirm := styles.NewConfirm(m.theme, "Delete all from "+hi.Domain+"?")
-					m.confirm = &confirm
-				}
-			}
-		case key.Matches(msg, m.keys.Cleanup):
+	case historyCleanedMsg:
-			// Show cleanup modal
+		return m.handleHistoryCleaned(msg)
-			cleanup := styles.NewCleanup(m.theme)
+	}
-			m.cleanup = &cleanup
-		case key.Matches(msg, m.keys.Filter):
-			// Cycle through domain filters
-			m.cycleDomainFilter()
-			m.updateList()
-		default:
-			// Pass to list
-			var cmd tea.Cmd
-			m.list, cmd = m.list.Update(msg)
-			cmds = append(cmds, cmd)
-		}
-	case historyLoadedMsg:
+	return m, nil
-		if msg.err != nil {
+}
-			m.err = msg.err
-		} else {
-			m.entries = msg.entries
-			m.updateList()
-		}
-	case domainStatsMsg:
+func (m HistoryModel) handleCleanupModal(msg tea.Msg) (tea.Model, tea.Cmd) {
-		if msg.err != nil {
+	cleanup, cmd := m.cleanup.Update(msg)
-			m.err = msg.err
+	m.cleanup = &cleanup
-		} else {
+	if m.cleanup.Done() {
-			m.topDomains = msg.domains
+		if m.cleanup.Confirmed {
+			cmd = m.performCleanup(m.cleanup.SelectedRange())
 		}
+		m.cleanup = nil
+	}
+	return m, cmd
+}
-	case historyDeletedMsg:
+func (m HistoryModel) handleConfirmModal(msg tea.Msg) (tea.Model, tea.Cmd) {
-		if msg.err != nil {
+	confirm, cmd := m.confirm.Update(msg)
-			m.err = msg.err
+	m.confirm = &confirm
-		} else {
+	if m.confirm.Done() {
-			// Reload history
+		if m.confirm.Result() {
-			cmds = append(cmds, m.loadHistory)
+			cmd = m.deleteCurrentEntry()
 		}
+		m.confirm = nil
+	}
+	return m, cmd
+}
-	case historyCleanedMsg:
+func (m HistoryModel) handleWindowSize(msg tea.WindowSizeMsg) (tea.Model, tea.Cmd) {
-		if msg.err != nil {
+	m.width = msg.Width
-			m.err = msg.err
+	m.height = msg.Height
-		} else {
+	m.help.Width = msg.Width
-			// Reload history
+	m.updateList()
-			cmds = append(cmds, m.loadHistory)
+	return m, nil
+}
+func (m HistoryModel) handleKeyMsg(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
+	if m.searchMode {
+		return m.handleSearchKey(msg)
+	}
+	return m.handleNormalKey(msg)
+}
+func (m HistoryModel) handleSearchKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
+	switch msg.String() {
+	case "esc":
+		m.searchMode = false
+		m.search.Blur()
+		return m, nil
+	case "enter":
+		m.searchMode = false
+		m.search.Blur()
+		return m, m.performSearch(m.search.Value())
+	default:
+		var cmd tea.Cmd
+		m.search, cmd = m.search.Update(msg)
+		return m, cmd
+	}
+}
+func (m HistoryModel) handleNormalKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
+	if updated, cmd, handled := m.handleGlobalKeys(msg); handled {
+		return updated, cmd
+	}
+	if updated, handled := m.handleTabSwitchKeys(msg); handled {
+		return updated, nil
+	}
+	if updated, cmd, handled := m.handleEntryActionKeys(msg); handled {
+		return updated, cmd
+	}
+	var cmd tea.Cmd
+	m.list, cmd = m.list.Update(msg)
+	return m, cmd
+}
+func (m HistoryModel) handleGlobalKeys(msg tea.KeyMsg) (HistoryModel, tea.Cmd, bool) {
+	switch {
+	case key.Matches(msg, m.keys.Quit):
+		return m, tea.Quit, true
+	case key.Matches(msg, m.keys.Help):
+		m.showHelp = !m.showHelp
+		return m, nil, true
+	case key.Matches(msg, m.keys.Search):
+		m.searchMode = true
+		m.search.Focus()
+		return m, textinput.Blink, true
+	default:
+		return m, nil, false
+	}
+}
+func (m HistoryModel) handleTabSwitchKeys(msg tea.KeyMsg) (HistoryModel, bool) {
+	switch {
+	case key.Matches(msg, m.keys.Tab1):
+		m.tabs.SetActive(0)
+	case key.Matches(msg, m.keys.Tab2):
+		m.tabs.SetActive(1)
+	case key.Matches(msg, m.keys.Tab3):
+		m.tabs.SetActive(2)
+	case key.Matches(msg, m.keys.Tab4):
+		m.tabs.SetActive(3)
+	case key.Matches(msg, m.keys.NextTab):
+		next := (m.tabs.Active + 1) % 4
+		m.tabs.SetActive(next)
+	case key.Matches(msg, m.keys.PrevTab):
+		prev := (m.tabs.Active + 3) % 4 // +3 is same as -1 mod 4
+		m.tabs.SetActive(prev)
+	default:
+		return m, false
+	}
+	m.updateList()
+	return m, true
+}
+func (m HistoryModel) handleEntryActionKeys(msg tea.KeyMsg) (HistoryModel, tea.Cmd, bool) {
+	switch {
+	case key.Matches(msg, m.keys.Open):
+		if item := m.list.SelectedItem(); item != nil {
+			if hi, ok := item.(styles.HistoryItem); ok {
+				return m, m.openURL(hi.URL), true
+			}
+		}
+		return m, nil, true
+	case key.Matches(msg, m.keys.Delete):
+		if m.list.SelectedItem() != nil {
+			confirm := styles.NewConfirm(m.theme, "Delete this entry?")
+			m.confirm = &confirm
 		}
+		return m, nil, true
+	case key.Matches(msg, m.keys.DeleteDomain):
+		if item := m.list.SelectedItem(); item != nil {
+			if hi, ok := item.(styles.HistoryItem); ok {
+				confirm := styles.NewConfirm(m.theme, "Delete all from "+hi.Domain+"?")
+				m.confirm = &confirm
+			}
+		}
+		return m, nil, true
+	case key.Matches(msg, m.keys.Cleanup):
+		cleanup := styles.NewCleanup(m.theme)
+		m.cleanup = &cleanup
+		return m, nil, true
+	case key.Matches(msg, m.keys.Filter):
+		m.cycleDomainFilter()
+		m.updateList()
+		return m, nil, true
+	default:
+		return m, nil, false
 	}
+}
-	return m, tea.Batch(cmds...)
+func (m HistoryModel) handleHistoryLoaded(msg historyLoadedMsg) (tea.Model, tea.Cmd) {
+	if msg.err != nil {
+		m.err = msg.err
+		return m, nil
+	}
+	m.entries = msg.entries
+	m.updateList()
+	return m, nil
+}
+func (m HistoryModel) handleDomainStats(msg domainStatsMsg) (tea.Model, tea.Cmd) {
+	if msg.err != nil {
+		m.err = msg.err
+		return m, nil
+	}
+	m.topDomains = msg.domains
+	return m, nil
+}
+func (m HistoryModel) handleHistoryDeleted(msg historyDeletedMsg) (tea.Model, tea.Cmd) {
+	if msg.err != nil {
+		m.err = msg.err
+		return m, nil
+	}
+	return m, m.loadHistory
+}
+func (m HistoryModel) handleHistoryCleaned(msg historyCleanedMsg) (tea.Model, tea.Cmd) {
+	if msg.err != nil {
+		m.err = msg.err
+		return m, nil
+	}
+	return m, m.loadHistory
 }
 // updateList updates the list with entries for the current tab.
 // openURL opens a URL in the default browser.
 func (m HistoryModel) openURL(urlStr string) tea.Cmd {
 	return func() tea.Msg {
+		log := logging.FromContext(m.ctx)
+		log.Debug().Str("url", urlStr).Msg("opening URL in browser")
 		// Use xdg-open on Linux
 		_ = exec.Command("xdg-open", urlStr).Start()
 		return nil
 // View implements tea.Model.
 func (m HistoryListModel) View() string {
+	if m.err != nil {
+		return ""
+	}
 	return "" // Output handled externally
 }

M internal/cli/model/stats.go +17 -9

 	// Build sparkline using block characters
 	blocks := []rune{'▁', '▂', '▃', '▄', '▅', '▆', '▇', '█'}
+	const (
+		sparklineMaxDays  = 30
+		sparklineMaxIndex = 7
+	)
 	var result string
 	// Show last 30 days or available data
 	days := m.analytics.DailyVisits
-	if len(days) > 30 {
+	if len(days) > sparklineMaxDays {
-		days = days[len(days)-30:]
+		days = days[len(days)-sparklineMaxDays:]
 	}
 	for _, d := range days {
 		// Scale to block index (0-7)
-		idx := int(float64(d.Visits) / float64(maxVisits) * 7)
+		idx := int(float64(d.Visits) / float64(maxVisits) * sparklineMaxIndex)
-		if idx > 7 {
+		if idx > sparklineMaxIndex {
-			idx = 7
+			idx = sparklineMaxIndex
 		}
 		result += string(blocks[idx])
 	}
 // formatNumber formats a number for display.
 func formatNumber(n int64) string {
+	const (
+		formatMillion = 1_000_000
+		formatThousand = 1_000
+	)
 	switch {
-	case n >= 1000000:
+	case n >= formatMillion:
-		return fmt.Sprintf("%.1fM", float64(n)/1000000)
+		return fmt.Sprintf("%.1fM", float64(n)/formatMillion)
-	case n >= 1000:
+	case n >= formatThousand:
-		return fmt.Sprintf("%.1fK", float64(n)/1000)
+		return fmt.Sprintf("%.1fK", float64(n)/formatThousand)
 	default:
 		return fmt.Sprintf("%d", n)
 	}

M internal/cli/styles/about.go +6 -1

 		fmt.Sprintf("%s %s %s", iconStyle.Render(IconGo), keyStyle.Render("Go"), valStyle.Render(info.GoVersion)),
 		"",
 		fmt.Sprintf("%s %s", iconStyle.Render(IconGithub), keyStyle.Render(build.RepoURL())),
-		fmt.Sprintf("%s %s %s", iconStyle.Render(IconHeart), keyStyle.Render("Made with love by"), valStyle.Render(strings.Join(build.Contributors(), ", "))),
+		fmt.Sprintf(
+			"%s %s %s",
+			iconStyle.Render(IconHeart),
+			keyStyle.Render("Made with love by"),
+			valStyle.Render(strings.Join(build.Contributors(), ", ")),
+		),
 	}
 	return strings.Join(lines, "\n")

M internal/cli/styles/badge.go +18 -8

 // StatusBadge renders a status badge with custom colors.
 func (t *Theme) StatusBadge(text string, fg, bg lipgloss.Color) string {
-	style := lipgloss.NewStyle().
+	style := lipgloss.NewStyle()
+	if t != nil {
+		style = t.Badge
+	}
+	style = style.
 		Foreground(fg).
 		Background(bg).
 		Padding(0, 1)
 func RelativeTime(tm time.Time) string {
 	now := time.Now()
 	diff := now.Sub(tm)
+	const (
+		hoursPerDay  = 24
+		daysPerWeek  = 7
+		daysPerMonth = 30
+		daysPerYear  = 365
+	)
 	switch {
 	case diff < time.Minute:
 			return "1m ago"
 		}
 		return fmt.Sprintf("%dm ago", mins)
-	case diff < 24*time.Hour:
+	case diff < hoursPerDay*time.Hour:
 		hours := int(diff.Hours())
 		if hours == 1 {
 			return "1h ago"
 		}
 		return fmt.Sprintf("%dh ago", hours)
-	case diff < 7*24*time.Hour:
+	case diff < time.Duration(daysPerWeek*hoursPerDay)*time.Hour:
-		days := int(diff.Hours() / 24)
+		days := int(diff.Hours() / hoursPerDay)
 		if days == 1 {
 			return "1d ago"
 		}
 		return fmt.Sprintf("%dd ago", days)
-	case diff < 30*24*time.Hour:
+	case diff < time.Duration(daysPerMonth*hoursPerDay)*time.Hour:
-		weeks := int(diff.Hours() / (24 * 7))
+		weeks := int(diff.Hours() / (hoursPerDay * daysPerWeek))
 		if weeks == 1 {
 			return "1w ago"
 		}
 		return fmt.Sprintf("%dw ago", weeks)
-	case diff < 365*24*time.Hour:
+	case diff < time.Duration(daysPerYear*hoursPerDay)*time.Hour:
-		months := int(diff.Hours() / (24 * 30))
+		months := int(diff.Hours() / (hoursPerDay * daysPerMonth))
 		if months == 1 {
 			return "1mo ago"
 		}

M internal/cli/styles/cleanup.go +6 -3

 	Ranges    []CleanupRangeInfo
 	Selected  int
 	Confirmed bool
-	Cancelled bool
+	Canceled bool
 	theme     *Theme
 }
 // Init implements tea.Model.
 func (m CleanupModel) Init() tea.Cmd {
+	if m.theme == nil {
+		return nil
+	}
 	return nil
 }
 		case key.Matches(msg, keys.Confirm):
 			m.Confirmed = true
 		case key.Matches(msg, keys.Cancel):
-			m.Cancelled = true
+			m.Canceled = true
 		}
 	}
 // Done returns true if the modal is complete.
 func (m CleanupModel) Done() bool {
-	return m.Confirmed || m.Cancelled
+	return m.Confirmed || m.Canceled
 }
 // SelectedRange returns the selected cleanup range.

M internal/cli/styles/confirm.go +6 -3

 	Message   string
 	Yes       bool // Current selection
 	Confirmed bool // User pressed enter
-	Cancelled bool // User pressed escape
+	Canceled bool // User pressed escape
 	theme     *Theme
 }
 // Init implements tea.Model.
 func (m ConfirmModel) Init() tea.Cmd {
+	if m.theme == nil {
+		return nil
+	}
 	return nil
 }
 		case key.Matches(msg, keys.Confirm):
 			m.Confirmed = true
 		case key.Matches(msg, keys.Cancel):
-			m.Cancelled = true
+			m.Canceled = true
 		}
 	}
 // Done returns true if the dialog is complete.
 func (m ConfirmModel) Done() bool {
-	return m.Confirmed || m.Cancelled
+	return m.Confirmed || m.Canceled
 }
 // Result returns true if user confirmed "Yes".

M internal/cli/styles/doctor.go +24 -8

 	"github.com/charmbracelet/lipgloss"
 )
+const (
+	statusYes = "Yes"
+	statusNo  = "No"
+)
 type DoctorRenderer struct {
 	theme *Theme
 }
 	lines := make([]string, 0, len(rt.Checks)+2)
 	if strings.TrimSpace(rt.Prefix) != "" {
-		lines = append(lines, fmt.Sprintf("%s %s %s", r.theme.Subtle.Render("Prefix"), r.theme.Normal.Render(rt.Prefix), r.theme.Subtle.Render("(runtime override)")))
+		lines = append(lines, fmt.Sprintf(
+			"%s %s %s",
+			r.theme.Subtle.Render("Prefix"),
+			r.theme.Normal.Render(rt.Prefix),
+			r.theme.Subtle.Render("(runtime override)"),
+		))
 	}
 	for _, c := range rt.Checks {
 	gstIcon := IconCheck
 	gstStyle := r.theme.SuccessStyle
-	gstText := "Yes"
+	gstText := statusYes
 	if !m.GStreamerAvailable {
 		gstIcon = IconX
 		gstStyle = r.theme.ErrorStyle
-		gstText = "No"
+		gstText = statusNo
 	}
 	lines = append(lines, fmt.Sprintf("%s %s %s", gstStyle.Render(gstIcon), r.theme.Subtle.Render("GStreamer"), gstStyle.Render(gstText)))
 	hwIcon := IconWarning
 	hwStyle := r.theme.WarningStyle
-	hwText := "No"
+	hwText := statusNo
 	if m.HWAccelAvailable {
 		hwIcon = IconCheck
 		hwStyle = r.theme.SuccessStyle
-		hwText = "Yes"
+		hwText = statusYes
 	}
 	lines = append(lines, fmt.Sprintf("%s %s %s", hwStyle.Render(hwIcon), r.theme.Subtle.Render("HW decode"), hwStyle.Render(hwText)))
 	av1Icon := IconWarning
 	av1Style := r.theme.WarningStyle
-	av1Text := "No"
+	av1Text := statusNo
 	if m.AV1HWAvailable {
 		av1Icon = IconCheck
 		av1Style = r.theme.SuccessStyle
-		av1Text = "Yes"
+		av1Text = statusYes
 	}
-	lines = append(lines, fmt.Sprintf("%s %s %s %s", av1Style.Render(av1Icon), r.theme.Subtle.Render("AV1"), av1Style.Render(av1Text), r.theme.Subtle.Render("(preferred)")))
+	lines = append(lines, fmt.Sprintf(
+		"%s %s %s %s",
+		av1Style.Render(av1Icon),
+		r.theme.Subtle.Render("AV1"),
+		av1Style.Render(av1Text),
+		r.theme.Subtle.Render("(preferred)"),
+	))
 	plugins := []string{
 		fmt.Sprintf("%s VA (stateless): %s", r.theme.Subtle.Render("•"), pluginStatus(r.theme, m.HasVAPlugin, "recommended")),

M internal/cli/styles/list.go +27 -4

 // Height returns the height of each item.
 func (d HistoryDelegate) Height() int {
+	if d.Theme == nil {
+		return 2
+	}
 	return 2
 }
 // Spacing returns the spacing between items.
 func (d HistoryDelegate) Spacing() int {
+	if d.Theme == nil {
+		return 0
+	}
 	return 0
 }
 // Update handles item-level events.
 func (d HistoryDelegate) Update(_ tea.Msg, _ *list.Model) tea.Cmd {
+	if d.Theme == nil {
+		return nil
+	}
 	return nil
 }
 	t := d.Theme
 	isSelected := index == m.Index()
+	const (
+		maxTitleLength = 60
+		maxURLLength   = 50
+		ellipsisLength = 3
+	)
 	// Title line
 	title := hi.TitleValue()
-	if len(title) > 60 {
+	if len(title) > maxTitleLength {
-		title = title[:57] + "..."
+		title = title[:maxTitleLength-ellipsisLength] + "..."
 	}
 	// URL/description line
 	url := hi.URL
-	if len(url) > 50 {
+	if len(url) > maxURLLength {
-		url = url[:47] + "..."
+		url = url[:maxURLLength-ellipsisLength] + "..."
 	}
 	// Metadata badges
 // Height returns the height of each item.
 func (d SimpleDelegate) Height() int {
+	if d.Theme == nil {
+		return 1
+	}
 	return 1
 }
 // Spacing returns the spacing between items.
 func (d SimpleDelegate) Spacing() int {
+	if d.Theme == nil {
+		return 0
+	}
 	return 0
 }
 // Update handles item-level events.
 func (d SimpleDelegate) Update(_ tea.Msg, _ *list.Model) tea.Cmd {
+	if d.Theme == nil {
+		return nil
+	}
 	return nil
 }

M internal/cli/styles/table.go +8 -4

 // formatInt formats an integer for display.
 func formatInt(n int) string {
+	const (
+		formatMillion = 1_000_000
+		formatThousand = 1_000
+	)
 	switch {
-	case n >= 1000000:
+	case n >= formatMillion:
-		return formatFloat(float64(n)/1000000) + "M"
+		return formatFloat(float64(n)/formatMillion) + "M"
-	case n >= 1000:
+	case n >= formatThousand:
-		return formatFloat(float64(n)/1000) + "K"
+		return formatFloat(float64(n)/formatThousand) + "K"
 	default:
 		return intToString(n)
 	}

M internal/cli/styles/tabs.go +2 -1


@@ -64,7 +64,8 @@ func (m TabsModel) View() string {
64		row += tab	64		row += tab
65		}	65		}
66			66
67	-	return m.theme.TabBar.Width(80).Render(row)	67	+	const tabBarWidth = 80
			68	+	return m.theme.TabBar.Width(tabBarWidth).Render(row)
68		}	69		}
69			70
70		// ViewCompact renders a compact tab bar without separators.	71		// ViewCompact renders a compact tab bar without separators.

M internal/cli/styles/theme.go +3 -0


@@ -218,5 +218,8 @@ func (t *Theme) buildStyles() {
218		218
219	// Renderer returns a lipgloss renderer for the current output.	219		// Renderer returns a lipgloss renderer for the current output.
220	func (t Theme) Renderer() lipgloss.Renderer {	220		func (t Theme) Renderer() lipgloss.Renderer {
		221	+	if t == nil {
		222	+	return lipgloss.DefaultRenderer()
		223	+	}
221	return lipgloss.DefaultRenderer()	224		return lipgloss.DefaultRenderer()
222	}	225		}

M internal/domain/validation/fonts.go +3 -2

 import "strings"
-func ValidateFontFamily(field string, value string) []string {
+func ValidateFontFamily(field, value string) []string {
+	const maxFontFamilyLength = 200
 	value = strings.TrimSpace(value)
 	var errs []string
 		errs = append(errs, field+" must not contain newlines")
 	}
-	if len(value) > 200 {
+	if len(value) > maxFontFamilyLength {
 		errs = append(errs, field+" is too long")
 	}

M internal/domain/validation/shortcuts.go +2 -1

 }
 func ValidateShortcutDescription(value string) []string {
+	const maxShortcutDescriptionLength = 200
 	var errs []string
 	value = strings.TrimSpace(value)
 	if strings.ContainsAny(value, "\r\n") {
 		errs = append(errs, "shortcut description must not contain newlines")
 	}
-	if len(value) > 200 {
+	if len(value) > maxShortcutDescriptionLength {
 		errs = append(errs, "shortcut description is too long")
 	}
 	return errs

M internal/infrastructure/config/loader.go +92 -46

 	m.mu.Lock()
 	defer m.mu.Unlock()
-	// Ensure directories exist
 	if err := EnsureDirectories(); err != nil {
 		return fmt.Errorf("failed to ensure directories: %w", err)
 	}
-	// Set defaults
 	m.setDefaults()
-	// Read config file if it exists
+	if err := m.readConfigFile(); err != nil {
+		return err
+	}
+	config, err := m.unmarshalConfig()
+	if err != nil {
+		return err
+	}
+	if err := ensureDatabasePath(config); err != nil {
+		return err
+	}
+	normalizeConfig(config)
+	if err := validateConfig(config); err != nil {
+		return fmt.Errorf("configuration validation failed: %w", err)
+	}
+	m.config = config
+	return nil
+}
+func (m *Manager) readConfigFile() error {
 	if err := m.viper.ReadInConfig(); err != nil {
 		var configFileNotFoundError viper.ConfigFileNotFoundError
 		if errors.As(err, &configFileNotFoundError) {
-			// Config file not found, create default one
+			if createErr := m.createDefaultConfig(); createErr != nil {
-			if err := m.createDefaultConfig(); err != nil {
 				configDir, _ := GetConfigDir()
-				return fmt.Errorf("failed to create default config at %s: %w\nTry creating the directory manually or check permissions", configDir, err)
+				return fmt.Errorf(
+					"failed to create default config at %s: %w\nTry creating the directory manually or check permissions",
+					configDir,
+					createErr,
+				)
 			}
-			// Re-read the newly created config file
+			if rereadErr := m.viper.ReadInConfig(); rereadErr != nil {
-			if err := m.viper.ReadInConfig(); err != nil {
+				return fmt.Errorf(
-				return fmt.Errorf("failed to read newly created config file: %w\nThe config file was created but couldn't be read. Please check the file format", err)
+					"failed to read newly created config file: %w\nThe config file was created but couldn't be read. Please check the file format",
+					rereadErr,
+				)
 			}
 		} else {
 			configFile := m.viper.ConfigFileUsed()
 			return fmt.Errorf("failed to read config file at %s: %w\nCheck the file format (must be valid TOML) and permissions", configFile, err)
 		}
 	}
+	return nil
+}
-	// Unmarshal into config struct
+func (m *Manager) unmarshalConfig() (*Config, error) {
 	config := &Config{}
 	if err := m.viper.Unmarshal(config); err != nil {
 		configFile := m.viper.ConfigFileUsed()
-		return fmt.Errorf("failed to parse config file at %s: %w\nCheck for syntax errors, invalid values, or type mismatches", configFile, err)
+		return nil, fmt.Errorf(
+			"failed to parse config file at %s: %w\nCheck for syntax errors, invalid values, or type mismatches",
+			configFile,
+			err,
+		)
 	}
+	return config, nil
+}
-	// Set database path if not specified
+func ensureDatabasePath(config *Config) error {
-	if config.Database.Path == "" {
+	if config.Database.Path != "" {
-		dbPath, err := GetDatabaseFile()
+		return nil
-		if err != nil {
+	}
-			return fmt.Errorf("failed to get database path: %w", err)
+	dbPath, err := GetDatabaseFile()
-		}
+	if err != nil {
-		config.Database.Path = dbPath
+		return fmt.Errorf("failed to get database path: %w", err)
 	}
+	config.Database.Path = dbPath
+	return nil
+}
-	// Normalize/validate rendering mode using switch statement
+func normalizeConfig(config *Config) {
 	switch strings.ToLower(string(config.RenderingMode)) {
 	case "", string(RenderingModeAuto):
 		config.RenderingMode = RenderingModeAuto
 		config.RenderingMode = RenderingModeAuto
 	}
-	// Validate ColorScheme setting using switch statement
 	switch config.Appearance.ColorScheme {
-	case "prefer-dark", "prefer-light", ThemeDefault:
+	case ThemePreferDark, ThemePreferLight, ThemeDefault:
-		// Valid values - no changes needed
 	case "":
-		// Empty string is treated the same as "default"
 		config.Appearance.ColorScheme = ThemeDefault
 	default:
-		// Invalid value - reset to default
 		config.Appearance.ColorScheme = ThemeDefault
 	}
-	// Validate Media.HardwareDecodingMode using switch statement
 	switch strings.ToLower(string(config.Media.HardwareDecodingMode)) {
 	case "", string(HardwareDecodingAuto):
 		config.Media.HardwareDecodingMode = HardwareDecodingAuto
 		config.Media.HardwareDecodingMode = HardwareDecodingAuto
 	}
-	// Normalize runtime prefix
 	config.Runtime.Prefix = strings.TrimSpace(config.Runtime.Prefix)
-	// Validate all config values
-	if err := validateConfig(config); err != nil {
-		return fmt.Errorf("configuration validation failed: %w", err)
-	}
-	m.config = config
-	return nil
 }
 // Get returns the current configuration (thread-safe).
 	// Note: Database.Path is set dynamically in Load(), no defaults needed
-	// History defaults
+	m.setHistoryDefaults(defaults)
+	m.setSearchDefaults(defaults)
+	m.setDmenuDefaults(defaults)
+	m.setLoggingDefaults(defaults)
+	m.setDebugDefaults(defaults)
+	m.setAppearanceDefaults(defaults)
+	m.setRenderingDefaults(defaults)
+	m.setWorkspaceDefaults(defaults)
+	m.setContentFilteringDefaults(defaults)
+	m.setOmniboxDefaults(defaults)
+	m.setMediaDefaults(defaults)
+	m.setRuntimeDefaults(defaults)
+}
+func (m *Manager) setHistoryDefaults(defaults *Config) {
 	m.viper.SetDefault("history.max_entries", defaults.History.MaxEntries)
 	m.viper.SetDefault("history.retention_period_days", defaults.History.RetentionPeriodDays)
 	m.viper.SetDefault("history.cleanup_interval_days", defaults.History.CleanupIntervalDays)
+}
-	// Search shortcuts defaults
+func (m *Manager) setSearchDefaults(defaults *Config) {
 	m.viper.SetDefault("search_shortcuts", defaults.SearchShortcuts)
 	m.viper.SetDefault("default_search_engine", defaults.DefaultSearchEngine)
+}
-	// Dmenu defaults
+func (m *Manager) setDmenuDefaults(defaults *Config) {
 	m.viper.SetDefault("dmenu.max_history_items", defaults.Dmenu.MaxHistoryItems)
 	m.viper.SetDefault("dmenu.show_visit_count", defaults.Dmenu.ShowVisitCount)
 	m.viper.SetDefault("dmenu.show_last_visited", defaults.Dmenu.ShowLastVisited)
 	m.viper.SetDefault("dmenu.url_prefix", defaults.Dmenu.URLPrefix)
 	m.viper.SetDefault("dmenu.date_format", defaults.Dmenu.DateFormat)
 	m.viper.SetDefault("dmenu.sort_by_visit_count", defaults.Dmenu.SortByVisitCount)
+}
-	// Logging defaults
+func (m *Manager) setLoggingDefaults(defaults *Config) {
 	m.viper.SetDefault("logging.level", defaults.Logging.Level)
 	m.viper.SetDefault("logging.format", defaults.Logging.Format)
 	m.viper.SetDefault("logging.max_age", defaults.Logging.MaxAge)
 	m.viper.SetDefault("logging.log_dir", defaults.Logging.LogDir)
 	m.viper.SetDefault("logging.enable_file_log", defaults.Logging.EnableFileLog)
 	m.viper.SetDefault("logging.capture_console", defaults.Logging.CaptureConsole)
+}
-	// Debug defaults
+func (m *Manager) setDebugDefaults(defaults *Config) {
 	m.viper.SetDefault("debug.enable_devtools", defaults.Debug.EnableDevTools)
+}
-	// Appearance defaults
+func (m *Manager) setAppearanceDefaults(defaults *Config) {
 	m.viper.SetDefault("appearance.sans_font", defaults.Appearance.SansFont)
 	m.viper.SetDefault("appearance.serif_font", defaults.Appearance.SerifFont)
 	m.viper.SetDefault("appearance.monospace_font", defaults.Appearance.MonospaceFont)
 	m.viper.SetDefault("appearance.light_palette", defaults.Appearance.LightPalette)
 	m.viper.SetDefault("appearance.dark_palette", defaults.Appearance.DarkPalette)
 	m.viper.SetDefault("appearance.color_scheme", defaults.Appearance.ColorScheme)
+}
-	// Rendering defaults
+func (m *Manager) setRenderingDefaults(defaults *Config) {
 	m.viper.SetDefault("rendering_mode", string(RenderingModeGPU))
 	m.viper.SetDefault("default_webpage_zoom", defaults.DefaultWebpageZoom)
 	m.viper.SetDefault("default_ui_scale", defaults.DefaultUIScale)
+}
-	// Workspace defaults
+func (m *Manager) setWorkspaceDefaults(defaults *Config) {
 	m.viper.SetDefault("workspace.pane_mode.activation_shortcut", defaults.Workspace.PaneMode.ActivationShortcut)
 	m.viper.SetDefault("workspace.pane_mode.timeout_ms", defaults.Workspace.PaneMode.TimeoutMilliseconds)
 	m.viper.SetDefault("workspace.pane_mode.actions", defaults.Workspace.PaneMode.Actions)
 	m.viper.SetDefault("workspace.styling.tab_mode_border_width", defaults.Workspace.Styling.TabModeBorderWidth)
 	m.viper.SetDefault("workspace.styling.tab_mode_border_color", defaults.Workspace.Styling.TabModeBorderColor)
 	m.viper.SetDefault("workspace.styling.transition_duration", defaults.Workspace.Styling.TransitionDuration)
+}
-	// Content filtering
+func (m *Manager) setContentFilteringDefaults(defaults *Config) {
 	m.viper.SetDefault("content_filtering.enabled", defaults.ContentFiltering.Enabled)
 	m.viper.SetDefault("content_filtering.auto_update", defaults.ContentFiltering.AutoUpdate)
+}
-	// Omnibox defaults
+func (m *Manager) setOmniboxDefaults(defaults *Config) {
 	m.viper.SetDefault("omnibox.initial_behavior", defaults.Omnibox.InitialBehavior)
+}
-	// Media defaults
+func (m *Manager) setMediaDefaults(defaults *Config) {
 	m.viper.SetDefault("media.hardware_decoding", string(defaults.Media.HardwareDecodingMode))
 	m.viper.SetDefault("media.prefer_av1", defaults.Media.PreferAV1)
 	m.viper.SetDefault("media.show_diagnostics", defaults.Media.ShowDiagnosticsOnStartup)
+}
-	// Runtime defaults
+func (m *Manager) setRuntimeDefaults(defaults *Config) {
 	m.viper.SetDefault("runtime.prefix", defaults.Runtime.Prefix)
 }

M internal/infrastructure/config/schema.go +24 -17

 	DefaultWebpageZoom float64 `mapstructure:"default_webpage_zoom" yaml:"default_webpage_zoom" toml:"default_webpage_zoom"`
 	// DefaultUIScale sets the default UI scale for GTK widgets (1.0 = 100%, 2.0 = 200%)
 	DefaultUIScale float64 `mapstructure:"default_ui_scale" yaml:"default_ui_scale" toml:"default_ui_scale"`
-	// Workspace defines workspace, pane, and tab handling behaviour.
+	// Workspace defines workspace, pane, and tab handling behavior.
 	Workspace WorkspaceConfig `mapstructure:"workspace" yaml:"workspace" toml:"workspace"`
 	// ContentFiltering controls ad blocking and content filtering
 	ContentFiltering ContentFilteringConfig `mapstructure:"content_filtering" yaml:"content_filtering" toml:"content_filtering"`
 // ThemeDefault is the default theme setting (follows system).
 const ThemeDefault = "default"
+const (
+	// ThemePreferDark explicitly selects dark theme.
+	ThemePreferDark = "prefer-dark"
+	// ThemePreferLight explicitly selects light theme.
+	ThemePreferLight = "prefer-light"
+)
 // MediaConfig holds video playback and hardware acceleration preferences.
 type MediaConfig struct {
 	// HardwareDecodingMode controls hardware vs software video decoding
 	EnableDevTools bool `mapstructure:"enable_devtools" yaml:"enable_devtools" toml:"enable_devtools"`
 }
-// WorkspaceConfig captures layout, pane, and tab behaviour preferences.
+// WorkspaceConfig captures layout, pane, and tab behavior preferences.
 type WorkspaceConfig struct {
-	// PaneMode defines modal pane behaviour and bindings.
+	// PaneMode defines modal pane behavior and bindings.
 	PaneMode PaneModeConfig `mapstructure:"pane_mode" yaml:"pane_mode" toml:"pane_mode" json:"pane_mode"`
-	// TabMode defines modal tab behaviour and bindings (Alt+T).
+	// TabMode defines modal tab behavior and bindings (Alt+T).
 	TabMode TabModeConfig `mapstructure:"tab_mode" yaml:"tab_mode" toml:"tab_mode" json:"tab_mode"`
 	// Shortcuts holds global (non-modal) keyboard shortcuts.
 	Shortcuts GlobalShortcutsConfig `mapstructure:"shortcuts" yaml:"shortcuts" toml:"shortcuts" json:"shortcuts"`
 	// TabBarPosition determines tab bar placement: "top" or "bottom".
 	TabBarPosition string `mapstructure:"tab_bar_position" yaml:"tab_bar_position" toml:"tab_bar_position" json:"tab_bar_position"`
 	// HideTabBarWhenSingleTab hides the tab bar when only one tab exists.
-	HideTabBarWhenSingleTab bool `mapstructure:"hide_tab_bar_when_single_tab" yaml:"hide_tab_bar_when_single_tab" toml:"hide_tab_bar_when_single_tab" json:"hide_tab_bar_when_single_tab"`
+	HideTabBarWhenSingleTab bool `mapstructure:"hide_tab_bar_when_single_tab" yaml:"hide_tab_bar_when_single_tab" toml:"hide_tab_bar_when_single_tab" json:"hide_tab_bar_when_single_tab"` //nolint:lll // struct tags must stay on one line
 	// Popups configures default popup placement rules.
 	Popups PopupBehaviorConfig `mapstructure:"popups" yaml:"popups" toml:"popups" json:"popups"`
 	// Styling configures workspace visual appearance.
 	Styling WorkspaceStylingConfig `mapstructure:"styling" yaml:"styling" toml:"styling" json:"styling"`
 }
-// PaneModeConfig defines modal behaviour for pane management.
+// PaneModeConfig defines modal behavior for pane management.
 type PaneModeConfig struct {
-	ActivationShortcut  string              `mapstructure:"activation_shortcut" yaml:"activation_shortcut" toml:"activation_shortcut" json:"activation_shortcut"`
+	ActivationShortcut  string              `mapstructure:"activation_shortcut" yaml:"activation_shortcut" toml:"activation_shortcut" json:"activation_shortcut"` //nolint:lll // struct tags must stay on one line
 	TimeoutMilliseconds int                 `mapstructure:"timeout_ms" yaml:"timeout_ms" toml:"timeout_ms" json:"timeout_ms"`
 	Actions             map[string][]string `mapstructure:"actions" yaml:"actions" toml:"actions" json:"actions"`
 }
 	return keyToAction
 }
-// TabModeConfig defines modal behaviour for tab management (Zellij-style).
+// TabModeConfig defines modal behavior for tab management (Zellij-style).
 type TabModeConfig struct {
-	ActivationShortcut  string              `mapstructure:"activation_shortcut" yaml:"activation_shortcut" toml:"activation_shortcut" json:"activation_shortcut"`
+	ActivationShortcut  string              `mapstructure:"activation_shortcut" yaml:"activation_shortcut" toml:"activation_shortcut" json:"activation_shortcut"` //nolint:lll // struct tags must stay on one line
 	TimeoutMilliseconds int                 `mapstructure:"timeout_ms" yaml:"timeout_ms" toml:"timeout_ms" json:"timeout_ms"`
 	Actions             map[string][]string `mapstructure:"actions" yaml:"actions" toml:"actions" json:"actions"`
 }
 	OpenInNewPane bool `mapstructure:"open_in_new_pane" yaml:"open_in_new_pane" toml:"open_in_new_pane" json:"open_in_new_pane"`
 	// FollowPaneContext determines if popup placement follows parent pane context
-	FollowPaneContext bool `mapstructure:"follow_pane_context" yaml:"follow_pane_context" toml:"follow_pane_context" json:"follow_pane_context"`
+	FollowPaneContext bool `mapstructure:"follow_pane_context" yaml:"follow_pane_context" toml:"follow_pane_context" json:"follow_pane_context"` //nolint:lll // struct tags must stay on one line
 	// BlankTargetBehavior determines how target="_blank" links are opened
 	// Accepted values: "split", "stacked" (default), "tabbed"
 	// This is separate from Behavior which controls JavaScript popups
-	BlankTargetBehavior string `mapstructure:"blank_target_behavior" yaml:"blank_target_behavior" toml:"blank_target_behavior" json:"blank_target_behavior"`
+	BlankTargetBehavior string `mapstructure:"blank_target_behavior" yaml:"blank_target_behavior" toml:"blank_target_behavior" json:"blank_target_behavior"` //nolint:lll // struct tags must stay on one line
 	// EnableSmartDetection uses WebKitWindowProperties to detect popup vs tab intents
-	EnableSmartDetection bool `mapstructure:"enable_smart_detection" yaml:"enable_smart_detection" toml:"enable_smart_detection" json:"enable_smart_detection"`
+	EnableSmartDetection bool `mapstructure:"enable_smart_detection" yaml:"enable_smart_detection" toml:"enable_smart_detection" json:"enable_smart_detection"` //nolint:lll // struct tags must stay on one line
 	// OAuthAutoClose enables auto-closing OAuth popups after successful auth redirects
 	OAuthAutoClose bool `mapstructure:"oauth_auto_close" yaml:"oauth_auto_close" toml:"oauth_auto_close" json:"oauth_auto_close"`
 	BorderColor string `mapstructure:"border_color" yaml:"border_color" toml:"border_color" json:"border_color"`
 	// PaneModeBorderWidth in pixels for pane mode indicator border (Ctrl+P N overlay)
-	PaneModeBorderWidth int `mapstructure:"pane_mode_border_width" yaml:"pane_mode_border_width" toml:"pane_mode_border_width" json:"pane_mode_border_width"`
+	PaneModeBorderWidth int `mapstructure:"pane_mode_border_width" yaml:"pane_mode_border_width" toml:"pane_mode_border_width" json:"pane_mode_border_width"` //nolint:lll // struct tags must stay on one line
 	// PaneModeBorderColor for the pane mode indicator border (CSS color value or theme variable)
 	// Defaults to "#4A90E2" (blue) if not set
-	PaneModeBorderColor string `mapstructure:"pane_mode_border_color" yaml:"pane_mode_border_color" toml:"pane_mode_border_color" json:"pane_mode_border_color"`
+	PaneModeBorderColor string `mapstructure:"pane_mode_border_color" yaml:"pane_mode_border_color" toml:"pane_mode_border_color" json:"pane_mode_border_color"` //nolint:lll // struct tags must stay on one line
 	// TabModeBorderWidth in pixels for tab mode indicator border (Ctrl+P T overlay)
-	TabModeBorderWidth int `mapstructure:"tab_mode_border_width" yaml:"tab_mode_border_width" toml:"tab_mode_border_width" json:"tab_mode_border_width"`
+	TabModeBorderWidth int `mapstructure:"tab_mode_border_width" yaml:"tab_mode_border_width" toml:"tab_mode_border_width" json:"tab_mode_border_width"` //nolint:lll // struct tags must stay on one line
 	// TabModeBorderColor for the tab mode indicator border (CSS color value or theme variable)
 	// Defaults to "#FFA500" (orange) if not set - MUST be different from PaneModeBorderColor
-	TabModeBorderColor string `mapstructure:"tab_mode_border_color" yaml:"tab_mode_border_color" toml:"tab_mode_border_color" json:"tab_mode_border_color"`
+	TabModeBorderColor string `mapstructure:"tab_mode_border_color" yaml:"tab_mode_border_color" toml:"tab_mode_border_color" json:"tab_mode_border_color"` //nolint:lll // struct tags must stay on one line
 	// TransitionDuration in milliseconds for border animations
-	TransitionDuration int `mapstructure:"transition_duration" yaml:"transition_duration" toml:"transition_duration" json:"transition_duration"`
+	TransitionDuration int `mapstructure:"transition_duration" yaml:"transition_duration" toml:"transition_duration" json:"transition_duration"` //nolint:lll // struct tags must stay on one line
 }

M internal/infrastructure/config/validation.go +119 -59


@@ -11,7 +11,30 @@ import (
11		func validateConfig(config *Config) error {	11		func validateConfig(config *Config) error {
12		var validationErrors []string	12		var validationErrors []string
13			13
14	-	// Validate numeric ranges	14	+	validationErrors = append(validationErrors, validateHistory(config)...)
			15	+	validationErrors = append(validationErrors, validateDmenu(config)...)
			16	+	validationErrors = append(validationErrors, validateAppearance(config)...)
			17	+	validationErrors = append(validationErrors, validateSearchEngine(config)...)
			18	+	validationErrors = append(validationErrors, validatePopups(config)...)
			19	+	validationErrors = append(validationErrors, validateWorkspaceStyling(config)...)
			20	+	validationErrors = append(validationErrors, validatePaneMode(config)...)
			21	+	validationErrors = append(validationErrors, validateTabBar(config)...)
			22	+	validationErrors = append(validationErrors, validateTabMode(config)...)
			23	+	validationErrors = append(validationErrors, validateLogging(config)...)
			24	+	validationErrors = append(validationErrors, validateOmnibox(config)...)
			25	+	validationErrors = append(validationErrors, validateRendering(config)...)
			26	+	validationErrors = append(validationErrors, validateColorScheme(config)...)
			27	+
			28	+	// If there are validation errors, return them
			29	+	if len(validationErrors) > 0 {
			30	+	return fmt.Errorf("config validation failed:\n - %s", strings.Join(validationErrors, "\n - "))
			31	+	}
			32	+
			33	+	return nil
			34	+	}
			35	+
			36	+	func validateHistory(config *Config) []string {
			37	+	var validationErrors []string
15		if config.History.MaxEntries < 0 {	38		if config.History.MaxEntries < 0 {
16		validationErrors = append(validationErrors, "history.max_entries must be non-negative")	39		validationErrors = append(validationErrors, "history.max_entries must be non-negative")
17		}	40		}

@@ -21,19 +44,27 @@ func validateConfig(config *Config) error {
21		if config.History.CleanupIntervalDays < 0 {	44		if config.History.CleanupIntervalDays < 0 {
22		validationErrors = append(validationErrors, "history.cleanup_interval_days must be non-negative")	45		validationErrors = append(validationErrors, "history.cleanup_interval_days must be non-negative")
23		}	46		}
			47	+	return validationErrors
			48	+	}
24			49
			50	+	func validateDmenu(config *Config) []string {
25		if config.Dmenu.MaxHistoryItems < 0 {	51		if config.Dmenu.MaxHistoryItems < 0 {
26	-	validationErrors = append(validationErrors, "dmenu.max_history_items must be non-negative")	52	+	return []string{"dmenu.max_history_items must be non-negative"}
27		}	53		}
			54	+	return nil
			55	+	}
28			56
			57	+	func validateAppearance(config *Config) []string {
			58	+	var validationErrors []string
29		if config.Appearance.DefaultFontSize < 1 \|\| config.Appearance.DefaultFontSize > 72 {	59		if config.Appearance.DefaultFontSize < 1 \|\| config.Appearance.DefaultFontSize > 72 {
30		validationErrors = append(validationErrors, "appearance.default_font_size must be between 1 and 72")	60		validationErrors = append(validationErrors, "appearance.default_font_size must be between 1 and 72")
31		}	61		}
32	-
33		validationErrors = append(validationErrors, domainvalidation.ValidateFontFamily("appearance.sans_font", config.Appearance.SansFont)...)	62		validationErrors = append(validationErrors, domainvalidation.ValidateFontFamily("appearance.sans_font", config.Appearance.SansFont)...)
34		validationErrors = append(validationErrors, domainvalidation.ValidateFontFamily("appearance.serif_font", config.Appearance.SerifFont)...)	63		validationErrors = append(validationErrors, domainvalidation.ValidateFontFamily("appearance.serif_font", config.Appearance.SerifFont)...)
35	-	validationErrors = append(validationErrors, domainvalidation.ValidateFontFamily("appearance.monospace_font", config.Appearance.MonospaceFont)...)	64	+	validationErrors = append(
36	-		65	+	validationErrors,
			66	+	domainvalidation.ValidateFontFamily("appearance.monospace_font", config.Appearance.MonospaceFont)...,
			67	+	)
37		validationErrors = append(validationErrors, domainvalidation.ValidatePaletteHex(	68		validationErrors = append(validationErrors, domainvalidation.ValidatePaletteHex(
38		"appearance.light_palette",	69		"appearance.light_palette",
39		config.Appearance.LightPalette.Background,	70		config.Appearance.LightPalette.Background,

@@ -54,48 +85,60 @@ func validateConfig(config *Config) error {
54		config.Appearance.DarkPalette.Accent,	85		config.Appearance.DarkPalette.Accent,
55		config.Appearance.DarkPalette.Border,	86		config.Appearance.DarkPalette.Border,
56		)...)	87		)...)
57	-
58		if config.DefaultWebpageZoom < 0.1 \|\| config.DefaultWebpageZoom > 5.0 {	88		if config.DefaultWebpageZoom < 0.1 \|\| config.DefaultWebpageZoom > 5.0 {
59		validationErrors = append(validationErrors, "default_webpage_zoom must be between 0.1 and 5.0")	89		validationErrors = append(validationErrors, "default_webpage_zoom must be between 0.1 and 5.0")
60		}	90		}
61		if config.DefaultUIScale < 0.5 \|\| config.DefaultUIScale > 3.0 {	91		if config.DefaultUIScale < 0.5 \|\| config.DefaultUIScale > 3.0 {
62		validationErrors = append(validationErrors, "default_ui_scale must be between 0.5 and 3.0")	92		validationErrors = append(validationErrors, "default_ui_scale must be between 0.5 and 3.0")
63		}	93		}
			94	+	return validationErrors
			95	+	}
64			96
65	-	// Validate default search engine	97	+	func validateSearchEngine(config *Config) []string {
66		if config.DefaultSearchEngine == "" {	98		if config.DefaultSearchEngine == "" {
67	-	validationErrors = append(validationErrors, "default_search_engine cannot be empty")	99	+	return []string{"default_search_engine cannot be empty"}
68	-	} else if !strings.Contains(config.DefaultSearchEngine, "%s") {
69	-	validationErrors = append(validationErrors, "default_search_engine must contain %s placeholder for the search query")
70		}	100		}
			101	+	if !strings.Contains(config.DefaultSearchEngine, "%s") {
			102	+	return []string{"default_search_engine must contain %s placeholder for the search query"}
			103	+	}
			104	+	return nil
			105	+	}
71			106
72	-	// Validate popup behavior using switch statement (per CLAUDE.md)	107	+	func validatePopups(config *Config) []string {
			108	+	var validationErrors []string
73		switch config.Workspace.Popups.Behavior {	109		switch config.Workspace.Popups.Behavior {
74		case PopupBehaviorSplit, PopupBehaviorStacked, PopupBehaviorTabbed, PopupBehaviorWindowed:	110		case PopupBehaviorSplit, PopupBehaviorStacked, PopupBehaviorTabbed, PopupBehaviorWindowed:
75	-	// Valid
76		default:	111		default:
77	-	validationErrors = append(validationErrors, fmt.Sprintf("workspace.popups.behavior must be one of: split, stacked, tabbed, windowed (got: %s)", config.Workspace.Popups.Behavior))	112	+	validationErrors = append(validationErrors, fmt.Sprintf(
			113	+	"workspace.popups.behavior must be one of: split, stacked, tabbed, windowed (got: %s)",
			114	+	config.Workspace.Popups.Behavior,
			115	+	))
78		}	116		}
79			117
80	-	// Validate popup placement for split behavior using switch statement
81		if config.Workspace.Popups.Behavior == PopupBehaviorSplit {	118		if config.Workspace.Popups.Behavior == PopupBehaviorSplit {
82		switch config.Workspace.Popups.Placement {	119		switch config.Workspace.Popups.Placement {
83		case "right", "left", "top", "bottom":	120		case "right", "left", "top", "bottom":
84	-	// Valid
85		default:	121		default:
86	-	validationErrors = append(validationErrors, fmt.Sprintf("workspace.popups.placement must be one of: right, left, top, bottom (got: %s)", config.Workspace.Popups.Placement))	122	+	validationErrors = append(validationErrors, fmt.Sprintf(
			123	+	"workspace.popups.placement must be one of: right, left, top, bottom (got: %s)",
			124	+	config.Workspace.Popups.Placement,
			125	+	))
87		}	126		}
88		}	127		}
89			128
90	-	// Validate blank target behavior using switch statement
91		switch config.Workspace.Popups.BlankTargetBehavior {	129		switch config.Workspace.Popups.BlankTargetBehavior {
92		case "split", "stacked", "tabbed":	130		case "split", "stacked", "tabbed":
93	-	// Valid
94		default:	131		default:
95	-	validationErrors = append(validationErrors, fmt.Sprintf("workspace.popups.blank_target_behavior must be one of: split, stacked, tabbed (got: %s)", config.Workspace.Popups.BlankTargetBehavior))	132	+	validationErrors = append(validationErrors, fmt.Sprintf(
			133	+	"workspace.popups.blank_target_behavior must be one of: split, stacked, tabbed (got: %s)",
			134	+	config.Workspace.Popups.BlankTargetBehavior,
			135	+	))
96		}	136		}
			137	+	return validationErrors
			138	+	}
97			139
98	-	// Validate workspace styling values	140	+	func validateWorkspaceStyling(config *Config) []string {
			141	+	var validationErrors []string
99		if config.Workspace.Styling.BorderWidth < 0 {	142		if config.Workspace.Styling.BorderWidth < 0 {
100		validationErrors = append(validationErrors, "workspace.styling.border_width must be non-negative")	143		validationErrors = append(validationErrors, "workspace.styling.border_width must be non-negative")
101		}	144		}

@@ -108,18 +151,18 @@ func validateConfig(config *Config) error {
108		if config.Workspace.Styling.TransitionDuration < 0 {	151		if config.Workspace.Styling.TransitionDuration < 0 {
109		validationErrors = append(validationErrors, "workspace.styling.transition_duration must be non-negative")	152		validationErrors = append(validationErrors, "workspace.styling.transition_duration must be non-negative")
110		}	153		}
			154	+	return validationErrors
			155	+	}
111			156
112	-	// Validate pane mode timeout	157	+	func validatePaneMode(config *Config) []string {
			158	+	var validationErrors []string
113		if config.Workspace.PaneMode.TimeoutMilliseconds < 0 {	159		if config.Workspace.PaneMode.TimeoutMilliseconds < 0 {
114		validationErrors = append(validationErrors, "workspace.pane_mode.timeout_ms must be non-negative")	160		validationErrors = append(validationErrors, "workspace.pane_mode.timeout_ms must be non-negative")
115		}	161		}
116	-
117	-	// Validate pane mode actions
118		if len(config.Workspace.PaneMode.Actions) == 0 {	162		if len(config.Workspace.PaneMode.Actions) == 0 {
119		validationErrors = append(validationErrors, "workspace.pane_mode.actions cannot be empty")	163		validationErrors = append(validationErrors, "workspace.pane_mode.actions cannot be empty")
120		}	164		}
121			165
122	-	// Check for duplicate keys and empty action key lists in pane mode
123		seenKeys := make(map[string]string)	166		seenKeys := make(map[string]string)
124		for action, keys := range config.Workspace.PaneMode.Actions {	167		for action, keys := range config.Workspace.PaneMode.Actions {
125		if len(keys) == 0 {	168		if len(keys) == 0 {

@@ -127,31 +170,37 @@ func validateConfig(config *Config) error {
127		}	170		}
128		for _, key := range keys {	171		for _, key := range keys {
129		if existingAction, exists := seenKeys[key]; exists {	172		if existingAction, exists := seenKeys[key]; exists {
130	-	validationErrors = append(validationErrors, fmt.Sprintf("duplicate key binding '%s' found in pane_mode actions '%s' and '%s'", key, existingAction, action))	173	+	validationErrors = append(validationErrors, fmt.Sprintf(
			174	+	"duplicate key binding '%s' found in pane_mode actions '%s' and '%s'",
			175	+	key,
			176	+	existingAction,
			177	+	action,
			178	+	))
131		}	179		}
132		seenKeys[key] = action	180		seenKeys[key] = action
133		}	181		}
134		}	182		}
			183	+	return validationErrors
			184	+	}
135			185
136	-	// Validate tab bar position using switch statement	186	+	func validateTabBar(config *Config) []string {
137		switch config.Workspace.TabBarPosition {	187		switch config.Workspace.TabBarPosition {
138		case "top", "bottom":	188		case "top", "bottom":
139	-	// Valid	189	+	return nil
140		default:	190		default:
141	-	validationErrors = append(validationErrors, fmt.Sprintf("workspace.tab_bar_position must be 'top' or 'bottom' (got: %s)", config.Workspace.TabBarPosition))	191	+	return []string{fmt.Sprintf("workspace.tab_bar_position must be 'top' or 'bottom' (got: %s)", config.Workspace.TabBarPosition)}
142		}	192		}
			193	+	}
143			194
144	-	// Validate tab mode timeout	195	+	func validateTabMode(config *Config) []string {
			196	+	var validationErrors []string
145		if config.Workspace.TabMode.TimeoutMilliseconds < 0 {	197		if config.Workspace.TabMode.TimeoutMilliseconds < 0 {
146		validationErrors = append(validationErrors, "workspace.tab_mode.timeout_ms must be non-negative")	198		validationErrors = append(validationErrors, "workspace.tab_mode.timeout_ms must be non-negative")
147		}	199		}
148	-
149	-	// Validate tab mode actions
150		if len(config.Workspace.TabMode.Actions) == 0 {	200		if len(config.Workspace.TabMode.Actions) == 0 {
151		validationErrors = append(validationErrors, "workspace.tab_mode.actions cannot be empty")	201		validationErrors = append(validationErrors, "workspace.tab_mode.actions cannot be empty")
152		}	202		}
153			203
154	-	// Check for duplicate keys and empty action key lists in tab mode
155		tabSeenKeys := make(map[string]string)	204		tabSeenKeys := make(map[string]string)
156		for action, keys := range config.Workspace.TabMode.Actions {	205		for action, keys := range config.Workspace.TabMode.Actions {
157		if len(keys) == 0 {	206		if len(keys) == 0 {

@@ -159,61 +208,72 @@ func validateConfig(config *Config) error {
159		}	208		}
160		for _, key := range keys {	209		for _, key := range keys {
161		if existingAction, exists := tabSeenKeys[key]; exists {	210		if existingAction, exists := tabSeenKeys[key]; exists {
162	-	validationErrors = append(validationErrors, fmt.Sprintf("duplicate key binding '%s' found in tab_mode actions '%s' and '%s'", key, existingAction, action))	211	+	validationErrors = append(validationErrors, fmt.Sprintf(
			212	+	"duplicate key binding '%s' found in tab_mode actions '%s' and '%s'",
			213	+	key,
			214	+	existingAction,
			215	+	action,
			216	+	))
163		}	217		}
164		tabSeenKeys[key] = action	218		tabSeenKeys[key] = action
165		}	219		}
166		}	220		}
			221	+	return validationErrors
			222	+	}
167			223
168	-	// Validate logging values	224	+	func validateLogging(config *Config) []string {
			225	+	var validationErrors []string
169		if config.Logging.MaxAge < 0 {	226		if config.Logging.MaxAge < 0 {
170		validationErrors = append(validationErrors, "logging.max_age must be non-negative")	227		validationErrors = append(validationErrors, "logging.max_age must be non-negative")
171		}	228		}
172	-
173	-	// Validate logging level using switch statement
174		switch config.Logging.Level {	229		switch config.Logging.Level {
175		case "trace", "debug", "info", "warn", "error", "fatal", "":	230		case "trace", "debug", "info", "warn", "error", "fatal", "":
176	-	// Valid (empty uses default)
177		default:	231		default:
178	-	validationErrors = append(validationErrors, fmt.Sprintf("logging.level must be one of: trace, debug, info, warn, error, fatal (got: %s)", config.Logging.Level))	232	+	validationErrors = append(validationErrors, fmt.Sprintf(
			233	+	"logging.level must be one of: trace, debug, info, warn, error, fatal (got: %s)",
			234	+	config.Logging.Level,
			235	+	))
179		}	236		}
180	-
181	-	// Validate logging format using switch statement
182		switch config.Logging.Format {	237		switch config.Logging.Format {
183		case "text", "json", "console", "":	238		case "text", "json", "console", "":
184	-	// Valid (empty uses default)
185		default:	239		default:
186	-	validationErrors = append(validationErrors, fmt.Sprintf("logging.format must be one of: text, json, console (got: %s)", config.Logging.Format))	240	+	validationErrors = append(validationErrors, fmt.Sprintf(
			241	+	"logging.format must be one of: text, json, console (got: %s)",
			242	+	config.Logging.Format,
			243	+	))
187		}	244		}
			245	+	return validationErrors
			246	+	}
188			247
189	-	// Validate omnibox initial behavior using switch statement	248	+	func validateOmnibox(config *Config) []string {
190		switch config.Omnibox.InitialBehavior {	249		switch config.Omnibox.InitialBehavior {
191		case "recent", "most_visited", "none":	250		case "recent", "most_visited", "none":
192	-	// Valid	251	+	return nil
193		default:	252		default:
194	-	validationErrors = append(validationErrors, fmt.Sprintf("omnibox.initial_behavior must be one of: recent, most_visited, none (got: %s)", config.Omnibox.InitialBehavior))	253	+	return []string{fmt.Sprintf(
			254	+	"omnibox.initial_behavior must be one of: recent, most_visited, none (got: %s)",
			255	+	config.Omnibox.InitialBehavior,
			256	+	)}
195		}	257		}
			258	+	}
196			259
197	-	// Validate rendering mode using switch statement	260	+	func validateRendering(config *Config) []string {
198		switch config.RenderingMode {	261		switch config.RenderingMode {
199		case RenderingModeAuto, RenderingModeGPU, RenderingModeCPU, "":	262		case RenderingModeAuto, RenderingModeGPU, RenderingModeCPU, "":
200	-	// Valid (empty uses default)	263	+	return nil
201		default:	264		default:
202	-	validationErrors = append(validationErrors, fmt.Sprintf("rendering_mode must be one of: auto, gpu, cpu (got: %s)", config.RenderingMode))	265	+	return []string{fmt.Sprintf("rendering_mode must be one of: auto, gpu, cpu (got: %s)", config.RenderingMode)}
203		}	266		}
			267	+	}
204			268
205	-	// Validate color scheme using switch statement	269	+	func validateColorScheme(config *Config) []string {
206		switch config.Appearance.ColorScheme {	270		switch config.Appearance.ColorScheme {
207	-	case "prefer-dark", "prefer-light", ThemeDefault, "":	271	+	case ThemePreferDark, ThemePreferLight, ThemeDefault, "":
208	-	// Valid (empty uses default)	272	+	return nil
209		default:	273		default:
210	-	validationErrors = append(validationErrors, fmt.Sprintf("appearance.color_scheme must be one of: prefer-dark, prefer-light, default (got: %s)", config.Appearance.ColorScheme))	274	+	return []string{fmt.Sprintf(
			275	+	"appearance.color_scheme must be one of: prefer-dark, prefer-light, default (got: %s)",
			276	+	config.Appearance.ColorScheme,
			277	+	)}
211		}	278		}
212	-
213	-	// If there are validation errors, return them
214	-	if len(validationErrors) > 0 {
215	-	return fmt.Errorf("config validation failed:\n - %s", strings.Join(validationErrors, "\n - "))
216	-	}
217	-
218	-	return nil
219		}	279		}

M internal/infrastructure/config/watcher.go +2 -2


@@ -18,7 +18,7 @@ func (m *Manager) Watch() error {
18		}	18		}
19			19
20		m.viper.WatchConfig()	20		m.viper.WatchConfig()
21	-	m.viper.OnConfigChange(func(e fsnotify.Event) {	21	+	m.viper.OnConfigChange(func(_ fsnotify.Event) {
22		// Reload config	22		// Reload config
23		if err := m.reload(); err != nil {	23		if err := m.reload(); err != nil {
24		fmt.Fprintf(os.Stderr, "Warning: failed to reload config: %v\n", err)	24		fmt.Fprintf(os.Stderr, "Warning: failed to reload config: %v\n", err)

@@ -83,7 +83,7 @@ func (m *Manager) reload() error {
83			83
84		// Validate ColorScheme setting using switch statement	84		// Validate ColorScheme setting using switch statement
85		switch config.Appearance.ColorScheme {	85		switch config.Appearance.ColorScheme {
86	-	case "prefer-dark", "prefer-light", ThemeDefault:	86	+	case ThemePreferDark, ThemePreferLight, ThemeDefault:
87		// Valid values - no changes needed	87		// Valid values - no changes needed
88		case "":	88		case "":
89		// Empty string is treated the same as "default"	89		// Empty string is treated the same as "default"

M internal/infrastructure/deps/env.go +1 -1


@@ -15,7 +15,7 @@ func ApplyPrefixEnv(prefix string) {
15		}	15		}
16			16
17		for key, values := range prefixEnv(prefix) {	17		for key, values := range prefixEnv(prefix) {
18	-	os.Setenv(key, prependPathList(os.Getenv(key), values...))	18	+	_ = os.Setenv(key, prependPathList(os.Getenv(key), values...))
19		}	19		}
20		}	20		}
21			21

M internal/infrastructure/deps/pkgconfig.go +8 -1

 	return &PkgConfigProbe{}
 }
-func (p *PkgConfigProbe) PkgConfigModVersion(ctx context.Context, pkgName string, prefix string) (string, error) {
+func (p *PkgConfigProbe) PkgConfigModVersion(ctx context.Context, pkgName, prefix string) (string, error) {
+	if p == nil {
+		return "", &port.PkgConfigError{
+			Kind:    port.PkgConfigErrorKindCommandMissing,
+			Package: pkgName,
+			Err:     port.ErrPkgConfigMissing,
+		}
+	}
 	pc, err := exec.LookPath("pkg-config")
 	if err != nil {
 		return "", &port.PkgConfigError{

M internal/infrastructure/desktop/adapter.go +10 -4

 	execPath, err := os.Executable()
 	if err == nil {
 		// Resolve symlinks
-		resolved, err := filepath.EvalSymlinks(execPath)
+		resolved, symlinkErr := filepath.EvalSymlinks(execPath)
-		if err == nil {
+		if symlinkErr == nil {
 			execPath = resolved
 		}
 		return execPath, nil
 	}
 	status.DesktopFilePath = desktopPath
-	if _, err := os.Stat(desktopPath); err == nil {
+	if _, statErr := os.Stat(desktopPath); statErr == nil {
 		status.DesktopFileInstalled = true
 	}
 	}
 	status.IconFilePath = iconPath
-	if _, err := os.Stat(iconPath); err == nil {
+	if _, iconStatErr := os.Stat(iconPath); iconStatErr == nil {
 		status.IconInstalled = true
 	}
 // InstallIcon writes the icon file to XDG icons directory.
 func (a *Adapter) InstallIcon(ctx context.Context, svgData []byte) (string, error) {
+	if a == nil {
+		return "", fmt.Errorf("desktop adapter is nil")
+	}
 	log := logging.FromContext(ctx)
 	iconPath, err := getIconFilePath()
 // RemoveIcon removes the icon file from XDG icons directory.
 func (a *Adapter) RemoveIcon(ctx context.Context) error {
+	if a == nil {
+		return fmt.Errorf("desktop adapter is nil")
+	}
 	log := logging.FromContext(ctx)
 	iconPath, err := getIconFilePath()

M internal/infrastructure/favicon/cache.go +0 -1


@@ -192,7 +192,6 @@ func (c *Cache) loadFromDisk(domain string) []byte {
192		return nil	192	return nil
193		}	193	}
194			194
195	-	//nolint:gosec // path is constructed from sanitized domain
196		data, err := os.ReadFile(path)	195	data, err := os.ReadFile(path)
197		if err != nil {	196	if err != nil {
198		return nil	197	return nil

M internal/infrastructure/favicon/fetcher.go +5 -1

 		log.Debug().Err(err).Str("domain", domain).Msg("failed to fetch favicon from DuckDuckGo")
 		return nil, err
 	}
-	defer resp.Body.Close()
+	defer func() {
+		if closeErr := resp.Body.Close(); closeErr != nil {
+			log.Debug().Err(closeErr).Str("domain", domain).Msg("failed to close favicon response body")
+		}
+	}()
 	if resp.StatusCode != http.StatusOK {
 		log.Debug().Int("status", resp.StatusCode).Str("domain", domain).Msg("DuckDuckGo favicon API returned non-OK status")

M internal/infrastructure/filtering/downloader.go +26 -10

 	"github.com/bnema/dumber/internal/logging"
 )
+const (
+	cacheDirPerm     = 0o755
+	manifestFilePerm = 0o644
+)
 // Downloader handles downloading filter files from GitHub releases.
 type Downloader struct {
 	baseURL    string
 	url := fmt.Sprintf("%s/%s", d.baseURL, FilterFiles.Manifest)
 	log.Debug().Str("url", url).Msg("fetching manifest")
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, http.NoBody)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create request: %w", err)
 	}
 	if err != nil {
 		return nil, fmt.Errorf("failed to fetch manifest: %w", err)
 	}
-	defer resp.Body.Close()
+	defer func() {
+		if closeErr := resp.Body.Close(); closeErr != nil {
+			log.Debug().Err(closeErr).Msg("failed to close manifest response body")
+		}
+	}()
 	if resp.StatusCode != http.StatusOK {
 		return nil, fmt.Errorf("manifest fetch failed with status %d", resp.StatusCode)
 		Logger()
 	// Ensure cache directory exists
-	if err := os.MkdirAll(d.cacheDir, 0o755); err != nil {
+	if err := os.MkdirAll(d.cacheDir, cacheDirPerm); err != nil {
 		return nil, fmt.Errorf("failed to create cache dir: %w", err)
 	}
 	url := fmt.Sprintf("%s/%s", d.baseURL, filename)
 	localPath := filepath.Join(d.cacheDir, filename)
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, http.NoBody)
 	if err != nil {
 		return "", 0, fmt.Errorf("failed to create request: %w", err)
 	}
 	if err != nil {
 		return "", 0, fmt.Errorf("failed to download %s: %w", filename, err)
 	}
-	defer resp.Body.Close()
+	defer func() {
+		if closeErr := resp.Body.Close(); closeErr != nil {
+			logging.FromContext(ctx).Debug().Err(closeErr).Str("file", filename).Msg("failed to close filter response body")
+		}
+	}()
 	if resp.StatusCode != http.StatusOK {
 		return "", 0, fmt.Errorf("download %s failed with status %d", filename, resp.StatusCode)
 	bytesWritten, err := io.Copy(file, resp.Body)
 	if err != nil {
-		file.Close()
+		_ = file.Close()
-		os.Remove(tmpPath)
+		_ = os.Remove(tmpPath)
 		return "", 0, fmt.Errorf("failed to write %s: %w", filename, err)
 	}
-	file.Close()
+	if err := file.Close(); err != nil {
+		_ = os.Remove(tmpPath)
+		return "", 0, fmt.Errorf("failed to close temp file: %w", err)
+	}
 	// Atomic rename
 	if err := os.Rename(tmpPath, localPath); err != nil {
-		os.Remove(tmpPath)
+		_ = os.Remove(tmpPath)
 		return "", 0, fmt.Errorf("failed to rename temp file: %w", err)
 	}
 	}
 	path := filepath.Join(d.cacheDir, FilterFiles.Manifest)
-	if err := os.WriteFile(path, data, 0o644); err != nil {
+	if err := os.WriteFile(path, data, manifestFilePerm); err != nil {
 		return fmt.Errorf("failed to write manifest: %w", err)
 	}

M internal/infrastructure/filtering/manager.go +12 -5

 	"github.com/bnema/puregotk-webkit/webkit"
 )
+const (
+	storeDirPerm  = 0o755
+	jsonDirPerm   = 0o755
+	mergedFilePerm = 0o644
+)
 // Manager orchestrates the content filter lifecycle.
 // It handles downloading, compiling, loading, and applying filters to WebViews.
 type Manager struct {
 // NewManager creates a new filter Manager.
 func NewManager(cfg ManagerConfig) (*Manager, error) {
 	// Ensure directories exist
-	if err := os.MkdirAll(cfg.StoreDir, 0o755); err != nil {
+	if err := os.MkdirAll(cfg.StoreDir, storeDirPerm); err != nil {
 		return nil, fmt.Errorf("failed to create store dir: %w", err)
 	}
-	if err := os.MkdirAll(cfg.JSONDir, 0o755); err != nil {
+	if err := os.MkdirAll(cfg.JSONDir, jsonDirPerm); err != nil {
 		return nil, fmt.Errorf("failed to create json dir: %w", err)
 	}
 	// Use provided implementations or create defaults
 	store := cfg.Store
 	if store == nil {
-		store = NewStore(cfg.StoreDir)
+		newStore := NewStore(cfg.StoreDir)
-		if store == nil {
+		if newStore == nil {
 			return nil, fmt.Errorf("failed to create filter store at %s", cfg.StoreDir)
 		}
+		store = newStore
 	}
 	downloader := cfg.Downloader
 	// Write merged file
 	mergedPath := filepath.Join(m.jsonDir, "merged.json")
-	if err := os.WriteFile(mergedPath, merged, 0o644); err != nil {
+	if err := os.WriteFile(mergedPath, merged, mergedFilePerm); err != nil {
 		return "", fmt.Errorf("failed to write merged file: %w", err)
 	}

M internal/infrastructure/filtering/manager_test.go +5 -5


@@ -74,9 +74,9 @@ func TestManager_LoadAsync_ChecksCacheFirst(t *testing.T) {
74		// Track status changes	74		// Track status changes
75		var statuses []filtering.FilterStatus	75		var statuses []filtering.FilterStatus
76		var mu sync.Mutex	76		var mu sync.Mutex
77	-	mgr.SetStatusCallback(func(s filtering.FilterStatus) {	77	+	mgr.SetStatusCallback(func(status filtering.FilterStatus) {
78		mu.Lock()	78		mu.Lock()
79	-	statuses = append(statuses, s)	79	+	statuses = append(statuses, status)
80		mu.Unlock()	80		mu.Unlock()
81		})	81		})
82			82

@@ -165,9 +165,9 @@ func TestManager_LoadAsync_DownloadsWhenCacheMiss(t *testing.T) {
165		// Track status changes	165		// Track status changes
166		var statuses []filtering.FilterStatus	166		var statuses []filtering.FilterStatus
167		var mu sync.Mutex	167		var mu sync.Mutex
168	-	mgr.SetStatusCallback(func(s filtering.FilterStatus) {	168	+	mgr.SetStatusCallback(func(status filtering.FilterStatus) {
169		mu.Lock()	169		mu.Lock()
170	-	statuses = append(statuses, s)	170	+	statuses = append(statuses, status)
171		mu.Unlock()	171		mu.Unlock()
172		})	172		})
173			173

@@ -470,7 +470,7 @@ func TestManager_StatusCallback_CalledOnStateChange(t *testing.T) {
470		// Track callback invocations	470		// Track callback invocations
471		callCount := 0	471		callCount := 0
472		var mu sync.Mutex	472		var mu sync.Mutex
473	-	mgr.SetStatusCallback(func(s filtering.FilterStatus) {	473	+	mgr.SetStatusCallback(func(_ filtering.FilterStatus) {
474		mu.Lock()	474		mu.Lock()
475		callCount++	475		callCount++
476		mu.Unlock()	476		mu.Unlock()

M internal/infrastructure/filtering/store.go +5 -5


@@ -44,7 +44,7 @@ type CompileResult struct {
44		// Compile compiles a JSON filter file and stores it with the given identifier.	44		// Compile compiles a JSON filter file and stores it with the given identifier.
45		// This is an async operation that may take several seconds for large filter sets.	45		// This is an async operation that may take several seconds for large filter sets.
46		// The JSON file must be in Safari Content Blocker format.	46		// The JSON file must be in Safari Content Blocker format.
47	-	func (s Store) Compile(ctx context.Context, identifier string, jsonPath string) (webkit.UserContentFilter, error) {	47	+	func (s Store) Compile(ctx context.Context, identifier, jsonPath string) (webkit.UserContentFilter, error) {
48		log := logging.FromContext(ctx).With().	48		log := logging.FromContext(ctx).With().
49		Str("component", "filter-store").	49		Str("component", "filter-store").
50		Str("identifier", identifier).	50		Str("identifier", identifier).

@@ -90,7 +90,7 @@ func (s *Store) Compile(ctx context.Context, identifier string, jsonPath string)
90		log.Info().Msg("filter compilation completed")	90		log.Info().Msg("filter compilation completed")
91		return result.Filter, nil	91		return result.Filter, nil
92		case <-ctx.Done():	92		case <-ctx.Done():
93	-	log.Warn().Msg("filter compilation cancelled")	93	+	log.Warn().Msg("filter compilation canceled")
94		return nil, ctx.Err()	94		return nil, ctx.Err()
95		}	95		}
96		}	96		}

@@ -142,7 +142,7 @@ func (s Store) Load(ctx context.Context, identifier string) (webkit.UserConten
142		log.Debug().Msg("filter loaded successfully")	142		log.Debug().Msg("filter loaded successfully")
143		return result.Filter, nil	143		return result.Filter, nil
144		case <-ctx.Done():	144		case <-ctx.Done():
145	-	log.Warn().Msg("filter load cancelled")	145	+	log.Warn().Msg("filter load canceled")
146		return nil, ctx.Err()	146		return nil, ctx.Err()
147		}	147		}
148		}	148		}

@@ -192,7 +192,7 @@ func (s *Store) FetchIdentifiers(ctx context.Context) ([]string, error) {
192		log.Debug().Int("count", len(result.Identifiers)).Msg("fetched filter identifiers")	192		log.Debug().Int("count", len(result.Identifiers)).Msg("fetched filter identifiers")
193		return result.Identifiers, nil	193		return result.Identifiers, nil
194		case <-ctx.Done():	194		case <-ctx.Done():
195	-	log.Warn().Msg("fetch identifiers cancelled")	195	+	log.Warn().Msg("fetch identifiers canceled")
196		return nil, ctx.Err()	196		return nil, ctx.Err()
197		}	197		}
198		}	198		}

@@ -237,7 +237,7 @@ func (s *Store) Remove(ctx context.Context, identifier string) error {
237		log.Info().Msg("filter removed")	237		log.Info().Msg("filter removed")
238		return nil	238		return nil
239		case <-ctx.Done():	239		case <-ctx.Done():
240	-	log.Warn().Msg("remove filter cancelled")	240	+	log.Warn().Msg("remove filter canceled")
241		return ctx.Err()	241		return ctx.Err()
242		}	242		}
243		}	243		}

M internal/infrastructure/media/diagnostics.go +22 -9

 // parseVADecoders extracts decoder names from gst-inspect-1.0 va output.
 func (a *Adapter) parseVADecoders(output string, r *port.MediaDiagnosticsResult) {
+	if a == nil {
+		return
+	}
 	lines := strings.Split(output, "\n")
 	for _, line := range lines {
 		line = strings.TrimSpace(line)
 // parseVAAPIDecoders extracts decoder names from gst-inspect-1.0 vaapi output.
 func (a *Adapter) parseVAAPIDecoders(output string, r *port.MediaDiagnosticsResult) {
+	if a == nil {
+		return
+	}
 	lines := strings.Split(output, "\n")
 	for _, line := range lines {
 		line = strings.TrimSpace(line)
 // parseNVCodecDecoders extracts decoder names from gst-inspect-1.0 nvcodec output.
 func (a *Adapter) parseNVCodecDecoders(output string, r *port.MediaDiagnosticsResult) {
+	if a == nil {
+		return
+	}
 	lines := strings.Split(output, "\n")
 	for _, line := range lines {
 		line = strings.TrimSpace(line)
 // checkVAAPI detects VA-API driver and version.
 func (a *Adapter) checkVAAPI(ctx context.Context, r *port.MediaDiagnosticsResult) {
 	log := logging.FromContext(ctx)
+	if a == nil {
+		return
+	}
 	// Check LIBVA_DRIVER_NAME environment first
 	if driver := os.Getenv("LIBVA_DRIVER_NAME"); driver != "" {
 }
 // generateWarnings creates user-friendly warning messages.
+//nolint:revive // receiver required for interface consistency
 func (a *Adapter) generateWarnings(r *port.MediaDiagnosticsResult) {
 	// Critical: GStreamer not installed
 	if !r.GStreamerAvailable {
 		r.Warnings = append(r.Warnings,
-			"CRITICAL: GStreamer not installed. Video playback will not work!")
+			"CRITICAL: GStreamer not installed. Video playback will not work!",
-		r.Warnings = append(r.Warnings,
+			"Install: gst-plugins-base gst-plugins-good gst-plugins-bad gst-plugins-ugly gst-libav",
-			"Install: gst-plugins-base gst-plugins-good gst-plugins-bad gst-plugins-ugly gst-libav")
+		)
 		return // No point checking other things
 	}
 	if !r.HWAccelAvailable {
 		r.Warnings = append(r.Warnings,
-			"No hardware video acceleration detected. Video will use software decoding (higher CPU).")
+			"No hardware video acceleration detected. Video will use software decoding (higher CPU).",
-		r.Warnings = append(r.Warnings,
+			"Install VA plugin: gst-plugin-va (Arch) or gstreamer1.0-plugins-bad (Debian/Ubuntu)",
-			"Install VA plugin: gst-plugin-va (Arch) or gstreamer1.0-plugins-bad (Debian/Ubuntu)")
+			"Install VA-API driver: libva-mesa-driver (AMD) | intel-media-driver (Intel) | nvidia-vaapi-driver (NVIDIA)",
-		r.Warnings = append(r.Warnings,
+		)
-			"Install VA-API driver: libva-mesa-driver (AMD) | intel-media-driver (Intel) | nvidia-vaapi-driver (NVIDIA)")
 	}
 	// AV1 is the preferred codec - warn if not available
 	// Prefer modern VA plugin over legacy VAAPI
 	if r.HasVAAPIPlugin && !r.HasVAPlugin {
 		r.Warnings = append(r.Warnings,
-			"Using legacy gstreamer-vaapi. Install gst-plugin-va (Arch) or gstreamer1.0-plugins-bad (Debian/Ubuntu) for modern VA stateless decoders.")
+			"Using legacy gstreamer-vaapi. Install gst-plugin-va (Arch) or "+
+				"gstreamer1.0-plugins-bad (Debian/Ubuntu) for modern VA stateless decoders.")
 	}
 }

M internal/infrastructure/persistence/sqlite/connection.go +2 -1

 // NewConnection creates a new SQLite database connection with optimized settings.
 // It creates the database directory if it doesn't exist and applies performance pragmas.
 func NewConnection(ctx context.Context, dbPath string) (*sql.DB, error) {
+	const dbDirPerm = 0o750
 	log := logging.FromContext(ctx)
 	if dbPath == "" {
 	}
 	// Ensure database directory exists
-	if err := os.MkdirAll(filepath.Dir(dbPath), 0750); err != nil {
+	if err := os.MkdirAll(filepath.Dir(dbPath), dbDirPerm); err != nil {
 		return nil, fmt.Errorf("failed to create database directory: %w", err)
 	}

M internal/infrastructure/persistence/sqlite/favorite_repo.go +9 -8

 import (
 	"context"
 	"database/sql"
+	"errors"
 	"github.com/bnema/dumber/internal/domain/entity"
 	"github.com/bnema/dumber/internal/domain/repository"
 func (r *favoriteRepo) FindByID(ctx context.Context, id entity.FavoriteID) (*entity.Favorite, error) {
 	row, err := r.queries.GetFavoriteByID(ctx, int64(id))
 	if err != nil {
-		if err == sql.ErrNoRows {
+		if errors.Is(err, sql.ErrNoRows) {
 			return nil, nil
 		}
 		return nil, err
 func (r *favoriteRepo) FindByURL(ctx context.Context, url string) (*entity.Favorite, error) {
 	row, err := r.queries.GetFavoriteByURL(ctx, url)
 	if err != nil {
-		if err == sql.ErrNoRows {
+		if errors.Is(err, sql.ErrNoRows) {
 			return nil, nil
 		}
 		return nil, err
 func (r *favoriteRepo) GetByShortcut(ctx context.Context, key int) (*entity.Favorite, error) {
 	row, err := r.queries.GetFavoriteByShortcut(ctx, sql.NullInt64{Int64: int64(key), Valid: true})
 	if err != nil {
-		if err == sql.ErrNoRows {
+		if errors.Is(err, sql.ErrNoRows) {
 			return nil, nil
 		}
 		return nil, err
 func favoritesFromRows(rows []sqlc.Favorite) []*entity.Favorite {
 	favorites := make([]*entity.Favorite, len(rows))
-	for i, row := range rows {
+	for i := range rows {
-		favorites[i] = favoriteFromRow(row)
+		favorites[i] = favoriteFromRow(rows[i])
 	}
 	return favorites
 }
 func (r *folderRepo) FindByID(ctx context.Context, id entity.FolderID) (*entity.Folder, error) {
 	row, err := r.queries.GetFolderByID(ctx, int64(id))
 	if err != nil {
-		if err == sql.ErrNoRows {
+		if errors.Is(err, sql.ErrNoRows) {
 			return nil, nil
 		}
 		return nil, err
 func (r *tagRepo) FindByID(ctx context.Context, id entity.TagID) (*entity.Tag, error) {
 	row, err := r.queries.GetTagByID(ctx, int64(id))
 	if err != nil {
-		if err == sql.ErrNoRows {
+		if errors.Is(err, sql.ErrNoRows) {
 			return nil, nil
 		}
 		return nil, err
 func (r *tagRepo) FindByName(ctx context.Context, name string) (*entity.Tag, error) {
 	row, err := r.queries.GetTagByName(ctx, name)
 	if err != nil {
-		if err == sql.ErrNoRows {
+		if errors.Is(err, sql.ErrNoRows) {
 			return nil, nil
 		}
 		return nil, err

M internal/infrastructure/persistence/sqlite/history_repo.go +9 -6

 import (
 	"context"
 	"database/sql"
+	"errors"
 	"time"
 	"github.com/bnema/dumber/internal/domain/entity"
 func (r *historyRepo) FindByURL(ctx context.Context, url string) (*entity.HistoryEntry, error) {
 	row, err := r.queries.GetHistoryByURL(ctx, url)
 	if err != nil {
-		if err == sql.ErrNoRows {
+		if errors.Is(err, sql.ErrNoRows) {
 			return nil, nil
 		}
 		return nil, err
 	}
 	matches := make([]entity.HistoryMatch, len(rows))
-	for i, row := range rows {
+	for i := range rows {
+		row := rows[i]
 		matches[i] = entity.HistoryMatch{
 			Entry: historyFromRow(row),
 			Score: 1.0, // FTS5 already ranked by bm25
 	}
 	entries := make([]*entity.HistoryEntry, len(rows))
-	for i, row := range rows {
+	for i := range rows {
-		entries[i] = historyFromRow(row)
+		entries[i] = historyFromRow(rows[i])
 	}
 	return entries, nil
 }
 	// Handle the interface{} type for total_visits
 	var totalVisits int64
-	if v, ok := row.TotalVisits.(int64); ok {
+	switch v := row.TotalVisits.(type) {
+	case int64:
 		totalVisits = v
-	} else if v, ok := row.TotalVisits.(float64); ok {
+	case float64:
 		totalVisits = int64(v)
 	}

M internal/infrastructure/persistence/sqlite/migrations.go +2 -2


@@ -36,8 +36,8 @@ func RunMigrations(ctx context.Context, db *sql.DB) error {
36		}	36		}
37			37
38		// Run migrations	38		// Run migrations
39	-	if err := goose.Up(db, "migrations"); err != nil {	39	+	if migrateErr := goose.Up(db, "migrations"); migrateErr != nil {
40	-	return fmt.Errorf("failed to run migrations: %w", err)	40	+	return fmt.Errorf("failed to run migrations: %w", migrateErr)
41		}	41		}
42			42
43		// Get new version after migration	43		// Get new version after migration

M internal/infrastructure/persistence/sqlite/zoom_repo.go +2 -1

 import (
 	"context"
 	"database/sql"
+	"errors"
 	"github.com/bnema/dumber/internal/domain/entity"
 	"github.com/bnema/dumber/internal/domain/repository"
 	row, err := r.queries.GetZoomLevel(ctx, domain)
 	if err != nil {
-		if err == sql.ErrNoRows {
+		if errors.Is(err, sql.ErrNoRows) {
 			return nil, nil
 		}
 		return nil, err

M internal/infrastructure/webkit/factory.go +1 -1


@@ -74,7 +74,7 @@ func (f *WebViewFactory) CreateRelated(ctx context.Context, parentID port.WebVie
74		log := logging.FromContext(ctx)	74		log := logging.FromContext(ctx)
75			75
76		// Look up parent WebView	76		// Look up parent WebView
77	-	parent := LookupWebView(WebViewID(parentID))	77	+	parent := LookupWebView(parentID)
78		if parent == nil {	78		if parent == nil {
79		return nil, fmt.Errorf("parent webview %d not found", parentID)	79		return nil, fmt.Errorf("parent webview %d not found", parentID)
80		}	80		}

M internal/infrastructure/webkit/handlers/config.go +3 -0


@@ -22,6 +22,9 @@ func NewConfigHandler() *ConfigHandler {
22		22
23	// Handle processes the save_config message.	23		// Handle processes the save_config message.
24	func (h *ConfigHandler) Handle(ctx context.Context, _ webkit.WebViewID, payload json.RawMessage) (any, error) {	24		func (h *ConfigHandler) Handle(ctx context.Context, _ webkit.WebViewID, payload json.RawMessage) (any, error) {
		25	+	if h == nil {
		26	+	return nil, fmt.Errorf("config handler is nil")
		27	+	}
25	log := logging.FromContext(ctx).With().Str("handler", "config").Logger()	28		log := logging.FromContext(ctx).With().Str("handler", "config").Logger()
26		29
27	var payloadCfg port.WebUIConfig	30		var payloadCfg port.WebUIConfig

M internal/infrastructure/webkit/handlers/homepage/favorites.go +4 -4


@@ -22,7 +22,7 @@ func NewFavoritesHandlers(favoritesUC usecase.ManageFavoritesUseCase) Favorite
22			22
23		// HandleList handles favorite_list messages.	23		// HandleList handles favorite_list messages.
24		func (h *FavoritesHandlers) HandleList() webkit.MessageHandler {	24		func (h *FavoritesHandlers) HandleList() webkit.MessageHandler {
25	-	return webkit.MessageHandlerFunc(func(ctx context.Context, webviewID webkit.WebViewID, payload json.RawMessage) (any, error) {	25	+	return webkit.MessageHandlerFunc(func(ctx context.Context, _ webkit.WebViewID, payload json.RawMessage) (any, error) {
26		log := logging.FromContext(ctx)	26		log := logging.FromContext(ctx)
27			27
28		requestID := ParseRequestID(payload)	28		requestID := ParseRequestID(payload)

@@ -49,7 +49,7 @@ type setShortcutRequest struct {
49			49
50		// HandleSetShortcut handles favorite_set_shortcut messages.	50		// HandleSetShortcut handles favorite_set_shortcut messages.
51		func (h *FavoritesHandlers) HandleSetShortcut() webkit.MessageHandler {	51		func (h *FavoritesHandlers) HandleSetShortcut() webkit.MessageHandler {
52	-	return webkit.MessageHandlerFunc(func(ctx context.Context, webviewID webkit.WebViewID, payload json.RawMessage) (any, error) {	52	+	return webkit.MessageHandlerFunc(func(ctx context.Context, _ webkit.WebViewID, payload json.RawMessage) (any, error) {
53		log := logging.FromContext(ctx)	53		log := logging.FromContext(ctx)
54			54
55		var req setShortcutRequest	55		var req setShortcutRequest

@@ -78,7 +78,7 @@ type getByShortcutRequest struct {
78			78
79		// HandleGetByShortcut handles favorite_get_by_shortcut messages.	79		// HandleGetByShortcut handles favorite_get_by_shortcut messages.
80		func (h *FavoritesHandlers) HandleGetByShortcut() webkit.MessageHandler {	80		func (h *FavoritesHandlers) HandleGetByShortcut() webkit.MessageHandler {
81	-	return webkit.MessageHandlerFunc(func(ctx context.Context, webviewID webkit.WebViewID, payload json.RawMessage) (any, error) {	81	+	return webkit.MessageHandlerFunc(func(ctx context.Context, _ webkit.WebViewID, payload json.RawMessage) (any, error) {
82		log := logging.FromContext(ctx)	82		log := logging.FromContext(ctx)
83			83
84		var req getByShortcutRequest	84		var req getByShortcutRequest

@@ -109,7 +109,7 @@ type setFolderRequest struct {
109			109
110		// HandleSetFolder handles favorite_set_folder messages.	110		// HandleSetFolder handles favorite_set_folder messages.
111		func (h *FavoritesHandlers) HandleSetFolder() webkit.MessageHandler {	111		func (h *FavoritesHandlers) HandleSetFolder() webkit.MessageHandler {
112	-	return webkit.MessageHandlerFunc(func(ctx context.Context, webviewID webkit.WebViewID, payload json.RawMessage) (any, error) {	112	+	return webkit.MessageHandlerFunc(func(ctx context.Context, _ webkit.WebViewID, payload json.RawMessage) (any, error) {
113		log := logging.FromContext(ctx)	113		log := logging.FromContext(ctx)
114			114
115		var req setFolderRequest	115		var req setFolderRequest

M internal/infrastructure/webkit/handlers/homepage/folders.go +4 -4


@@ -22,7 +22,7 @@ func NewFolderHandlers(favoritesUC usecase.ManageFavoritesUseCase) FolderHandl
22			22
23		// HandleList handles folder_list messages.	23		// HandleList handles folder_list messages.
24		func (h *FolderHandlers) HandleList() webkit.MessageHandler {	24		func (h *FolderHandlers) HandleList() webkit.MessageHandler {
25	-	return webkit.MessageHandlerFunc(func(ctx context.Context, webviewID webkit.WebViewID, payload json.RawMessage) (any, error) {	25	+	return webkit.MessageHandlerFunc(func(ctx context.Context, _ webkit.WebViewID, payload json.RawMessage) (any, error) {
26		log := logging.FromContext(ctx)	26		log := logging.FromContext(ctx)
27			27
28		requestID := ParseRequestID(payload)	28		requestID := ParseRequestID(payload)

@@ -49,7 +49,7 @@ type createFolderRequest struct {
49			49
50		// HandleCreate handles folder_create messages.	50		// HandleCreate handles folder_create messages.
51		func (h *FolderHandlers) HandleCreate() webkit.MessageHandler {	51		func (h *FolderHandlers) HandleCreate() webkit.MessageHandler {
52	-	return webkit.MessageHandlerFunc(func(ctx context.Context, webviewID webkit.WebViewID, payload json.RawMessage) (any, error) {	52	+	return webkit.MessageHandlerFunc(func(ctx context.Context, _ webkit.WebViewID, payload json.RawMessage) (any, error) {
53		log := logging.FromContext(ctx)	53		log := logging.FromContext(ctx)
54			54
55		var req createFolderRequest	55		var req createFolderRequest

@@ -84,7 +84,7 @@ type deleteFolderRequest struct {
84			84
85		// HandleDelete handles folder_delete messages.	85		// HandleDelete handles folder_delete messages.
86		func (h *FolderHandlers) HandleDelete() webkit.MessageHandler {	86		func (h *FolderHandlers) HandleDelete() webkit.MessageHandler {
87	-	return webkit.MessageHandlerFunc(func(ctx context.Context, webviewID webkit.WebViewID, payload json.RawMessage) (any, error) {	87	+	return webkit.MessageHandlerFunc(func(ctx context.Context, _ webkit.WebViewID, payload json.RawMessage) (any, error) {
88		log := logging.FromContext(ctx)	88		log := logging.FromContext(ctx)
89			89
90		var req deleteFolderRequest	90		var req deleteFolderRequest

@@ -116,7 +116,7 @@ type updateFolderRequest struct {
116		// HandleUpdate handles folder_update messages.	116		// HandleUpdate handles folder_update messages.
117		// NOTE: This requires UpdateFolder() method to be added to ManageFavoritesUseCase.	117		// NOTE: This requires UpdateFolder() method to be added to ManageFavoritesUseCase.
118		func (h *FolderHandlers) HandleUpdate() webkit.MessageHandler {	118		func (h *FolderHandlers) HandleUpdate() webkit.MessageHandler {
119	-	return webkit.MessageHandlerFunc(func(ctx context.Context, webviewID webkit.WebViewID, payload json.RawMessage) (any, error) {	119	+	return webkit.MessageHandlerFunc(func(ctx context.Context, _ webkit.WebViewID, payload json.RawMessage) (any, error) {
120		log := logging.FromContext(ctx)	120		log := logging.FromContext(ctx)
121			121
122		var req updateFolderRequest	122		var req updateFolderRequest

M internal/infrastructure/webkit/handlers/homepage/history.go +8 -8


@@ -30,7 +30,7 @@ type timelineRequest struct {
30			30
31		// HandleTimeline handles history_timeline messages.	31		// HandleTimeline handles history_timeline messages.
32		func (h *HistoryHandlers) HandleTimeline() webkit.MessageHandler {	32		func (h *HistoryHandlers) HandleTimeline() webkit.MessageHandler {
33	-	return webkit.MessageHandlerFunc(func(ctx context.Context, webviewID webkit.WebViewID, payload json.RawMessage) (any, error) {	33	+	return webkit.MessageHandlerFunc(func(ctx context.Context, _ webkit.WebViewID, payload json.RawMessage) (any, error) {
34		log := logging.FromContext(ctx)	34		log := logging.FromContext(ctx)
35			35
36		var req timelineRequest	36		var req timelineRequest

@@ -62,7 +62,7 @@ type searchRequest struct {
62			62
63		// HandleSearchFTS handles history_search_fts messages.	63		// HandleSearchFTS handles history_search_fts messages.
64		func (h *HistoryHandlers) HandleSearchFTS() webkit.MessageHandler {	64		func (h *HistoryHandlers) HandleSearchFTS() webkit.MessageHandler {
65	-	return webkit.MessageHandlerFunc(func(ctx context.Context, webviewID webkit.WebViewID, payload json.RawMessage) (any, error) {	65	+	return webkit.MessageHandlerFunc(func(ctx context.Context, _ webkit.WebViewID, payload json.RawMessage) (any, error) {
66		log := logging.FromContext(ctx)	66		log := logging.FromContext(ctx)
67			67
68		var req searchRequest	68		var req searchRequest

@@ -101,7 +101,7 @@ type deleteEntryRequest struct {
101			101
102		// HandleDeleteEntry handles history_delete_entry messages.	102		// HandleDeleteEntry handles history_delete_entry messages.
103		func (h *HistoryHandlers) HandleDeleteEntry() webkit.MessageHandler {	103		func (h *HistoryHandlers) HandleDeleteEntry() webkit.MessageHandler {
104	-	return webkit.MessageHandlerFunc(func(ctx context.Context, webviewID webkit.WebViewID, payload json.RawMessage) (any, error) {	104	+	return webkit.MessageHandlerFunc(func(ctx context.Context, _ webkit.WebViewID, payload json.RawMessage) (any, error) {
105		log := logging.FromContext(ctx)	105		log := logging.FromContext(ctx)
106			106
107		var req deleteEntryRequest	107		var req deleteEntryRequest

@@ -130,7 +130,7 @@ type deleteRangeRequest struct {
130			130
131		// HandleDeleteRange handles history_delete_range messages.	131		// HandleDeleteRange handles history_delete_range messages.
132		func (h *HistoryHandlers) HandleDeleteRange() webkit.MessageHandler {	132		func (h *HistoryHandlers) HandleDeleteRange() webkit.MessageHandler {
133	-	return webkit.MessageHandlerFunc(func(ctx context.Context, webviewID webkit.WebViewID, payload json.RawMessage) (any, error) {	133	+	return webkit.MessageHandlerFunc(func(ctx context.Context, _ webkit.WebViewID, payload json.RawMessage) (any, error) {
134		log := logging.FromContext(ctx)	134		log := logging.FromContext(ctx)
135			135
136		var req deleteRangeRequest	136		var req deleteRangeRequest

@@ -161,7 +161,7 @@ func (h *HistoryHandlers) HandleDeleteRange() webkit.MessageHandler {
161			161
162		// HandleClearAll handles history_clear_all messages.	162		// HandleClearAll handles history_clear_all messages.
163		func (h *HistoryHandlers) HandleClearAll() webkit.MessageHandler {	163		func (h *HistoryHandlers) HandleClearAll() webkit.MessageHandler {
164	-	return webkit.MessageHandlerFunc(func(ctx context.Context, webviewID webkit.WebViewID, payload json.RawMessage) (any, error) {	164	+	return webkit.MessageHandlerFunc(func(ctx context.Context, _ webkit.WebViewID, payload json.RawMessage) (any, error) {
165		log := logging.FromContext(ctx)	165		log := logging.FromContext(ctx)
166			166
167		requestID := ParseRequestID(payload)	167		requestID := ParseRequestID(payload)

@@ -200,7 +200,7 @@ func rangeToTime(r string) time.Time {
200			200
201		// HandleAnalytics handles history_analytics messages.	201		// HandleAnalytics handles history_analytics messages.
202		func (h *HistoryHandlers) HandleAnalytics() webkit.MessageHandler {	202		func (h *HistoryHandlers) HandleAnalytics() webkit.MessageHandler {
203	-	return webkit.MessageHandlerFunc(func(ctx context.Context, webviewID webkit.WebViewID, payload json.RawMessage) (any, error) {	203	+	return webkit.MessageHandlerFunc(func(ctx context.Context, _ webkit.WebViewID, payload json.RawMessage) (any, error) {
204		log := logging.FromContext(ctx)	204		log := logging.FromContext(ctx)
205			205
206		requestID := ParseRequestID(payload)	206		requestID := ParseRequestID(payload)

@@ -226,7 +226,7 @@ type domainStatsRequest struct {
226			226
227		// HandleDomainStats handles history_domain_stats messages.	227		// HandleDomainStats handles history_domain_stats messages.
228		func (h *HistoryHandlers) HandleDomainStats() webkit.MessageHandler {	228		func (h *HistoryHandlers) HandleDomainStats() webkit.MessageHandler {
229	-	return webkit.MessageHandlerFunc(func(ctx context.Context, webviewID webkit.WebViewID, payload json.RawMessage) (any, error) {	229	+	return webkit.MessageHandlerFunc(func(ctx context.Context, _ webkit.WebViewID, payload json.RawMessage) (any, error) {
230		log := logging.FromContext(ctx)	230		log := logging.FromContext(ctx)
231			231
232		var req domainStatsRequest	232		var req domainStatsRequest

@@ -256,7 +256,7 @@ type deleteDomainRequest struct {
256			256
257		// HandleDeleteDomain handles history_delete_domain messages.	257		// HandleDeleteDomain handles history_delete_domain messages.
258		func (h *HistoryHandlers) HandleDeleteDomain() webkit.MessageHandler {	258		func (h *HistoryHandlers) HandleDeleteDomain() webkit.MessageHandler {
259	-	return webkit.MessageHandlerFunc(func(ctx context.Context, webviewID webkit.WebViewID, payload json.RawMessage) (any, error) {	259	+	return webkit.MessageHandlerFunc(func(ctx context.Context, _ webkit.WebViewID, payload json.RawMessage) (any, error) {
260		log := logging.FromContext(ctx)	260		log := logging.FromContext(ctx)
261			261
262		var req deleteDomainRequest	262		var req deleteDomainRequest

M internal/infrastructure/webkit/handlers/homepage/tags.go +13 -28

 // HandleList handles tag_list messages.
 func (h *TagHandlers) HandleList() webkit.MessageHandler {
-	return webkit.MessageHandlerFunc(func(ctx context.Context, webviewID webkit.WebViewID, payload json.RawMessage) (any, error) {
+	return webkit.MessageHandlerFunc(func(ctx context.Context, _ webkit.WebViewID, payload json.RawMessage) (any, error) {
 		log := logging.FromContext(ctx)
 		requestID := ParseRequestID(payload)
 // HandleCreate handles tag_create messages.
 func (h *TagHandlers) HandleCreate() webkit.MessageHandler {
-	return webkit.MessageHandlerFunc(func(ctx context.Context, webviewID webkit.WebViewID, payload json.RawMessage) (any, error) {
+	return webkit.MessageHandlerFunc(func(ctx context.Context, _ webkit.WebViewID, payload json.RawMessage) (any, error) {
 		log := logging.FromContext(ctx)
 		var req createTagRequest
 // HandleDelete handles tag_delete messages.
 func (h *TagHandlers) HandleDelete() webkit.MessageHandler {
-	return webkit.MessageHandlerFunc(func(ctx context.Context, webviewID webkit.WebViewID, payload json.RawMessage) (any, error) {
+	return webkit.MessageHandlerFunc(func(ctx context.Context, _ webkit.WebViewID, payload json.RawMessage) (any, error) {
 		log := logging.FromContext(ctx)
 		var req deleteTagRequest
 // HandleUpdate handles tag_update messages.
 // NOTE: This requires UpdateTag() method to be added to ManageFavoritesUseCase.
 func (h *TagHandlers) HandleUpdate() webkit.MessageHandler {
-	return webkit.MessageHandlerFunc(func(ctx context.Context, webviewID webkit.WebViewID, payload json.RawMessage) (any, error) {
+	return webkit.MessageHandlerFunc(func(ctx context.Context, _ webkit.WebViewID, payload json.RawMessage) (any, error) {
 		log := logging.FromContext(ctx)
 		var req updateTagRequest
 // HandleAssign handles tag_assign messages.
 func (h *TagHandlers) HandleAssign() webkit.MessageHandler {
-	return webkit.MessageHandlerFunc(func(ctx context.Context, webviewID webkit.WebViewID, payload json.RawMessage) (any, error) {
+	return handleTagAssign("tag_assign", h.favoritesUC.TagFavorite)
-		log := logging.FromContext(ctx)
-		var req tagAssignRequest
-		if err := json.Unmarshal(payload, &req); err != nil {
-			return NewErrorResponse("", err), nil
-		}
-		log.Debug().
-			Str("request_id", req.RequestID).
-			Int64("favorite_id", req.FavoriteID).
-			Int64("tag_id", req.TagID).
-			Msg("handling tag_assign")
-		if err := h.favoritesUC.TagFavorite(ctx, entity.FavoriteID(req.FavoriteID), entity.TagID(req.TagID)); err != nil {
-			return NewErrorResponse(req.RequestID, err), nil
-		}
-		return NewSuccessResponse(req.RequestID, nil), nil
-	})
 }
 // HandleRemove handles tag_remove messages.
 func (h *TagHandlers) HandleRemove() webkit.MessageHandler {
-	return webkit.MessageHandlerFunc(func(ctx context.Context, webviewID webkit.WebViewID, payload json.RawMessage) (any, error) {
+	return handleTagAssign("tag_remove", h.favoritesUC.UntagFavorite)
+}
+func handleTagAssign(action string, op func(context.Context, entity.FavoriteID, entity.TagID) error) webkit.MessageHandler {
+	return webkit.MessageHandlerFunc(func(ctx context.Context, _ webkit.WebViewID, payload json.RawMessage) (any, error) {
 		log := logging.FromContext(ctx)
-		var req tagAssignRequest // same structure as assign
+		var req tagAssignRequest
 		if err := json.Unmarshal(payload, &req); err != nil {
 			return NewErrorResponse("", err), nil
 		}
 			Str("request_id", req.RequestID).
 			Int64("favorite_id", req.FavoriteID).
 			Int64("tag_id", req.TagID).
-			Msg("handling tag_remove")
+			Msg("handling " + action)
-		if err := h.favoritesUC.UntagFavorite(ctx, entity.FavoriteID(req.FavoriteID), entity.TagID(req.TagID)); err != nil {
+		if err := op(ctx, entity.FavoriteID(req.FavoriteID), entity.TagID(req.TagID)); err != nil {
 			return NewErrorResponse(req.RequestID, err), nil
 		}

M internal/infrastructure/webkit/messaging.go +8 -2

 // It registers the script message handler in the MAIN world (not isolated).
 // WebKit's messageHandlers is only available in main world.
 // The isolated world GUI scripts dispatch CustomEvents to main world, which forwards to this handler.
-func (r *MessageRouter) SetupMessageHandler(ucm *webkit.UserContentManager, worldName string) (uint32, error) {
+func (r *MessageRouter) SetupMessageHandler(ucm *webkit.UserContentManager, _ string) (uint32, error) {
 	log := logging.FromContext(r.baseCtx).With().Str("component", "message-router").Logger()
 	log.Debug().Msg("SetupMessageHandler called")
 		return fmt.Errorf("marshal callback payload: %w", err)
 	}
-	script := fmt.Sprintf(`(function(){try{if(window.%[1]s){window.%[1]s(%[2]s);}else{console.warn("dumber callback missing: %[1]s");}}catch(e){console.error("dumber callback %[1]s failed", e);}})();`, callback, string(data))
+	script := fmt.Sprintf(
+		`(function(){try{if(window.%[1]s){window.%[1]s(%[2]s);}`+
+			`else{console.warn("dumber callback missing: %[1]s");}}`+
+			`catch(e){console.error("dumber callback %[1]s failed", e);}})();`,
+		callback,
+		string(data),
+	)
 	wv.RunJavaScript(ctx, script, world)
 	return nil

M internal/infrastructure/webkit/pool.go +8 -2

 }
 // NewWebViewPool creates a new WebView pool.
-func NewWebViewPool(ctx context.Context, wkCtx *WebKitContext, settings *SettingsManager, cfg PoolConfig, injector *ContentInjector, router *MessageRouter) *WebViewPool {
+func NewWebViewPool(
+	ctx context.Context,
+	wkCtx *WebKitContext,
+	settings *SettingsManager,
+	cfg PoolConfig,
+	injector *ContentInjector,
+	router *MessageRouter,
+) *WebViewPool {
 	if cfg.MaxSize <= 0 {
 		cfg.MaxSize = 8
 	}
 		default:
 			// Pool full, destroy
 			wv.Destroy()
-			break
 		}
 		// Small delay between creations to avoid overwhelming the system

M internal/infrastructure/webkit/scheme_handler.go +62 -88


@@ -66,6 +66,23 @@ type DumbSchemeHandler struct {
66		mu sync.RWMutex	66		mu sync.RWMutex
67		}	67		}
68			68
			69	+	type configAppearancePayload struct {
			70	+	SansFont string `json:"sans_font"`
			71	+	SerifFont string `json:"serif_font"`
			72	+	MonospaceFont string `json:"monospace_font"`
			73	+	DefaultFontSize int `json:"default_font_size"`
			74	+	ColorScheme string `json:"color_scheme"`
			75	+	LightPalette config.ColorPalette `json:"light_palette"`
			76	+	DarkPalette config.ColorPalette `json:"dark_palette"`
			77	+	}
			78	+
			79	+	type configPayload struct {
			80	+	Appearance configAppearancePayload `json:"appearance"`
			81	+	DefaultUIScale float64 `json:"default_ui_scale"`
			82	+	DefaultSearchEngine string `json:"default_search_engine"`
			83	+	SearchShortcuts map[string]config.SearchShortcut `json:"search_shortcuts"`
			84	+	}
			85	+
69		// NewDumbSchemeHandler creates a new handler for the dumb:// scheme.	86		// NewDumbSchemeHandler creates a new handler for the dumb:// scheme.
70		func NewDumbSchemeHandler(ctx context.Context) *DumbSchemeHandler {	87		func NewDumbSchemeHandler(ctx context.Context) *DumbSchemeHandler {
71		log := logging.FromContext(ctx)	88		log := logging.FromContext(ctx)

@@ -93,7 +110,7 @@ func (h *DumbSchemeHandler) SetAssets(assets embed.FS) {
93		// registerDefaults sets up default page handlers.	110		// registerDefaults sets up default page handlers.
94		func (h *DumbSchemeHandler) registerDefaults() {	111		func (h *DumbSchemeHandler) registerDefaults() {
95		// Error page (static fallback)	112		// Error page (static fallback)
96	-	h.RegisterPage("/error", PageHandlerFunc(func(req SchemeRequest) SchemeResponse {	113	+	h.RegisterPage("/error", PageHandlerFunc(func(_ SchemeRequest) SchemeResponse {
97		return &SchemeResponse{	114		return &SchemeResponse{
98		Data: []byte(errorPageHTML),	115		Data: []byte(errorPageHTML),
99		ContentType: "text/html",	116		ContentType: "text/html",

@@ -107,46 +124,7 @@ func (h *DumbSchemeHandler) registerDefaults() {
107		return nil	124		return nil
108		}	125		}
109			126
110	-	cfg := config.Get()	127	+	return buildConfigResponse(config.Get())
111	-	resp := struct {
112	-	Appearance struct {
113	-	SansFont string `json:"sans_font"`
114	-	SerifFont string `json:"serif_font"`
115	-	MonospaceFont string `json:"monospace_font"`
116	-	DefaultFontSize int `json:"default_font_size"`
117	-	ColorScheme string `json:"color_scheme"`
118	-	LightPalette config.ColorPalette `json:"light_palette"`
119	-	DarkPalette config.ColorPalette `json:"dark_palette"`
120	-	} `json:"appearance"`
121	-	DefaultUIScale float64 `json:"default_ui_scale"`
122	-	DefaultSearchEngine string `json:"default_search_engine"`
123	-	SearchShortcuts map[string]config.SearchShortcut `json:"search_shortcuts"`
124	-	}{
125	-	DefaultUIScale: cfg.DefaultUIScale,
126	-	DefaultSearchEngine: cfg.DefaultSearchEngine,
127	-	SearchShortcuts: cfg.SearchShortcuts,
128	-	}
129	-	resp.Appearance.SansFont = cfg.Appearance.SansFont
130	-	resp.Appearance.SerifFont = cfg.Appearance.SerifFont
131	-	resp.Appearance.MonospaceFont = cfg.Appearance.MonospaceFont
132	-	resp.Appearance.DefaultFontSize = cfg.Appearance.DefaultFontSize
133	-	resp.Appearance.ColorScheme = cfg.Appearance.ColorScheme
134	-	resp.Appearance.LightPalette = cfg.Appearance.LightPalette
135	-	resp.Appearance.DarkPalette = cfg.Appearance.DarkPalette
136	-
137	-	data, err := json.Marshal(resp)
138	-	if err != nil {
139	-	return &SchemeResponse{
140	-	Data: []byte(fmt.Sprintf(`{"error": "%s"}`, err)),
141	-	ContentType: "application/json",
142	-	StatusCode: http.StatusInternalServerError,
143	-	}
144	-	}
145	-	return &SchemeResponse{
146	-	Data: data,
147	-	ContentType: "application/json",
148	-	StatusCode: http.StatusOK,
149	-	}
150		}))	128		}))
151			129
152		// API: Get default config (used by Reset Defaults in dumb://config)	130		// API: Get default config (used by Reset Defaults in dumb://config)

@@ -155,47 +133,40 @@ func (h *DumbSchemeHandler) registerDefaults() {
155		return nil	133		return nil
156		}	134		}
157			135
158	-	defaults := config.DefaultConfig()	136	+	return buildConfigResponse(config.DefaultConfig())
159	-	resp := struct {	137	+	}))
160	-	Appearance struct {	138	+	}
161	-	SansFont string `json:"sans_font"`	139	+
162	-	SerifFont string `json:"serif_font"`	140	+	func buildConfigResponse(cfg config.Config) SchemeResponse {
163	-	MonospaceFont string `json:"monospace_font"`	141	+	resp := configPayload{
164	-	DefaultFontSize int `json:"default_font_size"`	142	+	DefaultUIScale: cfg.DefaultUIScale,
165	-	ColorScheme string `json:"color_scheme"`	143	+	DefaultSearchEngine: cfg.DefaultSearchEngine,
166	-	LightPalette config.ColorPalette `json:"light_palette"`	144	+	SearchShortcuts: cfg.SearchShortcuts,
167	-	DarkPalette config.ColorPalette `json:"dark_palette"`	145	+	Appearance: configAppearancePayload{
168	-	} `json:"appearance"`	146	+	SansFont: cfg.Appearance.SansFont,
169	-	DefaultUIScale float64 `json:"default_ui_scale"`	147	+	SerifFont: cfg.Appearance.SerifFont,
170	-	DefaultSearchEngine string `json:"default_search_engine"`	148	+	MonospaceFont: cfg.Appearance.MonospaceFont,
171	-	SearchShortcuts map[string]config.SearchShortcut `json:"search_shortcuts"`	149	+	DefaultFontSize: cfg.Appearance.DefaultFontSize,
172	-	}{	150	+	ColorScheme: cfg.Appearance.ColorScheme,
173	-	DefaultUIScale: defaults.DefaultUIScale,	151	+	LightPalette: cfg.Appearance.LightPalette,
174	-	DefaultSearchEngine: defaults.DefaultSearchEngine,	152	+	DarkPalette: cfg.Appearance.DarkPalette,
175	-	SearchShortcuts: defaults.SearchShortcuts,	153	+	},
176	-	}	154	+	}
177	-	resp.Appearance.SansFont = defaults.Appearance.SansFont	155	+
178	-	resp.Appearance.SerifFont = defaults.Appearance.SerifFont	156	+	data, err := json.Marshal(resp)
179	-	resp.Appearance.MonospaceFont = defaults.Appearance.MonospaceFont	157	+	if err != nil {
180	-	resp.Appearance.DefaultFontSize = defaults.Appearance.DefaultFontSize
181	-	resp.Appearance.ColorScheme = defaults.Appearance.ColorScheme
182	-	resp.Appearance.LightPalette = defaults.Appearance.LightPalette
183	-	resp.Appearance.DarkPalette = defaults.Appearance.DarkPalette
184	-
185	-	data, err := json.Marshal(resp)
186	-	if err != nil {
187	-	return &SchemeResponse{
188	-	Data: []byte(fmt.Sprintf(`{"error": "%s"}`, err)),
189	-	ContentType: "application/json",
190	-	StatusCode: http.StatusInternalServerError,
191	-	}
192	-	}
193		return &SchemeResponse{	158		return &SchemeResponse{
194	-	Data: data,	159	+	Data: []byte(fmt.Sprintf(`{"error": %q}`, err)),
195		ContentType: "application/json",	160		ContentType: "application/json",
196	-	StatusCode: http.StatusOK,	161	+	StatusCode: http.StatusInternalServerError,
197		}	162		}
198	-	}))	163	+	}
			164	+
			165	+	return &SchemeResponse{
			166	+	Data: data,
			167	+	ContentType: "application/json",
			168	+	StatusCode: http.StatusOK,
			169	+	}
199		}	170		}
200			171
201		// RegisterPage registers a handler for a specific path.	172		// RegisterPage registers a handler for a specific path.

@@ -301,28 +272,28 @@ func (h DumbSchemeHandler) handleAsset(u url.URL) *SchemeResponse {
301			272
302		var relPath string	273		var relPath string
303		switch {	274		switch {
304	-	// dumb://home or dumb://home/ → index.html	275	+	// Home root maps to index.html.
305		case host == HomePath && (path == "" \|\| path == "/"):	276		case host == HomePath && (path == "" \|\| path == "/"):
306		relPath = IndexHTML	277		relPath = IndexHTML
307	-	// dumb://home/<asset> → serve asset	278	+	// Home asset paths map directly to assets.
308		case host == HomePath && path != "":	279		case host == HomePath && path != "":
309		relPath = path	280		relPath = path
310	-	// dumb://config or dumb://config/ → config.html	281	+	// Config root maps to config.html.
311		case host == ConfigPath && (path == "" \|\| path == "/"):	282		case host == ConfigPath && (path == "" \|\| path == "/"):
312		relPath = "config.html"	283		relPath = "config.html"
313	-	// dumb://config/<asset> → serve asset	284	+	// Config asset paths map directly to assets.
314		case host == ConfigPath && path != "":	285		case host == ConfigPath && path != "":
315		relPath = path	286		relPath = path
316	-	// dumb://error or dumb://error/ → error.html	287	+	// Error root maps to error.html.
317		case host == ErrorPath && (path == "" \|\| path == "/"):	288		case host == ErrorPath && (path == "" \|\| path == "/"):
318		relPath = "error.html"	289		relPath = "error.html"
319	-	// dumb://error/<asset> → serve asset	290	+	// Error asset paths map directly to assets.
320		case host == ErrorPath && path != "":	291		case host == ErrorPath && path != "":
321		relPath = path	292		relPath = path
322	-	// dumb:home (opaque form) → index.html	293	+	// Opaque home form maps to index.html.
323		case u.Opaque == HomePath:	294		case u.Opaque == HomePath:
324		relPath = IndexHTML	295		relPath = IndexHTML
325	-	// dumb:error (opaque form) → error.html	296	+	// Opaque error form maps to error.html.
326		case u.Opaque == ErrorPath:	297		case u.Opaque == ErrorPath:
327		relPath = "error.html"	298		relPath = "error.html"
328		default:	299		default:

@@ -354,6 +325,9 @@ func (h DumbSchemeHandler) handleAsset(u url.URL) *SchemeResponse {
354			325
355		// getMimeType determines the MIME type for a given file path.	326		// getMimeType determines the MIME type for a given file path.
356		func (h *DumbSchemeHandler) getMimeType(filename string) string {	327		func (h *DumbSchemeHandler) getMimeType(filename string) string {
			328	+	if h == nil {
			329	+	return "application/octet-stream"
			330	+	}
357		ext := strings.ToLower(filepath.Ext(filename))	331		ext := strings.ToLower(filepath.Ext(filename))
358			332
359		// Try standard mime type first	333		// Try standard mime type first

@@ -451,7 +425,7 @@ func (h DumbSchemeHandler) RegisterWithContext(wkCtx WebKitContext) {
451		return	425		return
452		}	426		}
453			427
454	-	callback := webkit.URISchemeRequestCallback(func(reqPtr, userData uintptr) {	428	+	callback := webkit.URISchemeRequestCallback(func(reqPtr, _ uintptr) {
455		h.HandleRequest(reqPtr)	429		h.HandleRequest(reqPtr)
456		})	430		})
457			431

M internal/infrastructure/webkit/settings.go +42 -26

 	"github.com/bnema/dumber/internal/infrastructure/config"
 	"github.com/bnema/dumber/internal/logging"
 	"github.com/bnema/puregotk-webkit/webkit"
+	"github.com/rs/zerolog"
 )
 // SettingsManager creates and manages WebKit Settings instances from config.
 // applySettings applies configuration to a webkit.Settings instance.
 func (sm *SettingsManager) applySettings(ctx context.Context, settings *webkit.Settings, cfg *config.Config) {
+	if sm == nil {
+		return
+	}
 	log := logging.FromContext(ctx)
-	// JavaScript settings
+	applyJavaScriptSettings(settings)
+	applyFontSettings(settings, cfg)
+	applyRenderingSettings(settings, cfg)
+	applyDebugSettings(settings, cfg)
+	applyBrowsingSettings(settings)
+	applyMediaSettings(settings, cfg, log)
+	applyStorageSettings(settings)
+	applyUISettings(settings)
+	applyCanvasSettings(settings)
+	applyWebRTCSettings(settings)
+	log.Debug().
+		Str("sans_font", cfg.Appearance.SansFont).
+		Str("rendering_mode", string(cfg.RenderingMode)).
+		Bool("developer_extras", cfg.Debug.EnableDevTools).
+	Msg("settings applied")
+}
+func applyJavaScriptSettings(settings *webkit.Settings) {
 	settings.SetEnableJavascript(true)
 	settings.SetEnableJavascriptMarkup(true)
+}
-	// Font settings from config
+func applyFontSettings(settings *webkit.Settings, cfg *config.Config) {
 	if cfg.Appearance.SansFont != "" {
 		settings.SetDefaultFontFamily(cfg.Appearance.SansFont)
 		settings.SetSansSerifFontFamily(cfg.Appearance.SansFont)
 	if cfg.Appearance.DefaultFontSize > 0 {
 		settings.SetDefaultFontSize(uint32(cfg.Appearance.DefaultFontSize))
 	}
+}
-	// Hardware acceleration based on rendering mode
+func applyRenderingSettings(settings *webkit.Settings, cfg *config.Config) {
 	switch cfg.RenderingMode {
 	case config.RenderingModeGPU:
 		settings.SetHardwareAccelerationPolicy(webkit.HardwareAccelerationPolicyAlwaysValue)
 	case config.RenderingModeCPU:
 		settings.SetHardwareAccelerationPolicy(webkit.HardwareAccelerationPolicyNeverValue)
 	case config.RenderingModeAuto:
-		// Default to always for auto mode (WebKit handles capability detection)
 		settings.SetHardwareAccelerationPolicy(webkit.HardwareAccelerationPolicyAlwaysValue)
 	}
+}
-	// Debug settings
+func applyDebugSettings(settings *webkit.Settings, cfg *config.Config) {
 	settings.SetEnableDeveloperExtras(cfg.Debug.EnableDevTools)
 	settings.SetEnableWriteConsoleMessagesToStdout(cfg.Logging.CaptureConsole)
+}
-	// Browsing experience
+func applyBrowsingSettings(settings *webkit.Settings) {
 	settings.SetEnableSmoothScrolling(true)
-	// Note: DNS prefetching setting deprecated in WebKitGTK 6 - use NetworkSession.PrefetchDns() instead
 	settings.SetEnablePageCache(true)
 	settings.SetEnableSiteSpecificQuirks(true)
+}
-	// Media settings
+func applyMediaSettings(settings *webkit.Settings, cfg *config.Config, log *zerolog.Logger) {
 	settings.SetEnableWebaudio(true)
 	settings.SetEnableWebgl(true)
 	settings.SetEnableMedia(true)
 	settings.SetMediaPlaybackRequiresUserGesture(true)
 	settings.SetMediaPlaybackAllowsInline(true)
-	// Hardware decoding mode - THE FIX for Twitch Error #4000
-	// Default "auto" allows GStreamer to choose best decoder with software fallback
 	switch cfg.Media.HardwareDecodingMode {
 	case config.HardwareDecodingForce:
-		// Force hardware - will fail if unavailable (not recommended)
-		// Prioritize AV1 (most efficient codec) when user wants forced HW
 		hwTypes := "video/av01;video/mp4;video/webm;video/x-h264;video/x-h265"
 		settings.SetMediaContentTypesRequiringHardwareSupport(&hwTypes)
 		log.Debug().Msg("hardware decoding: forced (may fail without hw support)")
 	case config.HardwareDecodingDisable:
-		// Force software only
 		settings.SetHardwareAccelerationPolicy(webkit.HardwareAccelerationPolicyNeverValue)
 		log.Debug().Msg("hardware decoding: disabled (software only)")
-	default: // HardwareDecodingAuto
+	default:
-		// Empty string = let GStreamer choose best decoder with software fallback
-		// This fixes Twitch Error #4000 by allowing playback when HW unavailable
 		emptyTypes := ""
 		settings.SetMediaContentTypesRequiringHardwareSupport(&emptyTypes)
 		log.Debug().Msg("hardware decoding: auto (hw preferred, software fallback)")
 	}
+}
-	// HTML5 storage
+func applyStorageSettings(settings *webkit.Settings) {
 	settings.SetEnableHtml5LocalStorage(true)
 	settings.SetEnableHtml5Database(true)
+}
-	// UI behavior - touchpad swipe gestures for back/forward navigation
+func applyUISettings(settings *webkit.Settings) {
 	settings.SetEnableBackForwardNavigationGestures(true)
 	settings.SetEnableFullscreen(true)
+}
-	// Canvas acceleration
+func applyCanvasSettings(settings *webkit.Settings) {
 	settings.SetEnable2dCanvasAcceleration(true)
+}
-	// WebRTC
+func applyWebRTCSettings(settings *webkit.Settings) {
 	settings.SetEnableWebrtc(true)
-	log.Debug().
-		Str("sans_font", cfg.Appearance.SansFont).
-		Str("rendering_mode", string(cfg.RenderingMode)).
-		Bool("developer_extras", cfg.Debug.EnableDevTools).
-		Msg("settings applied")
 }
 // UpdateFromConfig updates the manager with a new config (for hot-reload).

M internal/infrastructure/webkit/webview.go +49 -36

 // connectSignals sets up signal handlers for the WebView.
 func (wv *WebView) connectSignals() {
-	// load-changed signal
+	wv.connectLoadChangedSignal()
+	wv.connectCloseSignal()
+	wv.connectCreateSignal()
+	wv.connectReadyToShowSignal()
+	wv.connectTitleSignal()
+	wv.connectURISignal()
+	wv.connectFaviconSignal()
+	wv.connectProgressSignal()
+	wv.connectDecidePolicySignal()
+}
+func (wv *WebView) connectLoadChangedSignal() {
 	loadChangedCb := func(inner webkit.WebView, event webkit.LoadEvent) {
 		uri := inner.GetUri()
 		title := inner.GetTitle()
 	}
 	sigID := wv.inner.ConnectLoadChanged(&loadChangedCb)
 	wv.signalIDs = append(wv.signalIDs, sigID)
+}
-	// close signal
+func (wv *WebView) connectCloseSignal() {
-	closeCb := func(inner webkit.WebView) {
+	closeCb := func(_ webkit.WebView) {
 		if wv.OnClose != nil {
 			wv.OnClose()
 		}
 	}
-	sigID = wv.inner.ConnectClose(&closeCb)
+	sigID := wv.inner.ConnectClose(&closeCb)
 	wv.signalIDs = append(wv.signalIDs, sigID)
+}
-	// create signal for popup window handling
+func (wv *WebView) connectCreateSignal() {
-	createCb := func(inner webkit.WebView, navActionPtr uintptr) gtk.Widget {
+	createCb := func(_ webkit.WebView, navActionPtr uintptr) gtk.Widget {
 		if wv.OnCreate == nil {
 			return gtk.Widget{} // Block popup
 		}
 		return newWV.inner.Widget
 	}
-	sigID = wv.inner.ConnectCreate(&createCb)
+	sigID := wv.inner.ConnectCreate(&createCb)
 	wv.signalIDs = append(wv.signalIDs, sigID)
+}
-	// ready-to-show signal for popup display
+func (wv *WebView) connectReadyToShowSignal() {
-	readyToShowCb := func(inner webkit.WebView) {
+	readyToShowCb := func(_ webkit.WebView) {
 		if wv.OnReadyToShow != nil {
 			wv.OnReadyToShow()
 		}
 	}
-	sigID = wv.inner.ConnectReadyToShow(&readyToShowCb)
+	sigID := wv.inner.ConnectReadyToShow(&readyToShowCb)
 	wv.signalIDs = append(wv.signalIDs, sigID)
+}
-	// notify::title signal for title changes
+func (wv *WebView) connectTitleSignal() {
-	// This fires when the page title changes (e.g., after page load, SPA navigation)
 	titleCb := func() {
 		title := wv.inner.GetTitle()
 		wv.mu.Lock()
 			wv.OnTitleChanged(title)
 		}
 	}
-	sigID = gobject.SignalConnect(wv.inner.GoPointer(), "notify::title", glib.NewCallback(&titleCb))
+	sigID := gobject.SignalConnect(wv.inner.GoPointer(), "notify::title", glib.NewCallback(&titleCb))
 	wv.signalIDs = append(wv.signalIDs, sigID)
+}
-	// notify::uri signal for URI changes
+func (wv *WebView) connectURISignal() {
-	// This fires when the URI changes (e.g., redirects, SPA navigation via History API)
 	uriCb := func() {
 		uri := wv.inner.GetUri()
 		wv.mu.Lock()
 			wv.OnURIChanged(uri)
 		}
 	}
-	sigID = gobject.SignalConnect(wv.inner.GoPointer(), "notify::uri", glib.NewCallback(&uriCb))
+	sigID := gobject.SignalConnect(wv.inner.GoPointer(), "notify::uri", glib.NewCallback(&uriCb))
 	wv.signalIDs = append(wv.signalIDs, sigID)
+}
-	// notify::favicon signal for favicon changes
+func (wv *WebView) connectFaviconSignal() {
-	// This fires when the page favicon changes (after page load or dynamic updates)
 	faviconCb := func() {
 		favicon := wv.inner.GetFavicon()
 		if wv.OnFaviconChanged != nil {
 			wv.OnFaviconChanged(favicon)
 		}
 	}
-	sigID = gobject.SignalConnect(wv.inner.GoPointer(), "notify::favicon", glib.NewCallback(&faviconCb))
+	sigID := gobject.SignalConnect(wv.inner.GoPointer(), "notify::favicon", glib.NewCallback(&faviconCb))
 	wv.signalIDs = append(wv.signalIDs, sigID)
+}
-	// notify::estimated-load-progress signal for load progress updates
+func (wv *WebView) connectProgressSignal() {
-	// This fires frequently during page load with values from 0.0 to 1.0
 	progressCb := func() {
 		progress := wv.inner.GetEstimatedLoadProgress()
 		wv.mu.Lock()
 			wv.OnProgressChanged(progress)
 		}
 	}
-	sigID = gobject.SignalConnect(wv.inner.GoPointer(), "notify::estimated-load-progress", glib.NewCallback(&progressCb))
+	sigID := gobject.SignalConnect(wv.inner.GoPointer(), "notify::estimated-load-progress", glib.NewCallback(&progressCb))
 	wv.signalIDs = append(wv.signalIDs, sigID)
+}
-	// decide-policy signal for intercepting middle-click and Ctrl+click on links
+func (wv *WebView) connectDecidePolicySignal() {
-	decidePolicyCb := func(inner webkit.WebView, decisionPtr uintptr, decisionType webkit.PolicyDecisionType) bool {
+	decidePolicyCb := func(_ webkit.WebView, decisionPtr uintptr, decisionType webkit.PolicyDecisionType) bool {
-		// Only handle navigation actions (not new window or response policies)
 		if decisionType != webkit.PolicyDecisionTypeNavigationActionValue {
 			return false // Let WebKit handle
 		}
-		// Cast to NavigationPolicyDecision
 		navDecision := webkit.NavigationPolicyDecisionNewFromInternalPtr(decisionPtr)
 		if navDecision == nil {
 			return false
 			return false
 		}
-		// Only handle link clicks
 		if navAction.GetNavigationType() != webkit.NavigationTypeLinkClickedValue {
 			return false
 		}
-		// Get mouse button and modifiers
 		mouseButton := navAction.GetMouseButton()
 		modifiers := navAction.GetModifiers()
-		// Check for middle-click (button 2) or Ctrl+left-click (button 1 + Ctrl)
 		isMiddleClick := mouseButton == 2
 		isCtrlClick := mouseButton == 1 && (gdk.ModifierType(modifiers)&gdk.ControlMaskValue) != 0
 		if !isMiddleClick && !isCtrlClick {
-			return false // Normal click, let WebKit handle
+			return false
 		}
-		// Get the link URL
 		request := navAction.GetRequest()
 		if request == nil {
 			return false
 			Bool("ctrl", isCtrlClick).
 			Msg("middle-click/ctrl+click on link detected")
-		// Call the handler
 		if wv.OnLinkMiddleClick != nil {
 			if wv.OnLinkMiddleClick(linkURI) {
-				// Handler processed it, block the navigation
 				navDecision.Ignore()
 				return true
 			}
 		}
-		return false // Let WebKit handle if not handled
+		return false
 	}
-	sigID = wv.inner.ConnectDecidePolicy(&decidePolicyCb)
+	sigID := wv.inner.ConnectDecidePolicy(&decidePolicyCb)
 	wv.signalIDs = append(wv.signalIDs, sigID)
 }
 		baseURIPtr = &baseURI
 	}
 	wv.inner.LoadHtml(content, baseURIPtr)
+	logging.FromContext(ctx).Debug().Int("webview_id", int(wv.id)).Msg("loading HTML content")
 	return nil
 }
 		return fmt.Errorf("webview %d is destroyed", wv.id)
 	}
 	wv.inner.Reload()
+	logging.FromContext(ctx).Debug().Int("webview_id", int(wv.id)).Msg("reloading webview")
 	return nil
 }
 		return fmt.Errorf("webview %d is destroyed", wv.id)
 	}
 	wv.inner.ReloadBypassCache()
+	logging.FromContext(ctx).Debug().Int("webview_id", int(wv.id)).Msg("reloading webview bypassing cache")
 	return nil
 }
 		return fmt.Errorf("webview %d is destroyed", wv.id)
 	}
 	wv.inner.StopLoading()
+	logging.FromContext(ctx).Debug().Int("webview_id", int(wv.id)).Msg("stopping webview load")
 	return nil
 }
 		return fmt.Errorf("cannot go back")
 	}
 	wv.inner.GoBack()
+	logging.FromContext(ctx).Debug().Int("webview_id", int(wv.id)).Msg("webview go back")
 	return nil
 }
 		return fmt.Errorf("cannot go forward")
 	}
 	wv.inner.GoForward()
+	logging.FromContext(ctx).Debug().Int("webview_id", int(wv.id)).Msg("webview go forward")
 	return nil
 }
 		return fmt.Errorf("webview %d is destroyed", wv.id)
 	}
 	wv.inner.SetZoomLevel(level)
+	logging.FromContext(ctx).Debug().Float64("level", level).Int("webview_id", int(wv.id)).Msg("set webview zoom level")
 	return nil
 }

M internal/logging/logger.go +25 -15

 	"github.com/rs/zerolog"
 )
+const (
+	logFormatConsole = "console"
+	logFormatJSON    = "json"
+	logFormatText    = "text"
+)
 // Config holds logging configuration
 type Config struct {
 	Level      zerolog.Level
 func DefaultConfig() Config {
 	return Config{
 		Level:      zerolog.InfoLevel,
-		Format:     "console",
+		Format:     logFormatConsole,
 		TimeFormat: time.RFC3339,
 	}
 }
 	var output io.Writer = os.Stderr
 	switch cfg.Format {
-	case "console":
+	case logFormatConsole:
 		output = zerolog.ConsoleWriter{
 			Out:        os.Stderr,
 			TimeFormat: cfg.TimeFormat,
 		}
-	case "json":
+	case logFormatJSON:
 		// JSON is the default zerolog format
 		output = os.Stderr
 	}
 // LogDir must exist before calling this function (handled by config.EnsureDirectories).
 // Returns the logger and a cleanup function to close the file.
 func NewWithFile(cfg Config, fileCfg FileConfig) (zerolog.Logger, func(), error) {
+	const (
+		logDirPerm  = 0o755
+		logFilePerm = 0o644
+	)
 	var writers []io.Writer
-	var cleanup func() = func() {}
+	cleanup := func() {}
 	// Stderr output (only if enabled)
 	if fileCfg.WriteToStderr {
 		switch cfg.Format {
-		case "console", "text", "":
+		case logFormatConsole, logFormatText, "":
 			writers = append(writers, zerolog.ConsoleWriter{
 				Out:        os.Stderr,
 				TimeFormat: cfg.TimeFormat,
 			})
-		case "json":
+		case logFormatJSON:
 			writers = append(writers, os.Stderr)
 		default:
 			writers = append(writers, zerolog.ConsoleWriter{
 	// Session file output (JSON format for parsing)
 	if fileCfg.Enabled && fileCfg.LogDir != "" && fileCfg.SessionID != "" {
 		// Ensure log directory exists (LogDir is from config, may not have logs subdir)
-		if err := os.MkdirAll(fileCfg.LogDir, 0755); err != nil {
+		if err := os.MkdirAll(fileCfg.LogDir, logDirPerm); err != nil {
 			return zerolog.Logger{}, nil, err
 		}
 		filename := filepath.Join(fileCfg.LogDir, SessionFilename(fileCfg.SessionID))
-		file, err := os.OpenFile(filename, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0644)
+		file, err := os.OpenFile(filename, os.O_CREATE|os.O_APPEND|os.O_WRONLY, logFilePerm)
 		if err != nil {
 			return zerolog.Logger{}, nil, err
 		}
 		writers = append(writers, file)
-		cleanup = func() { file.Close() }
+		cleanup = func() { _ = file.Close() }
 	}
 	// Fallback to discard if no writers configured
 	if format := os.Getenv("DUMBER_LOG_FORMAT"); format != "" {
 		switch format {
-		case "json", "console", "text":
+		case logFormatJSON, logFormatConsole, logFormatText:
 			cfg.Format = format
 		}
 	}
 	cfg.Level = ParseLevel(level)
 	switch format {
-	case "json":
+	case logFormatJSON:
-		cfg.Format = "json"
+		cfg.Format = logFormatJSON
-	case "console", "text", "":
+	case logFormatConsole, logFormatText, "":
-		cfg.Format = "console"
+		cfg.Format = logFormatConsole
 	default:
-		cfg.Format = "console"
+		cfg.Format = logFormatConsole
 	}
 	return New(cfg)

M internal/ui/app.go +17 -8

 	a.keyboardHandler.SetOnModeChange(func(from, to input.Mode) {
 		a.handleModeChange(ctx, from, to)
 	})
+	a.keyboardHandler.SetShouldBypassInput(func() bool {
+		wsView := a.activeWorkspaceView()
+		if wsView == nil {
+			return false
+		}
+		return wsView.IsOmniboxVisible()
+	})
 	a.keyboardHandler.AttachTo(a.mainWindow.Window())
 	// Store omnibox config (omnibox is created per-pane via WorkspaceView)
 		InitialBehavior: a.deps.Config.Omnibox.InitialBehavior,
 		UIScale:         a.deps.Config.DefaultUIScale,
 		OnNavigate: func(url string) {
-			a.navCoord.Navigate(ctx, url)
+			if err := a.navCoord.Navigate(ctx, url); err != nil {
+				log.Error().Err(err).Str("url", url).Msg("navigation failed")
+			}
 		},
 	}
 	a.navCoord.SetOmniboxProvider(a)
 	// Wire tab bar click handling to coordinator
 	if a.mainWindow != nil && a.mainWindow.TabBar() != nil {
 		a.mainWindow.TabBar().SetOnSwitch(func(tabID entity.TabID) {
-			a.tabCoord.Switch(ctx, tabID)
+			if err := a.tabCoord.Switch(ctx, tabID); err != nil {
+				log.Error().Err(err).Str("tab_id", string(tabID)).Msg("tab switch failed")
+			}
 		})
 	}
 	// Only appearance is hot-reloaded for now.
 	a.configManager.OnConfigChange(func(newCfg *config.Config) {
 		cfgCopy := newCfg
-		var cb glib.SourceFunc
+		cb := glib.SourceFunc(func(_ uintptr) bool {
-		cb = func(_ uintptr) bool {
 			a.applyAppearanceConfig(ctx, cfgCopy)
 			return false
-		}
+		})
 		glib.IdleAdd(&cb, 0)
 	})
 	a.deps.FilterManager.SetStatusCallback(func(status filtering.FilterStatus) {
 		statusCopy := status // Capture for closure
-		var cb glib.SourceFunc
+		cb := glib.SourceFunc(func(_ uintptr) bool {
-		cb = func(_ uintptr) bool {
 			a.showFilterStatus(ctx, statusCopy)
 			return false // Don't repeat
-		}
+		})
 		glib.IdleAdd(&cb, 0)
 	})
 	a.deps.FilterManager.LoadAsync(ctx)

M internal/ui/component/find_bar.go +65 -29

 }
 func (fb *FindBar) createWidgets() error {
+	if err := fb.initContainerWidgets(); err != nil {
+		return err
+	}
+	if err := fb.initInputRowWidgets(); err != nil {
+		return err
+	}
+	if err := fb.initOptionsRowWidgets(); err != nil {
+		return err
+	}
+	fb.assembleWidgets()
+	return nil
+}
+func (fb *FindBar) setupHandlers() {
+	fb.connectEntryHandlers()
+	fb.connectNavHandlers()
+	fb.connectToggleHandlers()
+	fb.attachKeyController()
+}
+func (fb *FindBar) initContainerWidgets() error {
 	fb.outerBox = gtk.NewBox(gtk.OrientationVerticalValue, 0)
 	if fb.outerBox == nil {
 		return errNilWidget("findOuterBox")
 		return errNilWidget("findContainerBox")
 	}
 	fb.containerBox.AddCssClass("find-bar-container")
+	return nil
+}
+func (fb *FindBar) initInputRowWidgets() error {
 	fb.inputRow = gtk.NewBox(gtk.OrientationHorizontalValue, findBarRowSpacing)
 	if fb.inputRow == nil {
 		return errNilWidget("findInputRow")
 		return errNilWidget("findCloseBtn")
 	}
 	fb.closeBtn.AddCssClass("find-bar-close")
+	return nil
+}
+func (fb *FindBar) initOptionsRowWidgets() error {
 	fb.optionsRow = gtk.NewBox(gtk.OrientationHorizontalValue, findBarRowSpacing)
 	if fb.optionsRow == nil {
 		return errNilWidget("findOptionsRow")
 	}
 	fb.hlToggle.AddCssClass("find-bar-toggle")
 	fb.hlToggle.SetActive(true)
+	return nil
+}
+func (fb *FindBar) assembleWidgets() {
 	fb.inputRow.Append(&fb.entry.Widget)
 	fb.inputRow.Append(&fb.prevBtn.Widget)
 	fb.inputRow.Append(&fb.nextBtn.Widget)
 	fb.containerBox.Append(&fb.inputRow.Widget)
 	fb.containerBox.Append(&fb.optionsRow.Widget)
 	fb.outerBox.Append(&fb.containerBox.Widget)
-	return nil
 }
-func (fb *FindBar) setupHandlers() {
+func (fb *FindBar) connectEntryHandlers() {
-	if fb.entry != nil {
+	if fb.entry == nil {
-		changedCb := func(_ gtk.SearchEntry) {
+		return
-			if fb.uc != nil {
+	}
-				fb.uc.SetQuery(fb.entry.GetText())
+	changedCb := func(_ gtk.SearchEntry) {
-			}
+		if fb.uc != nil {
+			fb.uc.SetQuery(fb.entry.GetText())
 		}
-		fb.entry.ConnectSearchChanged(&changedCb)
 	}
+	fb.entry.ConnectSearchChanged(&changedCb)
+}
+func (fb *FindBar) connectNavHandlers() {
 	if fb.prevBtn != nil {
 		prevCb := func(_ gtk.Button) {
 			fb.FindPrevious()
 		}
 		fb.closeBtn.ConnectClicked(&closeCb)
 	}
+}
+func (fb *FindBar) connectToggleHandlers() {
 	if fb.caseToggle != nil {
 		caseCb := func(_ gtk.ToggleButton) {
 			if fb.uc != nil {
 		}
 		fb.hlToggle.ConnectToggled(&hlCb)
 	}
+}
+func (fb *FindBar) attachKeyController() {
 	controller := gtk.NewEventControllerKey()
-	if controller != nil {
+	if controller == nil {
-		controller.SetPropagationPhase(gtk.PhaseCaptureValue)
+		return
-		keyPressedCb := func(_ gtk.EventControllerKey, keyval uint, _ uint, state gdk.ModifierType) bool {
+	}
-			switch keyval {
+	controller.SetPropagationPhase(gtk.PhaseCaptureValue)
-			case uint(gdk.KEY_Escape):
+	keyPressedCb := func(_ gtk.EventControllerKey, keyval uint, _ uint, state gdk.ModifierType) bool {
-				fb.Hide()
+		switch keyval {
-				if fb.onClose != nil {
+		case uint(gdk.KEY_Escape):
-					fb.onClose()
+			fb.Hide()
-				}
+			if fb.onClose != nil {
-				return true
+				fb.onClose()
-			case uint(gdk.KEY_Return), uint(gdk.KEY_KP_Enter):
-				if state&gdk.ShiftMaskValue != 0 {
-					fb.FindPrevious()
-				} else {
-					fb.FindNext()
-				}
-				return true
 			}
-			return false
+			return true
+		case uint(gdk.KEY_Return), uint(gdk.KEY_KP_Enter):
+			if state&gdk.ShiftMaskValue != 0 {
+				fb.FindPrevious()
+			} else {
+				fb.FindNext()
+			}
+			return true
 		}
-		controller.ConnectKeyPressed(&keyPressedCb)
+		return false
-		fb.outerBox.AddController(&controller.EventController)
 	}
+	controller.ConnectKeyPressed(&keyPressedCb)
+	fb.outerBox.AddController(&controller.EventController)
 }
 func (fb *FindBar) bindUseCase() {

M internal/ui/component/omnibox.go +104 -80

 	omniboxMaxWidth   = 800 // Maximum width in pixels
 	omniboxHeightPct  = 0.6 // 60% of parent window height
 	omniboxMaxResults = 10
+	omniboxTopMarginPct = 0.2 // 20% from top
 	debounceDelayMs   = 150
 )
 		rowHeight = o.measuredHeights.singleRow
 	} else {
 		// Fallback to hardcoded estimate (before first measurement)
-		rowHeight = int(60 * o.uiScale)
+		const fallbackRowHeight = 60
+		rowHeight = int(fallbackRowHeight * o.uiScale)
 	}
 	// Calculate content height for the scrolled window
 // createWidgets builds the GTK widget hierarchy.
 func (o *Omnibox) createWidgets() error {
-	// Create outer container for positioning (will be added to an overlay)
+	if err := o.initOuterBox(); err != nil {
+		return err
+	}
+	if err := o.initMainBox(); err != nil {
+		return err
+	}
+	if err := o.initHeader(); err != nil {
+		return err
+	}
+	if err := o.initEntry(); err != nil {
+		return err
+	}
+	if err := o.initList(); err != nil {
+		return err
+	}
+	o.assembleWidgets()
+	return nil
+}
+// setupKeyboardHandling adds keyboard event handling.
+func (o *Omnibox) setupKeyboardHandling() {
+	log := logging.FromContext(o.ctx)
+	controller := gtk.NewEventControllerKey()
+	if controller == nil {
+		log.Error().Msg("failed to create event controller key")
+		return
+	}
+	// Set capture phase to intercept before entry
+	controller.SetPropagationPhase(gtk.PhaseCaptureValue)
+keyPressedCb := func(_ gtk.EventControllerKey, keyval uint, _ uint, state gdk.ModifierType) bool {
+		return o.handleKeyPress(keyval, state)
+	}
+	controller.ConnectKeyPressed(&keyPressedCb)
+	o.outerBox.AddController(&controller.EventController)
+}
+func (o *Omnibox) initOuterBox() error {
 	o.outerBox = gtk.NewBox(gtk.OrientationVerticalValue, 0)
 	if o.outerBox == nil {
 		return errNilWidget("outerBox")
 	o.outerBox.SetHalign(gtk.AlignCenterValue) // Center horizontally
 	o.outerBox.SetValign(gtk.AlignStartValue)  // Align to top
 	o.outerBox.SetVisible(false)               // Hidden by default
+	return nil
+}
-	// Main content box
+func (o *Omnibox) initMainBox() error {
 	o.mainBox = gtk.NewBox(gtk.OrientationVerticalValue, 0)
 	if o.mainBox == nil {
 		return errNilWidget("mainBox")
 	}
 	o.mainBox.AddCssClass("omnibox-container")
+	return nil
+}
-	// Header with History/Favorites toggle
+func (o *Omnibox) initHeader() error {
 	o.headerBox = gtk.NewBox(gtk.OrientationHorizontalValue, 0)
 	if o.headerBox == nil {
 		return errNilWidget("headerBox")
 	o.favoritesBtn.AddCssClass("omnibox-header-btn")
 	o.favoritesBtn.SetCanFocus(false)
-	// Connect header button clicks
+	historyClickCb := func(_ gtk.Button) {
-	historyClickCb := func(btn gtk.Button) {
 		o.setViewMode(ViewModeHistory)
 	}
 	o.historyBtn.ConnectClicked(&historyClickCb)
-	favoritesClickCb := func(btn gtk.Button) {
+	favoritesClickCb := func(_ gtk.Button) {
 		o.setViewMode(ViewModeFavorites)
 	}
 	o.favoritesBtn.ConnectClicked(&favoritesClickCb)
-	// Zoom indicator label (shown when zoom != 100%)
 	o.zoomLabel = gtk.NewLabel(nil)
 	if o.zoomLabel != nil {
 		o.zoomLabel.AddCssClass("omnibox-zoom-indicator")
 		o.zoomLabel.SetHalign(gtk.AlignEndValue)
 		o.zoomLabel.SetHexpand(true)
 	}
+	return nil
+}
-	o.headerBox.Append(&o.historyBtn.Widget)
+func (o *Omnibox) initEntry() error {
-	o.headerBox.Append(&o.favoritesBtn.Widget)
-	if o.zoomLabel != nil {
-		o.headerBox.Append(&o.zoomLabel.Widget)
-	}
-	// Search entry field
 	o.entry = gtk.NewSearchEntry()
 	if o.entry == nil {
 		return errNilWidget("entry")
 	placeholder := "Search history or enter URL..."
 	o.entry.SetPlaceholderText(&placeholder)
+	return nil
+}
-	// Scrolled window for list
+func (o *Omnibox) initList() error {
 	o.scrolledWin = gtk.NewScrolledWindow()
 	if o.scrolledWin == nil {
 		return errNilWidget("scrolledWin")
 	o.scrolledWin.AddCssClass("omnibox-scrolled")
 	o.scrolledWin.SetVexpand(true)
 	o.scrolledWin.SetPolicy(gtk.PolicyNeverValue, gtk.PolicyAutomaticValue)
-	// Let GTK handle natural sizing - propagate child height up to max
 	o.scrolledWin.SetPropagateNaturalHeight(true)
-	// List box for suggestions
 	o.listBox = gtk.NewListBox()
 	if o.listBox == nil {
 		return errNilWidget("listBox")
 	o.listBox.AddCssClass("omnibox-listbox")
 	o.listBox.SetSelectionMode(gtk.SelectionSingleValue)
-	// Connect row selection
+	rowSelectedCb := func(_ gtk.ListBox, rowPtr uintptr) {
-	rowSelectedCb := func(lb gtk.ListBox, rowPtr uintptr) {
 		if rowPtr == 0 {
 			o.mu.Lock()
 			o.selectedIndex = -1
 		}
 	}
 	o.listBox.ConnectRowSelected(&rowSelectedCb)
+	return nil
+}
+func (o *Omnibox) assembleWidgets() {
+	o.headerBox.Append(&o.historyBtn.Widget)
+	o.headerBox.Append(&o.favoritesBtn.Widget)
+	if o.zoomLabel != nil {
+		o.headerBox.Append(&o.zoomLabel.Widget)
+	}
-	// Assemble hierarchy
 	o.scrolledWin.SetChild(&o.listBox.Widget)
 	o.mainBox.Append(&o.headerBox.Widget)
 	o.mainBox.Append(&o.entry.Widget)
 	o.mainBox.Append(&o.scrolledWin.Widget)
 	o.outerBox.Append(&o.mainBox.Widget)
-	return nil
-}
-// setupKeyboardHandling adds keyboard event handling.
-func (o *Omnibox) setupKeyboardHandling() {
-	log := logging.FromContext(o.ctx)
-	controller := gtk.NewEventControllerKey()
-	if controller == nil {
-		log.Error().Msg("failed to create event controller key")
-		return
-	}
-	// Set capture phase to intercept before entry
-	controller.SetPropagationPhase(gtk.PhaseCaptureValue)
-	keyPressedCb := func(ctrl gtk.EventControllerKey, keyval uint, keycode uint, state gdk.ModifierType) bool {
-		return o.handleKeyPress(keyval, state)
-	}
-	controller.ConnectKeyPressed(&keyPressedCb)
-	o.outerBox.AddController(&controller.EventController)
 }
 // setupEntryChanged wires entry text changes to debounced search.
 	case uint(gdk.KEY_1), uint(gdk.KEY_2), uint(gdk.KEY_3), uint(gdk.KEY_4), uint(gdk.KEY_5),
 		uint(gdk.KEY_6), uint(gdk.KEY_7), uint(gdk.KEY_8), uint(gdk.KEY_9):
 		if ctrl {
-			index := int(keyval - uint(gdk.KEY_1)) // 0-8
+			const firstShortcutKey = uint(gdk.KEY_1)
+			index := int(keyval - firstShortcutKey) // 0-8
 			o.selectAndNavigate(index)
 			return true
 		}
 	case uint(gdk.KEY_0):
 		if ctrl {
-			o.selectAndNavigate(9) // 10th item
+			const tenthItemIndex = 9
+			o.selectAndNavigate(tenthItemIndex)
 			return true
 		}
 	}
 			o.idleAddUpdateSuggestions(nil)
 			return
-		case "most_visited":
+		case "most_visited", "recent", "":
 			// TODO: Implement GetMostVisited in use case if needed
-			fallthrough
-		case "recent", "":
 			results, err := o.historyUC.GetRecent(ctx, omniboxMaxResults, 0)
 			if err != nil {
 				log.Error().Err(err).Msg("failed to load recent history")
 }
 // createFaviconImage creates a favicon image with async loading from cache.
-func (o *Omnibox) createFaviconImage(url, fallbackIcon string) *gtk.Image {
+func (o *Omnibox) createFaviconImage(rawURL, fallbackIcon string) *gtk.Image {
 	favicon := gtk.NewImage()
 	if favicon == nil {
 		return nil
 	favicon.AddCssClass("omnibox-favicon")
 	// Async load favicon from cache
-	if o.faviconAdapter != nil && url != "" {
+	if o.faviconAdapter != nil && rawURL != "" {
-		o.faviconAdapter.GetOrFetch(o.ctx, url, func(texture *gdk.Texture) {
+		o.faviconAdapter.GetOrFetch(o.ctx, rawURL, func(texture *gdk.Texture) {
 			if texture != nil {
 				var cb glib.SourceFunc = func(data uintptr) bool {
 					favicon.SetFromPaintable(texture)
 }
 // createRowWithFavicon creates a ListBoxRow with favicon, title, URL, and shortcut badge.
-func (o *Omnibox) createRowWithFavicon(url, title, fallbackIcon string, index int) *gtk.ListBoxRow {
+func (o *Omnibox) createRowWithFavicon(rawURL, title, fallbackIcon string, index int) *gtk.ListBoxRow {
 	row := gtk.NewListBoxRow()
 	if row == nil {
 		return nil
 	}
 	row.AddCssClass("omnibox-row")
-	hbox := gtk.NewBox(gtk.OrientationHorizontalValue, 8)
+	const rowSpacing = 8
+	hbox := gtk.NewBox(gtk.OrientationHorizontalValue, rowSpacing)
 	if hbox == nil {
 		return nil
 	}
 	hbox.SetHexpand(true)
 	// Favicon image (vertically centered)
-	if favicon := o.createFaviconImage(url, fallbackIcon); favicon != nil {
+	if favicon := o.createFaviconImage(rawURL, fallbackIcon); favicon != nil {
 		favicon.SetValign(gtk.AlignCenterValue)
 		hbox.Append(&favicon.Widget)
 	}
 	// Title label (or URL if no title)
 	displayTitle := title
 	if displayTitle == "" {
-		displayTitle = url
+		displayTitle = rawURL
 	}
 	titleLabel := gtk.NewLabel(nil)
 	if titleLabel != nil {
 	}
 	// URL label (only if title exists and differs from URL)
-	if title != "" && title != url {
+	if title != "" && title != rawURL {
 		urlLabel := gtk.NewLabel(nil)
 		if urlLabel != nil {
-			urlLabel.SetText(url)
+			urlLabel.SetText(rawURL)
 			urlLabel.AddCssClass("omnibox-suggestion-url")
 			urlLabel.SetHalign(gtk.AlignStartValue)
 			urlLabel.SetEllipsize(2) // PANGO_ELLIPSIZE_END
 	hbox.Append(&textBox.Widget)
 	// Shortcut badge (Ctrl+1-9, Ctrl+0 for 10th)
-	if index <= 9 {
+	const maxShortcutIndex = 9
+	if index <= maxShortcutIndex {
 		shortcutLabel := gtk.NewLabel(nil)
 		if shortcutLabel != nil {
-			if index < 9 {
+			if index < maxShortcutIndex {
 				shortcutLabel.SetText(formatShortcut(index + 1))
 			} else {
 				shortcutLabel.SetText("Ctrl+0")
 	o.mu.RUnlock()
 	entryText := o.entry.GetText()
-	var url string
+	var targetURL string
 	// Check if user typed a URL-like string (contains . and no spaces)
 	// If so, navigate to that URL directly instead of the selection
 	if o.looksLikeURL(entryText) {
-		url = o.buildURL(entryText)
+		targetURL = o.buildURL(entryText)
 	} else if idx < 0 {
 		// No selection - use entry text as URL/search
-		url = o.buildURL(entryText)
+		targetURL = o.buildURL(entryText)
 	} else if mode == ViewModeHistory {
 		if idx < len(suggestions) {
-			url = suggestions[idx].URL
+			targetURL = suggestions[idx].URL
 		}
 	} else {
 		if idx < len(favorites) {
-			url = favorites[idx].URL
+			targetURL = favorites[idx].URL
 		}
 	}
-	if url == "" {
+	if targetURL == "" {
 		return
 	}
 	o.Hide(o.ctx)
 	if o.onNavigate != nil {
-		o.onNavigate(url)
+		o.onNavigate(targetURL)
 	}
 }
 		go func() {
 			ctx := o.ctx
-			log := logging.FromContext(ctx)
+			goLog := logging.FromContext(ctx)
-			log.Debug().Str("url", s.URL).Str("title", s.Title).Msg("adding to favorites")
+			goLog.Debug().Str("url", s.URL).Str("title", s.Title).Msg("adding to favorites")
 			input := usecase.AddFavoriteInput{
 				URL:   s.URL,
 			fav, err := o.favoritesUC.Add(ctx, input)
 			if err != nil {
-				log.Error().Err(err).Str("url", s.URL).Msg("failed to add favorite")
+				goLog.Error().Err(err).Str("url", s.URL).Msg("failed to add favorite")
 				return
 			}
-			log.Info().Str("url", s.URL).Int64("id", int64(fav.ID)).Msg("favorite added from omnibox")
+			goLog.Info().Str("url", s.URL).Int64("id", int64(fav.ID)).Msg("favorite added from omnibox")
 		}()
 	} else {
 		// Remove from favorites
 	favorites := o.favorites
 	o.mu.RUnlock()
-	var url string
+	var selectedURL string
 	if mode == ViewModeHistory {
 		if idx < 0 || idx >= len(suggestions) {
 			log.Debug().Int("index", idx).Msg("yank URL: invalid selection")
 			return
 		}
-		url = suggestions[idx].URL
+		selectedURL = suggestions[idx].URL
 	} else {
 		if idx < 0 || idx >= len(favorites) {
 			log.Debug().Int("index", idx).Msg("yank URL: invalid selection")
 			return
 		}
-		url = favorites[idx].URL
+		selectedURL = favorites[idx].URL
 	}
-	if url == "" {
+	if selectedURL == "" {
 		log.Debug().Msg("yank URL: empty URL")
 		return
 	}
 	go func() {
 		ctx := o.ctx
-		if err := o.copyURLUC.Copy(ctx, url); err != nil {
+		if err := o.copyURLUC.Copy(ctx, selectedURL); err != nil {
 			return // Use case already logs the error
 		}
 		// Show toast notification on success (must run on GTK main thread)
 		if o.onToast != nil {
-			var cb glib.SourceFunc
+			cb := glib.SourceFunc(func(_ uintptr) bool {
-			cb = func(_ uintptr) bool {
 				o.onToast("URL copied")
 				return false // Don't repeat
-			}
+			})
 			glib.IdleAdd(&cb, 0)
 		}
 	}()
 	if width > omniboxMaxWidth {
 		width = omniboxMaxWidth
 	}
-	marginTop := int(float64(parentHeight) * 0.20) // 20% from top
+	marginTop := int(float64(parentHeight) * omniboxTopMarginPct)
 	o.mainBox.SetSizeRequest(width, -1)
 	o.outerBox.SetMarginTop(marginTop)

M internal/ui/component/progress_bar.go +2 -3

 // startAnimation begins the smooth progress animation.
 // Must be called with lock held.
 func (pb *ProgressBar) startAnimation() {
-	var cb glib.SourceFunc
+	cb := glib.SourceFunc(func(_ uintptr) bool {
-	cb = func(_ uintptr) bool {
 		pb.mu.Lock()
 		defer pb.mu.Unlock()
 			return false
 		}
 		return true
-	}
+	})
 	pb.animationTimer = glib.TimeoutAdd(progressIntervalMs, &cb, 0)
 }

M internal/ui/component/tab_button.go +2 -1


@@ -46,8 +46,9 @@ func NewTabButton(tab entity.Tab) TabButton {
46		}	46		}
47			47
48		// Configure label for text overflow	48		// Configure label for text overflow
			49	+	const maxTabTitleChars = 20
49		tb.label.SetEllipsize(pango.EllipsizeMiddleValue)	50		tb.label.SetEllipsize(pango.EllipsizeMiddleValue)
50	-	tb.label.SetMaxWidthChars(20)	51	+	tb.label.SetMaxWidthChars(maxTabTitleChars)
51		tb.label.AddCssClass("tab-title")	52		tb.label.AddCssClass("tab-title")
52			53
53		// Set label as button child	54		// Set label as button child

M internal/ui/component/toaster.go +2 -3

 func (t *Toaster) startDismissTimer(ctx context.Context) {
 	log := logging.FromContext(ctx)
-	var cb glib.SourceFunc
+	cb := glib.SourceFunc(func(_ uintptr) bool {
-	cb = func(_ uintptr) bool {
 		t.mu.Lock()
 		defer t.mu.Unlock()
 		log.Debug().Msg("toast auto-dismissed")
 		return false // Don't repeat
-	}
+	})
 	t.dismissTimer = glib.TimeoutAdd(toastDismissTimeoutMs, &cb, 0)
 }

M internal/ui/component/workspace_view.go +4 -1

 import (
 	"context"
 	"errors"
+	"fmt"
 	"sync"
 	"github.com/bnema/dumber/internal/domain/entity"
 	// Set initial active pane
 	if ws.ActivePaneID != "" {
-		wv.setActivePaneIDInternal(ws.ActivePaneID)
+		if err := wv.setActivePaneIDInternal(ws.ActivePaneID); err != nil {
+			return fmt.Errorf("set initial active pane: %w", err)
+		}
 	}
 	return nil

M internal/ui/component/workspace_view_test.go +12 -12


@@ -14,7 +14,7 @@ import (
14		"github.com/bnema/dumber/internal/ui/layout/mocks"	14		"github.com/bnema/dumber/internal/ui/layout/mocks"
15		)	15		)
16			16
17	-	func setupWorkspaceViewBase(t testing.T, mockFactory mocks.MockWidgetFactory) (context.Context, mocks.MockBoxWidget, mocks.MockOverlayWidget) {	17	+	func setupWorkspaceViewBase(t testing.T, mockFactory mocks.MockWidgetFactory) (context.Context, *mocks.MockBoxWidget) {
18		ctx := context.Background()	18		ctx := context.Background()
19		mockContainer := mocks.NewMockBoxWidget(t)	19		mockContainer := mocks.NewMockBoxWidget(t)
20		mockOverlay := mocks.NewMockOverlayWidget(t)	20		mockOverlay := mocks.NewMockOverlayWidget(t)

@@ -30,7 +30,7 @@ func setupWorkspaceViewBase(t testing.T, mockFactory mocks.MockWidgetFactory)
30		mockOverlay.EXPECT().SetChild(mockContainer).Once()	30		mockOverlay.EXPECT().SetChild(mockContainer).Once()
31		mockOverlay.EXPECT().SetVisible(true).Once()	31		mockOverlay.EXPECT().SetVisible(true).Once()
32			32
33	-	return ctx, mockContainer, mockOverlay	33	+	return ctx, mockContainer
34		}	34		}
35			35
36		func setupWorkspacePaneViewMocks(t testing.T, mockFactory mocks.MockWidgetFactory) (mocks.MockOverlayWidget, mocks.MockBoxWidget) {	36		func setupWorkspacePaneViewMocks(t testing.T, mockFactory mocks.MockWidgetFactory) (mocks.MockOverlayWidget, mocks.MockBoxWidget) {

@@ -76,7 +76,7 @@ func setupStackedLeafMocks(
76		t *testing.T,	76		t *testing.T,
77		mockFactory *mocks.MockWidgetFactory,	77		mockFactory *mocks.MockWidgetFactory,
78		container *mocks.MockOverlayWidget,	78		container *mocks.MockOverlayWidget,
79	-	) (mocks.MockBoxWidget, mocks.MockBoxWidget) {	79	+	) *mocks.MockBoxWidget {
80		mockStackBox := mocks.NewMockBoxWidget(t)	80		mockStackBox := mocks.NewMockBoxWidget(t)
81		mockTitleBar := mocks.NewMockBoxWidget(t)	81		mockTitleBar := mocks.NewMockBoxWidget(t)
82		mockFavicon := mocks.NewMockImageWidget(t)	82		mockFavicon := mocks.NewMockImageWidget(t)

@@ -118,13 +118,13 @@ func setupStackedLeafMocks(
118		container.EXPECT().SetVisible(true).Once()	118		container.EXPECT().SetVisible(true).Once()
119		mockTitleBar.EXPECT().AddCssClass("active").Once()	119		mockTitleBar.EXPECT().AddCssClass("active").Once()
120			120
121	-	return mockStackBox, mockTitleBar	121	+	return mockStackBox
122		}	122		}
123			123
124		func TestNewWorkspaceView_CreatesEmptyContainer(t *testing.T) {	124		func TestNewWorkspaceView_CreatesEmptyContainer(t *testing.T) {
125		// Arrange	125		// Arrange
126		mockFactory := mocks.NewMockWidgetFactory(t)	126		mockFactory := mocks.NewMockWidgetFactory(t)
127	-	ctx, mockBox, _ := setupWorkspaceViewBase(t, mockFactory)	127	+	ctx, mockBox := setupWorkspaceViewBase(t, mockFactory)
128			128
129		// Act	129		// Act
130		wv := component.NewWorkspaceView(ctx, mockFactory)	130		wv := component.NewWorkspaceView(ctx, mockFactory)

@@ -138,7 +138,7 @@ func TestNewWorkspaceView_CreatesEmptyContainer(t *testing.T) {
138		func TestSetWorkspace_NilWorkspace_ReturnsError(t *testing.T) {	138		func TestSetWorkspace_NilWorkspace_ReturnsError(t *testing.T) {
139		// Arrange	139		// Arrange
140		mockFactory := mocks.NewMockWidgetFactory(t)	140		mockFactory := mocks.NewMockWidgetFactory(t)
141	-	ctx, _, _ := setupWorkspaceViewBase(t, mockFactory)	141	+	ctx, _ := setupWorkspaceViewBase(t, mockFactory)
142			142
143		wv := component.NewWorkspaceView(ctx, mockFactory)	143		wv := component.NewWorkspaceView(ctx, mockFactory)
144			144

@@ -152,12 +152,12 @@ func TestSetWorkspace_NilWorkspace_ReturnsError(t *testing.T) {
152		func TestSetWorkspace_SinglePane_CreatesPaneView(t *testing.T) {	152		func TestSetWorkspace_SinglePane_CreatesPaneView(t *testing.T) {
153		// Arrange	153		// Arrange
154		mockFactory := mocks.NewMockWidgetFactory(t)	154		mockFactory := mocks.NewMockWidgetFactory(t)
155	-	ctx, mockBox, _ := setupWorkspaceViewBase(t, mockFactory)	155	+	ctx, mockBox := setupWorkspaceViewBase(t, mockFactory)
156			156
157		wv := component.NewWorkspaceView(ctx, mockFactory)	157		wv := component.NewWorkspaceView(ctx, mockFactory)
158			158
159		mockOverlay, mockBorderBox := setupWorkspacePaneViewMocks(t, mockFactory)	159		mockOverlay, mockBorderBox := setupWorkspacePaneViewMocks(t, mockFactory)
160	-	mockStackBox, _ := setupStackedLeafMocks(t, mockFactory, mockOverlay)	160	+	mockStackBox := setupStackedLeafMocks(t, mockFactory, mockOverlay)
161			161
162		mockStackBox.EXPECT().SetVisible(true).Once()	162		mockStackBox.EXPECT().SetVisible(true).Once()
163		mockBox.EXPECT().Append(mockStackBox).Once()	163		mockBox.EXPECT().Append(mockStackBox).Once()

@@ -185,7 +185,7 @@ func TestSetWorkspace_SinglePane_CreatesPaneView(t *testing.T) {
185		func TestSetActivePaneID_UpdatesStyling(t *testing.T) {	185		func TestSetActivePaneID_UpdatesStyling(t *testing.T) {
186		// Arrange	186		// Arrange
187		mockFactory := mocks.NewMockWidgetFactory(t)	187		mockFactory := mocks.NewMockWidgetFactory(t)
188	-	ctx, mockBox, _ := setupWorkspaceViewBase(t, mockFactory)	188	+	ctx, mockBox := setupWorkspaceViewBase(t, mockFactory)
189			189
190		wv := component.NewWorkspaceView(ctx, mockFactory)	190		wv := component.NewWorkspaceView(ctx, mockFactory)
191			191

@@ -198,9 +198,9 @@ func TestSetActivePaneID_UpdatesStyling(t *testing.T) {
198		// Create mock widgets for split	198		// Create mock widgets for split
199		mockPaned := mocks.NewMockPanedWidget(t)	199		mockPaned := mocks.NewMockPanedWidget(t)
200		mockOverlay1, mockBorderBox1 := setupWorkspacePaneViewMocks(t, mockFactory)	200		mockOverlay1, mockBorderBox1 := setupWorkspacePaneViewMocks(t, mockFactory)
201	-	mockStackBox1, _ := setupStackedLeafMocks(t, mockFactory, mockOverlay1)	201	+	mockStackBox1 := setupStackedLeafMocks(t, mockFactory, mockOverlay1)
202		mockOverlay2, mockBorderBox2 := setupWorkspacePaneViewMocks(t, mockFactory)	202		mockOverlay2, mockBorderBox2 := setupWorkspacePaneViewMocks(t, mockFactory)
203	-	mockStackBox2, _ := setupStackedLeafMocks(t, mockFactory, mockOverlay2)	203	+	mockStackBox2 := setupStackedLeafMocks(t, mockFactory, mockOverlay2)
204			204
205		// Split view creation	205		// Split view creation
206		mockFactory.EXPECT().NewPaned(layout.OrientationHorizontal).Return(mockPaned).Once()	206		mockFactory.EXPECT().NewPaned(layout.OrientationHorizontal).Return(mockPaned).Once()

@@ -251,7 +251,7 @@ func TestSetActivePaneID_UpdatesStyling(t *testing.T) {
251		func TestSetActivePaneID_InvalidID_ReturnsError(t *testing.T) {	251		func TestSetActivePaneID_InvalidID_ReturnsError(t *testing.T) {
252		// Arrange	252		// Arrange
253		mockFactory := mocks.NewMockWidgetFactory(t)	253		mockFactory := mocks.NewMockWidgetFactory(t)
254	-	ctx, _, _ := setupWorkspaceViewBase(t, mockFactory)	254	+	ctx, _ := setupWorkspaceViewBase(t, mockFactory)
255			255
256		wv := component.NewWorkspaceView(ctx, mockFactory)	256		wv := component.NewWorkspaceView(ctx, mockFactory)
257			257

M internal/ui/coordinator/content.go +30 -18

 	wv.OnLoadChanged = func(event webkit.LoadEvent) {
 		switch event {
 		case webkit.LoadStarted:
-			c.onLoadStarted(ctx, paneID)
+			c.onLoadStarted(paneID)
 		case webkit.LoadCommitted:
 			c.onLoadCommitted(ctx, paneID, wv)
 		case webkit.LoadFinished:
-			c.onLoadFinished(ctx, paneID)
+			c.onLoadFinished(paneID)
 		}
 	}
 	// Set up progress callback for loading indicator
 	wv.OnProgressChanged = func(progress float64) {
-		c.onProgressChanged(ctx, paneID, progress)
+		c.onProgressChanged(paneID, progress)
 	}
 	// Set up URI change callback for SPA navigation (History API)
 }
 // updateStackedPaneTitle updates the title of a pane in a StackedView.
-func (c *ContentCoordinator) updateStackedPaneTitle(ctx context.Context, ws *entity.Workspace, sv *layout.StackedView, paneID entity.PaneID, title string) {
+func (c *ContentCoordinator) updateStackedPaneTitle(
+	ctx context.Context,
+	ws *entity.Workspace,
+	sv *layout.StackedView,
+	paneID entity.PaneID,
+	title string,
+) {
 	log := logging.FromContext(ctx)
 	if ws == nil {
 }
 // updateStackedPaneFavicon updates the favicon of a pane in a StackedView.
-func (c *ContentCoordinator) updateStackedPaneFavicon(ctx context.Context, ws *entity.Workspace, sv *layout.StackedView, paneID entity.PaneID, favicon *gdk.Texture) {
+func (c *ContentCoordinator) updateStackedPaneFavicon(
+	ctx context.Context,
+	ws *entity.Workspace,
+	sv *layout.StackedView,
+	paneID entity.PaneID,
+	favicon *gdk.Texture,
+) {
 	log := logging.FromContext(ctx)
 	if ws == nil {
 }
 // onLoadStarted shows the progress bar when page loading begins.
-func (c *ContentCoordinator) onLoadStarted(ctx context.Context, paneID entity.PaneID) {
+func (c *ContentCoordinator) onLoadStarted(paneID entity.PaneID) {
 	_, wsView := c.getActiveWS()
 	if wsView == nil {
 		return
 }
 // onLoadFinished hides the progress bar when page loading completes.
-func (c *ContentCoordinator) onLoadFinished(ctx context.Context, paneID entity.PaneID) {
+func (c *ContentCoordinator) onLoadFinished(paneID entity.PaneID) {
 	_, wsView := c.getActiveWS()
 	if wsView == nil {
 		return
 }
 // onProgressChanged updates the progress bar with current load progress.
-func (c *ContentCoordinator) onProgressChanged(ctx context.Context, paneID entity.PaneID, progress float64) {
+func (c *ContentCoordinator) onProgressChanged(paneID entity.PaneID, progress float64) {
 	_, wsView := c.getActiveWS()
 	if wsView == nil {
 		return
 	}
 	// Create related WebView for session sharing
-	parentID := port.WebViewID(parentWV.ID())
+	parentID := parentWV.ID()
 	popupWV, err := c.factory.CreateRelated(ctx, parentID)
 	if err != nil {
 		log.Error().Err(err).Msg("failed to create related webview for popup")
 	popupType := DetectPopupType(req.FrameName)
 	// Store pending popup for ready-to-show handling
-	popupID := port.WebViewID(popupWV.ID())
+	popupID := popupWV.ID()
 	pending := &PendingPopup{
 		WebView:         popupWV,
 		ParentPaneID:    parentPaneID,
 	// Request insertion into workspace
 	if c.onInsertPopup != nil {
-		input := InsertPopupInput{
+		popupInput := InsertPopupInput{
 			ParentPaneID: pending.ParentPaneID,
 			PopupPane:    popupPane,
 			WebView:      pending.WebView,
 			TargetURI:    pending.TargetURI,
 		}
-		if err := c.onInsertPopup(ctx, input); err != nil {
+		if err := c.onInsertPopup(ctx, popupInput); err != nil {
 			log.Error().Err(err).Msg("failed to insert popup into workspace")
 			// Clean up on failure
 			delete(c.webViews, paneID)
 	// Find pane by WebView ID
 	var paneID entity.PaneID
 	for pid, wv := range c.webViews {
-		if wv != nil && port.WebViewID(wv.ID()) == popupID {
+		if wv != nil && wv.ID() == popupID {
 			paneID = pid
 			break
 		}
 	wv.OnLoadChanged = func(event webkit.LoadEvent) {
 		switch event {
 		case webkit.LoadStarted:
-			c.onLoadStarted(ctx, paneID)
+			c.onLoadStarted(paneID)
 		case webkit.LoadCommitted:
 			c.onLoadCommitted(ctx, paneID, wv)
 		case webkit.LoadFinished:
-			c.onLoadFinished(ctx, paneID)
+			c.onLoadFinished(paneID)
 		}
 	}
 	// Progress
 	wv.OnProgressChanged = func(progress float64) {
-		c.onProgressChanged(ctx, paneID, progress)
+		c.onProgressChanged(paneID, progress)
 	}
 	// SPA navigation
 	// Request insertion into workspace
 	if c.onInsertPopup != nil {
-		input := InsertPopupInput{
+		popupInput := InsertPopupInput{
 			ParentPaneID: parentPaneID,
 			PopupPane:    newPane,
 			WebView:      newWV,
 			TargetURI:    uri,
 		}
-		if err := c.onInsertPopup(ctx, input); err != nil {
+		if err := c.onInsertPopup(ctx, popupInput); err != nil {
 			log.Error().Err(err).Msg("failed to insert middle-click pane into workspace")
 			// Clean up on failure
 			delete(c.webViews, paneID)

M internal/ui/coordinator/tab.go +6 -1

 // CreateWithPane creates a new tab with a pre-created pane and WebView.
 // This is used for tabbed popup behavior where the popup pane already exists.
-func (c *TabCoordinator) CreateWithPane(ctx context.Context, pane *entity.Pane, wv *webkit.WebView, initialURL string) (*entity.Tab, error) {
+func (c *TabCoordinator) CreateWithPane(
+	ctx context.Context,
+	pane *entity.Pane,
+	wv *webkit.WebView,
+	initialURL string,
+) (*entity.Tab, error) {
 	log := logging.FromContext(ctx)
 	output, err := c.tabsUC.CreateWithPane(ctx, usecase.CreateTabWithPaneInput{

M internal/ui/coordinator/workspace.go +666 -491


@@ -11,6 +11,12 @@ import (
11		"github.com/bnema/dumber/internal/ui/component"	11		"github.com/bnema/dumber/internal/ui/component"
12		"github.com/bnema/dumber/internal/ui/focus"	12		"github.com/bnema/dumber/internal/ui/focus"
13		"github.com/bnema/dumber/internal/ui/layout"	13		"github.com/bnema/dumber/internal/ui/layout"
			14	+	"github.com/rs/zerolog"
			15	+	)
			16	+
			17	+	const (
			18	+	defaultPaneTitle = "Untitled"
			19	+	nilString = "nil"
14		)	20		)
15			21
16		// WorkspaceCoordinator manages pane operations within a workspace.	22		// WorkspaceCoordinator manages pane operations within a workspace.

@@ -39,6 +45,22 @@ type WorkspaceCoordinatorConfig struct {
39		GenerateID func() string	45		GenerateID func() string
40		}	46		}
41			47
			48	+	type splitContext struct {
			49	+	ws *entity.Workspace
			50	+	wsView *component.WorkspaceView
			51	+	activePane *entity.PaneNode
			52	+	existingWidget layout.Widget
			53	+	isStackSplit bool
			54	+	}
			55	+
			56	+	type stackPaneContext struct {
			57	+	ws *entity.Workspace
			58	+	wsView *component.WorkspaceView
			59	+	activeNode *entity.PaneNode
			60	+	activePaneID entity.PaneID
			61	+	originalTitle string
			62	+	}
			63	+
42		// NewWorkspaceCoordinator creates a new WorkspaceCoordinator.	64		// NewWorkspaceCoordinator creates a new WorkspaceCoordinator.
43		func NewWorkspaceCoordinator(ctx context.Context, cfg WorkspaceCoordinatorConfig) *WorkspaceCoordinator {	65		func NewWorkspaceCoordinator(ctx context.Context, cfg WorkspaceCoordinatorConfig) *WorkspaceCoordinator {
44		log := logging.FromContext(ctx)	66		log := logging.FromContext(ctx)

@@ -81,108 +103,150 @@ func setupPaneViewHover(ctx context.Context, pv component.PaneView, wsView com
81		func (c *WorkspaceCoordinator) Split(ctx context.Context, direction usecase.SplitDirection) error {	103		func (c *WorkspaceCoordinator) Split(ctx context.Context, direction usecase.SplitDirection) error {
82		log := logging.FromContext(ctx)	104		log := logging.FromContext(ctx)
83			105
			106	+	splitCtx, ok := c.prepareSplit(ctx, direction)
			107	+	if !ok {
			108	+	return nil
			109	+	}
			110	+
			111	+	output, err := c.panesUC.Split(ctx, usecase.SplitPaneInput{
			112	+	Workspace: splitCtx.ws,
			113	+	TargetPane: splitCtx.activePane,
			114	+	Direction: direction,
			115	+	})
			116	+	if err != nil {
			117	+	log.Error().Err(err).Str("direction", string(direction)).Msg("failed to split pane")
			118	+	return err
			119	+	}
			120	+
			121	+	// Remember old active pane before changing
			122	+	oldActivePaneID := splitCtx.activePane.Pane.ID
			123	+
			124	+	// Set the new pane as active
			125	+	splitCtx.ws.ActivePaneID = output.NewPaneNode.Pane.ID
			126	+
			127	+	// Update the workspace view
			128	+	if splitCtx.wsView != nil {
			129	+	c.applySplitToView(ctx, splitCtx.wsView, splitCtx.ws, output, direction, splitCtx.existingWidget, splitCtx.isStackSplit, oldActivePaneID)
			130	+	}
			131	+
			132	+	log.Info().Str("direction", string(direction)).Str("new_pane_id", string(output.NewPaneNode.Pane.ID)).Msg("pane split completed")
			133	+
			134	+	return nil
			135	+	}
			136	+
			137	+	func (c *WorkspaceCoordinator) prepareSplit(
			138	+	ctx context.Context,
			139	+	direction usecase.SplitDirection,
			140	+	) (*splitContext, bool) {
			141	+	log := logging.FromContext(ctx)
84		if c.panesUC == nil {	142		if c.panesUC == nil {
85		log.Warn().Msg("panes use case not available")	143		log.Warn().Msg("panes use case not available")
86	-	return nil	144	+	return nil, false
87		}	145		}
88			146
89		ws, wsView := c.getActiveWS()	147		ws, wsView := c.getActiveWS()
90		if ws == nil {	148		if ws == nil {
91		log.Warn().Msg("no active workspace")	149		log.Warn().Msg("no active workspace")
92	-	return nil	150	+	return nil, false
93		}	151		}
94			152
95		activePane := ws.ActivePane()	153		activePane := ws.ActivePane()
96		if activePane == nil {	154		if activePane == nil {
97		log.Warn().Msg("no active pane to split")	155		log.Warn().Msg("no active pane to split")
98	-	return nil	156	+	return nil, false
99		}	157		}
100			158
101	-	// Check if we're splitting from inside a stack (horizontal split around stack)
102		isStackSplit := (direction == usecase.SplitLeft \|\| direction == usecase.SplitRight) &&	159		isStackSplit := (direction == usecase.SplitLeft \|\| direction == usecase.SplitRight) &&
103		activePane.Parent != nil && activePane.Parent.IsStacked	160		activePane.Parent != nil && activePane.Parent.IsStacked
104			161
105	-	// Get the existing widget BEFORE domain changes (for incremental operation)
106		var existingWidget layout.Widget	162		var existingWidget layout.Widget
107		if wsView != nil {	163		if wsView != nil {
108	-	if isStackSplit {	164	+	existingWidget = c.resolveSplitWidget(wsView, activePane, isStackSplit)
109	-	// Stack split: get the StackedView widget
110	-	tr := wsView.TreeRenderer()
111	-	if tr != nil {
112	-	stackedView := tr.GetStackedViewForPane(string(activePane.Pane.ID))
113	-	if stackedView != nil {
114	-	existingWidget = stackedView.Widget()
115	-	}
116	-	}
117	-	} else {
118	-	// Regular split: get the current root widget
119	-	existingWidget = wsView.GetRootWidget()
120	-	}
121		}	165		}
122			166
123	-	output, err := c.panesUC.Split(ctx, usecase.SplitPaneInput{	167	+	return &splitContext{
124	-	Workspace: ws,	168	+	ws: ws,
125	-	TargetPane: activePane,	169	+	wsView: wsView,
126	-	Direction: direction,	170	+	activePane: activePane,
127	-	})	171	+	existingWidget: existingWidget,
128	-	if err != nil {	172	+	isStackSplit: isStackSplit,
129	-	log.Error().Err(err).Str("direction", string(direction)).Msg("failed to split pane")	173	+	}, true
130	-	return err	174	+	}
			175	+
			176	+	func (c *WorkspaceCoordinator) resolveSplitWidget(
			177	+	wsView *component.WorkspaceView,
			178	+	activePane *entity.PaneNode,
			179	+	isStackSplit bool,
			180	+	) layout.Widget {
			181	+	if wsView == nil {
			182	+	return nil
131		}	183		}
132			184
133	-	// Remember old active pane before changing	185	+	if !isStackSplit {
134	-	oldActivePaneID := activePane.Pane.ID	186	+	return wsView.GetRootWidget()
			187	+	}
135			188
136	-	// Set the new pane as active	189	+	tr := wsView.TreeRenderer()
137	-	ws.ActivePaneID = output.NewPaneNode.Pane.ID	190	+	if tr == nil {
			191	+	return nil
			192	+	}
138			193
139	-	// Update the workspace view	194	+	stackedView := tr.GetStackedViewForPane(string(activePane.Pane.ID))
140	-	if wsView != nil && existingWidget != nil {	195	+	if stackedView == nil {
			196	+	return nil
			197	+	}
			198	+
			199	+	return stackedView.Widget()
			200	+	}
			201	+
			202	+	func (c *WorkspaceCoordinator) applySplitToView(
			203	+	ctx context.Context,
			204	+	wsView *component.WorkspaceView,
			205	+	ws *entity.Workspace,
			206	+	output *usecase.SplitPaneOutput,
			207	+	direction usecase.SplitDirection,
			208	+	existingWidget layout.Widget,
			209	+	isStackSplit bool,
			210	+	oldActivePaneID entity.PaneID,
			211	+	) {
			212	+	log := logging.FromContext(ctx)
			213	+	needsAttach := false
			214	+
			215	+	if existingWidget != nil {
141		var splitErr error	216		var splitErr error
142		if isStackSplit {	217		if isStackSplit {
143	-	// Incremental stack split: reuse existing stack widget	218	+	splitErr = c.doIncrementalStackSplit(ctx, wsView, output, direction, existingWidget, oldActivePaneID)
144	-	splitErr = c.doIncrementalStackSplit(ctx, wsView, ws, output, direction, existingWidget, oldActivePaneID)
145		} else {	219		} else {
146	-	// Incremental regular split: reuse existing root widget
147		splitErr = c.doIncrementalSplit(ctx, wsView, ws, output, direction, existingWidget, oldActivePaneID)	220		splitErr = c.doIncrementalSplit(ctx, wsView, ws, output, direction, existingWidget, oldActivePaneID)
148		}	221		}
149			222
150		if splitErr != nil {	223		if splitErr != nil {
151		log.Warn().Err(splitErr).Msg("incremental split failed, falling back to rebuild")	224		log.Warn().Err(splitErr).Msg("incremental split failed, falling back to rebuild")
152	-	// Fallback to full rebuild
153		if err := wsView.Rebuild(ctx); err != nil {	225		if err := wsView.Rebuild(ctx); err != nil {
154		log.Error().Err(err).Msg("failed to rebuild workspace view")	226		log.Error().Err(err).Msg("failed to rebuild workspace view")
155		}	227		}
156	-	c.contentCoord.AttachToWorkspace(ctx, ws, wsView)	228	+	needsAttach = true
157		}	229		}
158	-	// Update workspace view's active pane tracking	230	+	} else {
159	-	if err := wsView.SetActivePaneID(ws.ActivePaneID); err != nil {
160	-	log.Warn().Err(err).Msg("failed to set active pane in workspace view")
161	-	}
162	-	wsView.FocusPane(ws.ActivePaneID)
163	-	} else if wsView != nil {
164	-	// No existing widget (shouldn't happen), fallback to rebuild
165		if err := wsView.Rebuild(ctx); err != nil {	231		if err := wsView.Rebuild(ctx); err != nil {
166		log.Error().Err(err).Msg("failed to rebuild workspace view")	232		log.Error().Err(err).Msg("failed to rebuild workspace view")
167		}	233		}
168	-	c.contentCoord.AttachToWorkspace(ctx, ws, wsView)	234	+	needsAttach = true
169	-	// Update workspace view's active pane tracking
170	-	if err := wsView.SetActivePaneID(ws.ActivePaneID); err != nil {
171	-	log.Warn().Err(err).Msg("failed to set active pane in workspace view")
172	-	}
173	-	wsView.FocusPane(ws.ActivePaneID)
174		}	235		}
175			236
176	-	log.Info().Str("direction", string(direction)).Str("new_pane_id", string(output.NewPaneNode.Pane.ID)).Msg("pane split completed")	237	+	if needsAttach {
177	-		238	+	c.contentCoord.AttachToWorkspace(ctx, ws, wsView)
178	-	return nil	239	+	}
			240	+	if err := wsView.SetActivePaneID(ws.ActivePaneID); err != nil {
			241	+	log.Warn().Err(err).Msg("failed to set active pane in workspace view")
			242	+	}
			243	+	wsView.FocusPane(ws.ActivePaneID)
179		}	244		}
180			245
181		// doIncrementalStackSplit performs an incremental split around an existing stacked pane.	246		// doIncrementalStackSplit performs an incremental split around an existing stacked pane.
182		func (c *WorkspaceCoordinator) doIncrementalStackSplit(	247		func (c *WorkspaceCoordinator) doIncrementalStackSplit(
183		ctx context.Context,	248		ctx context.Context,
184		wsView *component.WorkspaceView,	249		wsView *component.WorkspaceView,
185	-	ws *entity.Workspace,
186		output *usecase.SplitPaneOutput,	250		output *usecase.SplitPaneOutput,
187		direction usecase.SplitDirection,	251		direction usecase.SplitDirection,
188		existingStackWidget layout.Widget,	252		existingStackWidget layout.Widget,

@@ -317,7 +381,7 @@ func (c *WorkspaceCoordinator) doIncrementalSplit(
317		if grandparentNode != nil {	381		if grandparentNode != nil {
318		return grandparentNode.ID	382		return grandparentNode.ID
319		}	383		}
320	-	return "nil"	384	+	return nilString
321		}()).	385		}()).
322		Msg("determined split type")	386		Msg("determined split type")
323			387

@@ -329,106 +393,40 @@ func (c *WorkspaceCoordinator) doIncrementalSplit(
329		newStackedView := layout.NewStackedView(factory)	393		newStackedView := layout.NewStackedView(factory)
330		newStackedView.AddPane(ctx, output.NewPaneNode.Pane.Title, "", newPaneView.Widget())	394		newStackedView.AddPane(ctx, output.NewPaneNode.Pane.Title, "", newPaneView.Widget())
331			395
332	-	// 6. Determine orientation based on direction	396	+	orientation, existingFirst, ok := splitOrientation(direction)
333	-	var orientation layout.Orientation	397	+	if !ok {
334	-	var existingFirst bool
335	-	switch direction {
336	-	case usecase.SplitRight:
337	-	orientation = layout.OrientationHorizontal
338	-	existingFirst = true
339	-	case usecase.SplitLeft:
340	-	orientation = layout.OrientationHorizontal
341	-	existingFirst = false
342	-	case usecase.SplitDown:
343	-	orientation = layout.OrientationVertical
344	-	existingFirst = true
345	-	case usecase.SplitUp:
346	-	orientation = layout.OrientationVertical
347	-	existingFirst = false
348	-	default:
349		return nil	398		return nil
350		}	399		}
351			400
352		// 7. Handle root vs non-root split differently	401		// 7. Handle root vs non-root split differently
353		if isRootSplit {	402		if isRootSplit {
354	-	// ROOT SPLIT: Remove from container, wrap in split, set as new root	403	+	if err := c.replaceRootSplit(
355	-	// Clear rootWidget ref first so SetRootWidgetDirect won't double-remove	404	+	ctx,
356	-	wsView.ClearRootWidgetRef()	405	+	wsView,
357	-	wsView.Container().Remove(existingRootWidget)	406	+	tr,
358	-		407	+	factory,
359	-	var splitView *layout.SplitView	408	+	existingRootWidget,
360	-	if existingFirst {	409	+	newStackedView,
361	-	splitView = layout.NewSplitView(ctx, factory, orientation,	410	+	output,
362	-	existingRootWidget, newStackedView.Widget(), output.SplitRatio)	411	+	orientation,
363	-	} else {	412	+	existingFirst,
364	-	splitView = layout.NewSplitView(ctx, factory, orientation,	413	+	); err != nil {
365	-	newStackedView.Widget(), existingRootWidget, output.SplitRatio)	414	+	return err
366		}	415		}
367	-
368	-	wsView.SetRootWidgetDirect(splitView.Widget())
369	-	tr.RegisterWidget(output.ParentNode.ID, splitView.Widget())
370	-
371	-	log.Debug().Msg("root split: replaced root with new split view")
372		} else {	416		} else {
373	-	// NON-ROOT SPLIT: Find grandparent's widget from TreeRenderer	417	+	if err := c.replaceNonRootSplit(
374	-	grandparentWidget := tr.Lookup(grandparentNode.ID)	418	+	ctx,
375	-	if grandparentWidget == nil {	419	+	tr,
376	-	log.Warn().Str("grandparent_id", grandparentNode.ID).Msg("grandparent widget not found in TreeRenderer")	420	+	factory,
377	-	return fmt.Errorf("grandparent widget not found")	421	+	grandparentNode,
378	-	}	422	+	output,
379	-		423	+	activePaneWidget,
380	-	// Cast to PanedWidget	424	+	newStackedView,
381	-	panedWidget, ok := grandparentWidget.(layout.PanedWidget)	425	+	orientation,
382	-	if !ok {	426	+	existingFirst,
383	-	log.Warn().Msg("grandparent widget is not a PanedWidget, falling back")	427	+	); err != nil {
384	-	return fmt.Errorf("grandparent is not a PanedWidget")	428	+	return err
385	-	}
386	-
387	-	// Determine if active pane was in start or end position
388	-	// The new split node (output.ParentNode) replaced the active pane's position
389	-	// So we check if the new split node is Left or Right child of grandparent
390	-	isStartChild := grandparentNode.Left() == output.ParentNode
391	-
392	-	log.Debug().
393	-	Bool("is_start_child", isStartChild).
394	-	Str("grandparent_left_id", func() string {
395	-	if grandparentNode.Left() != nil {
396	-	return grandparentNode.Left().ID
397	-	}
398	-	return "nil"
399	-	}()).
400	-	Str("new_parent_id", output.ParentNode.ID).
401	-	Msg("determined position in grandparent")
402	-
403	-	// Remove the active pane widget from grandparent paned
404	-	if isStartChild {
405	-	panedWidget.SetStartChild(nil)
406	-	} else {
407	-	panedWidget.SetEndChild(nil)
408	-	}
409	-
410	-	// Create new split view with active pane + new pane
411	-	var splitView *layout.SplitView
412	-	if existingFirst {
413	-	splitView = layout.NewSplitView(ctx, factory, orientation,
414	-	activePaneWidget, newStackedView.Widget(), output.SplitRatio)
415	-	} else {
416	-	splitView = layout.NewSplitView(ctx, factory, orientation,
417	-	newStackedView.Widget(), activePaneWidget, output.SplitRatio)
418	-	}
419	-
420	-	// Insert new split view in grandparent at same position
421	-	if isStartChild {
422	-	panedWidget.SetStartChild(splitView.Widget())
423	-	} else {
424	-	panedWidget.SetEndChild(splitView.Widget())
425		}	429		}
426	-
427	-	tr.RegisterWidget(output.ParentNode.ID, splitView.Widget())
428	-
429	-	log.Debug().
430	-	Bool("was_start_child", isStartChild).
431	-	Msg("non-root split: replaced pane in grandparent with new split view")
432		}	430		}
433			431
434		// 8. Register the new pane in tracking maps and activate it	432		// 8. Register the new pane in tracking maps and activate it

@@ -462,6 +460,117 @@ func (c *WorkspaceCoordinator) doIncrementalSplit(
462		return nil	460		return nil
463		}	461		}
464			462
			463	+	func splitOrientation(direction usecase.SplitDirection) (layout.Orientation, bool, bool) {
			464	+	switch direction {
			465	+	case usecase.SplitRight:
			466	+	return layout.OrientationHorizontal, true, true
			467	+	case usecase.SplitLeft:
			468	+	return layout.OrientationHorizontal, false, true
			469	+	case usecase.SplitDown:
			470	+	return layout.OrientationVertical, true, true
			471	+	case usecase.SplitUp:
			472	+	return layout.OrientationVertical, false, true
			473	+	default:
			474	+	return layout.OrientationHorizontal, false, false
			475	+	}
			476	+	}
			477	+
			478	+	func (c *WorkspaceCoordinator) replaceRootSplit(
			479	+	ctx context.Context,
			480	+	wsView *component.WorkspaceView,
			481	+	tr *layout.TreeRenderer,
			482	+	factory layout.WidgetFactory,
			483	+	existingRootWidget layout.Widget,
			484	+	newStackedView *layout.StackedView,
			485	+	output *usecase.SplitPaneOutput,
			486	+	orientation layout.Orientation,
			487	+	existingFirst bool,
			488	+	) error {
			489	+	wsView.ClearRootWidgetRef()
			490	+	wsView.Container().Remove(existingRootWidget)
			491	+
			492	+	var splitView *layout.SplitView
			493	+	if existingFirst {
			494	+	splitView = layout.NewSplitView(ctx, factory, orientation,
			495	+	existingRootWidget, newStackedView.Widget(), output.SplitRatio)
			496	+	} else {
			497	+	splitView = layout.NewSplitView(ctx, factory, orientation,
			498	+	newStackedView.Widget(), existingRootWidget, output.SplitRatio)
			499	+	}
			500	+
			501	+	wsView.SetRootWidgetDirect(splitView.Widget())
			502	+	tr.RegisterWidget(output.ParentNode.ID, splitView.Widget())
			503	+
			504	+	logging.FromContext(ctx).Debug().Msg("root split: replaced root with new split view")
			505	+	return nil
			506	+	}
			507	+
			508	+	func (c *WorkspaceCoordinator) replaceNonRootSplit(
			509	+	ctx context.Context,
			510	+	tr *layout.TreeRenderer,
			511	+	factory layout.WidgetFactory,
			512	+	grandparentNode *entity.PaneNode,
			513	+	output *usecase.SplitPaneOutput,
			514	+	activePaneWidget layout.Widget,
			515	+	newStackedView *layout.StackedView,
			516	+	orientation layout.Orientation,
			517	+	existingFirst bool,
			518	+	) error {
			519	+	log := logging.FromContext(ctx)
			520	+	grandparentWidget := tr.Lookup(grandparentNode.ID)
			521	+	if grandparentWidget == nil {
			522	+	log.Warn().Str("grandparent_id", grandparentNode.ID).Msg("grandparent widget not found in TreeRenderer")
			523	+	return fmt.Errorf("grandparent widget not found")
			524	+	}
			525	+
			526	+	panedWidget, ok := grandparentWidget.(layout.PanedWidget)
			527	+	if !ok {
			528	+	log.Warn().Msg("grandparent widget is not a PanedWidget, falling back")
			529	+	return fmt.Errorf("grandparent is not a PanedWidget")
			530	+	}
			531	+
			532	+	isStartChild := grandparentNode.Left() == output.ParentNode
			533	+
			534	+	log.Debug().
			535	+	Bool("is_start_child", isStartChild).
			536	+	Str("grandparent_left_id", func() string {
			537	+	if grandparentNode.Left() != nil {
			538	+	return grandparentNode.Left().ID
			539	+	}
			540	+	return nilString
			541	+	}()).
			542	+	Str("new_parent_id", output.ParentNode.ID).
			543	+	Msg("determined position in grandparent")
			544	+
			545	+	if isStartChild {
			546	+	panedWidget.SetStartChild(nil)
			547	+	} else {
			548	+	panedWidget.SetEndChild(nil)
			549	+	}
			550	+
			551	+	var splitView *layout.SplitView
			552	+	if existingFirst {
			553	+	splitView = layout.NewSplitView(ctx, factory, orientation,
			554	+	activePaneWidget, newStackedView.Widget(), output.SplitRatio)
			555	+	} else {
			556	+	splitView = layout.NewSplitView(ctx, factory, orientation,
			557	+	newStackedView.Widget(), activePaneWidget, output.SplitRatio)
			558	+	}
			559	+
			560	+	if isStartChild {
			561	+	panedWidget.SetStartChild(splitView.Widget())
			562	+	} else {
			563	+	panedWidget.SetEndChild(splitView.Widget())
			564	+	}
			565	+
			566	+	tr.RegisterWidget(output.ParentNode.ID, splitView.Widget())
			567	+
			568	+	log.Debug().
			569	+	Bool("was_start_child", isStartChild).
			570	+	Msg("non-root split: replaced pane in grandparent with new split view")
			571	+	return nil
			572	+	}
			573	+
465		// ClosePane closes the active pane.	574		// ClosePane closes the active pane.
466		func (c *WorkspaceCoordinator) ClosePane(ctx context.Context) error {	575		func (c *WorkspaceCoordinator) ClosePane(ctx context.Context) error {
467		log := logging.FromContext(ctx)	576		log := logging.FromContext(ctx)

@@ -531,7 +640,7 @@ func (c *WorkspaceCoordinator) ClosePane(ctx context.Context) error {
531		if siblingNode != nil {	640		if siblingNode != nil {
532		return siblingNode.ID	641		return siblingNode.ID
533		}	642		}
534	-	return "nil"	643	+	return nilString
535		}()).	644		}()).
536		Bool("sibling_is_start", siblingIsStartChild).	645		Bool("sibling_is_start", siblingIsStartChild).
537		Bool("parent_is_start_in_grand", parentIsStartInGrand).	646		Bool("parent_is_start_in_grand", parentIsStartInGrand).

@@ -548,47 +657,18 @@ func (c *WorkspaceCoordinator) ClosePane(ctx context.Context) error {
548		return err	657		return err
549		}	658		}
550			659
551	-	// Try incremental close if we have the context	660	+	c.finalizePaneClose(
552	-	if wsView != nil && parentNode != nil {	661	+	ctx,
553	-	var closeErr error	662	+	wsView,
554	-		663	+	ws,
555	-	if parentNode.IsStacked {	664	+	closingPaneID,
556	-	// Stacked close: remove pane from stack without rebuild	665	+	parentNode,
557	-	closeErr = c.doIncrementalStackClose(ctx, wsView, closingPaneID, parentNode)	666	+	siblingNode,
558	-	} else if siblingNode != nil && parentWidget != nil {	667	+	grandparentNode,
559	-	// Split close: promote sibling without rebuild	668	+	parentWidget,
560	-	closeErr = c.doIncrementalClose(ctx, wsView, ws, closingPaneID, siblingNode, parentNode, grandparentNode, parentWidget, siblingIsStartChild, parentIsStartInGrand)	669	+	siblingIsStartChild,
561	-	} else {	670	+	parentIsStartInGrand,
562	-	closeErr = fmt.Errorf("missing context for incremental close")	671	+	)
563	-	}
564	-
565	-	if closeErr != nil {
566	-	log.Warn().Err(closeErr).Msg("incremental close failed, falling back to rebuild")
567	-	// Fallback to full rebuild
568	-	if err := wsView.Rebuild(ctx); err != nil {
569	-	log.Error().Err(err).Msg("failed to rebuild workspace view")
570	-	}
571	-	c.contentCoord.ReleaseWebView(ctx, closingPaneID)
572	-	c.contentCoord.AttachToWorkspace(ctx, ws, wsView)
573	-	}
574	-	// Update workspace view's active pane tracking
575	-	if err := wsView.SetActivePaneID(ws.ActivePaneID); err != nil {
576	-	log.Warn().Err(err).Msg("failed to set active pane in workspace view")
577	-	}
578	-	wsView.FocusPane(ws.ActivePaneID)
579	-	} else if wsView != nil {
580	-	// Fallback to rebuild if we couldn't get context
581	-	if err := wsView.Rebuild(ctx); err != nil {
582	-	log.Error().Err(err).Msg("failed to rebuild workspace view")
583	-	}
584	-	c.contentCoord.ReleaseWebView(ctx, closingPaneID)
585	-	c.contentCoord.AttachToWorkspace(ctx, ws, wsView)
586	-	// Update workspace view's active pane tracking
587	-	if err := wsView.SetActivePaneID(ws.ActivePaneID); err != nil {
588	-	log.Warn().Err(err).Msg("failed to set active pane in workspace view")
589	-	}
590	-	wsView.FocusPane(ws.ActivePaneID)
591	-	}
592			672
593		log.Info().Msg("pane closed")	673		log.Info().Msg("pane closed")
594		return nil	674		return nil

@@ -664,42 +744,18 @@ func (c *WorkspaceCoordinator) ClosePaneByID(ctx context.Context, paneID entity.
664		return err	744		return err
665		}	745		}
666			746
667	-	// Try incremental close	747	+	c.finalizePaneClose(
668	-	if wsView != nil && parentNode != nil {	748	+	ctx,
669	-	var closeErr error	749	+	wsView,
670	-		750	+	ws,
671	-	if parentNode.IsStacked {	751	+	paneID,
672	-	closeErr = c.doIncrementalStackClose(ctx, wsView, paneID, parentNode)	752	+	parentNode,
673	-	} else if siblingNode != nil && parentWidget != nil {	753	+	siblingNode,
674	-	closeErr = c.doIncrementalClose(ctx, wsView, ws, paneID, siblingNode, parentNode, grandparentNode, parentWidget, siblingIsStartChild, parentIsStartInGrand)	754	+	grandparentNode,
675	-	} else {	755	+	parentWidget,
676	-	closeErr = fmt.Errorf("missing context for incremental close")	756	+	siblingIsStartChild,
677	-	}	757	+	parentIsStartInGrand,
678	-		758	+	)
679	-	if closeErr != nil {
680	-	log.Warn().Err(closeErr).Msg("incremental close failed, falling back to rebuild")
681	-	if err := wsView.Rebuild(ctx); err != nil {
682	-	log.Error().Err(err).Msg("failed to rebuild workspace view")
683	-	}
684	-	c.contentCoord.ReleaseWebView(ctx, paneID)
685	-	c.contentCoord.AttachToWorkspace(ctx, ws, wsView)
686	-	}
687	-
688	-	if err := wsView.SetActivePaneID(ws.ActivePaneID); err != nil {
689	-	log.Warn().Err(err).Msg("failed to set active pane in workspace view")
690	-	}
691	-	wsView.FocusPane(ws.ActivePaneID)
692	-	} else if wsView != nil {
693	-	if err := wsView.Rebuild(ctx); err != nil {
694	-	log.Error().Err(err).Msg("failed to rebuild workspace view")
695	-	}
696	-	c.contentCoord.ReleaseWebView(ctx, paneID)
697	-	c.contentCoord.AttachToWorkspace(ctx, ws, wsView)
698	-	if err := wsView.SetActivePaneID(ws.ActivePaneID); err != nil {
699	-	log.Warn().Err(err).Msg("failed to set active pane in workspace view")
700	-	}
701	-	wsView.FocusPane(ws.ActivePaneID)
702	-	}
703			759
704		log.Info().Str("pane_id", string(paneID)).Msg("pane closed by ID")	760		log.Info().Str("pane_id", string(paneID)).Msg("pane closed by ID")
705		return nil	761		return nil

@@ -709,7 +765,6 @@ func (c *WorkspaceCoordinator) ClosePaneByID(ctx context.Context, paneID entity.
709		func (c *WorkspaceCoordinator) doIncrementalClose(	765		func (c *WorkspaceCoordinator) doIncrementalClose(
710		ctx context.Context,	766		ctx context.Context,
711		wsView *component.WorkspaceView,	767		wsView *component.WorkspaceView,
712	-	ws *entity.Workspace,
713		closingPaneID entity.PaneID,	768		closingPaneID entity.PaneID,
714		siblingNode *entity.PaneNode,	769		siblingNode *entity.PaneNode,
715		parentNode *entity.PaneNode,	770		parentNode *entity.PaneNode,

@@ -835,24 +890,85 @@ func (c *WorkspaceCoordinator) doIncrementalClose(
835		return nil	890		return nil
836		}	891		}
837			892
838	-	// doIncrementalStackClose removes a pane from a stack without rebuilding the entire tree.	893	+	func (c *WorkspaceCoordinator) finalizePaneClose(
839	-	func (c *WorkspaceCoordinator) doIncrementalStackClose(
840		ctx context.Context,	894		ctx context.Context,
841		wsView *component.WorkspaceView,	895		wsView *component.WorkspaceView,
842	-	closingPaneID entity.PaneID,	896	+	ws *entity.Workspace,
843	-	stackNode *entity.PaneNode,	897	+	paneID entity.PaneID,
844	-	) error {	898	+	parentNode *entity.PaneNode,
845	-	log := logging.FromContext(ctx)	899	+	siblingNode *entity.PaneNode,
846	-	tr := wsView.TreeRenderer()	900	+	grandparentNode *entity.PaneNode,
847	-	if tr == nil {	901	+	parentWidget layout.Widget,
848	-	return fmt.Errorf("tree renderer not available")	902	+	siblingIsStartChild bool,
			903	+	parentIsStartInGrand bool,
			904	+	) {
			905	+	if wsView == nil {
			906	+	return
849		}	907		}
850			908
851	-	log.Debug().	909	+	log := logging.FromContext(ctx)
852	-	Str("closing_pane", string(closingPaneID)).	910	+
853	-	Str("stack_node", stackNode.ID).	911	+	if parentNode != nil {
854	-	Int("stack_children", len(stackNode.Children)).	912	+	var closeErr error
855	-	Msg("performing incremental stack close")	913	+
			914	+	if parentNode.IsStacked {
			915	+	closeErr = c.doIncrementalStackClose(ctx, wsView, paneID, parentNode)
			916	+	} else if siblingNode != nil && parentWidget != nil {
			917	+	closeErr = c.doIncrementalClose(
			918	+	ctx,
			919	+	wsView,
			920	+	paneID,
			921	+	siblingNode,
			922	+	parentNode,
			923	+	grandparentNode,
			924	+	parentWidget,
			925	+	siblingIsStartChild,
			926	+	parentIsStartInGrand,
			927	+	)
			928	+	} else {
			929	+	closeErr = fmt.Errorf("missing context for incremental close")
			930	+	}
			931	+
			932	+	if closeErr != nil {
			933	+	log.Warn().Err(closeErr).Msg("incremental close failed, falling back to rebuild")
			934	+	if err := wsView.Rebuild(ctx); err != nil {
			935	+	log.Error().Err(err).Msg("failed to rebuild workspace view")
			936	+	}
			937	+	c.contentCoord.ReleaseWebView(ctx, paneID)
			938	+	c.contentCoord.AttachToWorkspace(ctx, ws, wsView)
			939	+	}
			940	+	} else {
			941	+	if err := wsView.Rebuild(ctx); err != nil {
			942	+	log.Error().Err(err).Msg("failed to rebuild workspace view")
			943	+	}
			944	+	c.contentCoord.ReleaseWebView(ctx, paneID)
			945	+	c.contentCoord.AttachToWorkspace(ctx, ws, wsView)
			946	+	}
			947	+
			948	+	if err := wsView.SetActivePaneID(ws.ActivePaneID); err != nil {
			949	+	log.Warn().Err(err).Msg("failed to set active pane in workspace view")
			950	+	}
			951	+	wsView.FocusPane(ws.ActivePaneID)
			952	+	}
			953	+
			954	+	// doIncrementalStackClose removes a pane from a stack without rebuilding the entire tree.
			955	+	func (c *WorkspaceCoordinator) doIncrementalStackClose(
			956	+	ctx context.Context,
			957	+	wsView *component.WorkspaceView,
			958	+	closingPaneID entity.PaneID,
			959	+	stackNode *entity.PaneNode,
			960	+	) error {
			961	+	log := logging.FromContext(ctx)
			962	+	tr := wsView.TreeRenderer()
			963	+	if tr == nil {
			964	+	return fmt.Errorf("tree renderer not available")
			965	+	}
			966	+
			967	+	log.Debug().
			968	+	Str("closing_pane", string(closingPaneID)).
			969	+	Str("stack_node", stackNode.ID).
			970	+	Int("stack_children", len(stackNode.Children)).
			971	+	Msg("performing incremental stack close")
856			972
857		// Get the StackedView for this pane	973		// Get the StackedView for this pane
858		stackedView := tr.GetStackedViewForPane(string(closingPaneID))	974		stackedView := tr.GetStackedViewForPane(string(closingPaneID))

@@ -984,104 +1100,18 @@ func (c *WorkspaceCoordinator) syncStackedViewActive(ctx context.Context, wsView
984		func (c *WorkspaceCoordinator) StackPane(ctx context.Context) error {	1100		func (c *WorkspaceCoordinator) StackPane(ctx context.Context) error {
985		log := logging.FromContext(ctx)	1101		log := logging.FromContext(ctx)
986			1102
987	-	if c.stackedPaneMgr == nil {	1103	+	stackCtx, ok := c.prepareStackPane(ctx)
988	-	log.Warn().Msg("stacked pane manager not available")	1104	+	if !ok {
989	-	return nil
990	-	}
991	-
992	-	ws, wsView := c.getActiveWS()
993	-	if ws == nil {
994	-	log.Warn().Msg("no active workspace")
995	-	return nil
996	-	}
997	-
998	-	activeNode := ws.ActivePane()
999	-	if activeNode == nil \|\| activeNode.Pane == nil {
1000	-	log.Warn().Msg("no active pane")
1001	-	return nil
1002	-	}
1003	-
1004	-	if wsView == nil {
1005	-	log.Warn().Msg("no workspace view")
1006		return nil	1105		return nil
1007		}	1106		}
1008			1107
1009	-	activePaneID := activeNode.Pane.ID
1010	-
1011	-	// Create a new pane entity
1012		newPaneID := entity.PaneID(c.generateID())	1108		newPaneID := entity.PaneID(c.generateID())
1013		newPane := entity.NewPane(newPaneID)	1109		newPane := entity.NewPane(newPaneID)
1014		newPane.URI = "about:blank"	1110		newPane.URI = "about:blank"
1015	-	newPane.Title = "Untitled"	1111	+	newPane.Title = defaultPaneTitle
1016	-
1017	-	// Get the original pane's current title
1018	-	originalTitle := c.contentCoord.GetTitle(activePaneID)
1019	-	if originalTitle == "" {
1020	-	originalTitle = activeNode.Pane.Title
1021	-	}
1022	-	if originalTitle == "" {
1023	-	originalTitle = "Untitled"
1024	-	}
1025	-
1026	-	// Update domain model: convert leaf to stacked if needed, add new pane
1027	-	var stackNode *entity.PaneNode
1028	-	var needsFirstPaneTitleUpdate bool
1029	-	if activeNode.Parent != nil && activeNode.Parent.IsStacked {
1030	-	// Active pane is already in a stack - add to parent stack
1031	-	stackNode = activeNode.Parent
1032	-	log.Debug().
1033	-	Str("stack_id", stackNode.ID).
1034	-	Str("active_pane", string(activePaneID)).
1035	-	Int("stack_size", len(stackNode.Children)).
1036	-	Msg("adding to existing stack via parent")
1037	-	} else if activeNode.IsStacked {
1038	-	// Active node is itself a stack container - add to it
1039	-	stackNode = activeNode
1040	-	} else {
1041	-	// Convert leaf node to stacked container
1042	-	originalPane := activeNode.Pane
1043	-	originalPane.Title = originalTitle
1044	-	originalPaneChild := &entity.PaneNode{
1045	-	ID: activeNode.ID + "_0",
1046	-	Pane: originalPane,
1047	-	Parent: activeNode,
1048	-	}
1049			1112
1050	-	activeNode.Pane = nil	1113	+	stackNode, needsFirstPaneTitleUpdate := c.ensureStackNode(ctx, stackCtx.activeNode, stackCtx.activePaneID, stackCtx.originalTitle)
1051	-	activeNode.IsStacked = true	1114	+	insertIndex := insertStackChild(stackNode, newPaneID, newPane)
1052	-	activeNode.Children = []*entity.PaneNode{originalPaneChild}
1053	-	stackNode = activeNode
1054	-	needsFirstPaneTitleUpdate = true
1055	-
1056	-	log.Debug().
1057	-	Str("node_id", activeNode.ID).
1058	-	Str("original_pane", string(originalPane.ID)).
1059	-	Str("original_title", originalTitle).
1060	-	Msg("converted leaf to stacked node")
1061	-	}
1062	-
1063	-	// Create new child node for the new pane
1064	-	newChildNode := &entity.PaneNode{
1065	-	ID: stackNode.ID + "_" + string(newPaneID),
1066	-	Pane: newPane,
1067	-	Parent: stackNode,
1068	-	}
1069	-
1070	-	// Insert right after current active pane (not at end)
1071	-	currentActiveIndex := stackNode.ActiveStackIndex
1072	-	if currentActiveIndex < 0 \|\| currentActiveIndex >= len(stackNode.Children) {
1073	-	currentActiveIndex = len(stackNode.Children) - 1
1074	-	if currentActiveIndex < 0 {
1075	-	currentActiveIndex = -1
1076	-	}
1077	-	}
1078	-	insertIndex := currentActiveIndex + 1
1079	-
1080	-	// Slice insertion at correct position
1081	-	stackNode.Children = append(stackNode.Children, nil)
1082	-	copy(stackNode.Children[insertIndex+1:], stackNode.Children[insertIndex:])
1083	-	stackNode.Children[insertIndex] = newChildNode
1084	-	stackNode.ActiveStackIndex = insertIndex
1085			1115
1086		log.Debug().	1116		log.Debug().
1087		Int("stack_size", len(stackNode.Children)).	1117		Int("stack_size", len(stackNode.Children)).

@@ -1091,28 +1121,18 @@ func (c *WorkspaceCoordinator) StackPane(ctx context.Context) error {
1091			1121
1092		// Create PaneView for the new pane	1122		// Create PaneView for the new pane
1093		newPaneView := component.NewPaneView(c.widgetFactory, newPaneID, nil)	1123		newPaneView := component.NewPaneView(c.widgetFactory, newPaneID, nil)
1094	-	setupPaneViewHover(ctx, newPaneView, wsView)	1124	+	setupPaneViewHover(ctx, newPaneView, stackCtx.wsView)
1095	-	wsView.RegisterPaneView(newPaneID, newPaneView)	1125	+	stackCtx.wsView.RegisterPaneView(newPaneID, newPaneView)
1096			1126
1097		// Add to the UI StackedView	1127		// Add to the UI StackedView
1098	-	if err := c.stackedPaneMgr.AddPaneToStack(ctx, wsView, activePaneID, newPaneView, "Untitled"); err != nil {	1128	+	if err := c.stackedPaneMgr.AddPaneToStack(ctx, stackCtx.wsView, stackCtx.activePaneID, newPaneView, defaultPaneTitle); err != nil {
1099		log.Error().Err(err).Msg("failed to add pane to stack")	1129		log.Error().Err(err).Msg("failed to add pane to stack")
1100		return err	1130		return err
1101		}	1131		}
1102			1132
1103		// Update the first pane's title if we just converted from leaf to stacked	1133		// Update the first pane's title if we just converted from leaf to stacked
1104		if needsFirstPaneTitleUpdate {	1134		if needsFirstPaneTitleUpdate {
1105	-	tr := wsView.TreeRenderer()	1135	+	c.updateFirstStackTitle(ctx, stackCtx.wsView, stackCtx.activePaneID, stackCtx.originalTitle)
1106	-	if tr != nil {
1107	-	stackedView := tr.GetStackedViewForPane(string(activePaneID))
1108	-	if stackedView != nil {
1109	-	if err := stackedView.UpdateTitle(0, originalTitle); err != nil {
1110	-	log.Warn().Err(err).Str("title", originalTitle).Msg("failed to update first pane title")
1111	-	} else {
1112	-	log.Debug().Str("title", originalTitle).Msg("updated first pane title in StackedView")
1113	-	}
1114	-	}
1115	-	}
1116		}	1136		}
1117			1137
1118		// Get WebView and attach	1138		// Get WebView and attach

@@ -1131,17 +1151,17 @@ func (c *WorkspaceCoordinator) StackPane(ctx context.Context) error {
1131		}	1151		}
1132			1152
1133		// Update workspace active pane ID	1153		// Update workspace active pane ID
1134	-	ws.ActivePaneID = newPaneID	1154	+	stackCtx.ws.ActivePaneID = newPaneID
1135			1155
1136		// Update workspace view	1156		// Update workspace view
1137	-	if err := wsView.SetActivePaneID(newPaneID); err != nil {	1157	+	if err := stackCtx.wsView.SetActivePaneID(newPaneID); err != nil {
1138		log.Warn().Err(err).Msg("failed to set active pane")	1158		log.Warn().Err(err).Msg("failed to set active pane")
1139		}	1159		}
1140			1160
1141		// Set up title bar click callback	1161		// Set up title bar click callback
1142	-	tr := wsView.TreeRenderer()	1162	+	tr := stackCtx.wsView.TreeRenderer()
1143		if tr != nil {	1163		if tr != nil {
1144	-	stackedView := tr.GetStackedViewForPane(string(activePaneID))	1164	+	stackedView := tr.GetStackedViewForPane(string(stackCtx.activePaneID))
1145		if stackedView != nil {	1165		if stackedView != nil {
1146		capturedStackNode := stackNode	1166		capturedStackNode := stackNode
1147		stackedView.SetOnActivate(func(index int) {	1167		stackedView.SetOnActivate(func(index int) {

@@ -1151,7 +1171,7 @@ func (c *WorkspaceCoordinator) StackPane(ctx context.Context) error {
1151		}	1171		}
1152			1172
1153		log.Info().	1173		log.Info().
1154	-	Str("original_pane", string(activePaneID)).	1174	+	Str("original_pane", string(stackCtx.activePaneID)).
1155		Str("new_pane", string(newPaneID)).	1175		Str("new_pane", string(newPaneID)).
1156		Int("stack_size", len(stackNode.Children)).	1176		Int("stack_size", len(stackNode.Children)).
1157		Msg("stacked new pane")	1177		Msg("stacked new pane")

@@ -1159,6 +1179,137 @@ func (c *WorkspaceCoordinator) StackPane(ctx context.Context) error {
1159		return nil	1179		return nil
1160		}	1180		}
1161			1181
			1182	+	func (c *WorkspaceCoordinator) prepareStackPane(
			1183	+	ctx context.Context,
			1184	+	) (*stackPaneContext, bool) {
			1185	+	log := logging.FromContext(ctx)
			1186	+	if c.stackedPaneMgr == nil {
			1187	+	log.Warn().Msg("stacked pane manager not available")
			1188	+	return nil, false
			1189	+	}
			1190	+
			1191	+	ws, wsView := c.getActiveWS()
			1192	+	if ws == nil {
			1193	+	log.Warn().Msg("no active workspace")
			1194	+	return nil, false
			1195	+	}
			1196	+
			1197	+	activeNode := ws.ActivePane()
			1198	+	if activeNode == nil \|\| activeNode.Pane == nil {
			1199	+	log.Warn().Msg("no active pane")
			1200	+	return nil, false
			1201	+	}
			1202	+
			1203	+	if wsView == nil {
			1204	+	log.Warn().Msg("no workspace view")
			1205	+	return nil, false
			1206	+	}
			1207	+
			1208	+	activePaneID := activeNode.Pane.ID
			1209	+	originalTitle := c.contentCoord.GetTitle(activePaneID)
			1210	+	if originalTitle == "" {
			1211	+	originalTitle = activeNode.Pane.Title
			1212	+	}
			1213	+	if originalTitle == "" {
			1214	+	originalTitle = defaultPaneTitle
			1215	+	}
			1216	+
			1217	+	return &stackPaneContext{
			1218	+	ws: ws,
			1219	+	wsView: wsView,
			1220	+	activeNode: activeNode,
			1221	+	activePaneID: activePaneID,
			1222	+	originalTitle: originalTitle,
			1223	+	}, true
			1224	+	}
			1225	+
			1226	+	func (c *WorkspaceCoordinator) ensureStackNode(
			1227	+	ctx context.Context,
			1228	+	activeNode *entity.PaneNode,
			1229	+	activePaneID entity.PaneID,
			1230	+	originalTitle string,
			1231	+	) (*entity.PaneNode, bool) {
			1232	+	log := logging.FromContext(ctx)
			1233	+	if activeNode.Parent != nil && activeNode.Parent.IsStacked {
			1234	+	stackNode := activeNode.Parent
			1235	+	log.Debug().
			1236	+	Str("stack_id", stackNode.ID).
			1237	+	Str("active_pane", string(activePaneID)).
			1238	+	Int("stack_size", len(stackNode.Children)).
			1239	+	Msg("adding to existing stack via parent")
			1240	+	return stackNode, false
			1241	+	}
			1242	+
			1243	+	if activeNode.IsStacked {
			1244	+	return activeNode, false
			1245	+	}
			1246	+
			1247	+	originalPane := activeNode.Pane
			1248	+	originalPane.Title = originalTitle
			1249	+	originalPaneChild := &entity.PaneNode{
			1250	+	ID: activeNode.ID + "_0",
			1251	+	Pane: originalPane,
			1252	+	Parent: activeNode,
			1253	+	}
			1254	+
			1255	+	activeNode.Pane = nil
			1256	+	activeNode.IsStacked = true
			1257	+	activeNode.Children = []*entity.PaneNode{originalPaneChild}
			1258	+
			1259	+	log.Debug().
			1260	+	Str("node_id", activeNode.ID).
			1261	+	Str("original_pane", string(originalPane.ID)).
			1262	+	Str("original_title", originalTitle).
			1263	+	Msg("converted leaf to stacked node")
			1264	+
			1265	+	return activeNode, true
			1266	+	}
			1267	+
			1268	+	func insertStackChild(stackNode entity.PaneNode, newPaneID entity.PaneID, newPane entity.Pane) int {
			1269	+	newChildNode := &entity.PaneNode{
			1270	+	ID: stackNode.ID + "_" + string(newPaneID),
			1271	+	Pane: newPane,
			1272	+	Parent: stackNode,
			1273	+	}
			1274	+
			1275	+	currentActiveIndex := stackNode.ActiveStackIndex
			1276	+	if currentActiveIndex < 0 \|\| currentActiveIndex >= len(stackNode.Children) {
			1277	+	currentActiveIndex = len(stackNode.Children) - 1
			1278	+	if currentActiveIndex < 0 {
			1279	+	currentActiveIndex = -1
			1280	+	}
			1281	+	}
			1282	+	insertIndex := currentActiveIndex + 1
			1283	+
			1284	+	stackNode.Children = append(stackNode.Children, nil)
			1285	+	copy(stackNode.Children[insertIndex+1:], stackNode.Children[insertIndex:])
			1286	+	stackNode.Children[insertIndex] = newChildNode
			1287	+	stackNode.ActiveStackIndex = insertIndex
			1288	+	return insertIndex
			1289	+	}
			1290	+
			1291	+	func (c *WorkspaceCoordinator) updateFirstStackTitle(
			1292	+	ctx context.Context,
			1293	+	wsView *component.WorkspaceView,
			1294	+	activePaneID entity.PaneID,
			1295	+	originalTitle string,
			1296	+	) {
			1297	+	log := logging.FromContext(ctx)
			1298	+	tr := wsView.TreeRenderer()
			1299	+	if tr == nil {
			1300	+	return
			1301	+	}
			1302	+	stackedView := tr.GetStackedViewForPane(string(activePaneID))
			1303	+	if stackedView == nil {
			1304	+	return
			1305	+	}
			1306	+	if err := stackedView.UpdateTitle(0, originalTitle); err != nil {
			1307	+	log.Warn().Err(err).Str("title", originalTitle).Msg("failed to update first pane title")
			1308	+	return
			1309	+	}
			1310	+	log.Debug().Str("title", originalTitle).Msg("updated first pane title in StackedView")
			1311	+	}
			1312	+
1162		// NavigateStack navigates up or down within a stacked pane container.	1313		// NavigateStack navigates up or down within a stacked pane container.
1163		func (c *WorkspaceCoordinator) NavigateStack(ctx context.Context, direction string) error {	1314		func (c *WorkspaceCoordinator) NavigateStack(ctx context.Context, direction string) error {
1164		log := logging.FromContext(ctx)	1315		log := logging.FromContext(ctx)

@@ -1324,40 +1475,14 @@ func (c *WorkspaceCoordinator) insertPopupSplit(ctx context.Context, input Inser
1324		return fmt.Errorf("parent pane not found: %s", input.ParentPaneID)	1475		return fmt.Errorf("parent pane not found: %s", input.ParentPaneID)
1325		}	1476		}
1326			1477
1327	-	// Map placement to split direction	1478	+	direction := resolvePopupSplitDirection(input.Placement)
1328	-	var direction usecase.SplitDirection
1329	-	switch input.Placement {
1330	-	case "left":
1331	-	direction = usecase.SplitLeft
1332	-	case "right":
1333	-	direction = usecase.SplitRight
1334	-	case "top", "up":
1335	-	direction = usecase.SplitUp
1336	-	case "bottom", "down":
1337	-	direction = usecase.SplitDown
1338	-	default:
1339	-	direction = usecase.SplitRight
1340	-	}
1341			1479
1342		// Check if parent is in a stack - if so, split around the stack	1480		// Check if parent is in a stack - if so, split around the stack
1343		isStackSplit := (direction == usecase.SplitLeft \|\| direction == usecase.SplitRight) &&	1481		isStackSplit := (direction == usecase.SplitLeft \|\| direction == usecase.SplitRight) &&
1344		parentNode.Parent != nil && parentNode.Parent.IsStacked	1482		parentNode.Parent != nil && parentNode.Parent.IsStacked
1345			1483
1346		// Get existing widget before domain changes	1484		// Get existing widget before domain changes
1347	-	var existingWidget layout.Widget	1485	+	existingWidget := c.resolvePopupSplitWidget(wsView, parentNode, isStackSplit)
1348	-	if wsView != nil {
1349	-	if isStackSplit {
1350	-	tr := wsView.TreeRenderer()
1351	-	if tr != nil {
1352	-	stackedView := tr.GetStackedViewForPane(string(parentNode.Pane.ID))
1353	-	if stackedView != nil {
1354	-	existingWidget = stackedView.Widget()
1355	-	}
1356	-	}
1357	-	} else {
1358	-	existingWidget = wsView.GetRootWidget()
1359	-	}
1360	-	}
1361			1486
1362		// Perform the split with pre-created pane	1487		// Perform the split with pre-created pane
1363		output, err := c.panesUC.Split(ctx, usecase.SplitPaneInput{	1488		output, err := c.panesUC.Split(ctx, usecase.SplitPaneInput{

@@ -1374,38 +1499,9 @@ func (c *WorkspaceCoordinator) insertPopupSplit(ctx context.Context, input Inser
1374		ws.ActivePaneID = input.PopupPane.ID	1499		ws.ActivePaneID = input.PopupPane.ID
1375			1500
1376		// Update UI	1501		// Update UI
1377	-	if wsView != nil && existingWidget != nil {	1502	+	if wsView != nil {
1378	-	var splitErr error	1503	+	c.applySplitToView(ctx, wsView, ws, output, direction, existingWidget, isStackSplit, input.ParentPaneID)
1379	-	if isStackSplit {	1504	+	c.attachPopupWebView(ctx, wsView, input)
1380	-	splitErr = c.doIncrementalStackSplit(ctx, wsView, ws, output, direction, existingWidget, input.ParentPaneID)
1381	-	} else {
1382	-	splitErr = c.doIncrementalSplit(ctx, wsView, ws, output, direction, existingWidget, input.ParentPaneID)
1383	-	}
1384	-
1385	-	if splitErr != nil {
1386	-	log.Warn().Err(splitErr).Msg("incremental popup split failed, falling back to rebuild")
1387	-	if err := wsView.Rebuild(ctx); err != nil {
1388	-	log.Error().Err(err).Msg("failed to rebuild workspace view")
1389	-	}
1390	-	c.contentCoord.AttachToWorkspace(ctx, ws, wsView)
1391	-	}
1392	-
1393	-	// Update active pane tracking
1394	-	if err := wsView.SetActivePaneID(ws.ActivePaneID); err != nil {
1395	-	log.Warn().Err(err).Msg("failed to set active pane in workspace view")
1396	-	}
1397	-	wsView.FocusPane(ws.ActivePaneID)
1398	-	}
1399	-
1400	-	// Attach WebView widget to the new pane
1401	-	if wsView != nil && input.WebView != nil {
1402	-	widget := c.contentCoord.WrapWidget(ctx, input.WebView)
1403	-	if widget != nil {
1404	-	paneView := wsView.GetPaneView(input.PopupPane.ID)
1405	-	if paneView != nil {
1406	-	paneView.SetWebViewWidget(widget)
1407	-	}
1408	-	}
1409		}	1505		}
1410			1506
1411		log.Info().	1507		log.Info().

@@ -1416,6 +1512,68 @@ func (c *WorkspaceCoordinator) insertPopupSplit(ctx context.Context, input Inser
1416		return nil	1512		return nil
1417		}	1513		}
1418			1514
			1515	+	func resolvePopupSplitDirection(placement string) usecase.SplitDirection {
			1516	+	switch placement {
			1517	+	case string(usecase.SplitLeft):
			1518	+	return usecase.SplitLeft
			1519	+	case string(usecase.SplitRight):
			1520	+	return usecase.SplitRight
			1521	+	case "top", string(usecase.SplitUp):
			1522	+	return usecase.SplitUp
			1523	+	case "bottom", string(usecase.SplitDown):
			1524	+	return usecase.SplitDown
			1525	+	default:
			1526	+	return usecase.SplitRight
			1527	+	}
			1528	+	}
			1529	+
			1530	+	func (c *WorkspaceCoordinator) resolvePopupSplitWidget(
			1531	+	wsView *component.WorkspaceView,
			1532	+	parentNode *entity.PaneNode,
			1533	+	isStackSplit bool,
			1534	+	) layout.Widget {
			1535	+	if wsView == nil {
			1536	+	return nil
			1537	+	}
			1538	+
			1539	+	if !isStackSplit {
			1540	+	return wsView.GetRootWidget()
			1541	+	}
			1542	+
			1543	+	tr := wsView.TreeRenderer()
			1544	+	if tr == nil {
			1545	+	return nil
			1546	+	}
			1547	+
			1548	+	stackedView := tr.GetStackedViewForPane(string(parentNode.Pane.ID))
			1549	+	if stackedView == nil {
			1550	+	return nil
			1551	+	}
			1552	+
			1553	+	return stackedView.Widget()
			1554	+	}
			1555	+
			1556	+	func (c *WorkspaceCoordinator) attachPopupWebView(
			1557	+	ctx context.Context,
			1558	+	wsView *component.WorkspaceView,
			1559	+	input InsertPopupInput,
			1560	+	) {
			1561	+	if wsView == nil \|\| input.WebView == nil {
			1562	+	return
			1563	+	}
			1564	+
			1565	+	widget := c.contentCoord.WrapWidget(ctx, input.WebView)
			1566	+	if widget == nil {
			1567	+	return
			1568	+	}
			1569	+
			1570	+	paneView := wsView.GetPaneView(input.PopupPane.ID)
			1571	+	if paneView == nil {
			1572	+	return
			1573	+	}
			1574	+	paneView.SetWebViewWidget(widget)
			1575	+	}
			1576	+
1419		// insertPopupStacked inserts a popup as a stacked pane on top of the parent.	1577		// insertPopupStacked inserts a popup as a stacked pane on top of the parent.
1420		func (c *WorkspaceCoordinator) insertPopupStacked(ctx context.Context, input InsertPopupInput) error {	1578		func (c *WorkspaceCoordinator) insertPopupStacked(ctx context.Context, input InsertPopupInput) error {
1421		log := logging.FromContext(ctx)	1579		log := logging.FromContext(ctx)

@@ -1425,64 +1583,87 @@ func (c *WorkspaceCoordinator) insertPopupStacked(ctx context.Context, input Ins
1425		return fmt.Errorf("no active workspace")	1583		return fmt.Errorf("no active workspace")
1426		}	1584		}
1427			1585
1428	-	// Find parent pane node
1429		parentNode := ws.FindPane(input.ParentPaneID)	1586		parentNode := ws.FindPane(input.ParentPaneID)
1430		if parentNode == nil {	1587		if parentNode == nil {
1431		return fmt.Errorf("parent pane not found: %s", input.ParentPaneID)	1588		return fmt.Errorf("parent pane not found: %s", input.ParentPaneID)
1432		}	1589		}
1433			1590
1434	-	// Determine stack node - either parent is already a stack, or we need to convert it	1591	+	stackNode := c.resolveStackNode(input, parentNode, log)
1435	-	var stackNode *entity.PaneNode	1592	+	if stackNode == nil {
1436	-	var needsStackConversion bool	1593	+	return fmt.Errorf("failed to resolve stack node for popup")
			1594	+	}
1437			1595
1438	-	if parentNode.Parent != nil && parentNode.Parent.IsStacked {	1596	+	c.insertStackChild(stackNode, input.PopupPane)
1439	-	// Parent is already in a stack - add to existing stack	1597	+
1440	-	stackNode = parentNode.Parent	1598	+	// Update workspace active pane
1441	-	} else if parentNode.IsStacked {	1599	+	ws.ActivePaneID = input.PopupPane.ID
1442	-	// Parent itself is a stack - add to it	1600	+
1443	-	stackNode = parentNode	1601	+	if err := c.attachPopupPaneView(ctx, input, wsView, stackNode, log); err != nil {
1444	-	} else {	1602	+	return err
1445	-	// Need to convert parent leaf to a stack
1446	-	needsStackConversion = true
1447	-	stackNode = parentNode
1448		}	1603		}
1449			1604
1450	-	if needsStackConversion {	1605	+	log.Info().
1451	-	// Convert leaf node to stacked container	1606	+	Str("popup_pane", string(input.PopupPane.ID)).
1452	-	originalPane := parentNode.Pane	1607	+	Int("stack_size", len(stackNode.Children)).
1453	-	originalTitle := c.contentCoord.GetTitle(input.ParentPaneID)	1608	+	Msg("popup inserted as stacked pane")
1454	-	if originalTitle == "" {
1455	-	originalTitle = originalPane.Title
1456	-	}
1457	-	if originalTitle == "" {
1458	-	originalTitle = "Untitled"
1459	-	}
1460	-	originalPane.Title = originalTitle
1461			1609
1462	-	originalPaneChild := &entity.PaneNode{	1610	+	return nil
1463	-	ID: parentNode.ID + "_0",	1611	+	}
1464	-	Pane: originalPane,
1465	-	Parent: parentNode,
1466	-	}
1467			1612
1468	-	parentNode.Pane = nil	1613	+	func (c *WorkspaceCoordinator) resolveStackNode(
1469	-	parentNode.IsStacked = true	1614	+	input InsertPopupInput,
1470	-	parentNode.Children = []*entity.PaneNode{originalPaneChild}	1615	+	parentNode *entity.PaneNode,
			1616	+	log *zerolog.Logger,
			1617	+	) *entity.PaneNode {
			1618	+	if parentNode.Parent != nil && parentNode.Parent.IsStacked {
			1619	+	return parentNode.Parent
			1620	+	}
			1621	+	if parentNode.IsStacked {
			1622	+	return parentNode
			1623	+	}
			1624	+	return c.convertToStackedNode(input, parentNode, log)
			1625	+	}
1471			1626
1472	-	log.Debug().	1627	+	func (c *WorkspaceCoordinator) convertToStackedNode(
1473	-	Str("node_id", parentNode.ID).	1628	+	input InsertPopupInput,
1474	-	Str("original_pane", string(originalPane.ID)).	1629	+	parentNode *entity.PaneNode,
1475	-	Msg("converted leaf to stacked node for popup")	1630	+	log *zerolog.Logger,
			1631	+	) *entity.PaneNode {
			1632	+	originalPane := parentNode.Pane
			1633	+	originalTitle := c.contentCoord.GetTitle(input.ParentPaneID)
			1634	+	if originalTitle == "" {
			1635	+	originalTitle = originalPane.Title
			1636	+	}
			1637	+	if originalTitle == "" {
			1638	+	originalTitle = defaultPaneTitle
1476		}	1639		}
			1640	+	originalPane.Title = originalTitle
			1641	+
			1642	+	originalPaneChild := &entity.PaneNode{
			1643	+	ID: parentNode.ID + "_0",
			1644	+	Pane: originalPane,
			1645	+	Parent: parentNode,
			1646	+	}
			1647	+
			1648	+	parentNode.Pane = nil
			1649	+	parentNode.IsStacked = true
			1650	+	parentNode.Children = []*entity.PaneNode{originalPaneChild}
			1651	+
			1652	+	log.Debug().
			1653	+	Str("node_id", parentNode.ID).
			1654	+	Str("original_pane", string(originalPane.ID)).
			1655	+	Msg("converted leaf to stacked node for popup")
1477			1656
1478	-	// Create new child node for the popup pane	1657	+	return parentNode
			1658	+	}
			1659	+
			1660	+	func (c WorkspaceCoordinator) insertStackChild(stackNode entity.PaneNode, pane *entity.Pane) {
1479		newChildNode := &entity.PaneNode{	1661		newChildNode := &entity.PaneNode{
1480	-	ID: stackNode.ID + "_popup_" + string(input.PopupPane.ID),	1662	+	ID: stackNode.ID + "_popup_" + string(pane.ID),
1481	-	Pane: input.PopupPane,	1663	+	Pane: pane,
1482		Parent: stackNode,	1664		Parent: stackNode,
1483		}	1665		}
1484			1666
1485	-	// Insert right after current active pane (not at end)
1486		currentActiveIndex := stackNode.ActiveStackIndex	1667		currentActiveIndex := stackNode.ActiveStackIndex
1487		if currentActiveIndex < 0 \|\| currentActiveIndex >= len(stackNode.Children) {	1668		if currentActiveIndex < 0 \|\| currentActiveIndex >= len(stackNode.Children) {
1488		currentActiveIndex = len(stackNode.Children) - 1	1669		currentActiveIndex = len(stackNode.Children) - 1

@@ -1492,58 +1673,52 @@ func (c *WorkspaceCoordinator) insertPopupStacked(ctx context.Context, input Ins
1492		}	1673		}
1493		insertIndex := currentActiveIndex + 1	1674		insertIndex := currentActiveIndex + 1
1494			1675
1495	-	// Slice insertion at correct position
1496		stackNode.Children = append(stackNode.Children, nil)	1676		stackNode.Children = append(stackNode.Children, nil)
1497		copy(stackNode.Children[insertIndex+1:], stackNode.Children[insertIndex:])	1677		copy(stackNode.Children[insertIndex+1:], stackNode.Children[insertIndex:])
1498		stackNode.Children[insertIndex] = newChildNode	1678		stackNode.Children[insertIndex] = newChildNode
1499		stackNode.ActiveStackIndex = insertIndex	1679		stackNode.ActiveStackIndex = insertIndex
			1680	+	}
1500			1681
1501	-	// Update workspace active pane	1682	+	func (c *WorkspaceCoordinator) attachPopupPaneView(
1502	-	ws.ActivePaneID = input.PopupPane.ID	1683	+	ctx context.Context,
1503	-		1684	+	input InsertPopupInput,
1504	-	// Create PaneView for the popup	1685	+	wsView *component.WorkspaceView,
1505	-	if wsView != nil {	1686	+	stackNode *entity.PaneNode,
1506	-	newPaneView := component.NewPaneView(c.widgetFactory, input.PopupPane.ID, nil)	1687	+	log *zerolog.Logger,
1507	-	setupPaneViewHover(ctx, newPaneView, wsView)	1688	+	) error {
1508	-	wsView.RegisterPaneView(input.PopupPane.ID, newPaneView)	1689	+	if wsView == nil {
			1690	+	return nil
			1691	+	}
			1692	+	newPaneView := component.NewPaneView(c.widgetFactory, input.PopupPane.ID, nil)
			1693	+	setupPaneViewHover(ctx, newPaneView, wsView)
			1694	+	wsView.RegisterPaneView(input.PopupPane.ID, newPaneView)
1509			1695
1510	-	// Add to StackedView	1696	+	if err := c.stackedPaneMgr.AddPaneToStack(ctx, wsView, input.ParentPaneID, newPaneView, input.PopupPane.Title); err != nil {
1511	-	if err := c.stackedPaneMgr.AddPaneToStack(ctx, wsView, input.ParentPaneID, newPaneView, input.PopupPane.Title); err != nil {	1697	+	log.Error().Err(err).Msg("failed to add popup pane to stack")
1512	-	log.Error().Err(err).Msg("failed to add popup pane to stack")	1698	+	return err
1513	-	return err	1699	+	}
1514	-	}
1515			1700
1516	-	// Attach WebView widget	1701	+	if input.WebView != nil {
1517	-	if input.WebView != nil {	1702	+	widget := c.contentCoord.WrapWidget(ctx, input.WebView)
1518	-	widget := c.contentCoord.WrapWidget(ctx, input.WebView)	1703	+	if widget != nil {
1519	-	if widget != nil {	1704	+	newPaneView.SetWebViewWidget(widget)
1520	-	newPaneView.SetWebViewWidget(widget)
1521	-	}
1522		}	1705		}
			1706	+	}
1523			1707
1524	-	// Update active pane tracking	1708	+	if err := wsView.SetActivePaneID(input.PopupPane.ID); err != nil {
1525	-	if err := wsView.SetActivePaneID(ws.ActivePaneID); err != nil {	1709	+	log.Warn().Err(err).Msg("failed to set active pane in workspace view")
1526	-	log.Warn().Err(err).Msg("failed to set active pane in workspace view")	1710	+	}
1527	-	}
1528			1711
1529	-	// Setup title bar click callback	1712	+	tr := wsView.TreeRenderer()
1530	-	tr := wsView.TreeRenderer()	1713	+	if tr != nil {
1531	-	if tr != nil {	1714	+	stackedView := tr.GetStackedViewForPane(string(input.ParentPaneID))
1532	-	stackedView := tr.GetStackedViewForPane(string(input.ParentPaneID))	1715	+	if stackedView != nil {
1533	-	if stackedView != nil {	1716	+	capturedStackNode := stackNode
1534	-	capturedStackNode := stackNode	1717	+	stackedView.SetOnActivate(func(index int) {
1535	-	stackedView.SetOnActivate(func(index int) {	1718	+	c.onTitleBarClick(ctx, capturedStackNode, stackedView, index)
1536	-	c.onTitleBarClick(ctx, capturedStackNode, stackedView, index)	1719	+	})
1537	-	})
1538	-	}
1539		}	1720		}
1540		}	1721		}
1541	-
1542	-	log.Info().
1543	-	Str("popup_pane", string(input.PopupPane.ID)).
1544	-	Int("stack_size", len(stackNode.Children)).
1545	-	Msg("popup inserted as stacked pane")
1546	-
1547		return nil	1722		return nil
1548		}	1723		}
1549			1724

M internal/ui/dispatcher/keyboard.go +132 -125


@@ -2,6 +2,7 @@ package dispatcher
2			2
3		import (	3		import (
4		"context"	4		"context"
			5	+	"fmt"
5			6
6		"github.com/bnema/dumber/internal/application/usecase"	7		"github.com/bnema/dumber/internal/application/usecase"
7		"github.com/bnema/dumber/internal/domain/entity"	8		"github.com/bnema/dumber/internal/domain/entity"

@@ -19,6 +20,7 @@ type KeyboardDispatcher struct {
19		navCoord *coordinator.NavigationCoordinator	20		navCoord *coordinator.NavigationCoordinator
20		zoomUC *usecase.ManageZoomUseCase	21		zoomUC *usecase.ManageZoomUseCase
21		copyURLUC *usecase.CopyURLUseCase	22		copyURLUC *usecase.CopyURLUseCase
			23	+	actionHandlers map[input.Action]func(ctx context.Context) error
22		onQuit func()	24		onQuit func()
23		onFindOpen func(ctx context.Context) error	25		onFindOpen func(ctx context.Context) error
24		onFindNext func(ctx context.Context) error	26		onFindNext func(ctx context.Context) error

@@ -38,13 +40,15 @@ func NewKeyboardDispatcher(
38		log := logging.FromContext(ctx)	40		log := logging.FromContext(ctx)
39		log.Debug().Msg("creating keyboard dispatcher")	41		log.Debug().Msg("creating keyboard dispatcher")
40			42
41	-	return &KeyboardDispatcher{	43	+	dispatcher := &KeyboardDispatcher{
42		tabCoord: tabCoord,	44		tabCoord: tabCoord,
43		wsCoord: wsCoord,	45		wsCoord: wsCoord,
44		navCoord: navCoord,	46		navCoord: navCoord,
45		zoomUC: zoomUC,	47		zoomUC: zoomUC,
46		copyURLUC: copyURLUC,	48		copyURLUC: copyURLUC,
47		}	49		}
			50	+	dispatcher.initActionHandlers()
			51	+	return dispatcher
48		}	52		}
49			53
50		// SetOnQuit sets the callback for quit action.	54		// SetOnQuit sets the callback for quit action.

@@ -72,135 +76,139 @@ func (d *KeyboardDispatcher) SetOnFindClose(fn func(ctx context.Context) error)
72		d.onFindClose = fn	76		d.onFindClose = fn
73		}	77		}
74			78
			79	+	func (d *KeyboardDispatcher) initActionHandlers() {
			80	+	const (
			81	+	firstTabIndex = 0
			82	+	secondTabIndex = 1
			83	+	thirdTabIndex = 2
			84	+	fourthTabIndex = 3
			85	+	fifthTabIndex = 4
			86	+	sixthTabIndex = 5
			87	+	seventhTabIndex = 6
			88	+	eighthTabIndex = 7
			89	+	ninthTabIndex = 8
			90	+	tenthTabIndex = 9
			91	+	)
			92	+	d.actionHandlers = map[input.Action]func(ctx context.Context) error{
			93	+	// Tab actions
			94	+	input.ActionNewTab: func(ctx context.Context) error { _, err := d.tabCoord.Create(ctx, "about:blank"); return err },
			95	+	input.ActionCloseTab: d.tabCoord.Close,
			96	+	input.ActionNextTab: d.tabCoord.SwitchNext,
			97	+	input.ActionPreviousTab: d.tabCoord.SwitchPrev,
			98	+	input.ActionSwitchLastTab: d.tabCoord.SwitchToLastActive,
			99	+	input.ActionSwitchTabIndex1: func(ctx context.Context) error { return d.tabCoord.SwitchByIndex(ctx, firstTabIndex) },
			100	+	input.ActionSwitchTabIndex2: func(ctx context.Context) error { return d.tabCoord.SwitchByIndex(ctx, secondTabIndex) },
			101	+	input.ActionSwitchTabIndex3: func(ctx context.Context) error { return d.tabCoord.SwitchByIndex(ctx, thirdTabIndex) },
			102	+	input.ActionSwitchTabIndex4: func(ctx context.Context) error { return d.tabCoord.SwitchByIndex(ctx, fourthTabIndex) },
			103	+	input.ActionSwitchTabIndex5: func(ctx context.Context) error { return d.tabCoord.SwitchByIndex(ctx, fifthTabIndex) },
			104	+	input.ActionSwitchTabIndex6: func(ctx context.Context) error { return d.tabCoord.SwitchByIndex(ctx, sixthTabIndex) },
			105	+	input.ActionSwitchTabIndex7: func(ctx context.Context) error { return d.tabCoord.SwitchByIndex(ctx, seventhTabIndex) },
			106	+	input.ActionSwitchTabIndex8: func(ctx context.Context) error { return d.tabCoord.SwitchByIndex(ctx, eighthTabIndex) },
			107	+	input.ActionSwitchTabIndex9: func(ctx context.Context) error { return d.tabCoord.SwitchByIndex(ctx, ninthTabIndex) },
			108	+	input.ActionSwitchTabIndex10: func(ctx context.Context) error { return d.tabCoord.SwitchByIndex(ctx, tenthTabIndex) },
			109	+	input.ActionRenameTab: func(ctx context.Context) error {
			110	+	return d.logNoop(ctx, "rename tab action (not yet implemented)")
			111	+	},
			112	+	// Pane actions
			113	+	input.ActionSplitRight: func(ctx context.Context) error { return d.wsCoord.Split(ctx, usecase.SplitRight) },
			114	+	input.ActionSplitLeft: func(ctx context.Context) error { return d.wsCoord.Split(ctx, usecase.SplitLeft) },
			115	+	input.ActionSplitUp: func(ctx context.Context) error { return d.wsCoord.Split(ctx, usecase.SplitUp) },
			116	+	input.ActionSplitDown: func(ctx context.Context) error { return d.wsCoord.Split(ctx, usecase.SplitDown) },
			117	+	input.ActionClosePane: d.wsCoord.ClosePane,
			118	+	input.ActionStackPane: d.wsCoord.StackPane,
			119	+	input.ActionFocusRight: func(ctx context.Context) error { return d.wsCoord.FocusPane(ctx, usecase.NavRight) },
			120	+	input.ActionFocusLeft: func(ctx context.Context) error { return d.wsCoord.FocusPane(ctx, usecase.NavLeft) },
			121	+	input.ActionFocusUp: func(ctx context.Context) error { return d.wsCoord.FocusPane(ctx, usecase.NavUp) },
			122	+	input.ActionFocusDown: func(ctx context.Context) error { return d.wsCoord.FocusPane(ctx, usecase.NavDown) },
			123	+	// Stack navigation
			124	+	input.ActionStackNavUp: func(ctx context.Context) error { return d.wsCoord.NavigateStack(ctx, "up") },
			125	+	input.ActionStackNavDown: func(ctx context.Context) error { return d.wsCoord.NavigateStack(ctx, "down") },
			126	+	// Navigation
			127	+	input.ActionGoBack: d.navCoord.GoBack,
			128	+	input.ActionGoForward: d.navCoord.GoForward,
			129	+	input.ActionReload: d.navCoord.Reload,
			130	+	input.ActionHardReload: d.navCoord.HardReload,
			131	+	// Zoom actions
			132	+	input.ActionZoomIn: func(ctx context.Context) error { return d.handleZoom(ctx, "in") },
			133	+	input.ActionZoomOut: func(ctx context.Context) error { return d.handleZoom(ctx, "out") },
			134	+	input.ActionZoomReset: func(ctx context.Context) error { return d.handleZoom(ctx, "reset") },
			135	+	// UI
			136	+	input.ActionOpenOmnibox: d.navCoord.OpenOmnibox,
			137	+	input.ActionOpenFind: d.handleFindOpen,
			138	+	input.ActionFindNext: d.handleFindNext,
			139	+	input.ActionFindPrev: d.handleFindPrev,
			140	+	input.ActionCloseFind: d.handleFindClose,
			141	+	input.ActionOpenDevTools: d.navCoord.OpenDevTools,
			142	+	input.ActionToggleFullscreen: func(ctx context.Context) error {
			143	+	return d.logNoop(ctx, "toggle fullscreen action (not yet implemented)")
			144	+	},
			145	+	// Clipboard
			146	+	input.ActionCopyURL: d.handleCopyURL,
			147	+	// Application
			148	+	input.ActionQuit: d.handleQuit,
			149	+	}
			150	+	}
			151	+
75		// Dispatch routes a keyboard action to the appropriate coordinator.	152		// Dispatch routes a keyboard action to the appropriate coordinator.
76		func (d *KeyboardDispatcher) Dispatch(ctx context.Context, action input.Action) error {	153		func (d *KeyboardDispatcher) Dispatch(ctx context.Context, action input.Action) error {
77		log := logging.FromContext(ctx)	154		log := logging.FromContext(ctx)
78		log.Debug().Str("action", string(action)).Msg("dispatching keyboard action")	155		log.Debug().Str("action", string(action)).Msg("dispatching keyboard action")
79			156
80	-	switch action {	157	+	if handler, ok := d.actionHandlers[action]; ok {
81	-	// Tab actions	158	+	return handler(ctx)
82	-	case input.ActionNewTab:	159	+	}
83	-	_, err := d.tabCoord.Create(ctx, "about:blank")	160	+
84	-	return err	161	+	log.Warn().Str("action", string(action)).Msg("unhandled keyboard action")
85	-	case input.ActionCloseTab:	162	+	return nil
86	-	return d.tabCoord.Close(ctx)	163	+	}
87	-	case input.ActionNextTab:
88	-	return d.tabCoord.SwitchNext(ctx)
89	-	case input.ActionPreviousTab:
90	-	return d.tabCoord.SwitchPrev(ctx)
91	-	case input.ActionSwitchLastTab:
92	-	return d.tabCoord.SwitchToLastActive(ctx)
93	-	case input.ActionSwitchTabIndex1:
94	-	return d.tabCoord.SwitchByIndex(ctx, 0)
95	-	case input.ActionSwitchTabIndex2:
96	-	return d.tabCoord.SwitchByIndex(ctx, 1)
97	-	case input.ActionSwitchTabIndex3:
98	-	return d.tabCoord.SwitchByIndex(ctx, 2)
99	-	case input.ActionSwitchTabIndex4:
100	-	return d.tabCoord.SwitchByIndex(ctx, 3)
101	-	case input.ActionSwitchTabIndex5:
102	-	return d.tabCoord.SwitchByIndex(ctx, 4)
103	-	case input.ActionSwitchTabIndex6:
104	-	return d.tabCoord.SwitchByIndex(ctx, 5)
105	-	case input.ActionSwitchTabIndex7:
106	-	return d.tabCoord.SwitchByIndex(ctx, 6)
107	-	case input.ActionSwitchTabIndex8:
108	-	return d.tabCoord.SwitchByIndex(ctx, 7)
109	-	case input.ActionSwitchTabIndex9:
110	-	return d.tabCoord.SwitchByIndex(ctx, 8)
111	-	case input.ActionSwitchTabIndex10:
112	-	return d.tabCoord.SwitchByIndex(ctx, 9)
113	-	case input.ActionRenameTab:
114	-	log.Debug().Msg("rename tab action (not yet implemented)")
115	-
116	-	// Pane actions
117	-	case input.ActionSplitRight:
118	-	return d.wsCoord.Split(ctx, usecase.SplitRight)
119	-	case input.ActionSplitLeft:
120	-	return d.wsCoord.Split(ctx, usecase.SplitLeft)
121	-	case input.ActionSplitUp:
122	-	return d.wsCoord.Split(ctx, usecase.SplitUp)
123	-	case input.ActionSplitDown:
124	-	return d.wsCoord.Split(ctx, usecase.SplitDown)
125	-	case input.ActionClosePane:
126	-	return d.wsCoord.ClosePane(ctx)
127	-	case input.ActionStackPane:
128	-	return d.wsCoord.StackPane(ctx)
129	-	case input.ActionFocusRight:
130	-	return d.wsCoord.FocusPane(ctx, usecase.NavRight)
131	-	case input.ActionFocusLeft:
132	-	return d.wsCoord.FocusPane(ctx, usecase.NavLeft)
133	-	case input.ActionFocusUp:
134	-	return d.wsCoord.FocusPane(ctx, usecase.NavUp)
135	-	case input.ActionFocusDown:
136	-	return d.wsCoord.FocusPane(ctx, usecase.NavDown)
137	-
138	-	// Stack navigation
139	-	case input.ActionStackNavUp:
140	-	return d.wsCoord.NavigateStack(ctx, "up")
141	-	case input.ActionStackNavDown:
142	-	return d.wsCoord.NavigateStack(ctx, "down")
143	-
144	-	// Navigation
145	-	case input.ActionGoBack:
146	-	return d.navCoord.GoBack(ctx)
147	-	case input.ActionGoForward:
148	-	return d.navCoord.GoForward(ctx)
149	-	case input.ActionReload:
150	-	return d.navCoord.Reload(ctx)
151	-	case input.ActionHardReload:
152	-	return d.navCoord.HardReload(ctx)
153	-
154	-	// Zoom actions
155	-	case input.ActionZoomIn:
156	-	return d.handleZoom(ctx, "in")
157	-	case input.ActionZoomOut:
158	-	return d.handleZoom(ctx, "out")
159	-	case input.ActionZoomReset:
160	-	return d.handleZoom(ctx, "reset")
161	-
162	-	// UI
163	-	case input.ActionOpenOmnibox:
164	-	return d.navCoord.OpenOmnibox(ctx)
165	-	case input.ActionOpenFind:
166	-	if d.onFindOpen != nil {
167	-	return d.onFindOpen(ctx)
168	-	}
169	-	log.Debug().Msg("find open action (no handler)")
170	-	case input.ActionFindNext:
171	-	if d.onFindNext != nil {
172	-	return d.onFindNext(ctx)
173	-	}
174	-	log.Debug().Msg("find next action (no handler)")
175	-	case input.ActionFindPrev:
176	-	if d.onFindPrev != nil {
177	-	return d.onFindPrev(ctx)
178	-	}
179	-	log.Debug().Msg("find prev action (no handler)")
180	-	case input.ActionCloseFind:
181	-	if d.onFindClose != nil {
182	-	return d.onFindClose(ctx)
183	-	}
184	-	log.Debug().Msg("find close action (no handler)")
185	-	case input.ActionOpenDevTools:
186	-	return d.navCoord.OpenDevTools(ctx)
187	-	case input.ActionToggleFullscreen:
188	-	log.Debug().Msg("toggle fullscreen action (not yet implemented)")
189	-
190	-	// Clipboard
191	-	case input.ActionCopyURL:
192	-	return d.handleCopyURL(ctx)
193	-
194	-	// Application
195	-	case input.ActionQuit:
196	-	if d.onQuit != nil {
197	-	d.onQuit()
198	-	}
199			164
200	-	default:	165	+	func (d *KeyboardDispatcher) handleFindOpen(ctx context.Context) error {
201	-	log.Warn().Str("action", string(action)).Msg("unhandled keyboard action")	166	+	if d.onFindOpen != nil {
			167	+	return d.onFindOpen(ctx)
202		}	168		}
			169	+	logging.FromContext(ctx).Debug().Msg("find open action (no handler)")
			170	+	return nil
			171	+	}
203			172
			173	+	func (d *KeyboardDispatcher) handleFindNext(ctx context.Context) error {
			174	+	if d.onFindNext != nil {
			175	+	return d.onFindNext(ctx)
			176	+	}
			177	+	logging.FromContext(ctx).Debug().Msg("find next action (no handler)")
			178	+	return nil
			179	+	}
			180	+
			181	+	func (d *KeyboardDispatcher) handleFindPrev(ctx context.Context) error {
			182	+	if d.onFindPrev != nil {
			183	+	return d.onFindPrev(ctx)
			184	+	}
			185	+	logging.FromContext(ctx).Debug().Msg("find prev action (no handler)")
			186	+	return nil
			187	+	}
			188	+
			189	+	func (d *KeyboardDispatcher) handleFindClose(ctx context.Context) error {
			190	+	if d.onFindClose != nil {
			191	+	return d.onFindClose(ctx)
			192	+	}
			193	+	logging.FromContext(ctx).Debug().Msg("find close action (no handler)")
			194	+	return nil
			195	+	}
			196	+
			197	+	func (d *KeyboardDispatcher) logNoop(ctx context.Context, message string) error {
			198	+	if ctx == nil {
			199	+	return fmt.Errorf("missing context")
			200	+	}
			201	+	logging.FromContext(ctx).Debug().Msg(message)
			202	+	return nil
			203	+	}
			204	+
			205	+	func (d *KeyboardDispatcher) handleQuit(ctx context.Context) error {
			206	+	if d.onQuit != nil {
			207	+	d.onQuit()
			208	+	}
			209	+	if ctx == nil {
			210	+	return fmt.Errorf("missing context")
			211	+	}
204		return nil	212		return nil
205		}	213		}
206			214

@@ -297,11 +305,10 @@ func (d *KeyboardDispatcher) handleCopyURL(ctx context.Context) error {
297		}	305		}
298			306
299		// Show toast on GTK main thread	307		// Show toast on GTK main thread
300	-	var cb glib.SourceFunc	308	+	cb := glib.SourceFunc(func(_ uintptr) bool {
301	-	cb = func(_ uintptr) bool {
302		d.wsCoord.ShowToastOnActivePane(ctx, "URL copied", component.ToastSuccess)	309		d.wsCoord.ShowToastOnActivePane(ctx, "URL copied", component.ToastSuccess)
303		return false	310		return false
304	-	}	311	+	})
305		glib.IdleAdd(&cb, 0)	312		glib.IdleAdd(&cb, 0)
306		}()	313		}()
307			314

M internal/ui/input/gesture.go +1 -1


@@ -64,7 +64,7 @@ func (h GestureHandler) AttachTo(widget gtk.Widget) {
64		h.clickGesture.SetButton(0)	64		h.clickGesture.SetButton(0)
65			65
66		// Connect pressed handler	66		// Connect pressed handler
67	-	pressedCb := func(gesture gtk.GestureClick, nPress int, x float64, y float64) {	67	+	pressedCb := func(_ gtk.GestureClick, nPress int, _ float64, _ float64) {
68		h.handlePressed(nPress)	68		h.handlePressed(nPress)
69		}	69		}
70		h.clickGesture.ConnectPressed(&pressedCb)	70		h.clickGesture.ConnectPressed(&pressedCb)

M internal/ui/input/hover.go +2 -2


@@ -64,13 +64,13 @@ func (h HoverHandler) AttachTo(widget gtk.Widget) {
64		}	64		}
65			65
66		// Connect enter handler with debounce	66		// Connect enter handler with debounce
67	-	enterCb := func(ctrl gtk.EventControllerMotion, x, y float64) {	67	+	enterCb := func(_ gtk.EventControllerMotion, _ float64, _ float64) {
68		h.handleEnter()	68		h.handleEnter()
69		}	69		}
70		h.motionCtrl.ConnectEnter(&enterCb)	70		h.motionCtrl.ConnectEnter(&enterCb)
71			71
72		// Connect leave handler to cancel pending focus	72		// Connect leave handler to cancel pending focus
73	-	leaveCb := func(ctrl gtk.EventControllerMotion) {	73	+	leaveCb := func(_ gtk.EventControllerMotion) {
74		h.handleLeave()	74		h.handleLeave()
75		}	75		}
76		h.motionCtrl.ConnectLeave(&leaveCb)	76		h.motionCtrl.ConnectLeave(&leaveCb)

M internal/ui/input/keyboard.go +20 -3

 	// Action handler callback
 	onAction ActionHandler
+	// Optional bypass check (e.g., omnibox visible)
+	shouldBypass func() bool
 	// GTK controller (nil until attached)
 	controller *gtk.EventControllerKey
 	h.modal.SetOnModeChange(fn)
 }
+// SetShouldBypassInput sets a hook to bypass keyboard handling entirely.
+// When true, events propagate to focused widgets instead.
+func (h *KeyboardHandler) SetShouldBypassInput(fn func() bool) {
+	h.mu.Lock()
+	defer h.mu.Unlock()
+	h.shouldBypass = fn
+}
 // Mode returns the current input mode.
 func (h *KeyboardHandler) Mode() Mode {
 	return h.modal.Mode()
 	h.controller.SetPropagationPhase(gtk.PhaseCaptureValue)
 	// Connect key pressed handler
-	keyPressedCb := func(ctrl gtk.EventControllerKey, keyval uint, keycode uint, state gdk.ModifierType) bool {
+	keyPressedCb := func(_ gtk.EventControllerKey, keyval uint, _ uint, state gdk.ModifierType) bool {
-		return h.handleKeyPress(keyval, keycode, state)
+		return h.handleKeyPress(keyval, state)
 	}
 	h.controller.ConnectKeyPressed(&keyPressedCb)
 // handleKeyPress processes a key press event.
 // Returns true if the event was handled and should not propagate further.
-func (h *KeyboardHandler) handleKeyPress(keyval uint, keycode uint, state gdk.ModifierType) bool {
+func (h *KeyboardHandler) handleKeyPress(keyval uint, state gdk.ModifierType) bool {
+	h.mu.RLock()
+	shouldBypass := h.shouldBypass
+	h.mu.RUnlock()
+	if shouldBypass != nil && shouldBypass() {
+		return false
+	}
 	// Build KeyBinding from event
 	modifiers := Modifier(state) & modifierMask
 	binding := KeyBinding{

M internal/ui/input/modal_test.go +1 -1


@@ -225,7 +225,7 @@ func TestModalState_ExitCancelsTimeout(t *testing.T) {
225			225
226		// Callback should not have been called again	226		// Callback should not have been called again
227		if callCount != 2 {	227		if callCount != 2 {
228	-	t.Errorf("callback count = %d, want 2 (timeout should have been cancelled)", callCount)	228	+	t.Errorf("callback count = %d, want 2 (timeout should have been canceled)", callCount)
229		}	229		}
230		}	230		}
231			231

M internal/ui/input/shortcuts.go +107 -127

 // modifierMask filters out non-standard modifiers from GDK state.
 const modifierMask = ModCtrl | ModShift | ModAlt
+var keyvalByName = map[string]uint{
+	"escape":    uint(gdk.KEY_Escape),
+	"esc":       uint(gdk.KEY_Escape),
+	"return":    uint(gdk.KEY_Return),
+	"enter":     uint(gdk.KEY_Return),
+	"tab":       uint(gdk.KEY_Tab),
+	"space":     uint(gdk.KEY_space),
+	"backspace": uint(gdk.KEY_BackSpace),
+	"delete":    uint(gdk.KEY_Delete),
+	"del":       uint(gdk.KEY_Delete),
+	"home":      uint(gdk.KEY_Home),
+	"end":       uint(gdk.KEY_End),
+	"pageup":    uint(gdk.KEY_Page_Up),
+	"page_up":   uint(gdk.KEY_Page_Up),
+	"pagedown":  uint(gdk.KEY_Page_Down),
+	"page_down": uint(gdk.KEY_Page_Down),
+	"left":      uint(gdk.KEY_Left),
+	"arrowleft": uint(gdk.KEY_Left),
+	"right":     uint(gdk.KEY_Right),
+	"arrowright": uint(gdk.KEY_Right),
+	"up":        uint(gdk.KEY_Up),
+	"arrowup":   uint(gdk.KEY_Up),
+	"down":      uint(gdk.KEY_Down),
+	"arrowdown": uint(gdk.KEY_Down),
+	"f1":        uint(gdk.KEY_F1),
+	"f2":        uint(gdk.KEY_F2),
+	"f3":        uint(gdk.KEY_F3),
+	"f4":        uint(gdk.KEY_F4),
+	"f5":        uint(gdk.KEY_F5),
+	"f6":        uint(gdk.KEY_F6),
+	"f7":        uint(gdk.KEY_F7),
+	"f8":        uint(gdk.KEY_F8),
+	"f9":        uint(gdk.KEY_F9),
+	"f10":       uint(gdk.KEY_F10),
+	"f11":       uint(gdk.KEY_F11),
+	"f12":       uint(gdk.KEY_F12),
+	"plus":      uint(gdk.KEY_plus),
+	"+":         uint(gdk.KEY_plus),
+	"minus":     uint(gdk.KEY_minus),
+	"-":         uint(gdk.KEY_minus),
+	"equal":     uint(gdk.KEY_equal),
+	"=":         uint(gdk.KEY_equal),
+	"0":         uint(gdk.KEY_0),
+	"1":         uint(gdk.KEY_1),
+	"2":         uint(gdk.KEY_2),
+	"3":         uint(gdk.KEY_3),
+	"4":         uint(gdk.KEY_4),
+	"5":         uint(gdk.KEY_5),
+	"6":         uint(gdk.KEY_6),
+	"7":         uint(gdk.KEY_7),
+	"8":         uint(gdk.KEY_8),
+	"9":         uint(gdk.KEY_9),
+}
 // KeyBinding represents a single key combination.
 type KeyBinding struct {
 	Keyval    uint     // GDK key value (e.g., gdk.KEY_t)
 // buildGlobalShortcuts populates global shortcuts from config.
 func (s *ShortcutSet) buildGlobalShortcuts(ctx context.Context, cfg *config.WorkspaceConfig) {
+	s.registerActivationShortcuts(ctx, cfg)
+	s.registerConfiguredShortcuts(cfg)
+	s.registerStandardShortcuts()
+	s.registerPaneNavigationShortcuts()
+	s.registerTabSwitchShortcuts()
+}
+// buildTabModeShortcuts populates tab mode shortcuts from config.
+func (s *ShortcutSet) buildTabModeShortcuts(ctx context.Context, cfg *config.WorkspaceConfig) {
+	s.buildModeShortcuts(ctx, cfg.TabMode.GetKeyBindings(), s.TabMode, "tab")
+}
+// buildPaneModeShortcuts populates pane mode shortcuts from config.
+func (s *ShortcutSet) buildPaneModeShortcuts(ctx context.Context, cfg *config.WorkspaceConfig) {
+	s.buildModeShortcuts(ctx, cfg.PaneMode.GetKeyBindings(), s.PaneMode, "pane")
+}
+func (s *ShortcutSet) registerActivationShortcuts(ctx context.Context, cfg *config.WorkspaceConfig) {
 	log := logging.FromContext(ctx)
-	// Mode entry from activation shortcuts
 	if binding, ok := ParseKeyString(cfg.TabMode.ActivationShortcut); ok {
 		s.Global[binding] = ActionEnterTabMode
-		log.Trace().Str("shortcut", cfg.TabMode.ActivationShortcut).Uint("keyval", binding.Keyval).Uint("mod", uint(binding.Modifiers)).Msg("tab mode activation registered")
+		log.Trace().
+			Str("shortcut", cfg.TabMode.ActivationShortcut).
+			Uint("keyval", binding.Keyval).
+			Uint("mod", uint(binding.Modifiers)).
+			Msg("tab mode activation registered")
 	} else {
 		log.Warn().Str("shortcut", cfg.TabMode.ActivationShortcut).Msg("failed to parse tab mode activation shortcut")
 	}
 	if binding, ok := ParseKeyString(cfg.PaneMode.ActivationShortcut); ok {
 		s.Global[binding] = ActionEnterPaneMode
-		log.Trace().Str("shortcut", cfg.PaneMode.ActivationShortcut).Uint("keyval", binding.Keyval).Uint("mod", uint(binding.Modifiers)).Msg("pane mode activation registered")
+		log.Trace().
+			Str("shortcut", cfg.PaneMode.ActivationShortcut).
+			Uint("keyval", binding.Keyval).
+			Uint("mod", uint(binding.Modifiers)).
+			Msg("pane mode activation registered")
 	} else {
 		log.Warn().Str("shortcut", cfg.PaneMode.ActivationShortcut).Msg("failed to parse pane mode activation shortcut")
 	}
+}
+func (s *ShortcutSet) registerConfiguredShortcuts(cfg *config.WorkspaceConfig) {
 	// Note: Ctrl+T is NOT registered globally - it enters tab mode.
 	// In tab mode, use:
 	//   n = new tab
 	if binding, ok := ParseKeyString(cfg.Shortcuts.PreviousTab); ok {
 		s.Global[binding] = ActionPreviousTab // Ctrl+Shift+Tab
 	}
+}
-	// Standard browser shortcuts (hardcoded defaults)
+func (s *ShortcutSet) registerStandardShortcuts() {
 	s.Global[KeyBinding{uint(gdk.KEY_l), ModCtrl}] = ActionOpenOmnibox
 	s.Global[KeyBinding{uint(gdk.KEY_f), ModCtrl}] = ActionOpenFind
 	s.Global[KeyBinding{uint(gdk.KEY_F3), ModNone}] = ActionFindNext
 	s.Global[KeyBinding{uint(gdk.KEY_q), ModCtrl}] = ActionQuit
 	s.Global[KeyBinding{uint(gdk.KEY_F11), ModNone}] = ActionToggleFullscreen
 	s.Global[KeyBinding{uint(gdk.KEY_C), ModCtrl | ModShift}] = ActionCopyURL
+}
-	// Pane navigation (Alt+HJKL like vim)
+func (s *ShortcutSet) registerPaneNavigationShortcuts() {
 	s.Global[KeyBinding{uint(gdk.KEY_h), ModAlt}] = ActionFocusLeft
 	s.Global[KeyBinding{uint(gdk.KEY_l), ModAlt}] = ActionFocusRight
 	s.Global[KeyBinding{uint(gdk.KEY_k), ModAlt}] = ActionFocusUp
 	s.Global[KeyBinding{uint(gdk.KEY_j), ModAlt}] = ActionFocusDown
-	// Also support Alt+Arrow keys for pane navigation (except Left/Right used for back/forward)
 	s.Global[KeyBinding{uint(gdk.KEY_Up), ModAlt}] = ActionFocusUp
 	s.Global[KeyBinding{uint(gdk.KEY_Down), ModAlt}] = ActionFocusDown
+}
-	// Direct tab switching (Alt+1-9, Alt+0 for tab 10)
+func (s *ShortcutSet) registerTabSwitchShortcuts() {
 	s.Global[KeyBinding{uint(gdk.KEY_1), ModAlt}] = ActionSwitchTabIndex1
 	s.Global[KeyBinding{uint(gdk.KEY_2), ModAlt}] = ActionSwitchTabIndex2
 	s.Global[KeyBinding{uint(gdk.KEY_3), ModAlt}] = ActionSwitchTabIndex3
 	s.Global[KeyBinding{uint(gdk.KEY_9), ModAlt}] = ActionSwitchTabIndex9
 	s.Global[KeyBinding{uint(gdk.KEY_0), ModAlt}] = ActionSwitchTabIndex10
-	// Alt+Tab style switching (switch to last active tab)
 	s.Global[KeyBinding{uint(gdk.KEY_Tab), ModAlt}] = ActionSwitchLastTab
 	s.Global[KeyBinding{uint(gdk.KEY_Tab), ModAlt | ModShift}] = ActionSwitchLastTab
 }
-// buildTabModeShortcuts populates tab mode shortcuts from config.
+func (s *ShortcutSet) buildModeShortcuts(ctx context.Context, bindings map[string]string, dest map[KeyBinding]Action, mode string) {
-func (s *ShortcutSet) buildTabModeShortcuts(ctx context.Context, cfg *config.WorkspaceConfig) {
-	log := logging.FromContext(ctx)
-	bindings := cfg.TabMode.GetKeyBindings()
-	var registered, parseErrors, unknownActions int
-	for key, configAction := range bindings {
-		if binding, ok := ParseKeyString(key); ok {
-			if action := mapConfigAction(configAction); action != "" {
-				s.TabMode[binding] = action
-				registered++
-				log.Trace().Str("key", key).Str("configAction", configAction).Str("action", string(action)).Uint("keyval", binding.Keyval).Msg("tab mode shortcut registered")
-			} else {
-				unknownActions++
-				log.Warn().Str("key", key).Str("configAction", configAction).Msg("unknown config action in tab mode")
-			}
-		} else {
-			parseErrors++
-			log.Warn().Str("key", key).Msg("failed to parse tab mode key")
-		}
-	}
-	log.Debug().Int("registered", registered).Int("parseErrors", parseErrors).Int("unknownActions", unknownActions).Msg("tab mode shortcuts built")
-}
-// buildPaneModeShortcuts populates pane mode shortcuts from config.
-func (s *ShortcutSet) buildPaneModeShortcuts(ctx context.Context, cfg *config.WorkspaceConfig) {
 	log := logging.FromContext(ctx)
-	bindings := cfg.PaneMode.GetKeyBindings()
 	var registered, parseErrors, unknownActions int
 	for key, configAction := range bindings {
 		if binding, ok := ParseKeyString(key); ok {
 			if action := mapConfigAction(configAction); action != "" {
-				s.PaneMode[binding] = action
+				dest[binding] = action
 				registered++
-				log.Trace().Str("key", key).Str("configAction", configAction).Str("action", string(action)).Uint("keyval", binding.Keyval).Msg("pane mode shortcut registered")
+				log.Trace().
+					Str("key", key).
+					Str("configAction", configAction).
+					Str("action", string(action)).
+					Uint("keyval", binding.Keyval).
+					Msg(mode + " mode shortcut registered")
 			} else {
 				unknownActions++
-				log.Warn().Str("key", key).Str("configAction", configAction).Msg("unknown config action in pane mode")
+				log.Warn().Str("key", key).Str("configAction", configAction).Msg("unknown config action in " + mode + " mode")
 			}
 		} else {
 			parseErrors++
-			log.Warn().Str("key", key).Msg("failed to parse pane mode key")
+			log.Warn().Str("key", key).Msg("failed to parse " + mode + " mode key")
 		}
 	}
-	log.Debug().Int("registered", registered).Int("parseErrors", parseErrors).Int("unknownActions", unknownActions).Msg("pane mode shortcuts built")
+	log.Debug().
+		Int("registered", registered).
+		Int("parseErrors", parseErrors).
+		Int("unknownActions", unknownActions).
+		Msg(mode + " mode shortcuts built")
 }
 // mapConfigAction maps config action names to Action constants.
 // stringToKeyval converts a key name to its GDK keyval.
 func stringToKeyval(s string) (uint, bool) {
-	// Special keys
+	if keyval, ok := keyvalByName[s]; ok {
-	switch s {
+		return keyval, true
-	case "escape", "esc":
-		return uint(gdk.KEY_Escape), true
-	case "return", "enter":
-		return uint(gdk.KEY_Return), true
-	case "tab":
-		return uint(gdk.KEY_Tab), true
-	case "space":
-		return uint(gdk.KEY_space), true
-	case "backspace":
-		return uint(gdk.KEY_BackSpace), true
-	case "delete", "del":
-		return uint(gdk.KEY_Delete), true
-	case "home":
-		return uint(gdk.KEY_Home), true
-	case "end":
-		return uint(gdk.KEY_End), true
-	case "pageup", "page_up":
-		return uint(gdk.KEY_Page_Up), true
-	case "pagedown", "page_down":
-		return uint(gdk.KEY_Page_Down), true
-	// Arrow keys
-	case "left", "arrowleft":
-		return uint(gdk.KEY_Left), true
-	case "right", "arrowright":
-		return uint(gdk.KEY_Right), true
-	case "up", "arrowup":
-		return uint(gdk.KEY_Up), true
-	case "down", "arrowdown":
-		return uint(gdk.KEY_Down), true
-	// Function keys
-	case "f1":
-		return uint(gdk.KEY_F1), true
-	case "f2":
-		return uint(gdk.KEY_F2), true
-	case "f3":
-		return uint(gdk.KEY_F3), true
-	case "f4":
-		return uint(gdk.KEY_F4), true
-	case "f5":
-		return uint(gdk.KEY_F5), true
-	case "f6":
-		return uint(gdk.KEY_F6), true
-	case "f7":
-		return uint(gdk.KEY_F7), true
-	case "f8":
-		return uint(gdk.KEY_F8), true
-	case "f9":
-		return uint(gdk.KEY_F9), true
-	case "f10":
-		return uint(gdk.KEY_F10), true
-	case "f11":
-		return uint(gdk.KEY_F11), true
-	case "f12":
-		return uint(gdk.KEY_F12), true
-	// Symbols
-	case "plus", "+":
-		return uint(gdk.KEY_plus), true
-	case "minus", "-":
-		return uint(gdk.KEY_minus), true
-	case "equal", "=":
-		return uint(gdk.KEY_equal), true
-	// Numbers
-	case "0":
-		return uint(gdk.KEY_0), true
-	case "1":
-		return uint(gdk.KEY_1), true
-	case "2":
-		return uint(gdk.KEY_2), true
-	case "3":
-		return uint(gdk.KEY_3), true
-	case "4":
-		return uint(gdk.KEY_4), true
-	case "5":
-		return uint(gdk.KEY_5), true
-	case "6":
-		return uint(gdk.KEY_6), true
-	case "7":
-		return uint(gdk.KEY_7), true
-	case "8":
-		return uint(gdk.KEY_8), true
-	case "9":
-		return uint(gdk.KEY_9), true
 	}
 	// Single letter keys (a-z)

M internal/ui/layout/gtk_widgets.go +4 -4


@@ -156,7 +156,7 @@ func (p *gtkPaned) SetWideHandle(wide bool) { p.inner.SetWideHandle(wide) }
156		func (p *gtkPaned) GetWideHandle() bool { return p.inner.GetWideHandle() }	156		func (p *gtkPaned) GetWideHandle() bool { return p.inner.GetWideHandle() }
157			157
158		func (p *gtkPaned) ConnectMap(callback func()) uint32 {	158		func (p *gtkPaned) ConnectMap(callback func()) uint32 {
159	-	cb := func(w gtk.Widget) {	159	+	cb := func(_ gtk.Widget) {
160		callback()	160		callback()
161		}	161		}
162		return p.inner.ConnectMap(&cb)	162		return p.inner.ConnectMap(&cb)

@@ -245,7 +245,7 @@ func (b *gtkBox) Remove(child Widget) {
245		b.inner.Remove(child.GtkWidget())	245		b.inner.Remove(child.GtkWidget())
246		}	246		}
247			247
248	-	func (b *gtkBox) InsertChildAfter(child Widget, sibling Widget) {	248	+	func (b *gtkBox) InsertChildAfter(child, sibling Widget) {
249		if child == nil {	249		if child == nil {
250		return	250		return
251		}	251		}

@@ -256,7 +256,7 @@ func (b *gtkBox) InsertChildAfter(child Widget, sibling Widget) {
256		b.inner.InsertChildAfter(child.GtkWidget(), sibGtk)	256		b.inner.InsertChildAfter(child.GtkWidget(), sibGtk)
257		}	257		}
258			258
259	-	func (b *gtkBox) ReorderChildAfter(child Widget, sibling Widget) {	259	+	func (b *gtkBox) ReorderChildAfter(child, sibling Widget) {
260		if child == nil {	260		if child == nil {
261		return	261		return
262		}	262		}

@@ -524,7 +524,7 @@ func (btn *gtkButton) GetChild() Widget {
524		}	524		}
525			525
526		func (btn *gtkButton) ConnectClicked(callback func()) uint32 {	526		func (btn *gtkButton) ConnectClicked(callback func()) uint32 {
527	-	cb := func(b gtk.Button) {	527	+	cb := func(_ gtk.Button) {
528		callback()	528		callback()
529		}	529		}
530		return btn.inner.ConnectClicked(&cb)	530		return btn.inner.ConnectClicked(&cb)

M internal/ui/layout/split.go +4 -1

 // NewSplitView creates a new split view with the given orientation and children.
 // The ratio determines the initial divider position (0.0-1.0).
-func NewSplitView(ctx context.Context, factory WidgetFactory, orientation Orientation, startChild, endChild Widget, ratio float64) *SplitView {
+func NewSplitView(
+	ctx context.Context, factory WidgetFactory, orientation Orientation,
+	startChild, endChild Widget, ratio float64,
+) *SplitView {
 	log := logging.FromContext(ctx)
 	paned := factory.NewPaned(orientation)

M internal/ui/layout/split_test.go +4 -4


@@ -55,7 +55,7 @@ func TestNewSplitView_Horizontal(t *testing.T) {
55		// Assert	55		// Assert
56		require.NotNil(t, sv)	56		require.NotNil(t, sv)
57		assert.Equal(t, layout.OrientationHorizontal, sv.Orientation())	57		assert.Equal(t, layout.OrientationHorizontal, sv.Orientation())
58	-	assert.Equal(t, 0.5, sv.GetRatio())	58	+	assert.InEpsilon(t, 0.5, sv.GetRatio(), 0.0001)
59		assert.Equal(t, mockStartChild, sv.StartChild())	59		assert.Equal(t, mockStartChild, sv.StartChild())
60		assert.Equal(t, mockEndChild, sv.EndChild())	60		assert.Equal(t, mockEndChild, sv.EndChild())
61		}	61		}

@@ -131,7 +131,7 @@ func TestSetRatio_ValidRange(t *testing.T) {
131		sv.SetRatio(tt.input)	131		sv.SetRatio(tt.input)
132			132
133		// Assert	133		// Assert
134	-	assert.Equal(t, tt.expected, sv.GetRatio())	134	+	assert.InEpsilon(t, tt.expected, sv.GetRatio(), 0.0001)
135		})	135		})
136		}	136		}
137		}	137		}

@@ -164,7 +164,7 @@ func TestSetRatio_OutOfRange_Clamped(t *testing.T) {
164		sv.SetRatio(tt.input)	164		sv.SetRatio(tt.input)
165			165
166		// Assert	166		// Assert
167	-	assert.Equal(t, tt.expected, sv.GetRatio())	167	+	assert.InEpsilon(t, tt.expected, sv.GetRatio(), 0.0001)
168		})	168		})
169		}	169		}
170		}	170		}

@@ -368,7 +368,7 @@ func TestNewSplitView_InitialRatio_Clamped(t *testing.T) {
368		sv := layout.NewSplitView(ctx, mockFactory, layout.OrientationHorizontal, nil, nil, tt.input)	368		sv := layout.NewSplitView(ctx, mockFactory, layout.OrientationHorizontal, nil, nil, tt.input)
369			369
370		// Assert	370		// Assert
371	-	assert.Equal(t, tt.expected, sv.GetRatio())	371	+	assert.InEpsilon(t, tt.expected, sv.GetRatio(), 0.0001)
372		})	372		})
373		}	373		}
374		}	374		}

M internal/ui/layout/stacked.go +4 -2

 // ErrCannotRemoveLastPane is returned when trying to remove the last pane from a stack.
 var ErrCannotRemoveLastPane = errors.New("cannot remove last pane from stack")
+const stackedTitleMaxWidthChars = 30
 // stackedPane represents a single pane within a stacked container.
 type stackedPane struct {
 	titleBar  BoxWidget // horizontal box with favicon + title label
 	// Create title label
 	label := sv.factory.NewLabel(title)
 	label.SetEllipsize(EllipsizeEnd)
-	label.SetMaxWidthChars(30)
+	label.SetMaxWidthChars(stackedTitleMaxWidthChars)
 	label.SetHexpand(true)
 	label.SetXalign(0.0)
 	titleBar.Append(label)
 	// Create title label
 	label := sv.factory.NewLabel(title)
 	label.SetEllipsize(EllipsizeEnd)
-	label.SetMaxWidthChars(30)
+	label.SetMaxWidthChars(stackedTitleMaxWidthChars)
 	label.SetHexpand(true)
 	label.SetXalign(0.0)
 	titleBar.Append(label)

M internal/ui/layout/stacked_test.go +81 -23

 	// Arrange
 	ctx := context.Background()
 	mockFactory, mockBox := setupMockFactory(t)
-	mockTitleBar, _, _, _, mockContainer := setupPaneMocks(t, mockFactory, mockBox)
+	mockTitleBar, mockFavicon, mockLabel, mockButton, mockContainer := setupPaneMocks(t, mockFactory, mockBox)
+	_ = mockFavicon
+	_ = mockLabel
+	_ = mockButton
 	// Visibility updates for active pane
 	mockTitleBar.EXPECT().GetParent().Return(nil).Maybe()
 	mockFactory, mockBox := setupMockFactory(t)
 	// First pane
-	mockTitleBar1, _, _, _, mockContainer1 := setupPaneMocks(t, mockFactory, mockBox)
+	mockTitleBar1, mockFavicon1, mockLabel1, mockButton1, mockContainer1 := setupPaneMocks(t, mockFactory, mockBox)
+	_ = mockFavicon1
+	_ = mockLabel1
+	_ = mockButton1
 	mockTitleBar1.EXPECT().GetParent().Return(nil).Maybe()
 	mockContainer1.EXPECT().SetVisible(true).Once()
 	mockTitleBar1.EXPECT().AddCssClass("active").Once()
 	// Second pane - first pane becomes inactive
-	mockTitleBar2, _, _, _, mockContainer2 := setupPaneMocks(t, mockFactory, mockBox)
+	mockTitleBar2, mockFavicon2, mockLabel2, mockButton2, mockContainer2 := setupPaneMocks(t, mockFactory, mockBox)
+	_ = mockFavicon2
+	_ = mockLabel2
+	_ = mockButton2
 	// When second pane is added, update visibility for both
 	mockTitleBar1.EXPECT().GetParent().Return(nil).Maybe()
 	// Arrange
 	ctx := context.Background()
 	mockFactory, mockBox := setupMockFactory(t)
-	mockTitleBar, _, _, _, mockContainer := setupPaneMocks(t, mockFactory, mockBox)
+	mockTitleBar, mockFavicon, mockLabel, mockButton, mockContainer := setupPaneMocks(t, mockFactory, mockBox)
+	_ = mockFavicon
+	_ = mockLabel
+	_ = mockButton
 	mockTitleBar.EXPECT().GetParent().Return(nil).Maybe()
 	mockContainer.EXPECT().SetVisible(true).Once()
 	err := sv.RemovePane(ctx, 0)
 	// Assert
-	assert.ErrorIs(t, err, layout.ErrCannotRemoveLastPane)
+	require.ErrorIs(t, err, layout.ErrCannotRemoveLastPane)
 	assert.Equal(t, 1, sv.Count())
 }
 	err := sv.RemovePane(ctx, 0)
 	// Assert
-	assert.ErrorIs(t, err, layout.ErrStackEmpty)
+	require.ErrorIs(t, err, layout.ErrStackEmpty)
 }
 func TestRemovePane_IndexOutOfBounds(t *testing.T) {
 	// Arrange
 	ctx := context.Background()
 	mockFactory, mockBox := setupMockFactory(t)
-	mockTitleBar, _, _, _, mockContainer := setupPaneMocks(t, mockFactory, mockBox)
+	mockTitleBar, mockFavicon, mockLabel, mockButton, mockContainer := setupPaneMocks(t, mockFactory, mockBox)
+	_ = mockFavicon
+	_ = mockLabel
+	_ = mockButton
 	mockTitleBar.EXPECT().GetParent().Return(nil).Maybe()
 	mockContainer.EXPECT().SetVisible(true).Once()
 	err := sv.RemovePane(ctx, 5)
 	// Assert
-	assert.ErrorIs(t, err, layout.ErrIndexOutOfBounds)
+	require.ErrorIs(t, err, layout.ErrIndexOutOfBounds)
 }
 func TestSetActive_ValidIndex(t *testing.T) {
 	titleBars := make([]*mocks.MockBoxWidget, 2)
 	for i := 0; i < 2; i++ {
-		titleBars[i], _, _, _, containers[i] = setupPaneMocks(t, mockFactory, mockBox)
+		titleBar, mockFavicon, mockOverlay, mockSpinner, container := setupPaneMocks(t, mockFactory, mockBox)
+		_ = mockFavicon
+		_ = mockOverlay
+		_ = mockSpinner
+		titleBars[i] = titleBar
+		containers[i] = container
 		titleBars[i].EXPECT().GetParent().Return(nil).Maybe()
 		containers[i].EXPECT().SetVisible(mock.Anything).Maybe()
 		titleBars[i].EXPECT().AddCssClass("active").Maybe()
 	// Arrange
 	ctx := context.Background()
 	mockFactory, mockBox := setupMockFactory(t)
-	mockTitleBar, _, _, _, mockContainer := setupPaneMocks(t, mockFactory, mockBox)
+	mockTitleBar, mockFavicon, mockLabel, mockButton, mockContainer := setupPaneMocks(t, mockFactory, mockBox)
+	_ = mockFavicon
+	_ = mockLabel
+	_ = mockButton
 	mockTitleBar.EXPECT().GetParent().Return(nil).Maybe()
 	mockContainer.EXPECT().SetVisible(true).Once()
 	err := sv.SetActive(ctx, 5)
 	// Assert
-	assert.ErrorIs(t, err, layout.ErrIndexOutOfBounds)
+	require.ErrorIs(t, err, layout.ErrIndexOutOfBounds)
 }
 func TestSetActive_EmptyStack(t *testing.T) {
 	err := sv.SetActive(ctx, 0)
 	// Assert
-	assert.ErrorIs(t, err, layout.ErrStackEmpty)
+	require.ErrorIs(t, err, layout.ErrStackEmpty)
 }
 func TestUpdateTitle(t *testing.T) {
 	err := sv.UpdateTitle(0, "Title")
 	// Assert
-	assert.ErrorIs(t, err, layout.ErrIndexOutOfBounds)
+	require.ErrorIs(t, err, layout.ErrIndexOutOfBounds)
 }
 func TestUpdateFavicon(t *testing.T) {
 	// Arrange
 	ctx := context.Background()
 	mockFactory, mockBox := setupMockFactory(t)
-	mockTitleBar, _, _, _, mockContainer := setupPaneMocks(t, mockFactory, mockBox)
+	mockTitleBar, mockFavicon, mockOverlay, mockSpinner, mockContainer := setupPaneMocks(t, mockFactory, mockBox)
+	_ = mockFavicon
+	_ = mockOverlay
+	_ = mockSpinner
 	mockTitleBar.EXPECT().GetParent().Return(nil).Maybe()
 	mockContainer.EXPECT().SetVisible(true).Once()
 	container, err := sv.GetContainer(0)
 	// Assert
-	assert.ErrorIs(t, err, layout.ErrIndexOutOfBounds)
+	require.ErrorIs(t, err, layout.ErrIndexOutOfBounds)
 	assert.Nil(t, container)
 }
 	titleBars := make([]*mocks.MockBoxWidget, 2)
 	for i := 0; i < 2; i++ {
-		titleBars[i], _, _, _, containers[i] = setupPaneMocks(t, mockFactory, mockBox)
+		titleBar, mockFavicon, mockOverlay, mockSpinner, container := setupPaneMocks(t, mockFactory, mockBox)
+		_ = mockFavicon
+		_ = mockOverlay
+		_ = mockSpinner
+		titleBars[i] = titleBar
+		containers[i] = container
 		titleBars[i].EXPECT().GetParent().Return(nil).Maybe()
 		containers[i].EXPECT().SetVisible(mock.Anything).Maybe()
 		titleBars[i].EXPECT().AddCssClass("active").Maybe()
 	titleBars := make([]*mocks.MockBoxWidget, 2)
 	for i := 0; i < 2; i++ {
-		titleBars[i], _, _, _, containers[i] = setupPaneMocks(t, mockFactory, mockBox)
+		titleBar, mockFavicon, mockOverlay, mockSpinner, container := setupPaneMocks(t, mockFactory, mockBox)
+		_ = mockFavicon
+		_ = mockOverlay
+		_ = mockSpinner
+		titleBars[i] = titleBar
+		containers[i] = container
 		titleBars[i].EXPECT().GetParent().Return(nil).Maybe()
 		containers[i].EXPECT().SetVisible(mock.Anything).Maybe()
 		titleBars[i].EXPECT().AddCssClass("active").Maybe()
 	err := sv.NavigateNext(ctx)
 	// Assert
-	assert.ErrorIs(t, err, layout.ErrStackEmpty)
+	require.ErrorIs(t, err, layout.ErrStackEmpty)
 }
 func TestNavigatePrevious_EmptyStack(t *testing.T) {
 	err := sv.NavigatePrevious(ctx)
 	// Assert
-	assert.ErrorIs(t, err, layout.ErrStackEmpty)
+	require.ErrorIs(t, err, layout.ErrStackEmpty)
 }
 func TestSetOnActivate_Callback(t *testing.T) {
 	mockFactory, mockBox := setupMockFactory(t)
 	// First pane - appended normally
-	mockTitleBar1, _, _, _, mockContainer1 := setupPaneMocks(t, mockFactory, mockBox)
+	mockTitleBar1, mockFavicon1, mockOverlay1, mockSpinner1, mockContainer1 := setupPaneMocks(t, mockFactory, mockBox)
+	_ = mockFavicon1
+	_ = mockOverlay1
+	_ = mockSpinner1
 	mockTitleBar1.EXPECT().GetParent().Return(nil).Maybe()
 	mockContainer1.EXPECT().SetVisible(true).Once()
 	mockTitleBar1.EXPECT().AddCssClass("active").Once()
 	mockFactory, mockBox := setupMockFactory(t)
 	// First pane
-	mockTitleBar1, _, _, _, mockContainer1 := setupPaneMocks(t, mockFactory, mockBox)
+	mockTitleBar1, mockFavicon1, mockOverlay1, mockSpinner1, mockContainer1 := setupPaneMocks(t, mockFactory, mockBox)
+	_ = mockFavicon1
+	_ = mockOverlay1
+	_ = mockSpinner1
 	mockTitleBar1.EXPECT().GetParent().Return(nil).Maybe()
 	mockContainer1.EXPECT().SetVisible(true).Once()
 	mockTitleBar1.EXPECT().AddCssClass("active").Once()
 	titleBars := make([]*mocks.MockBoxWidget, 3)
 	for i := 0; i < 3; i++ {
-		titleBars[i], _, _, _, containers[i] = setupPaneMocks(t, mockFactory, mockBox)
+		titleBar, mockFavicon, mockOverlay, mockSpinner, container := setupPaneMocks(t, mockFactory, mockBox)
+		_ = mockFavicon
+		_ = mockOverlay
+		_ = mockSpinner
+		titleBars[i] = titleBar
+		containers[i] = container
 		titleBars[i].EXPECT().GetParent().Return(nil).Maybe()
 		containers[i].EXPECT().SetVisible(mock.Anything).Maybe()
 		titleBars[i].EXPECT().AddCssClass("active").Maybe()
 	mockFactory, mockBox := setupMockFactory(t)
 	// First pane
-	mockTitleBar1, _, _, _, mockContainer1 := setupPaneMocks(t, mockFactory, mockBox)
+	mockTitleBar1, mockFavicon1, mockOverlay1, mockSpinner1, mockContainer1 := setupPaneMocks(t, mockFactory, mockBox)
+	_ = mockFavicon1
+	_ = mockOverlay1
+	_ = mockSpinner1
 	mockTitleBar1.EXPECT().GetParent().Return(nil).Maybe()
 	mockContainer1.EXPECT().SetVisible(true).Once()
 	mockTitleBar1.EXPECT().AddCssClass("active").Once()

M internal/ui/layout/tree_test.go +4 -1

 	mockStackBox.EXPECT().SetHexpand(true).Once()
 	mockStackBox.EXPECT().SetVexpand(true).Once()
-	mockTitleBar, _, _, _, mockContainer := setupPaneMocks(t, mockFactory, mockStackBox)
+	mockTitleBar, mockFavicon, mockOverlay, mockSpinner, mockContainer := setupPaneMocks(t, mockFactory, mockStackBox)
+	_ = mockFavicon
+	_ = mockOverlay
+	_ = mockSpinner
 	mockTitleBar.EXPECT().GetParent().Return(nil).Maybe()
 	mockContainer.EXPECT().SetVisible(true).Once()
 	mockTitleBar.EXPECT().AddCssClass("active").Once()

M internal/ui/theme/find_highlight.go +2 -1


@@ -9,7 +9,8 @@ import (
9		// GenerateFindHighlightCSS builds CSS to style find-in-page matches using the accent color.	9		// GenerateFindHighlightCSS builds CSS to style find-in-page matches using the accent color.
10		func GenerateFindHighlightCSS(p Palette) string {	10		func GenerateFindHighlightCSS(p Palette) string {
11		accent := strings.TrimSpace(p.Accent)	11		accent := strings.TrimSpace(p.Accent)
12	-	dim := rgbaFromHex(accent, 0.50)	12	+	const highlightDimAlpha = 0.5
			13	+	dim := rgbaFromHex(accent, highlightDimAlpha)
13		active := accent	14		active := accent
14			15
15		return fmt.Sprintf(`/* Find highlight styling */	16		return fmt.Sprintf(`/* Find highlight styling */