riplex 0.9.9__tar.gz → 1.0.2__tar.gz

{riplex-0.9.9 → riplex-1.0.2}/.github/agents/riplex.agent.md

@@ -151,7 +151,18 @@ Do NOT use `py -m riplex` (errors — riplex is a library package). Do NOT use `
 
 ## Debugging the GUI
 
-The GUI writes detailed logs to `riplex_app.log` in the working directory (project root when launched from the repo). This log includes screen navigation, disc analysis details, title classification decisions, and rip progress. Check this file first when debugging GUI behavior — do NOT try to capture terminal output (Flet's `2>&1` redirect breaks its Flutter-Python IPC).
+**When the user reports a bug they can reproduce locally, ALWAYS check the debug log first** — before reading code, before guessing at causes. The log will usually tell you exactly which code path ran and what state it saw. Guessing at fixes without checking the log wastes time and often lands the wrong fix.
+
+The GUI writes detailed logs including screen navigation, dvdcompare/TMDb lookups, disc analysis, title classification decisions, group routing, autofill results, and rip progress. Log locations (per `platformdirs`):
+
+- **Windows**: `%LOCALAPPDATA%\riplex\riplex\Logs\riplex_app.log`
+  (typically `C:\Users\<user>\AppData\Local\riplex\riplex\Logs\riplex_app.log`)
+- **macOS**: `~/Library/Logs/riplex/riplex_app.log`
+- **Linux**: `~/.local/state/riplex/log/riplex_app.log` (or `$XDG_STATE_HOME/riplex/log/`)
+
+The log is truncated / rotated on each GUI launch, so grab it before the user restarts the app. Use `Select-String` (PowerShell) or `grep` for keywords tied to the buggy behavior — `Season`, `dvdcompare_film`, `group`, `autofill`, `classify`, etc.
+
+Do NOT try to capture terminal output with `2>&1` — Flet's Flutter-Python IPC breaks when stderr is redirected.
 
 ## Testing
 

{riplex-0.9.9 → riplex-1.0.2}/.github/copilot-instructions.md

@@ -1,5 +1,24 @@
 # Copilot Instructions for riplex
 
+## Shared flow logic (CLI/GUI parity)
+
+The CLI (`src/riplex_cli/`) and the GUI (`src/riplex_app/`) must not carry
+duplicated multi-step orchestration. Any flow-level logic — anything that
+does more than "render this" or "prompt for that" — lives in `src/riplex/`
+as a plain function that takes inputs and returns a dataclass. Both surfaces
+then become thin callers: the CLI does `prompt_*` / `print(...)`, the GUI
+does `ft.Control` / `state[...] = ...`.
+
+Reference example: `src/riplex/resume.py` centralizes the resume-from-session
+adapter. `_fetch_dvdcompare_for_resume` in
+`src/riplex_app/screens/disc_detection.py` and the resume short-circuit in
+`src/riplex_cli/commands/orchestrate.py` are both callers of that one
+function; adding a new field to the resumed lookup only touches the
+adapter (and its tests), never both surfaces.
+
+When adding a new feature that both surfaces need, default to this
+pattern before writing any UI code.
+
 ## Documentation changelog
 
 When any file under `docs/` is added, modified, or removed, update `docs/changelog.md` with a dated entry describing the change. Follow the [Keep a Changelog](https://keepachangelog.com/) format with sections like Added, Changed, Removed, or Fixed under a date heading.
@@ -108,10 +127,15 @@ Run tests with `pytest` (or `python -m pytest`) from the project root with the v
 
 ## Debugging the GUI
 
-The GUI writes detailed logs to `riplex_app.log` in the working directory
-(project root when launched from the repo). Check this file first when
-debugging GUI behavior. Do NOT try to capture the GUI's terminal output with
-a `2>&1` redirect — it breaks Flet's Flutter-Python IPC.
+**When the user reports a bug they can reproduce locally, ALWAYS check the debug log first** — before reading code, before guessing. The log usually tells you exactly which code path ran and what state it saw.
+
+Log locations (per `platformdirs`):
+
+- **Windows**: `%LOCALAPPDATA%\riplex\riplex\Logs\riplex_app.log`
+- **macOS**: `~/Library/Logs/riplex/riplex_app.log`
+- **Linux**: `~/.local/state/riplex/log/riplex_app.log`
+
+The log is rotated on each GUI launch, so grab it before the user restarts the app. Do NOT try to capture terminal output with `2>&1` — it breaks Flet's Flutter-Python IPC.
 
 ## Releases and packaging
 

{riplex-0.9.9 → riplex-1.0.2}/.github/workflows/release.yml

@@ -192,6 +192,12 @@ jobs:
           cp artifacts/riplex-windows/riplex-ui.exe release/riplex-ui-windows.exe
           cp artifacts/riplex-macos/riplex-macos release/
           cp artifacts/riplex-macos/riplex-ui-macos.zip release/
+          # Publish SHA-256 checksums so the app can verify a download before
+          # applying an in-place update (see riplex.updater.stage_update).
+          cd release
+          for f in riplex-windows.exe riplex-ui-windows.exe riplex-macos riplex-ui-macos.zip; do
+            sha256sum "$f" > "$f.sha256"
+          done
 
       - name: Create GitHub Release
         uses: softprops/action-gh-release@v2
@@ -204,6 +210,10 @@ jobs:
           body: ${{ steps.tag_notes.outputs.body }}
           files: |
             release/riplex-windows.exe
+            release/riplex-windows.exe.sha256
             release/riplex-ui-windows.exe
+            release/riplex-ui-windows.exe.sha256
             release/riplex-macos
+            release/riplex-macos.sha256
             release/riplex-ui-macos.zip
+            release/riplex-ui-macos.zip.sha256

{riplex-0.9.9 → riplex-1.0.2}/.github/workflows/update-contributors.yml

@@ -35,8 +35,8 @@ jobs:
       - name: Create pull request
         uses: peter-evans/create-pull-request@v6
         with:
-          commit-message: chore: refresh CONTRIBUTORS.md
-          title: chore: refresh CONTRIBUTORS.md
+          commit-message: "chore: refresh CONTRIBUTORS.md"
+          title: "chore: refresh CONTRIBUTORS.md"
           body: |
             Updates the generated Bug Bashers table in CONTRIBUTORS.md from closed issue reports.
           branch: chore/update-contributors

{riplex-0.9.9/src/riplex.egg-info → riplex-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: riplex
-Version: 0.9.9
+Version: 1.0.2
 Summary: Automates the tedious manual work around MakeMKV: figuring out what to rip, which MKV files are actually what, and organizing everything into Plex-compatible folder structures.
 License: MIT
 Requires-Python: >=3.11
@@ -8,7 +8,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: certifi>=2024.2.2
 Requires-Dist: httpx>=0.27
-Requires-Dist: dvdcompare-scraper>=0.1.16
+Requires-Dist: dvdcompare-scraper>=0.1.18
 Requires-Dist: platformdirs>=4.0
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
@@ -67,7 +67,7 @@ More screenshots:
 [disc overview](screenshots/5_Multi_Disc_Overview_BTTF.png).
 
 > [!NOTE]
-> riplex currently handles one film (or one TV show) per session. Multi-film box sets that bundle separate films onto separate discs (e.g. a trilogy in one box) need to be ripped one film at a time.
+> riplex handles multi-work box sets and complete multi-season TV series in a single guided session. It detects the separate films (or films plus a show) inside a release, groups the discs that belong to each work, and routes every one to its own Plex destination — you can stop after any disc and resume the set later.
 
 ## Requirements
 

{riplex-0.9.9 → riplex-1.0.2}/README.md

@@ -47,7 +47,7 @@ More screenshots:
 [disc overview](screenshots/5_Multi_Disc_Overview_BTTF.png).
 
 > [!NOTE]
-> riplex currently handles one film (or one TV show) per session. Multi-film box sets that bundle separate films onto separate discs (e.g. a trilogy in one box) need to be ripped one film at a time.
+> riplex handles multi-work box sets and complete multi-season TV series in a single guided session. It detects the separate films (or films plus a show) inside a release, groups the discs that belong to each work, and routes every one to its own Plex destination — you can stop after any disc and resume the set later.
 
 ## Requirements
 

riplex-1.0.2/RELEASE_NOTES_v1.0.0.md

@@ -0,0 +1,139 @@
+# riplex v1.0.0
+
+**The first stable release.** v1.0.0 consolidates riplex's box-set and TV-series
+support, hardens episode matching, adds a comprehensive automated test suite so
+the flows that matter stay working as the project grows, and makes upgrades
+painless with one-click in-place updates on Windows.
+
+Until now every disc was treated as a standalone rip, and updating meant
+re-downloading the app each release. This release lets riplex understand a whole
+box set at once — detecting the *works* inside a release, grouping the discs that
+belong to each, and routing every work to its correct Plex destination in a
+single guided session — and then keeps itself up to date automatically.
+
+## Why 1.0.0?
+
+riplex has been usable for a while; three things make this the right moment to
+call it stable:
+
+- **The hard workflows are done.** Multi-work box sets and complete multi-season
+  TV series — the cases that used to mean ripping disc-by-disc and sorting by
+  hand — now work end to end, in both the desktop app and the CLI.
+- **It's protected against regressions.** A headless integration suite exercises
+  the entire GUI wizard and the CLI against real-world scenarios generated from
+  archived rips, so the flows you depend on keep working as development continues.
+- **Updates are effortless.** In-place updates mean you install once and never
+  have to re-download and re-approve the app for each new version.
+
+## Headline features
+
+### Multi-work box sets
+
+A release that contains several distinct works — several films, or films plus a
+TV series — is detected as *multiple works* instead of one. Each work gets its
+own title selection, its own rip grouping, and its own Plex target, so a mixed
+box set is ripped and filed correctly in one pass:
+
+• Disc grouping splits on dvdcompare's per-film hyperlinks (`pointer_fid`) rather than a coarse "is this a film" guess, so a bonus-films disc forms its own group and the main features stay separate.
+• The Select Titles screen shows each work's rip output separately, so you can see exactly which files belong to which movie or show.
+• Full CLI parity: `riplex orchestrate` and `riplex organize` route multi-work releases the same way the GUI does, through the shared flow logic.
+
+### Multi-season TV series
+
+Complete-series sets that span several seasons are ripped season by season:
+
+• A **Season Select** screen (GUI) and season prompt (CLI) assign each disc to its season.
+• TV rips nest automatically under `Season NN/`, and specials land in `Season 00`.
+• Season labels and chips appear throughout the Disc Overview, so a 12-disc set is easy to keep track of.
+
+### Guided resume across a whole set
+
+Every session writes a `_riplex_session.json` marker capturing the full plan, so
+you can rip a few discs, come back later, and pick up exactly where you left off:
+
+• Resume from *any* disc of a multi-work or multi-season set — not just the next in sequence.
+• `riplex orchestrate` (CLI) resumes from the marker with GUI parity, via a shared `resume.py` adapter.
+• `riplex organize` discovers the marker and fans out across every work in the set.
+
+### Metadata persisted per rip
+
+Rip manifests record the exact TMDb and dvdcompare ids you confirmed at rip time.
+When you organize (or resume) a ripped disc, riplex reuses those ids and skips
+the metadata pickers entirely — no re-searching, no risk of picking a different
+release the second time.
+
+### Smarter, more resilient TV episode matching
+
+Matching ripped titles to episodes used to be a runtime guessing game that falls
+apart when episodes run within seconds of each other — or when a metadata
+listing is simply wrong. Now:
+
+• dvdcompare's episode listing is cross-referenced against the TMDb episode list.
+• When a disc's episode-length titles line up 1:1 with the episode list, they're assigned by **disc position** rather than by runtime, so a single wrong dvdcompare runtime can't orphan an episode or let a same-runtime neighbour steal its slot.
+• Organize honors the rip-time season/episode classification and no longer collides identically-named files across different discs.
+• Over-length titles are labeled **Unmatched content** and stay visible instead of being forced into the wrong slot.
+
+### Seamless in-place updates (Windows)
+
+When a new version is available, the update screen offers **Update & Restart**:
+riplex downloads the new build, **verifies its SHA-256 checksum**, swaps the
+running `.exe` in place, and relaunches — no re-downloading and no repeated
+SmartScreen approval. It only runs from a writable install folder (otherwise it
+falls back to the browser download), and every release now publishes `.sha256`
+checksums for its assets.
+
+> Note: this applies going forward. Upgrading *to* v1.0.0 from an older build
+> still uses the browser download (the old build doesn't know how to self-update);
+> from v1.0.0 onward, updates are one click.
+
+### Auto-eject after ripping
+
+The disc ejects automatically once a rip finishes, so you can swap discs — or
+just know it's done — without reaching for the drive. On by default; set
+`auto_eject = false` in the config to disable.
+
+## Reliability & testing
+
+v1.0.0 adds a substantial automated safety net so future changes don't quietly
+break the flows you rely on:
+
+• **Headless GUI integration tests** drive the full desktop wizard through mocked disc / TMDb / dvdcompare scenarios, asserting every screen renders and hands off correctly without touching a real drive or the network.
+• **CLI integration tests** run the real argument parser and command dispatch for `organize` and `lookup`.
+• **Real-world fixtures** are generated from archived rips and classified by media type (movie, mini-series, series), so new rips can grow the protected-scenario set over time.
+• Cancelling a rip now returns to the **current** disc's Insert Disc screen (retry / skip / eject) instead of skipping ahead, and doesn't mark the disc as ripped.
+• Duplicate-title extras no longer clobber their episode's destination during organize.
+
+## Minor improvements
+
+• "Currently loaded" disc dropdown on the Disc Overview for quickly switching context.
+• "Organize into Library" shortcut appears once every disc in the set has been ripped.
+• Hidden-discs banner explains any discs the plan intentionally skips, and the primary-work slot shows its runtime.
+• "View on dvdcompare.net" link shown once a release has been matched.
+• Interactive title-selection editor at the CLI Proceed prompt, so you can adjust picks before the rip starts.
+• Every `orchestrate` disc routes through an Insert Disc scan-confirm step for consistent behavior.
+• Ctrl-C exits cleanly (exit code 130, no traceback, no orphaned `makemkvcon` process).
+
+## Bug fixes
+
+• Duplicate **Quit** buttons on the rip-complete summary and Insert Disc screens.
+• False "multiple films" alert on Select Titles, with a confirmed movie title and clearer section headers.
+• Ctrl-C at a prompt no longer behaves like pressing Enter.
+• Movie picks filter to just the movie disc(s), on both fresh and resumed sessions.
+• Organize fuzzy-matches dvdcompare episode titles against TMDb, and reads title/season from the rip manifest for season-nested output.
+• Organize no longer crashes after a resumed rip.
+• Organize Rips scan-results footer anchors to the bottom, and its Back button walks up the flow instead of dropping to Welcome.
+• `detect_disc_format` recognizes standard-definition DVDs.
+• Linked-film autofill strips dvdcompare format markers, and the main feature is no longer misclassified as a play-all title.
+• The dvdcompare cache auto-invalidates when the scraper version changes, and auto-lookup no longer picks the wrong franchise.
+
+## ⚠️ Breaking change
+
+Disc-group ids changed from the old `main_1` / `film_31` scheme to
+`disc_1` / `discs_1_4` / `disc_31`. A session saved by an earlier version will
+not resume — **start a fresh session after upgrading**.
+
+## Full changelog
+
+See [docs/changelog.md](https://github.com/AnyCredit5518/riplex/blob/v1.0.0/docs/changelog.md)
+for the per-section breakdown, and the auto-generated commit list below for
+every commit since v0.9.8.

{riplex-0.9.9 → riplex-1.0.2}/docs/architecture.md

@@ -77,7 +77,10 @@ src/
             organize_done.py    # Organize results summary
 tests/
     test_*.py               # One test file per source module
+    integration/            # Headless GUI flow tests (see Development > Testing)
+    support/                # Integration harness: fake page, driver, provider mocks
     fixtures/               # makemkvcon output samples for parsing tests
+        gui/scenarios/      # Committed GUI scenarios (generated from archived rips)
     snapshots/              # MKV metadata snapshots for offline test replay
 ```
 

