Clean up stale Continue Watching entries

Livestreams and ended broadcasts accumulated in every user's resume row because Jellyfin saves a playback position for channel items regardless of whether the position means anything. A livestream has nothing to return to, so the entry stayed pinned forever. Two parts: - PlaybackResumeGuard, an IHostedService on ISessionManager.PlaybackStopped. Jellyfin saves the resume point before raising the event, so the guard zeroes it afterwards for livestreams. Stops new entries at the source. - ResumeCleanupService plus a daily 4 AM task (after the 3 AM expiration check) for the existing backlog. Clears livestreams, resume points older than N days, positions under N seconds and playback past N% of runtime, each threshold configurable. Only plugin-owned items are touched, matched by the SRF provider ID with a fallback to the owning channel ID so recordings are covered too. Clearing sets PlaybackPositionTicks to 0 and leaves Played false: nothing is deleted and the item stays unwatched. Config page gains the thresholds plus "Clean Up Stale Entries Now" and "Clear All SRF Play Entries" buttons, backed by MaintenanceController under RequiresElevation. Also folds the duplicated urn.Contains("livestream") check in MediaSourceFactory and RecordingService into UrnHelper.IsLivestreamUrn. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-12 18:55:41 +02:00
parent a9db0aa09c
commit 1b149c628c
13 changed files with 766 additions and 2 deletions
@@ -0,0 +1,29 @@
+using System.Collections.Generic;
+
+namespace Jellyfin.Plugin.SRFPlay.Api.Models;
+
+/// <summary>
+/// Outcome of a resume point ("Continue Watching") cleanup run.
+/// </summary>
+public class ResumeCleanupResult
+{
+    /// <summary>
+    /// Gets or sets the number of users whose resume list was inspected.
+    /// </summary>
+    public int UsersChecked { get; set; }
+
+    /// <summary>
+    /// Gets or sets the number of plugin-owned resume points that were inspected.
+    /// </summary>
+    public int Inspected { get; set; }
+
+    /// <summary>
+    /// Gets or sets the number of resume points that were cleared.
+    /// </summary>
+    public int Cleared { get; set; }
+
+    /// <summary>
+    /// Gets the number of cleared resume points grouped by the rule that matched.
+    /// </summary>
+    public Dictionary<string, int> ClearedByReason { get; } = new Dictionary<string, int>();
+}
@@ -76,6 +76,11 @@ public class PluginConfiguration : BasePluginConfiguration
        EnabledTopics = new System.Collections.Generic.List<string>();
        GenerateTitleCards = true;
        LiveStartSegmentsBack = 3;
+        CleanUpResumePoints = true;
+        ClearLiveStreamResumePoints = true;
+        ResumePointMaxAgeDays = 30;
+        ResumePointMinPositionSeconds = 60;
+        ResumePointCompletedPercent = 92;
    }

    /// <summary>
@@ -173,4 +178,37 @@ public class PluginConfiguration : BasePluginConfiguration
    /// Set to 0 to disable injection entirely.
    /// </summary>
    public int LiveStartSegmentsBack { get; set; }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether the "Clean Up SRF Play Continue Watching" task
+    /// removes stale resume points. When false the task inspects nothing and clears nothing.
+    /// </summary>
+    public bool CleanUpResumePoints { get; set; }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether resume points for livestreams are cleared.
+    /// A livestream has no meaningful resume position, so stopping one otherwise leaves it
+    /// pinned in "Continue Watching" forever. When enabled the position is also cleared
+    /// immediately on playback stop, not just by the scheduled task.
+    /// </summary>
+    public bool ClearLiveStreamResumePoints { get; set; }
+
+    /// <summary>
+    /// Gets or sets the age in days after which an untouched resume point is cleared.
+    /// Measured from the last time the item was played. Set to 0 to disable the age rule.
+    /// </summary>
+    public int ResumePointMaxAgeDays { get; set; }
+
+    /// <summary>
+    /// Gets or sets the minimum resume position in seconds. Anything at or below this is
+    /// treated as an accidental start rather than something worth resuming.
+    /// Set to 0 to disable the rule.
+    /// </summary>
+    public int ResumePointMinPositionSeconds { get; set; }
+
+    /// <summary>
+    /// Gets or sets the percentage of runtime at or beyond which playback counts as finished.
+    /// Only applied to items with a known runtime. Set to 0 to disable the rule.
+    /// </summary>
+    public int ResumePointCompletedPercent { get; set; }
 }
@@ -88,6 +88,42 @@
                        <div class="fieldDescription">How many segments back from the live edge livestreams start playing. Fixes jumpy/stalling playback at the start on Android TV. Minimum 3 (RFC requirement); 0 disables it. Default 3.</div>
                    </div>
                    <br />
