Fix mono path bg + tune bg synthesis thresholds

Validated with real-wallpaper extraction across ~/Wallpapers (sunset,
forest, kanagawa, nord, everforest, ship-at-sea, moon, etc.):

- Apply bg synthesis to monochrome path (synthesizeMonoBgIfMuddy) with
  a relaxed L>0.35 threshold so themed wallpapers (Nord at L≈0.32,
  Tokyo Night, Catppuccin) keep their iconic backgrounds, but genuinely
  muddy mono-mode bg's still get cleaned up
- Loosen chroma caps in chromatic bg synthesis (0.030→0.05 dark,
  0.025→0.04 light) so saturated dark backgrounds keep visible tint
- Use absolute target lightness (0.97/0.05) in FindForegroundColor's
  synthesized fallback instead of bgL ± 0.65, guaranteeing 7:1+ contrast
  without conditional math

Cache version bumped to 7.

Author: bjarneo

internal/extraction/analysis.go

@@ -135,15 +135,16 @@ func FindForegroundColor(colors []string, lightMode bool, bgColor string, usedIn
 		return colors[candidates[0].index], candidates[0].index
 	}
 
-	// Fallback: synthesize a foreground at the right contrast. Returns -1 for index
-	// so callers don't lock a real pool color out of ANSI assignment based on a
-	// color that isn't actually the synthesized fg.
+	// Fallback: synthesize a foreground at the contrast extreme. Absolute targets
+	// (0.97 / 0.05) guarantee 7:1+ contrast against any sane bg without conditional
+	// math. Returns -1 for index so callers don't lock a real pool color out of
+	// ANSI assignment based on a color that isn't actually the synthesized fg.
 	bgLab := color.HexToOKLab(bgColor)
 	fgLab := color.HexToOKLab(fgColor)
 	if bgLab.L < 0.5 {
-		fgLab.L = math.Min(1.0, bgLab.L+0.65)
+		fgLab.L = 0.97
 	} else {
-		fgLab.L = math.Max(0.0, bgLab.L-0.65)
+		fgLab.L = 0.05
 	}
 	return color.OKLabToHex(fgLab), -1
 }

internal/extraction/constants.go

@@ -2,7 +2,7 @@ package extraction
 
 const (
 	ANSIPaletteSize   = 16
-	CacheVersion      = 6 // Bumped: auto-extract pipeline fixes (outlier loop, scoring, bg synth)
+	CacheVersion      = 7 // Bumped: mono bg synthesis + relaxed thresholds
 	ImageScaleSize    = 400
 	MinPixelsToSample = 1000
 	MaxPixelsToSample = 50000

internal/extraction/palette_chromatic.go

@@ -70,19 +70,20 @@ func extractChromaticHues(dominantColors []string, lightMode bool) [16]string {
 
 // synthesizeBgIfTooMid replaces a mid-lightness image bg with a synthesized OKLCH
 // color at a sane bg lightness, preserving hue. Without this, images with no truly
-// dark/light pixels (e.g. a sunset photo) produce muddy backgrounds.
+// dark/light pixels (e.g. a sunset photo or a Nord-themed wallpaper) produce muddy
+// backgrounds. Chroma is loosely capped — saturated bg's stay visibly tinted.
 func synthesizeBgIfTooMid(bgColor string, lightMode bool) string {
 	lch := color.HexToOKLCH(bgColor)
 	if lightMode {
 		if lch.L >= 0.85 {
 			return bgColor
 		}
-		return color.OKLCHToHex(color.OKLCH{L: 0.94, C: math.Min(lch.C, 0.025), H: lch.H})
+		return color.OKLCHToHex(color.OKLCH{L: 0.94, C: math.Min(lch.C, 0.04), H: lch.H})
 	}
 	if lch.L <= 0.20 {
 		return bgColor
 	}
-	return color.OKLCHToHex(color.OKLCH{L: 0.12, C: math.Min(lch.C, 0.030), H: lch.H})
+	return color.OKLCHToHex(color.OKLCH{L: 0.12, C: math.Min(lch.C, 0.05), H: lch.H})
 }
 
 // GenerateChromaticPalette: vibrant chromatic palette from image-derived hues.

internal/extraction/palette_monochrome.go

@@ -6,6 +6,24 @@ import (
 	"aether/internal/color"
 )
 
+// synthesizeMonoBgIfMuddy is a more conservative variant of synthesizeBgIfTooMid for
+// the monochrome path. It only kicks in when the image bg is clearly muddy
+// (L > 0.35 in dark mode, < 0.75 in light mode), preserving the iconic muted
+// backgrounds of themed wallpapers like Nord (L≈0.32) or Tokyo Night (L≈0.21).
+func synthesizeMonoBgIfMuddy(bgColor string, lightMode bool) string {
+	lch := color.HexToOKLCH(bgColor)
+	if lightMode {
+		if lch.L >= 0.75 {
+			return bgColor
+		}
+		return color.OKLCHToHex(color.OKLCH{L: 0.94, C: math.Min(lch.C, 0.04), H: lch.H})
+	}
+	if lch.L <= 0.35 {
+		return bgColor
+	}
+	return color.OKLCHToHex(color.OKLCH{L: 0.14, C: math.Min(lch.C, 0.06), H: lch.H})
+}
+
 // detectMonochromeTint detects the dominant tint hue from mostly-gray colors
 // using weighted circular mean in OKLCH space. Colors with more chroma get more weight.
 func detectMonochromeTint(colors []string) (hue float64, hasTint bool) {
@@ -51,23 +69,24 @@ func GenerateMonochromePalette(grayColors []string, lightMode bool) [16]string {
 
 	var palette [16]string
 
-	// Background and foreground from actual image extremes
-	palette[0] = darkest.Color
-	palette[7] = lightest.Color
+	// Mono path treats the image AS the theme — keep image-derived bg unless it's
+	// genuinely muddy (L > 0.35 dark / < 0.75 light), so themed wallpapers
+	// (Nord, Tokyo Night, etc.) keep their authentic colors.
 	if lightMode {
-		palette[0] = lightest.Color
+		palette[0] = synthesizeMonoBgIfMuddy(lightest.Color, lightMode)
 		palette[7] = darkest.Color
+	} else {
+		palette[0] = synthesizeMonoBgIfMuddy(darkest.Color, lightMode)
+		palette[7] = lightest.Color
 	}
 
-	// Ensure bg/fg have sufficient contrast
-	contrast := color.ContrastRatio(palette[0], palette[7])
-	if contrast < MinFgBgContrast {
+	if color.ContrastRatio(palette[0], palette[7]) < MinFgBgContrast {
 		bgLab := color.HexToOKLab(palette[0])
 		fgLab := color.HexToOKLab(palette[7])
 		if bgLab.L < 0.5 {
-			fgLab.L = math.Min(1.0, bgLab.L+0.65)
+			fgLab.L = 0.97
 		} else {
-			fgLab.L = math.Max(0.0, bgLab.L-0.65)
+			fgLab.L = 0.05
 		}
 		palette[7] = color.OKLabToHex(fgLab)
 	}