{riplex-0.9.9 → riplex-1.0.2}/docs/changelog.md

@@ -4,6 +4,98 @@ All notable changes to the riplex documentation are recorded here.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/).
 
+## Unreleased
+
+### Fixed
+
+- **TV episodes with parenthetical titles (or filed under extras) no longer land in `Other/`.** When organizing a TV rip, the destination is now chosen from the authoritative `SxxEyy` classification recorded in each disc's rip manifest at rip time, taking priority over the re-derived dvdcompare match label. Previously an episode whose title contains a parenthetical (e.g. *Shawn and Gus in Drag (Racing)*), or one that dvdcompare files under a disc's extras (e.g. an *(Extended Version)* listing such as *Romeo and Juliet and Juliet* or *Dual Spires*), was misread as an extra and dropped into `Other/` instead of its season folder — even though orchestrate had already classified it correctly (e.g. Psych S5 E01/E05/E12).
+
+### Added
+
+- **Durations on the organize preview.** Each matched file now shows its runtime next to the matched episode/target's expected runtime; a divergence of more than a minute is highlighted so an incorrect match is easy to spot before you execute.
+
+## v1.0.1 — 2026-07-20
+
+### Fixed
+
+- **Out-of-order episode matching.** When dvdcompare files an “(Extended Version)” of an episode under a disc's *extras*, TMDb enrichment promotes it to an episode but leaves it positioned after the real episode list, so the episode entries arrive out of broadcast order. Positional episode alignment now sorts episodes by their canonical `SxxEyy` number before matching disc titles, so a disc whose titles are in broadcast order maps correctly. Previously the misordered list could orphan a title to a generic “Episode” label and shift the following episodes by one (e.g. Psych S6 D3).
+
+## v1.0.0 — 2026-07-18
+
+Summary: the first stable release. v1.0.0 brings full multi-work and
+multi-season box-set support, hardens TV episode matching, adds a comprehensive
+headless GUI + CLI integration test suite to guard against regressions, and
+introduces one-click in-place updates on Windows so future upgrades are
+seamless. A box set that bundles several films, or a complete multi-season TV
+series, can be ripped and organized in a single guided session, with each work
+routed to its correct Plex destination.
+
+### Highlights
+
+- **Multi-work box sets.** A single release containing several distinct films (or films plus a TV series) is now detected as multiple works. Each work gets its own title selection, rip grouping, and Plex target, so a mixed box set no longer has to be ripped one disc at a time and sorted by hand.
+- **Multi-season TV.** Complete-series sets spanning multiple seasons are ripped season by season. A new Season Select screen (GUI) and season prompt (CLI) assign each disc to a season, and rips nest under `Season NN/` automatically.
+- **Guided resume.** A session marker (`_riplex_session.json`) records the whole plan, so you can stop after any disc and resume later — from any disc of the set — without re-picking metadata.
+- **Metadata persisted per rip.** Rip manifests now store the chosen TMDb and dvdcompare ids, so organizing (or resuming) a ripped disc skips the pickers and reuses the exact match you confirmed at rip time.
+- **Smarter TV matching.** dvdcompare episode listings are cross-referenced against the TMDb episode list, and episodes are assigned deterministically from their rip-time classification instead of guessing between near-identical runtimes.
+- **Seamless updates.** On Windows, the app can download, verify, and install its own updates in place and relaunch — no more re-downloading the exe and clearing SmartScreen every release.
+- **Regression-proofed for 1.0.** A headless integration suite drives the full GUI wizard and the CLI through mocked disc/TMDb/dvdcompare scenarios (generated from real archived rips), so the flows that matter stay protected as the project grows.
+
+### ⚠️ Breaking
+
+- **Disc-group ids changed** from the old `main_1` / `film_31` scheme to `disc_1` / `discs_1_4` / `disc_31`. A session saved by an earlier version will not resume — start a fresh session after upgrading.
+
+### Added
+
+- Multi-work release routing: per-work title selection, rip groups, and Plex destinations, with full CLI parity for `organize` and `orchestrate`.
+- Season Select screen (GUI) and season prompt (CLI) for assigning discs to seasons in multi-season sets.
+- Interactive title-selection editor at the CLI Proceed prompt, so picks can be adjusted before the rip starts.
+- Per-group rip output on the Select Titles screen, showing each work's files separately.
+- Multi-work session marker (`_riplex_session.json`) enabling resume from any disc of a set.
+- Rip manifests now record the confirmed TMDb and dvdcompare ids to skip the pickers on organize and resume.
+- Season labels and chips on the Disc Overview, plus a "Currently loaded" disc dropdown.
+- "Organize into Library" shortcut on the Disc Overview once every disc has been ripped.
+- Hidden-discs banner explaining discs the plan intentionally skips.
+- "View on dvdcompare.net" link when a release has already been matched.
+- **Development > Testing guide** (`development/testing.md`) documenting the headless GUI and CLI integration test suites, the `tests/support/` harness, the `gui` fixture, media-type-targeted flows, and how to generate scenario fixtures from archived rips with `scripts/gen_gui_fixtures.py`.
+- **GUI auto-eject.** The disc is ejected automatically after a rip finishes so you can swap discs (or know it's done) without reaching for the drive. On by default; set `auto_eject = false` in the config to disable.
+- **GUI in-place update (Windows).** The update screen now offers **Update & Restart**: riplex downloads the new build, verifies its SHA-256 checksum, swaps the running `.exe` in place, and relaunches — no manual re-download or repeated SmartScreen approval. Requires a writable install folder; falls back to the browser download otherwise. Releases now publish `.sha256` checksums for every asset.
+
+### Changed
+
+- CLI `orchestrate` now resumes from the session marker (GUI parity) via the shared `resume.py` adapter.
+- Disc grouping splits on dvdcompare hyperlinks (`pointer_fid`) rather than `is_film`, so a bonus-films disc forms its own group.
+- `DiscGroup.kind` removed; group labels and ids simplified.
+- TV rips nest under `Season NN/` and cross-reference dvdcompare features against the TMDb episode list.
+- Ctrl-C now exits cleanly (exit code 130, no traceback, no orphaned `makemkvcon` process).
+- Softer disc-mismatch wording, and the release picker shows the matched dvdcompare film.
+- `_plan_show` keeps Season 0 (Specials); the Organize preview shows a title/season source badge.
+- Every `orchestrate` disc now routes through an Insert Disc scan-confirm step.
+- **Architecture** file tree now lists `tests/integration/`, `tests/support/`, and `tests/fixtures/gui/scenarios/`.
+- Home page and docs index/README refreshed for the 1.0.0 feature set (multi-work box sets, multi-season TV, in-place updates, auto-eject).
+
+### Fixed
+
+- **TV: a single wrong dvdcompare episode runtime no longer mislabels two episodes.** When a disc's episode-length titles line up 1:1 with the dvdcompare episode list, riplex now assigns them by disc position instead of purely by runtime. Previously a bad listed runtime (e.g. Psych S6 D3 listing "Heeeeere's Lassie" at 43:10 when the disc title is 49:41) orphaned that episode to a generic "Episode" label and let a same-runtime neighbour steal its slot. Positional alignment fixes both; it only applies on an exact 1:1 count match with at most one runtime outlier, and defers to runtime matching on ragged or reordered discs.
+- **GUI: cancelling a rip returns to the current disc, not the next one.** In an orchestrate session, stopping a rip mid-disc took you to the *next* disc's Insert Disc screen. It now returns to the current disc's Insert Disc screen so you can retry, skip, or eject — and the cancelled disc is no longer marked as ripped (no manifest written) or auto-ejected.
+- **GUI: Organize Rips scan-results footer now anchors to the bottom** like every other wizard screen. The results form now scrolls internally while the Back/Next buttons stay pinned at the window edge.
+- **GUI: Organize Rips Back button walks up the flow** instead of dropping to the Welcome screen. On the scan-results view it restores the multi-group picker (when the folder held several seasons or works) or otherwise returns to the folder input; the multi-group picker's Back button now returns to the folder input as well.
+- **Organize: duplicate-title extras no longer clobber their episode's destination.** dvdcompare sometimes lists the same episode name twice (real broadcast episode + a shorter bonus re-edit). The rip-time enrichment already demotes the shorter entry to ``[extra]``, but the organizer was ignoring that tag and fuzzy-routing both files to the same ``s0Xe0Y - Title.mkv`` destination — so the second file silently overwrote the first when organize actually executed. The organizer now respects the ``[extra]`` classification and routes the duplicate to an extras folder instead.
+- Duplicate Quit buttons on the rip-complete summary and Insert Disc screens.
+- False "multiple films" alert on Select Titles, with a confirmed movie title and clearer section headers.
+- Ctrl-C at a prompt no longer behaves like pressing Enter.
+- Movie picks now filter to just the movie disc(s), on both fresh and resumed sessions.
+- The primary-work film slot shows its runtime, and hidden discs are explained.
+- Organize honors the rip-time season/episode classification and no longer collides same-basename files across discs.
+- Organize fuzzy-matches dvdcompare episode titles against TMDb, and reads title/season from the rip manifest for season-nested output.
+- Organize no longer crashes after a resumed rip.
+- TV episodes are assigned sequentially (first-fit); over-length titles are labeled "Unmatched content".
+- The Disc Release screen shows the dvdcompare film title as its heading.
+- `detect_disc_format` recognizes standard-definition DVDs.
+- `riplex organize` discovers the session marker and fans out across all works.
+- Resume works from any disc of a multi-work release, and season chips show on leading discs on resume.
+- Linked-film autofill strips dvdcompare format markers, and the main feature is no longer misclassified as a play-all title.
+- The dvdcompare cache auto-invalidates when the scraper version changes, and auto-lookup no longer picks the wrong franchise.
+
 ## v0.9.2 — 2026-06-24
 
 ### Fixed

{riplex-0.9.9 → riplex-1.0.2}/docs/cli-guide/orchestrate.md

@@ -29,8 +29,10 @@ In interactive mode, orchestrate presents prompts at each decision point:
 
 - **Title confirmation**: auto-detected title shown for confirmation or correction
 - **TMDb disambiguation**: if multiple matches, pick the correct one
+- **Season selection** (TV multi-season shows only): when the show has more than one season on TMDb, pick which season is on the disc. The picked season is used both to narrow the plan and to bias the dvdcompare query (e.g. `Psych: Season 2`) so it lands on the correct per-season film page. Season 0 (Specials) is never shown in the picker but is always retained in the plan so extras on the disc that match a curated TMDb special can still route to `Season 00/`. Mini-series (only one non-special season, e.g. *Planet Earth II*) skip this prompt entirely.
 - **dvdcompare release selection**: choose the regional release (default: America)
 - **Disc selection**: pick which discs to rip (skip standard Blu-ray copies, bonus discs, etc.)
+- **Title selection**: after the per-disc analysis, the `Proceed? [Y/n/e(dit)]` prompt accepts `e` to open an interactive picker that lets you toggle titles by index, range (`3-7`), or list (`1,4,6`); type `all`, `none`, `default` to reset, or `done` / Enter to accept. This is the CLI equivalent of the GUI selection screen.
 - **Disc swap**: after each disc, prompted to insert the next one
 - **Archive**: after organize, prompted to archive the rip folder (if `archive_root` is configured)
 

{riplex-0.9.9 → riplex-1.0.2}/docs/cli-guide/organize.md

@@ -34,16 +34,28 @@ riplex organize "path/to/rips/PLANET EARTH II" --type tv --format "Blu-ray 4K"
 
 Multi-disc rips in separate folders (e.g. "Planet Earth III - Disc 1", "Planet Earth III - Disc 2") are automatically grouped into a single title.
 
+## Multi-work releases (TV series + bonus films)
+
+Some releases bundle more than one work — a classic example is *Psych: The Complete Series*, with the eight-season show on discs 1-30 and three standalone TV-movies on disc 31. `organize` detects this and splits the release into groups, planning each group against its own TMDb match:
+
+- The main-content discs organize into the TV show folder using the top-level match you searched for.
+- Each film disc's slot gets a best-guess TMDb match auto-filled from its dvdcompare title.
+- In interactive mode you'll be prompted per slot to accept the auto-fill, search for a different match, or skip the slot (its files stay unmatched).
+- In non-interactive mode (piped output, CI) auto-fills stand and any unresolved slot is reported as `SKIPPED (no TMDb match assigned)` in the group summary.
+
+The dry-run preview prints one line per group so you can verify the routing before running with `--execute`.
+
 ## Chapter splitting
 
 When the scanner detects that a file has chapter markers matching the number of TMDb Season 00 episodes, the tool automatically plans a chapter split instead of a single move. With `--execute`, this uses mkvmerge to split the file by chapters and moves each piece to the correct Season 00 location.
 
 ## Regional release selection
 
-dvdcompare lists multiple regional releases. In interactive mode (the default when running in a terminal), you will be presented with all available releases to choose from:
+dvdcompare lists multiple regional releases. In interactive mode (the default when running in a terminal), you will be presented with all available releases to choose from. The line above the picker shows which dvdcompare film page was matched so you can spot a wrong pick (e.g. a season 1 page when the disc is season 2) before choosing a region:
 
 ```
-Select a dvdcompare release:
+Matched dvdcompare film: Oppenheimer (2023) [film #12345]
+Select a dvdcompare release for Oppenheimer:
   1. North America (4K Ultra HD) [4 discs] *
   2. United Kingdom (4K Ultra HD) [4 discs]
   3. Germany (4K Ultra HD) [3 discs]

{riplex-0.9.9 → riplex-1.0.2}/docs/cli-guide/workflow.md

@@ -83,7 +83,9 @@ This will:
 5. Show a disc analysis table with rip recommendations
 6. Prompt for confirmation, then rip the selected titles
 
-Add `--yes` to skip the final rip confirmation prompt. Use `--auto` to also skip all interactive selection prompts (title, TMDb, release). Use `--titles 1,2,3` to override the auto-selection, or `--all` to rip everything. Add `--organize` to automatically run the organize step after ripping.
+At the final `Proceed? [Y/n/e(dit)]` prompt, press `e` to open an interactive title picker. The picker shows every title on the disc with `[x]`/`[ ]` marks reflecting the current selection and lets you toggle by index (`3`), comma-separated list (`1,4`), or range (`3-7`). Type `all` or `none` to select or clear everything, `default` to restore the analyzer's recommendation, `done` (or Enter) to accept, or `cancel` to abort the edit. This is the CLI equivalent of the GUI selection screen, so you no longer need to abort and re-run with `--titles 1,3,5` to fix a wrong recommendation.
+
+Add `--yes` to skip the final rip confirmation prompt (and the edit picker with it). Use `--auto` to also skip all interactive selection prompts (title, TMDb, release, season, edit). Use `--titles 1,2,3` to override the auto-selection non-interactively, or `--all` to rip everything. Add `--organize` to automatically run the organize step after ripping.
 
 Repeat for each disc in the set, swapping discs between runs.
 

riplex-1.0.2/docs/development/testing.md

@@ -0,0 +1,182 @@
+# Testing
+
+riplex uses `pytest`. Run the whole suite from the project root with the venv
+active:
+
+```
+pytest
+```
+
+The suite has two layers:
+
+- **Unit tests** (`tests/test_*.py`) — one file per source module, covering
+  parsing, planning, matching, and per-screen handler logic in isolation.
+- **Integration tests** (`tests/integration/`) — headless end-to-end flows that
+  drive the GUI wizard and the CLI through mocked scenarios to catch regressions
+  in how the pieces fit together.
+
+To run only the integration flows (or skip them):
+
+```
+pytest -m integration
+pytest -m "not integration"
+```
+
+## GUI integration tests
+
+The integration suite builds a real `RiplexApp` on a fake page and clicks
+through the wizard the way a user would — but with every external system
+(makemkv, TMDb, dvdcompare, config, network) replaced by fakes. This means a
+whole flow (welcome → disc detection → metadata → release → disc overview →
+rip → done) runs in milliseconds with no disc, no network, and no crash dialog.
+
+The goal is to catch the most common regression class: a screen that throws
+while rendering because an upstream change altered the shape of the state it
+reads.
+
+### Harness (`tests/support/`)
+
+| Module | Responsibility |
+| ------ | -------------- |
+| `fake_page.py` | `FakePage`, a stand-in for `ft.Page` implementing only the surface the screens touch, plus control-tree walking helpers. |
+| `sync_runtime.py` | Makes background threads and `page.run_task` run synchronously so flows are deterministic (no sleeps, no polling loops). |
+| `fixtures.py` | Loads a scenario JSON and reconstructs the **real** riplex dataclasses (`DiscInfo`, `MetadataSearchResult`, `PlannedDisc`, …). |
+| `provider_mocks.py` | Installs scenario-driven fakes for makemkv, TMDb, dvdcompare, config, and network in one call. |
+| `driver.py` | `WizardDriver` — `click(label)`, `has_text(...)`, `current`, `state`, `crashed()`. |
+
+The `gui` pytest fixture (in `tests/conftest.py`) wires it all together:
+
+```python
+def test_movie_flow(gui):
+    d = gui("the-matrix-1999")        # load a scenario, mock everything
+    d.click("Rip Disc")               # welcome -> disc detection -> metadata
+    d.click("Next")                   # accept the TMDb match
+    assert d.current == "disc_overview"
+    assert not d.crashed()
+```
+
+Failure injection to prove the net works: adding a `raise` to any screen's
+`build()` fails both the relevant flow test and the screen-build smoke matrix.
+
+### What is covered
+
+- **Screen-build smoke matrix** (`test_screen_build_smoke.py`) — builds *every*
+  screen with a fully-populated state for one representative scenario per media
+  type (plus a no-dvdcompare edge case).
+- **Media-type flow tests** (`test_flow_media_types.py`) — drive *every* fixture
+  of a given media type through the core orchestrate path, so the whole fixture
+  corpus is exercised through the real screens.
+- **Named flow tests** — movie orchestrate, TV multi-disc, organize,
+  resume/prefill fast paths, and error paths (makemkv unavailable, TMDb
+  empty/raises, dvdcompare failure, rip failure).
+- **Fixture integrity** — every committed scenario reconstructs into real
+  dataclasses and carries a valid media-type category.
+
+### Targeting media types
+
+Each scenario is classified into one media-type **category** so a test can run
+against exactly the fixtures it applies to — and automatically pick up new
+fixtures of that type as they're generated:
+
+| Category | Meaning |
+| -------- | ------- |
+| `movie` | A theatrical / feature film release. |
+| `tv_miniseries` | A limited, self-contained series (e.g. Chernobyl). |
+| `tv_series` | An ongoing multi-season show — a single-season rip *or* a complete-series set. |
+
+A single season of an ongoing show (e.g. a `Season 01` folder) is **series
+content**, so it classifies as `tv_series` and flows through the series tests.
+"Seasonal series" isn't a separate category; use `season_scenarios()` to target
+just the single-season rips.
+
+The category is inferred from the archive folder name, dvdcompare release name,
+and TMDb season structure; a scenario can also pin it with a top-level
+`"category"` key. `tests/support/fixtures.py` exposes filter helpers that return
+the matching scenario names for parametrization:
+
+```python
+from tests.support.fixtures import movie_scenarios, series_scenarios, season_scenarios
+
+@pytest.mark.parametrize("name", series_scenarios())   # every TV series fixture
+def test_series_flow(gui, name):
+    d = gui(name)
+    ...
+
+@pytest.mark.parametrize("name", season_scenarios())   # just single-season rips
+def test_seasonal_flow(gui, name):
+    ...
+```
+
+Adding a new fixture of a category makes it flow through that category's tests
+on the next run — no test edits required.
+
+## CLI integration tests
+
+The CLI is exercised end-to-end the same way: `tests/support/cli.py` runs the
+real argparse parser and async command dispatch (`_run`) in-process, so tests
+cover argument parsing, command routing, and command logic together. External
+boundaries (config, TMDb, dvdcompare) are stubbed via monkeypatch.
+
+```python
+from tests.support.cli import install_cli_mocks, run_command
+
+def test_lookup(monkeypatch, capsys):
+    install_cli_mocks(monkeypatch)              # offline config + providers
+    ...                                         # mock the lookup seam
+    code = run_command(["lookup", "The Matrix"])
+    assert code == 0
+    assert "The Matrix" in capsys.readouterr().out
+```
+
+Covered: parser/dispatch (help on no command, `--version`, unknown command,
+every subcommand parses), `organize` dry-run against a committed scan snapshot
+plus its guard rails (`--execute` rejected with `--snapshot`, missing snapshot,
+non-directory folder), and `lookup` (rip guide, graceful dvdcompare failure,
+`--json` output). The `organize --snapshot` path replays a real
+`tests/snapshots/*.snapshot.json` so no ffprobe or live files are needed.
+
+## Test fixtures from archived rips
+
+Integration scenarios live as committed JSON under
+`tests/fixtures/gui/scenarios/`. They share one schema between hand-authored
+edge cases and scenarios generated from real archived rips. The loader reads
+only the committed JSON, so the test suite never needs the archive and CI stays
+hermetic.
+
+### Generating scenarios
+
+Archived rips carry everything a scenario needs — the disc titles makemkv
+reported, the confirmed TMDb match, and the dvdcompare release breakdown — in
+their debug artifacts:
+
+- `<Title (Year)>/_riplex/riplex-rip.snapshot.json` — disc titles, TMDb match,
+  dvdcompare disc breakdown.
+- `<Title (Year)>/Disc N/_rip_manifest.json` — richer per-title stream info plus
+  the exact dvdcompare release name, disc format, and volume label (when
+  present).
+
+`scripts/gen_gui_fixtures.py` walks an archive root, normalizes each title
+folder into a scenario JSON, and writes it under `tests/fixtures/gui/scenarios/`:
+
+```
+# List archived folders (a * marks ones with a usable snapshot)
+python scripts/gen_gui_fixtures.py --list
+
+# Generate all scenarios
+python scripts/gen_gui_fixtures.py
+
+# Generate just one, from a custom archive path
+python scripts/gen_gui_fixtures.py --only "Chernobyl (2019)" \
+    --archive "/path/to/_archive"
+```
+
+Missing pieces (a TMDb id, per-episode lists on older snapshots, TMDb season
+structure) are synthesized deterministically and listed under a `synthesized`
+key in the output so consumers know which blocks are inferred rather than
+observed. Each generated scenario also carries a `category` (see
+[Targeting media types](#targeting-media-types)), which you can override by
+hand-editing the field.
+
+Re-run the generator and commit the resulting JSON whenever you want to refresh
+or add real-world scenarios. The archive itself is never required to run the
+tests.