feat(playlists): reset a playlist to its YouTube state (discard local edits)

The in-session undo/redo is lost when switching playlists, leaving no way to undo
local edits to a YouTube-linked list afterwards. Add a per-playlist 'Reset to YouTube'
action (shown when a linked playlist is dirty) that force-repulls that single playlist
from YouTube, replacing its items/order/name and clearing dirty — even though the bulk
read-sync skips dirty playlists. Backend: repull_playlist() + POST /api/playlists/
{id}/revert-youtube (read-scope gated). Confirm dialog (destructive). Trilingual.

backend/app/routes/playlists.py

@@ -10,7 +10,12 @@ from app.auth import current_user, has_read_scope, has_write_scope
 from app.db import get_db
 from app.models import Channel, Playlist, PlaylistItem, User, Video, VideoState
 from app.routes.feed import _saved_expr, _serialize
-from app.sync.playlists import plan_push, push_playlist, sync_user_playlists
+from app.sync.playlists import (
+    plan_push,
+    push_playlist,
+    repull_playlist,
+    sync_user_playlists,
+)
 from app.youtube.client import YouTubeClient, YouTubeError
 
 router = APIRouter(prefix="/api/playlists", tags=["playlists"])
@@ -251,6 +256,30 @@ def sync_youtube(
         return sync_user_playlists(db, user)
 
 
+@router.post("/{playlist_id}/revert-youtube")
+def revert_youtube(
+    playlist_id: int,
+    user: User = Depends(current_user),
+    db: Session = Depends(get_db),
+) -> dict:
+    """Reset one YouTube-linked playlist to its current YouTube state, discarding local
+    edits (and clearing the dirty flag). The user-facing 'undo all my changes' for a list
+    once the in-session undo history is gone."""
+    pl = _own_playlist(db, user, playlist_id)
+    if not pl.yt_playlist_id:
+        raise HTTPException(status_code=400, detail="This playlist isn't linked to YouTube.")
+    if not has_read_scope(user):
+        raise HTTPException(
+            status_code=403, detail="Connect YouTube (read access) to sync your playlists."
+        )
+    try:
+        with quota.attribute(user.id, "playlist_sync"):
+            return repull_playlist(db, user, pl)
+    except YouTubeError:
+        db.rollback()
+        raise HTTPException(status_code=502, detail="Couldn't refresh from YouTube.")
+
+
 def _pushable(db: Session, user: User, playlist_id: int) -> Playlist:
     """A local playlist the user may push to YouTube (create or update). The built-in
     Watch later and read-only YouTube mirrors are never pushable."""

backend/app/sync/playlists.py

@@ -305,6 +305,39 @@ def push_playlist(db: Session, user: User, pl: Playlist) -> dict:
     }
 
 
+def repull_playlist(db: Session, user: User, pl: Playlist) -> dict:
+    """Force-refresh ONE YouTube-linked playlist from YouTube, discarding local edits and
+    clearing dirty. This is the per-playlist 'reset to YouTube' — unlike the bulk read-sync
+    it deliberately does NOT skip a dirty playlist (overwriting local changes is the point).
+    Works for both mirrors (source='youtube') and exported local playlists (yt_playlist_id)."""
+    if not pl.yt_playlist_id:
+        raise YouTubeError("Playlist is not linked to YouTube")
+    with YouTubeClient(db, user) as yt:
+        snippet = yt.get_playlist_snippet(pl.yt_playlist_id)
+        if snippet is None:
+            raise YouTubeError("Playlist no longer exists on YouTube")
+        ids = list(yt.iter_my_playlist_video_ids(pl.yt_playlist_id))
+        _ensure_videos(db, yt, ids)
+        present = (
+            set(db.execute(select(Video.id).where(Video.id.in_(ids))).scalars().all())
+            if ids
+            else set()
+        )
+        ordered: list[str] = []
+        seen: set[str] = set()
+        for v in ids:
+            if v in present and v not in seen:
+                seen.add(v)
+                ordered.append(v)
+        pl.name = snippet.get("title") or pl.name
+        db.execute(delete(PlaylistItem).where(PlaylistItem.playlist_id == pl.id))
+        for pos, vid in enumerate(ordered):
+            db.add(PlaylistItem(playlist_id=pl.id, video_id=vid, position=pos))
+        pl.dirty = False
+        db.commit()
+    return {"items": len(ordered)}
+
+
 def sync_all_playlists(db: Session) -> dict:
     """Scheduler entry point: mirror playlists for every user with a read scope + token."""
     users = (