fix(continue-watching): clear the resume position when an item is marked watched

Marking a movie or episode watched left it sitting in Continue Watching with a
checkmark, and the only way to shift it was to play it and skip to the end.

Continue Watching membership on a MediaBrowser server is derived from
UserData.PlaybackPositionTicks alone; Played is never consulted. Marking played
normally zeroes that position as a side effect, so the row usually disappears
and nothing ever checked that it had. When something writes a position back
afterwards the item is left played *and* resumable, which the resume route
happily keeps returning forever. markWatched now reads the UserItemDataDto the
mark already returns and clears the bookmark itself when the server left one
behind, so the postcondition holds however the item got into that state. The
follow-up write costs a request only when the invariant is actually broken.

The writer putting items there is our own offline queue. insertWatchAction
already drops queued progress for an item when the mark is itself queued, but
the online mark writes straight to the server and queues nothing, so a progress
row recorded earlier survived and replayed afterwards — pending actions go out
oldest first — restoring the very position the mark had cleared. The sync
service now listens for watch-state events and discards queued progress for
that item as the mark lands. Progress recorded after a mark is a rewatch and is
queued later, so it is untouched. Plex never showed this because it forwards the
recorded-at timestamp and lets the server discard a stale replay; the
MediaBrowser stop report has nowhere to put one.

Continue Watching also drops the row locally now instead of waiting a round trip
for the refetch to confirm it, matching what removal events already did, and
marking a season or show takes its on-deck episode with it.

Watched items are deliberately still not filtered out of the shelf: Jellyfin
keeps Played set when new progress arrives, so a rewatch in progress is
indistinguishable from a stuck row, and filtering would hide it.

close #1812

lib/database/app_database.dart

@@ -984,6 +984,37 @@ class AppDatabase extends _$AppDatabase {
     });
   }
 