+                    <h2>Continue Watching Cleanup</h2>
+                    <div class="fieldDescription" style="margin-bottom: 1em;">
+                        Livestreams and abandoned playback otherwise stay pinned in every user's
+                        &quot;Continue Watching&quot; row forever. Clearing a resume point only resets the
+                        playback position &mdash; nothing is deleted and the item stays unwatched.
+                    </div>
+                    <div class="checkboxContainer checkboxContainer-withDescription">
+                        <label class="emby-checkbox-label">
+                            <input id="CleanUpResumePoints" name="CleanUpResumePoints" type="checkbox" is="emby-checkbox" />
+                            <span>Clean up stale resume points</span>
+                        </label>
+                        <div class="fieldDescription checkboxFieldDescription">Runs daily at 4 AM (Scheduled Tasks &rarr; &quot;Clean Up SRF Play Continue Watching&quot;)</div>
+                    </div>
+                    <div class="checkboxContainer checkboxContainer-withDescription">
+                        <label class="emby-checkbox-label">
+                            <input id="ClearLiveStreamResumePoints" name="ClearLiveStreamResumePoints" type="checkbox" is="emby-checkbox" />
+                            <span>Never keep a resume point for livestreams</span>
+                        </label>
+                        <div class="fieldDescription checkboxFieldDescription">Clears the position as soon as a livestream stops playing, rather than waiting for the daily task</div>
+                    </div>
+                    <div class="inputContainer">
+                        <label class="inputLabel inputLabelUnfocused" for="ResumePointMaxAgeDays">Maximum Resume Point Age (days)</label>
+                        <input id="ResumePointMaxAgeDays" name="ResumePointMaxAgeDays" type="number" is="emby-input" min="0" max="3650" />
+                        <div class="fieldDescription">Clear resume points not touched for this many days. 0 disables the rule. Default 30.</div>
+                    </div>
+                    <div class="inputContainer">
+                        <label class="inputLabel inputLabelUnfocused" for="ResumePointMinPositionSeconds">Minimum Resume Position (seconds)</label>
+                        <input id="ResumePointMinPositionSeconds" name="ResumePointMinPositionSeconds" type="number" is="emby-input" min="0" max="3600" />
+                        <div class="fieldDescription">Positions at or below this are treated as an accidental start and cleared. 0 disables the rule. Default 60.</div>
+                    </div>
+                    <div class="inputContainer">
+                        <label class="inputLabel inputLabelUnfocused" for="ResumePointCompletedPercent">Finished Threshold (%)</label>
+                        <input id="ResumePointCompletedPercent" name="ResumePointCompletedPercent" type="number" is="emby-input" min="0" max="100" />
+                        <div class="fieldDescription">Playback at or beyond this share of the runtime counts as finished. Only applies when the runtime is known. 0 disables the rule. Default 92.</div>
+                    </div>
+                    <br />
                    <h2>Network Settings</h2>
                    <div class="inputContainer">
                        <label class="inputLabel inputLabelUnfocused" for="PublicServerUrl">Public Server URL (Optional)</label>
@@ -105,6 +141,17 @@
                    </div>
                </form>

+                <br />
+                <h2>Continue Watching Maintenance</h2>
+                <div class="fieldDescription">Run the cleanup right now instead of waiting for the daily task. Only SRF Play items are affected.</div>
+                <div id="resumeCleanupResult" style="margin: 10px 0;"></div>
+                <button is="emby-button" type="button" class="raised emby-button" onclick="SRFPlayMaintenance.cleanupResumePoints(false)" style="margin-bottom: 20px;">
+                    <span>Clean Up Stale Entries Now</span>
+                </button>
+                <button is="emby-button" type="button" class="raised emby-button" onclick="SRFPlayMaintenance.cleanupResumePoints(true)" style="margin-bottom: 20px;">
+                    <span>Clear All SRF Play Entries</span>
+                </button>
+
                <br />
                <h2>Sport Livestream Recordings</h2>

@@ -154,6 +201,11 @@
                        document.querySelector('#PublicServerUrl').value = config.PublicServerUrl || '';
                        document.querySelector('#RecordingOutputPath').value = config.RecordingOutputPath || '';
                        document.querySelector('#LiveStartSegmentsBack').value = config.LiveStartSegmentsBack != null ? config.LiveStartSegmentsBack : 3;
+                        document.querySelector('#CleanUpResumePoints').checked = config.CleanUpResumePoints !== false;
+                        document.querySelector('#ClearLiveStreamResumePoints').checked = config.ClearLiveStreamResumePoints !== false;
+                        document.querySelector('#ResumePointMaxAgeDays').value = config.ResumePointMaxAgeDays != null ? config.ResumePointMaxAgeDays : 30;
+                        document.querySelector('#ResumePointMinPositionSeconds').value = config.ResumePointMinPositionSeconds != null ? config.ResumePointMinPositionSeconds : 60;
+                        document.querySelector('#ResumePointCompletedPercent').value = config.ResumePointCompletedPercent != null ? config.ResumePointCompletedPercent : 92;
                        Dashboard.hideLoadingMsg();

                        // Load recordings UI
