fix: address code review findings

- Strip standalone reissue keywords (remaster/remastered/remix/deluxe/
  expanded/edition/reissue/anniversary/bonus) regardless of brackets so
  non-parenthesized remasters still match the plain local title above the
  0.85 threshold (was falsely reported missing).
- Fix TestAppRun_ScanLogsMissingReleases to verify run() performs the
  scan itself (capture its log output) instead of re-running ScanAll
  independently, which passed even if run() were a no-op.
- Fix TestSimilarity misleading cases that downgraded to a <0.85 range
  check with dead want/epsilon fields; assert actual computed scores.

internal/normalize/normalize.go

@@ -17,6 +17,12 @@ var (
 	bracketRe = regexp.MustCompile(`\[[^\]]*\]`)
 	parenRe   = regexp.MustCompile(`\([^)]*\)`)
 	yearRe    = regexp.MustCompile(`\b[0-9]{4}\b`)
+	// keywordRe strips common reissue/edition keywords that appear WITHOUT
+	// brackets or parentheses (e.g. "The Wall 2011 Remaster", "Album 2020
+	// Remastered", "X Deluxe"). MusicBrainz release-group titles frequently
+	// carry these as free-standing words; they must be removed so a remaster
+	// still matches the plain local title above the fuzzy threshold.
+	keywordRe = regexp.MustCompile(`(?i)\b(remaster|remastered|remix|deluxe|expanded|edition|reissue|anniversary|bonus)\b`)
 	spaceRe   = regexp.MustCompile(`\s+`)
 	// bareYearRe matches a title that is *only* a single year (with optional
 	// surrounding whitespace), e.g. "1989" or "2112". Used to decide whether a
@@ -46,6 +52,12 @@ func NormalizeString(s string) string {
 	// Remove parenthesized content (e.g., (Deluxe), (Remastered))
 	s = parenRe.ReplaceAllString(s, "")
 
+	// Remove standalone reissue/edition keywords (e.g. "2011 Remaster",
+	// "2020 Remastered", "Deluxe"). These appear without brackets/parens
+	// in many MusicBrainz titles and must be stripped so a remaster still
+	// matches the plain local title above the fuzzy threshold.
+	s = keywordRe.ReplaceAllString(s, "")
+
 	// Remove years (any 4-digit number). If stripping the year
 	// empties the entire string, decide what to keep:
 	//   - A bare year title (e.g. "1989", "2112") has no other words, so keep

internal/normalize/normalize_test.go

@@ -22,7 +22,12 @@ func TestNormalizeString_Basic(t *testing.T) {
 		{"Album (Remastered)", "album"},
 		// Year removal
 		{"Dark Side of the Moon 1973", "dark side of the moon"},
-		{"Album 2020 Remastered", "album remastered"},
+		// Standalone reissue keywords (no brackets/parens) are stripped
+		{"Album 2020 Remastered", "album"},
+		{"The Wall 2011 Remaster", "the wall"},
+		{"X Deluxe", "x"},
+		{"Y Expanded Edition", "y"},
+		{"Z Remix", "z"},
 		// Space collapsing
 		{"Dark   Side   of   the   Moon", "dark side of the moon"},
 		// Trim

internal/scanner/scanner_test.go

@@ -44,34 +44,30 @@ func TestSimilarity(t *testing.T) {
 			epsilon: 1e-9,
 		},
 		{
-			name:    "clearly different titles score below 0.85",
+			name:    "clearly different titles score low",
 			a:       "The Wall",
 			b:       "Completely Different Album",
-			want:    0.0,
-			epsilon: 1e-9,
+			want:    0.1538,
+			epsilon: 1e-3,
 		},
 		{
-			name:    "substring-ish title scores moderately",
+			name:    "substring-ish title scores moderately below threshold",
 			a:       "Dark Side of the Moon",
 			b:       "Dark Side of the Moon Part II",
-			want:    0.0, // non-empty; value asserted only as below threshold
-			epsilon: 1e-9,
+			want:    0.7241,
+			epsilon: 1e-3,
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			got := Similarity(tt.a, tt.b)
-			switch {
-			case tt.name == "clearly different titles score below 0.85" ||
-				tt.name == "substring-ish title scores moderately":
-				if got >= 0.85 {
-					t.Errorf("Similarity(%q, %q) = %v, want < 0.85", tt.a, tt.b, got)
-				}
-			default:
-				if diff := got - tt.want; diff > tt.epsilon || diff < -tt.epsilon {
-					t.Errorf("Similarity(%q, %q) = %v, want %v (+/- %v)", tt.a, tt.b, got, tt.want, tt.epsilon)
-				}
+			if diff := got - tt.want; diff > tt.epsilon || diff < -tt.epsilon {
+				t.Errorf("Similarity(%q, %q) = %v, want %v (+/- %v)", tt.a, tt.b, got, tt.want, tt.epsilon)
+			}
+			// Sanity: anything at/above the default threshold must be a match.
+			if got >= 0.85 && !IsMatch(tt.a, tt.b, 0) {
+				t.Errorf("Similarity(%q, %q) = %v >= 0.85 but IsMatch(...,0) is false", tt.a, tt.b, got)
 			}
 		})
 	}