[Bug] Shows with paused seasons stop getting reindexed — new TVDB episodes never discovered

[bioengineered]

Summary

When a show has older seasons paused and completes all known episodes in the current season, it becomes PartiallyCompleted and stops being monitored for new TVDB episodes. New episodes added to TVDB after this point are never discovered, even though the show is still airing (tvdb_status = "Continuing").

Steps to Reproduce

1. Add a currently-airing show (e.g. Summer House, tvdb_status=Continuing)
2. Pause older seasons (S1-S9) — only track the current season (S10)
3. Wait for all known episodes in S10 to complete
4. Show state becomes PartiallyCompleted (Paused seasons + Completed season)
5. TVDB adds new episodes (E11, E12, etc.)
6. Riven never discovers them — no reindex is ever triggered again

Root Cause

Two interacting issues:

1. _determine_state in Show doesn't check TVDB status for the PartiallyCompleted case

The code already handles "all seasons completed but show still airing" correctly:

if all(season.state == States.Completed for season in self.seasons):
    if self.tvdb_status and self.tvdb_status.lower() in ["continuing", "upcoming"]:
        return States.Ongoing   # correctly stays Ongoing
    return States.Completed

But when any season is Paused, all(... == Completed) is False, so this check is never reached. The code falls through to:

if any(season.state in (States.Completed, States.PartiallyCompleted) ...):
    return States.PartiallyCompleted   # no TVDB status check here

2. _monitor_ongoing_schedules only monitors Ongoing/Unreleased shows

select(Show).where(Show.last_state.in_([States.Ongoing, States.Unreleased]))

PartiallyCompleted shows are excluded, so no reindex_show tasks are ever created for them.

Suggested Fix

In Show._determine_state, apply the TVDB continuing/upcoming check to the PartiallyCompleted branch as well — if any non-paused season is fully completed and the show is still airing on TVDB, it should remain Ongoing so the scheduler keeps monitoring it:

if any(season.state in (States.Completed, States.PartiallyCompleted) for season in self.seasons):
    if self.tvdb_status and self.tvdb_status.lower() in ["continuing", "upcoming"]:
        return States.Ongoing
    return States.PartiallyCompleted

Environment

• Riven v1.0.0 (spoked/riven:dev, image built 2026-04-11)
• PostgreSQL 17 Alpine
• Show tested: Summer House (TVDB 321121, tvdb_status=Continuing)

[bioengineered]

Two updates after further testing on spoked/riven:dev (06f5a78).

The state change proposed here is necessary but not sufficient. Even when a reindex_show task does run against the show (forced via a ScheduledTask, or with the show kept Ongoing), newly-discovered episodes still aren't saved — so restoring monitoring alone won't surface them.

The cause is a separate persistence bug in Season.add_episode. _create_episode_from_data sets episode.parent = season, which back-populates season.episodes with the transient episode. That backref-attached transient child isn't enlisted by the save-update cascade, and add_episode then returns early on its number in [...] guard (the object is already in the collection), so it's never added to the session:

def add_episode(self, episode: "Episode"):
    if episode.number in [e.number for e in self.episodes]:
        return
    self.episodes.append(episode)
    episode.parent = self
    self.episodes = sorted(self.episodes, key=lambda e: e.number)

Verified: after indexer.run(show) the season holds all episodes in memory, but inspect(new_ep).transient is True, new_ep not in session, and flush/commit inserts nothing.

Fix (enlist the episode, and don't early-return on the object already attached via the backref):

def add_episode(self, episode: "Episode"):
    if any(e.number == episode.number and e is not episode for e in self.episodes):
        return
    if episode not in self.episodes:
        self.episodes.append(episode)
    episode.parent = self
    self.episodes = sorted(self.episodes, key=lambda e: e.number)
    session = object_session(self)
    if session is not None:
        session.add(episode)

With this applied, a reindex of a show with new TVDB episodes persists them (confirmed end-to-end: a completed 16-episode season picked up its 3 new reunion episodes on the next reindex). object_session is already imported in item.py. Show.add_season has the same pattern and needs the equivalent change for new seasons.