@@ -180,6 +232,11 @@
                    config.PublicServerUrl = document.querySelector('#PublicServerUrl').value;
                    config.RecordingOutputPath = document.querySelector('#RecordingOutputPath').value;
                    config.LiveStartSegmentsBack = parseInt(document.querySelector('#LiveStartSegmentsBack').value) || 0;
+                    config.CleanUpResumePoints = document.querySelector('#CleanUpResumePoints').checked;
+                    config.ClearLiveStreamResumePoints = document.querySelector('#ClearLiveStreamResumePoints').checked;
+                    config.ResumePointMaxAgeDays = parseInt(document.querySelector('#ResumePointMaxAgeDays').value) || 0;
+                    config.ResumePointMinPositionSeconds = parseInt(document.querySelector('#ResumePointMinPositionSeconds').value) || 0;
+                    config.ResumePointCompletedPercent = parseInt(document.querySelector('#ResumePointCompletedPercent').value) || 0;
                    ApiClient.updatePluginConfiguration(SRFPlayConfig.pluginUniqueId, config).then(function (result) {
                        Dashboard.processPluginConfigurationUpdateResult(result);
                    });
@@ -189,6 +246,40 @@
                return false;
            });

+            var SRFPlayMaintenance = {
+                cleanupResumePoints: function(clearAll) {
+                    if (clearAll && !confirm('Clear the playback position of every SRF Play item for all users? Nothing is deleted and items stay unwatched.')) {
+                        return;
+                    }
+
+                    var target = document.querySelector('#resumeCleanupResult');
+                    target.innerHTML = '<p><em>Cleaning up...</em></p>';
+
+                    fetch(ApiClient.serverAddress() + '/Plugins/SRFPlay/Maintenance/ResumePoints/Cleanup?clearAll=' + (clearAll ? 'true' : 'false'), {
+                        method: 'POST',
+                        headers: { 'X-Emby-Token': ApiClient.accessToken() }
+                    })
+                    .then(function(response) {
+                        if (!response.ok) {
+                            throw new Error('HTTP ' + response.status);
+                        }
+                        return response.json();
+                    })
+                    .then(function(result) {
+                        var byReason = result.clearedByReason || {};
+                        var reasons = Object.keys(byReason)
+                            .map(function(key) { return key + ': ' + byReason[key]; })
+                            .join(', ');
+                        target.innerHTML = '<p>Cleared <strong>' + result.cleared + '</strong> of ' + result.inspected +
+                            ' SRF Play resume point(s) across ' + result.usersChecked + ' user(s).' +
+                            (reasons ? ' (' + reasons + ')' : '') + '</p>';
+                    })
+                    .catch(function(error) {
+                        target.innerHTML = '<p style="color: #d44;">Cleanup failed: ' + error.message + '</p>';
+                    });
+                }
+            };
+
            var SRFPlayRecordings = {
                apiBase: ApiClient.serverAddress() + '/Plugins/SRFPlay/Recording',

@@ -0,0 +1,53 @@
+using System.Threading;
+using Jellyfin.Plugin.SRFPlay.Api.Models;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+using MediaBrowser.Common.Api;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Controllers;
+
+/// <summary>
+/// Administrative maintenance actions for the SRF Play plugin.
+/// </summary>
+[ApiController]
+[Route("Plugins/SRFPlay/Maintenance")]
+[Authorize(Policy = Policies.RequiresElevation)]
+public class MaintenanceController : ControllerBase
+{
+    private readonly ILogger<MaintenanceController> _logger;
+    private readonly IResumeCleanupService _resumeCleanupService;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="MaintenanceController"/> class.
+    /// </summary>
+    /// <param name="logger">The logger.</param>
+    /// <param name="resumeCleanupService">The resume cleanup service.</param>
+    public MaintenanceController(
+        ILogger<MaintenanceController> logger,
+        IResumeCleanupService resumeCleanupService)
+    {
+        _logger = logger;
+        _resumeCleanupService = resumeCleanupService;
+    }
+
+    /// <summary>
+    /// Clears stale SRF Play resume points from every user's "Continue Watching" row.
+    /// </summary>
+    /// <param name="clearAll">
+    /// When true, clears every SRF Play resume point instead of only the stale ones.
+    /// </param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>A summary of what was inspected and cleared.</returns>
+    [HttpPost("ResumePoints/Cleanup")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    public ActionResult<ResumeCleanupResult> CleanupResumePoints(
+        [FromQuery] bool clearAll,
+        CancellationToken cancellationToken)
+    {
+        _logger.LogInformation("Manual Continue Watching cleanup requested (clearAll: {ClearAll})", clearAll);
+        return Ok(_resumeCleanupService.Cleanup(clearAll, cancellationToken));
+    }
+}
@@ -0,0 +1,87 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+using MediaBrowser.Model.Tasks;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.ScheduledTasks;
+
+/// <summary>
+/// Scheduled task that clears stale SRF Play resume points from "Continue Watching".
+/// </summary>
+public class ResumeCleanupTask : IScheduledTask
+{
+    private readonly ILogger<ResumeCleanupTask> _logger;
+    private readonly IResumeCleanupService _resumeCleanupService;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ResumeCleanupTask"/> class.
+    /// </summary>
+    /// <param name="logger">The logger.</param>
+    /// <param name="resumeCleanupService">The resume cleanup service.</param>
+    public ResumeCleanupTask(
+        ILogger<ResumeCleanupTask> logger,
+        IResumeCleanupService resumeCleanupService)
+    {
+        _logger = logger;
+        _resumeCleanupService = resumeCleanupService;
+    }
+
+    /// <inheritdoc />
+    public string Name => "Clean Up SRF Play Continue Watching";
+
+    /// <inheritdoc />
+    public string Description => "Removes stale SRF Play resume points - ended livestreams, abandoned playback and finished programmes - from every user's Continue Watching row";
+
+    /// <inheritdoc />
+    public string Category => "SRF Play";
+
+    /// <inheritdoc />
+    public string Key => "SRFPlayResumeCleanup";
+
+    /// <inheritdoc />
+    public Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellationToken)
+    {
+        _logger.LogInformation("Starting SRF Play Continue Watching cleanup");
+        progress?.Report(0);
+
+        try
+        {
+            var result = _resumeCleanupService.Cleanup(false, cancellationToken);
+
+            progress?.Report(100);
+            _logger.LogInformation(
+                "SRF Play Continue Watching cleanup completed. Cleared {Cleared} of {Inspected} resume points",
+                result.Cleared,
+                result.Inspected);
+        }
+        catch (OperationCanceledException)
+        {
+            _logger.LogInformation("SRF Play Continue Watching cleanup was cancelled");
+            throw;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error during SRF Play Continue Watching cleanup");
+            throw;
+        }
+
+        return Task.CompletedTask;
+    }
+
+    /// <inheritdoc />
+    public IEnumerable<TaskTriggerInfo> GetDefaultTriggers()
+    {
+        // Runs after the 3 AM expiration check so items deleted there are already gone.
+        return new[]
+        {
+            new TaskTriggerInfo
+            {
+                Type = TaskTriggerInfo.TriggerDaily,
+                TimeOfDayTicks = TimeSpan.FromHours(4).Ticks
+            }
+        };
+    }
+}
@@ -32,6 +32,11 @@ public class ServiceRegistrator : IPluginServiceRegistrator
        serviceCollection.AddSingleton<IContentExpirationService, ContentExpirationService>();
        serviceCollection.AddSingleton<IContentRefreshService, ContentRefreshService>();
        serviceCollection.AddSingleton<ICategoryService, CategoryService>();
+        serviceCollection.AddSingleton<IResumeCleanupService, ResumeCleanupService>();
+
+        // Clears livestream resume points the moment playback stops, so ended broadcasts never
+        // linger in "Continue Watching" waiting for the nightly cleanup task.
+        serviceCollection.AddHostedService<PlaybackResumeGuard>();

        // Register metadata providers
        serviceCollection.AddSingleton<SRFSeriesProvider>();
@@ -48,6 +53,7 @@ public class ServiceRegistrator : IPluginServiceRegistrator
        serviceCollection.AddSingleton<IScheduledTask, ContentRefreshTask>();
        serviceCollection.AddSingleton<IScheduledTask, ExpirationCheckTask>();
        serviceCollection.AddSingleton<IScheduledTask, RecordingSchedulerTask>();
+        serviceCollection.AddSingleton<IScheduledTask, ResumeCleanupTask>();

        // Register one channel (tile) per SRG business unit. Each must be registered as IChannel
        // for Jellyfin to discover it. A unit that is not in EnabledBusinessUnits returns no
@@ -0,0 +1,53 @@
+using System.Collections.Generic;
+using System.Threading;
+using Jellyfin.Data.Entities;
+using Jellyfin.Plugin.SRFPlay.Api.Models;
+using MediaBrowser.Controller.Entities;
+
+namespace Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+
+/// <summary>
+/// Removes stale plugin-owned resume points so ended livestreams and abandoned playback
+/// stop accumulating in every user's "Continue Watching" row.
+/// </summary>
+public interface IResumeCleanupService
+{
+    /// <summary>
+    /// Scans every user's resumable items and clears the resume point of those owned by this
+    /// plugin that match a staleness rule. Items belonging to other plugins or to the regular
+    /// library are never touched.
+    /// </summary>
+    /// <param name="clearAll">
+    /// When true every plugin-owned resume point is cleared regardless of the staleness rules.
+    /// Used by the "Clear all" maintenance action.
+    /// </param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>A summary of what was inspected and cleared.</returns>
+    ResumeCleanupResult Cleanup(bool clearAll, CancellationToken cancellationToken);
+
+    /// <summary>
+    /// Clears the resume point of a single item for the given users.
+    /// </summary>
+    /// <param name="item">The item whose resume point should be reset.</param>
+    /// <param name="users">The users to clear it for.</param>
+    /// <param name="reason">A short reason, logged for traceability.</param>
+    /// <returns>The number of resume points actually cleared.</returns>
+    int ClearResumePoint(BaseItem item, IEnumerable<User> users, string reason);
+
+    /// <summary>
+    /// Determines whether an item belongs to this plugin (an SRG channel item or a recording).
+    /// </summary>
+    /// <param name="item">The item to test.</param>
+    /// <returns>True if the item is owned by this plugin.</returns>
+    bool IsPluginItem(BaseItem item);
+
+    /// <summary>
+    /// Clears the resume point if the item is one of this plugin's livestreams and livestream
+    /// cleanup is enabled. Called right after playback stops so an ended broadcast never reaches
+    /// "Continue Watching" in the first place, instead of waiting for the nightly task.
+    /// </summary>
+    /// <param name="item">The item that just stopped playing.</param>
+    /// <param name="users">The users the playback was attributed to.</param>
+    /// <returns>The number of resume points cleared.</returns>
+    int ClearLiveStreamResumePoint(BaseItem item, IEnumerable<User> users);
+}
@@ -7,6 +7,7 @@ using Jellyfin.Plugin.SRFPlay.Api.Models;
 using Jellyfin.Plugin.SRFPlay.Configuration;
 using Jellyfin.Plugin.SRFPlay.Constants;
 using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+using Jellyfin.Plugin.SRFPlay.Utilities;
 using MediaBrowser.Controller;
 using MediaBrowser.Model.Dto;
 using MediaBrowser.Model.Entities;
@@ -66,7 +67,7 @@ public class MediaSourceFactory : IMediaSourceFactory
        // Past replays (ValidTo in the past) and upcoming events (ValidFrom in the future)
        // are treated as VOD to avoid IsInfiniteStream/IgnoreDts flags and FFmpeg -re mode.
        var isScheduledLivestream = chapter.Type == "SCHEDULED_LIVESTREAM" ||
-                                    urn.Contains("livestream", StringComparison.OrdinalIgnoreCase);
+                                    UrnHelper.IsLivestreamUrn(urn);
        var now = DateTime.UtcNow;
        var isLiveStream = isScheduledLivestream &&
            (chapter.ValidFrom == null || chapter.ValidFrom.Value.ToUniversalTime() <= now) &&
@@ -0,0 +1,79 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Session;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Services;
+
+/// <summary>
+/// Watches for livestream playback ending and immediately drops the resume point Jellyfin
+/// just saved for it. Without this, every livestream a user stops watching sticks in
+/// "Continue Watching" until the nightly cleanup task runs.
+/// </summary>
+public class PlaybackResumeGuard : IHostedService
+{
+    private readonly ILogger<PlaybackResumeGuard> _logger;
+    private readonly ISessionManager _sessionManager;
+    private readonly IResumeCleanupService _resumeCleanupService;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="PlaybackResumeGuard"/> class.
+    /// </summary>
+    /// <param name="logger">The logger.</param>
+    /// <param name="sessionManager">The session manager raising playback events.</param>
+    /// <param name="resumeCleanupService">The resume cleanup service.</param>
+    public PlaybackResumeGuard(
+        ILogger<PlaybackResumeGuard> logger,
+        ISessionManager sessionManager,
+        IResumeCleanupService resumeCleanupService)
+    {
+        _logger = logger;
+        _sessionManager = sessionManager;
+        _resumeCleanupService = resumeCleanupService;
+    }
+
+    /// <inheritdoc />
+    public Task StartAsync(CancellationToken cancellationToken)
+    {
+        _sessionManager.PlaybackStopped += OnPlaybackStopped;
+        _logger.LogDebug("PlaybackResumeGuard attached to session manager");
+        return Task.CompletedTask;
+    }
+
+    /// <inheritdoc />
+    public Task StopAsync(CancellationToken cancellationToken)
+    {
+        _sessionManager.PlaybackStopped -= OnPlaybackStopped;
+        return Task.CompletedTask;
+    }
+
+    private void OnPlaybackStopped(object? sender, PlaybackStopEventArgs e)
+    {
+        // Jellyfin saves the resume point before raising this event, so clearing it here wins.
+        if (e?.Item == null || e.Users == null || e.Users.Count == 0)
+        {
+            return;
+        }
+
+        try
+        {
+            var cleared = _resumeCleanupService.ClearLiveStreamResumePoint(e.Item, e.Users);
+            if (cleared > 0)
+            {
+                _logger.LogDebug(
+                    "Dropped {Count} resume point(s) for finished livestream '{Name}'",
+                    cleared,
+                    e.Item.Name);
+            }
+        }
+        catch (Exception ex)
+        {
+            // Never let a cleanup failure escape into Jellyfin's playback event pipeline.
+            _logger.LogError(ex, "Error clearing livestream resume point for '{Name}'", e.Item.Name);
+        }
+    }
+}
@@ -13,6 +13,7 @@ using Jellyfin.Plugin.SRFPlay.Api;
 using Jellyfin.Plugin.SRFPlay.Api.Models;
 using Jellyfin.Plugin.SRFPlay.Api.Models.PlayV3;
 using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+using Jellyfin.Plugin.SRFPlay.Utilities;
 using MediaBrowser.Controller;
 using MediaBrowser.Controller.MediaEncoding;
 using Microsoft.Extensions.Logging;
@@ -442,7 +443,7 @@ public class RecordingService : IRecordingService, IDisposable

            // Register the stream with the proxy so we can use the proxy URL
            var itemId = $"rec_{entry.Id}";
-            var isLiveStream = chapter.Type == "SCHEDULED_LIVESTREAM" || entry.Urn.Contains("livestream", StringComparison.OrdinalIgnoreCase);
+            var isLiveStream = chapter.Type == "SCHEDULED_LIVESTREAM" || UrnHelper.IsLivestreamUrn(entry.Urn);
            _proxyService.RegisterStreamDeferred(itemId, streamUrl, entry.Urn, isLiveStream);

            // Build proxy URL for ffmpeg (use localhost for local access)
@@ -0,0 +1,302 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Threading;
+using Jellyfin.Data.Entities;
+using Jellyfin.Data.Enums;
+using Jellyfin.Plugin.SRFPlay.Api.Models;
+using Jellyfin.Plugin.SRFPlay.Configuration;
+using Jellyfin.Plugin.SRFPlay.Services.Interfaces;
+using Jellyfin.Plugin.SRFPlay.Utilities;
+using MediaBrowser.Controller.Dto;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.Entities;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Plugin.SRFPlay.Services;
+
+/// <summary>
+/// Removes stale plugin-owned resume points from every user's "Continue Watching" row.
+/// </summary>
+public class ResumeCleanupService : IResumeCleanupService
+{
+    /// <summary>
+    /// Provider ID key stamped onto every item built from the SRG API.
+    /// </summary>
+    private const string SrfProviderId = "SRF";
+
+    private readonly ILogger<ResumeCleanupService> _logger;
+    private readonly ILibraryManager _libraryManager;
+    private readonly IUserManager _userManager;
+    private readonly IUserDataManager _userDataManager;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ResumeCleanupService"/> class.
+    /// </summary>
+    /// <param name="loggerFactory">The logger factory.</param>
+    /// <param name="libraryManager">The library manager.</param>
+    /// <param name="userManager">The user manager.</param>
+    /// <param name="userDataManager">The user data manager.</param>
+    public ResumeCleanupService(
+        ILoggerFactory loggerFactory,
+        ILibraryManager libraryManager,
+        IUserManager userManager,
+        IUserDataManager userDataManager)
+    {
+        _logger = loggerFactory.CreateLogger<ResumeCleanupService>();
+        _libraryManager = libraryManager;
+        _userManager = userManager;
+        _userDataManager = userDataManager;
+    }
+
+    /// <inheritdoc />
+    public ResumeCleanupResult Cleanup(bool clearAll, CancellationToken cancellationToken)
+    {
+        var result = new ResumeCleanupResult();
+        var config = Plugin.Instance?.Configuration;
+
+        if (config == null)
+        {
+            _logger.LogWarning("Plugin configuration not available - skipping resume point cleanup");
+            return result;
+        }
+
+        if (!clearAll && !config.CleanUpResumePoints)
+        {
+            _logger.LogDebug("Resume point cleanup is disabled in configuration");
+            return result;
+        }
+
+        var channelIds = GetPluginChannelIds();
+
+        foreach (var user in _userManager.Users)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            result.UsersChecked++;
+
+            var query = new InternalItemsQuery(user)
+            {
+                IsResumable = true,
+                Recursive = true,
+                EnableTotalRecordCount = false,
+                DtoOptions = new DtoOptions(false)
+            };
+
+            foreach (var item in _libraryManager.GetItemList(query))
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+
+                if (!IsPluginItem(item, channelIds))
+                {
+                    continue;
+                }
+
+                result.Inspected++;
+
+                var userData = _userDataManager.GetUserData(user, item);
+                if (userData == null || userData.PlaybackPositionTicks <= 0)
+                {
+                    continue;
+                }
+
+                var reason = clearAll ? "clear all" : GetStaleReason(item, userData, config);
+                if (reason == null)
+                {
+                    continue;
+                }
+
+                if (ClearResumePoint(item, user, userData, reason))
+                {
+                    result.Cleared++;
+                    result.ClearedByReason.TryGetValue(reason, out var count);
+                    result.ClearedByReason[reason] = count + 1;
+                }
+            }
+        }
+
+        _logger.LogInformation(
+            "Resume point cleanup finished: {Cleared} of {Inspected} SRF Play resume points cleared across {Users} user(s)",
+            result.Cleared,
+            result.Inspected,
+            result.UsersChecked);
+
+        return result;
+    }
+
+    /// <inheritdoc />
+    public int ClearResumePoint(BaseItem item, IEnumerable<User> users, string reason)
+    {
+        ArgumentNullException.ThrowIfNull(item);
+        ArgumentNullException.ThrowIfNull(users);
+
+        var cleared = 0;
+
+        foreach (var user in users)
+        {
+            var userData = _userDataManager.GetUserData(user, item);
+            if (userData == null || userData.PlaybackPositionTicks <= 0)
+            {
+                continue;
+            }
+
+            if (ClearResumePoint(item, user, userData, reason))
+            {
+                cleared++;
+            }
+        }
+
+        return cleared;
+    }
+
+    /// <inheritdoc />
+    public bool IsPluginItem(BaseItem item)
+    {
+        return IsPluginItem(item, GetPluginChannelIds());
+    }
+
+    /// <inheritdoc />
+    public int ClearLiveStreamResumePoint(BaseItem item, IEnumerable<User> users)
+    {
+        if (item == null || Plugin.Instance?.Configuration.ClearLiveStreamResumePoints != true)
+        {
+            return 0;
+        }
+
+        // Only the URN heuristic here - the item is already known, and re-querying the channel
+        // list on every playback stop would be wasteful.
+        if (!UrnHelper.IsLivestreamUrn(item.ProviderIds.GetValueOrDefault(SrfProviderId)))
+        {
+            return 0;
+        }
+
+        return ClearResumePoint(item, users, "livestream stopped");
+    }
+
+    /// <summary>
+    /// Determines whether an item belongs to one of this plugin's channels.
+    /// </summary>
+    /// <param name="item">The item to test.</param>
+    /// <param name="channelIds">The set of channel IDs owned by this plugin.</param>
+    /// <returns>True if the item is owned by this plugin.</returns>
+    private static bool IsPluginItem(BaseItem item, HashSet<Guid> channelIds)
+    {
+        if (item == null)
+        {
+            return false;
+        }
+
+        // API-sourced content carries the URN as a provider ID. Recordings do not, so fall back
+        // to the owning channel, which also covers any item shape added later.
+        return item.ProviderIds.ContainsKey(SrfProviderId)
+            || (!item.ChannelId.Equals(Guid.Empty) && channelIds.Contains(item.ChannelId));
+    }
+
+    /// <summary>
+    /// Resolves the IDs of the channel entries created by this plugin, one per business unit.
+    /// </summary>
+    /// <returns>The set of channel IDs, empty if the channels have not been scanned yet.</returns>
+    private HashSet<Guid> GetPluginChannelIds()
+    {
+        // SrgChannelBase names every channel "{unit} Play".
+        var names = Enum.GetNames<BusinessUnit>()
+            .Select(unit => unit + " Play")
+            .ToHashSet(StringComparer.OrdinalIgnoreCase);
+
+        var channels = _libraryManager.GetItemList(new InternalItemsQuery
+        {
+            IncludeItemTypes = new[] { BaseItemKind.Channel },
+            EnableTotalRecordCount = false,
+            DtoOptions = new DtoOptions(false)
+        });
+
+        return channels
+            .Where(channel => channel.Name != null && names.Contains(channel.Name))
+            .Select(channel => channel.Id)
+            .ToHashSet();
+    }
+
+    /// <summary>
+    /// Decides whether a resume point is stale, and why.
+    /// </summary>
+    /// <param name="item">The item the resume point belongs to.</param>
+    /// <param name="userData">The user data holding the resume position.</param>
+    /// <param name="config">The plugin configuration supplying the thresholds.</param>
+    /// <returns>A short reason string, or null when the resume point should be kept.</returns>
+    private static string? GetStaleReason(BaseItem item, UserItemData userData, PluginConfiguration config)
+    {
+        // A livestream has no meaningful position to return to: by the time the user comes back
+        // the broadcast has moved on or ended. These are the entries that pile up the fastest.
+        if (config.ClearLiveStreamResumePoints
+            && UrnHelper.IsLivestreamUrn(item.ProviderIds.GetValueOrDefault(SrfProviderId)))
+        {
+            return "livestream";
+        }
+
+        if (config.ResumePointMaxAgeDays > 0
+            && userData.LastPlayedDate.HasValue
+            && userData.LastPlayedDate.Value.ToUniversalTime() < DateTime.UtcNow.AddDays(-config.ResumePointMaxAgeDays))
+        {
+            return "older than " + config.ResumePointMaxAgeDays.ToString(CultureInfo.InvariantCulture) + " days";
+        }
+
+        if (config.ResumePointMinPositionSeconds > 0
+            && userData.PlaybackPositionTicks <= TimeSpan.FromSeconds(config.ResumePointMinPositionSeconds).Ticks)
+        {
+            return "barely started";
+        }
+
+        // Runtime is unknown for live and for some API items; without it there is nothing to
+        // compare the position against, so leave the resume point alone.
+        if (config.ResumePointCompletedPercent > 0
+            && item.RunTimeTicks.HasValue
+            && item.RunTimeTicks.Value > 0)
+        {
+            var watchedPercent = userData.PlaybackPositionTicks * 100.0 / item.RunTimeTicks.Value;
+            if (watchedPercent >= config.ResumePointCompletedPercent)
+            {
+                return "watched to the end";
+            }
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// Zeroes the resume position, which removes the item from "Continue Watching" while
+    /// leaving it unwatched so it can still be played again from the start.
+    /// </summary>
+    /// <param name="item">The item to clear.</param>
+    /// <param name="user">The user to clear it for.</param>
+    /// <param name="userData">The user data to update.</param>
+    /// <param name="reason">A short reason, logged for traceability.</param>
+    /// <returns>True if the resume point was cleared.</returns>
+    private bool ClearResumePoint(BaseItem item, User user, UserItemData userData, string reason)
+    {
+        try
+        {
+            userData.PlaybackPositionTicks = 0;
+
+            _userDataManager.SaveUserData(
+                user,
+                item,
+                userData,
+                UserDataSaveReason.UpdateUserData,
+                CancellationToken.None);
+
+            _logger.LogInformation(
+                "Cleared resume point for '{Name}' (user {User}, reason: {Reason})",
+                item.Name,
+                user.Username,
+                reason);
+
+            return true;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to clear resume point for '{Name}'", item.Name);
+            return false;
+        }
+    }
+}
@@ -24,4 +24,17 @@ public static class UrnHelper
        return guid.ToString();
    }
 #pragma warning restore CA5351
