fix(stats): preserve season boundaries during AniList merge resolution

- Allow manual cross-season reassignment without merging entries
- Require validated title matches for automatic merges
- Share title normalization across AniList and stats flows

src/core/services/immersion-tracker/__tests__/anime-merge.test.ts

@@ -560,6 +560,35 @@ test('resolveAnimeAnilistConflict leaves explicit incompatible seasons and assig
   });
 });
 
+test('manual AniList resolution reassigns across explicit seasons without merging them', () => {
+  withDb((db) => {
+    insertAnime(db, {
+      animeId: 1,
+      key: 'show season 1',
+      title: 'Show Season 1',
+      anilistId: 163132,
+      titleRomaji: 'Show',
+    });
+    insertAnime(db, { animeId: 2, key: 'show season 2', title: 'Show Season 2' });
+    insertEpisode(db, { videoId: 1, animeId: 1, season: 1 });
+    insertEpisode(db, { videoId: 2, animeId: 2, season: 2 });
+
+    const summary = resolveAnimeAnilistConflict(db, 2, 163132, { survivor: 'target' });
+
+    assert.equal(summary.anilistAssignmentBlocked, false);
+    assert.deepEqual(animeIds(db), [1, 2]);
+    const assignments = db
+      .prepare(
+        'SELECT anime_id AS animeId, anilist_id AS anilistId FROM imm_anime ORDER BY anime_id',
+      )
+      .all() as Array<{ animeId: number; anilistId: number | null }>;
+    assert.deepEqual(assignments, [
+      { animeId: 1, anilistId: null },
+      { animeId: 2, anilistId: 163132 },
+    ]);
+  });
+});
+
 test('automatic AniList update does not transfer an assignment across explicit seasons', () => {
   withDb((db) => {
     insertAnime(db, {
@@ -596,6 +625,55 @@ test('automatic AniList update does not transfer an assignment across explicit s
   });
 });
 
+test('automatic AniList update with unknown match confidence validates stored titles', () => {
+  withDb((db) => {
+    insertAnime(db, {
+      animeId: 1,
+      key: 'actual show',
+      title: 'Actual Show',
+      anilistId: 163132,
+      titleRomaji: 'Actual Show',
+    });
+    insertAnime(db, { animeId: 2, key: 'unrelated release', title: 'Unrelated Release' });
+    insertEpisode(db, { videoId: 1, animeId: 1, season: 1 });
+    insertEpisode(db, { videoId: 2, animeId: 2, season: 1 });
+
+    updateAnimeAnilistInfo(db, 2, {
+      anilistId: 163132,
+      titleRomaji: 'Actual Show',
+      titleEnglish: null,
+      titleNative: null,
+      episodesTotal: 12,
+    });
+
+    assert.deepEqual(animeIds(db), [1, 2]);
+    assert.equal(videoAnimeId(db, 2), 2);
+    assert.deepEqual(getAnimeMergeRecommendations(db), [{ recommendationId: 1, animeIds: [1, 2] }]);
+  });
+});
+
+test('stored AniList titles ignore season suffixes when validating an automatic merge', () => {
+  withDb((db) => {
+    insertAnime(db, {
+      animeId: 1,
+      key: 'legacy show',
+      title: 'Show Season 1',
+      anilistId: 163132,
+      titleRomaji: 'Show Season 1',
+    });
+    insertAnime(db, { animeId: 2, key: 'show season 1', title: 'Show Season 1' });
+    insertEpisode(db, { videoId: 1, animeId: 1, season: 1 });
+    insertEpisode(db, { videoId: 2, animeId: 2, season: 1 });
+
+    const summary = resolveAnimeAnilistConflict(db, 2, 163132);
+
+    assert.equal(summary.deletedAnimeRows, 1);
+    assert.deepEqual(animeIds(db), [1]);
+    assert.equal(videoAnimeId(db, 2), 1);
+    assert.deepEqual(getAnimeMergeRecommendations(db), []);
+  });
+});
+
 test('resolveAnimeAnilistConflict leaves an entry that already links elsewhere alone', () => {
   withDb((db) => {
     insertAnime(db, { animeId: 1, key: 'show', title: 'Show', anilistId: 163132 });

src/core/services/immersion-tracker/anime-merge-recommendations.ts

@@ -66,7 +66,7 @@ export function hasExactStoredTitleMatch(
     conflict.canonical_title,
   ]
     .filter((title): title is string => Boolean(title?.trim()))
-    .map(normalizeAnimeIdentityKey)
+    .map((title) => normalizeAnimeIdentityKey(stripSeasonIdentitySuffix(title)))
     .filter(Boolean);
   return targetKeys.some((key) => anilistTitleKeys.includes(key));
 }

src/core/services/immersion-tracker/anime-season-repair.ts

@@ -392,6 +392,7 @@ export function resolveAnimeAnilistConflict(
     const targetSeasons = getParsedSeasonsForAnime(db, targetAnimeId);
     const conflictSeasons = getParsedSeasonsForAnime(db, conflict.animeId);
     if (
+      !isManual &&
       targetSeasons.size === 1 &&
       conflictSeasons.size === 1 &&
       [...targetSeasons][0] !== [...conflictSeasons][0]

src/core/services/immersion-tracker/query-maintenance.ts

@@ -427,7 +427,8 @@ export function updateAnimeAnilistInfo(
   if (!row?.anime_id) return;
 
   const repair = resolveAnimeAnilistConflict(db, row.anime_id, info.anilistId, {
-    matchConfidence: info.exactTitleMatch === false ? 'weak' : 'exact',
+    matchConfidence:
+      info.exactTitleMatch === true ? 'exact' : info.exactTitleMatch === false ? 'weak' : undefined,
   });
   if (repair.mergeRecommended || repair.anilistAssignmentBlocked) return;
   const targetRow = db

src/core/services/immersion-tracker/storage.ts

@@ -1,5 +1,6 @@
 import { createHash } from 'node:crypto';
 import { parseMediaInfo } from '../../../jimaku/utils';
+import { normalizeTitleIdentity } from '../../utils/title-normalization';
 import type { DatabaseSync } from './sqlite';
 import { nowMs } from './time';
 import { SCHEMA_VERSION } from './types';
@@ -319,14 +320,7 @@ export function applyPragmas(db: DatabaseSync): void {
   db.exec(`PRAGMA journal_size_limit = ${WAL_JOURNAL_SIZE_LIMIT_BYTES}`);
 }
 
-export function normalizeAnimeIdentityKey(title: string): string {
-  return title
-    .normalize('NFKC')
-    .toLowerCase()
-    .replace(/[^\p{L}\p{N}]+/gu, ' ')
-    .trim()
-    .replace(/\s+/g, ' ');
-}
+export const normalizeAnimeIdentityKey = normalizeTitleIdentity;
 
 function normalizeSeasonScope(value: number | null | undefined): number | null {
   if (typeof value !== 'number' || !Number.isSafeInteger(value) || value <= 0) {