+  /// Drop queued `progress` rows for one item, leaving `watched`/`unwatched`
+  /// rows alone. Returns how many were removed.
+  ///
+  /// The mirror of the purge [insertWatchAction] performs: a terminal watch
+  /// state written straight to the server (the online path, which queues
+  /// nothing) also supersedes any progress still waiting to replay. Without
+  /// it, [getPendingWatchActions] hands back the older progress row — it
+  /// orders by `createdAt` — and replaying it rewrites the resume position the
+  /// mark just cleared, pinning the item to Continue Watching (#1812).
+  ///
+  /// Progress queued *after* a mark is a genuine rewatch and is not affected:
+  /// this only runs at the moment the mark lands.
+  Future<int> deleteQueuedProgressForItem({
+    String? profileId,
+    required ServerId serverId,
+    String? clientScopeId,
+    required String ratingKey,
+  }) {
+    return _runPendingMutation(() async {
+      final globalKey = buildGlobalKey(ServerId(serverId), ratingKey);
+      return (delete(offlineWatchProgress)..where(
+            (t) =>
+                t.globalKey.equals(globalKey) &
+                _nullableTextPredicate(t.profileId, profileId) &
+                _nullableTextPredicate(t.clientScopeId, clientScopeId) &
+                t.actionType.equals(OfflineActionType.progress.id),
+          ))
+          .go();
+    });
+  }
+
   /// Delete a specific watch action after successful sync
   Future<void> deleteWatchAction(int id) {
     return _runPendingMutation(() async {

lib/media/media_server_client.dart

@@ -348,6 +348,14 @@ abstract class MediaServerClient {
   /// emission (and tracker fan-out); the offline sync replay calls this
   /// directly precisely because the event already fired when the action was
   /// queued.
+  ///
+  /// Postcondition: once this completes the backend must no longer treat
+  /// [item] as resumable, so it cannot come back from [fetchContinueWatching].
+  /// Plex gets this for free (PMS filters watched items out of its on-deck
+  /// hub). MediaBrowser derives Continue Watching membership purely from
+  /// `UserData.PlaybackPositionTicks > 0`, so its implementation must ensure
+  /// the resume position is cleared rather than assume the played flag did it
+  /// (#1812).
   Future<void> markWatched(MediaItem item);
 
   /// Mark [item] as unwatched. Transport only — see [markWatched].

lib/providers/discover_provider.dart

@@ -489,15 +489,29 @@ class DiscoverProvider extends ChangeNotifier with DisposableChangeNotifierMixin
     }
 
     if (event.changeType == WatchStateChangeType.removedFromContinueWatching) {
-      final remaining = _onDeck.where((item) => item.id != event.itemId).toList();
-      if (remaining.length != _onDeck.length) {
-        _onDeck = remaining;
-        safeNotifyListeners();
-      }
+      _evictFromOnDeck((item) => item.id == event.itemId);
+    } else if (event.changeType == WatchStateChangeType.watched ||
+        (event.changeType == WatchStateChangeType.progressUpdate && event.isNowWatched == true)) {
+      // Finished items have no business in Continue Watching, so drop the row
+      // now instead of waiting a round trip for the refetch below to confirm
+      // it. Marking a season or show watched takes its on-deck episode with
+      // it, matching the parent-aware filter this subscription uses — the
+      // series' successor comes back from the refetch (#1812).
+      _evictFromOnDeck(
+        (item) => item.id == event.itemId || item.parentId == event.itemId || item.grandparentId == event.itemId,
+      );
     }
     unawaited(refreshContinueWatching());
   }
 
+  void _evictFromOnDeck(bool Function(MediaItem item) matches) {
+    final remaining = _onDeck.where((item) => !matches(item)).toList();
+    if (remaining.length == _onDeck.length) return;
+    _onDeck = remaining;
+    safeNotifyListeners();
+    unawaited(_syncSystemShelf(_onDeck));
+  }
+
   /// Everything on screen: the Continue Watching row plus every hub row.
   Iterable<MediaItem> get _visibleItems => _onDeck.followedBy(_hubs.expand((hub) => hub.items));
 

lib/services/jellyfin_client/parts/watch_state.dart

@@ -1,10 +1,41 @@
 part of '../../jellyfin_client.dart';
 
 mixin _JellyfinWatchStateMethods on _JellyfinClientInternals {
+  /// Marking played normally zeroes `UserData.PlaybackPositionTicks` server-side,
+  /// which is what drops the row from Continue Watching — membership on this API
+  /// is derived from the position alone, never from `Played` (verified on
+  /// Jellyfin 10.11.10). Relying on that side effect is not enough: a stale
+  /// playback report replayed from the offline queue, another client, or a
+  /// server-side plugin can leave `Played` set *and* a position behind, and the
+  /// row is then pinned to Continue Watching forever (#1812).
+  ///
+  /// So assert the postcondition instead of assuming it, using the
+  /// `UserItemDataDto` the mark already returns. The follow-up write costs a
+  /// request only when the invariant is actually broken.
+  ///
+  /// Folders (series/season) report their own position as 0 while the server
+  /// resets their children recursively, so nothing extra is owed here.
   @override
   Future<void> markWatched(MediaItem item) async {
     final response = await _http.post(paths.playedItem(item.id), queryParameters: {'userId': connection.userId});
     throwIfHttpError(response);
+
+    final data = response.data;
+    final positionMs = data is Map<String, dynamic> ? jellyfinTicksToMs(data['PlaybackPositionTicks']) : null;
+    if (positionMs == null || positionMs <= 0) return;
+
+    appLogger.d('JellyfinClient: ${item.id} stayed resumable after mark-played; clearing its resume position');
+    await _clearResumePosition(item.id);
+  }
+
+  /// Drop [itemId]'s resume bookmark without touching its played flag.
+  Future<void> _clearResumePosition(String itemId) async {
+    final response = await _http.post(
+      paths.userItemData(itemId),
+      queryParameters: {'userId': connection.userId},
+      body: {'PlaybackPositionTicks': 0},
+    );
+    throwIfHttpError(response);
   }
 
   @override

lib/services/media_browser_paths.dart

@@ -34,6 +34,18 @@ class MediaBrowserPaths {
   String playedItem(String itemId) =>
       dialect.requiresUserScopedItemRoutes ? '$_user/PlayedItems/${_id(itemId)}' : '/UserPlayedItems/${_id(itemId)}';
 
+  /// Per-user playback-state write. `POST` with `{"PlaybackPositionTicks": 0}`
+  /// clears the resume bookmark while leaving `Played` untouched (verified on
+  /// Jellyfin 10.11.10 for both spellings).
+  ///
+  /// Continue Watching membership on this API is derived purely from
+  /// `UserData.PlaybackPositionTicks > 0` — `Played` is not consulted — so this
+  /// is the only route that can guarantee a finished item stops being
+  /// resumable. See [MediaServerClient.markWatched].
+  String userItemData(String itemId) => dialect.requiresUserScopedItemRoutes
+      ? '$_user/Items/${_id(itemId)}/UserData'
+      : '/UserItems/${_id(itemId)}/UserData';
+
   /// Favourite flag write route (`POST` to add, `DELETE` to remove).
   String favoriteItem(String itemId) => dialect.requiresUserScopedItemRoutes
       ? '$_user/FavoriteItems/${_id(itemId)}'

lib/services/offline_watch_sync_service.dart

@@ -86,7 +86,48 @@ class OfflineWatchSyncService extends ChangeNotifier {
   /// silently drops local watch progress.
   static const int maxSyncAttempts = 5;
 
-  OfflineWatchSyncService({required this._database, required this._serverManager});
+  StreamSubscription<WatchStateEvent>? _watchStateSubscription;
+
+  OfflineWatchSyncService({required this._database, required this._serverManager}) {
+    _watchStateSubscription = WatchStateNotifier().stream.listen(_onWatchStateChanged);
+  }
+
+  /// A terminal watch state just landed, so any progress still queued for that
+  /// item is stale and must not replay.
+  ///
+  /// [AppDatabase.insertWatchAction] already purges the queue when the mark is
+  /// itself queued (offline). The online path writes straight to the server and
+  /// queues nothing, so without this the older progress row survives and
+  /// [syncPendingItems] later rewrites the resume position the mark cleared —
+  /// on MediaBrowser that pins the item to Continue Watching for good (#1812).
+  /// Plex is unaffected in practice (PMS discards a replay whose `updated`
+  /// timestamp is stale) but the queue entry is meaningless there too.
+  ///
+  /// Progress recorded *after* the mark is a genuine rewatch: it is queued
+  /// later, so it is never touched here.
+  void _onWatchStateChanged(WatchStateEvent event) {
+    if (_isShutDown) return;
+    if (event.changeType != WatchStateChangeType.watched && event.changeType != WatchStateChangeType.unwatched) {
+      return;
+    }
+    unawaited(_discardQueuedProgress(ServerId(event.serverId), event.itemId));
+  }
+
+  Future<void> _discardQueuedProgress(ServerId serverId, String itemId) async {
+    try {
+      final removed = await _database.deleteQueuedProgressForItem(
+        profileId: _activeProfileId,
+        serverId: serverId,
+        clientScopeId: await _clientScopeIdForItem(serverId, itemId),
+        ratingKey: itemId,
+      );
+      if (removed == 0) return;
+      appLogger.d('Dropped $removed superseded queued progress action(s) for $serverId:$itemId');
+      notifyListeners();
+    } catch (e) {
+      appLogger.w('Failed to drop superseded queued progress for $serverId:$itemId', error: e);
+    }
+  }
 
   /// Whether a sync is currently in progress
   bool get isSyncing => _isSyncing;
@@ -834,6 +875,8 @@ class OfflineWatchSyncService extends ChangeNotifier {
   @override
   void dispose() {
     _isShutDown = true;
+    _watchStateSubscription?.cancel();
+    _watchStateSubscription = null;
     if (_offlineModeSource != null && _offlineModeListener != null) {
       _offlineModeSource!.removeListener(_offlineModeListener!);
     }