+
+    /// <summary>
+    /// Determines whether a URN refers to a livestream (scheduled or continuous).
+    /// This is a URN-only heuristic that needs no API call, so it stays usable long after
+    /// the broadcast has ended and the media composition is no longer worth fetching.
+    /// </summary>
+    /// <param name="urn">The URN to inspect. May be null or empty.</param>
+    /// <returns>True if the URN identifies livestream content.</returns>
+    public static bool IsLivestreamUrn(string? urn)
+    {
+        return !string.IsNullOrEmpty(urn)
+            && urn.Contains("livestream", StringComparison.OrdinalIgnoreCase);
+    }
 }
@@ -22,6 +22,7 @@ Then install "SRF Play" from the plugin catalog.
 - **Live Sports Streaming** - Watch scheduled sports events (skiing, Formula 1, football, tennis, etc.)
 - Support for all Swiss broadcasting units (SRF, RTS, RSI, RTR, SWI)
 - Automatic content expiration handling
+- Continue Watching cleanup — ended livestreams and abandoned playback don't pile up in the resume row
 - Latest and trending content discovery
 - Quality selection (Auto lets CDN decide, SD prefers 480p/360p, HD prefers 1080p/720p)
 - HLS streaming support with Akamai token authentication
@@ -137,6 +138,16 @@ The compiled plugin will be in `bin/Debug/net8.0/`
  - **Proxy Address**: Proxy server URL (e.g., http://proxy.example.com:8080)
  - **Proxy Username**: Optional authentication username
  - **Proxy Password**: Optional authentication password
+- **Continue Watching Cleanup**: Stops stale SRF Play entries accumulating in the resume row
+  - **Clean up stale resume points**: Enables the daily "Clean Up SRF Play Continue Watching" task (4 AM)
+  - **Never keep a resume point for livestreams**: Clears the position the moment a livestream stops
+  - **Maximum Resume Point Age**: Clear entries untouched for this many days (default 30, 0 disables)
+  - **Minimum Resume Position**: Clear entries at or below this position (default 60s, 0 disables)
+  - **Finished Threshold**: Clear entries at or beyond this share of the runtime (default 92%, 0 disables)
+
+Clearing a resume point only resets the playback position. Nothing is deleted, the item stays
+unwatched, and only SRF Play items are ever touched. The plugin config page also has
+**Clean Up Stale Entries Now** and **Clear All SRF Play Entries** buttons for running it on demand.

 For detailed proxy setup instructions, see [PROXY_SETUP_GUIDE.md](PROXY_SETUP_GUIDE.md).