app/src/test/java/org/justinvisser/wolfskin/tv/ActivityTruthProjectionTest.kt

@@ -1,74 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-only
-package org.justinvisser.wolfskin.tv
-
-import kotlinx.serialization.json.Json
-import org.junit.Assert.assertFalse
-import org.junit.Assert.assertNull
-import org.justinvisser.wolfskin.conductarr.model.ReadinessStage
-import org.justinvisser.wolfskin.design.ComingInStage
-import org.justinvisser.wolfskin.design.ShellPerson
-import org.junit.Assert.assertEquals
-import org.junit.Test
-import org.justinvisser.wolfskin.conductarr.model.ActivityFeed
-
-/** Recorded history separates acquisition, visibility proof, entitlement and file health. */
-class ActivityTruthProjectionTest {
-    private val rows = Json { ignoreUnknownKeys = true }.decodeFromString<ActivityFeed>(
-        javaClass.getResourceAsStream("/conductarr/activity-history.json")!!.bufferedReader().use { it.readText() }).items.orEmpty().associateBy { it.id }
-    @Test fun recordedHistoryDoesNotClaimActiveWorkOrFailedDownloadsWithoutEvidence() {
-        val viewer = ShellPerson("justin", "Justin", "J", false)
-        val expected = mapOf(
-            "request-2" to "Check needed", // Steins;Gate: represented file, failed visibility proof.
-            "request-1" to "Check needed", // Yu Yu Hakusho: represented files, failed visibility proof.
-            "dispatch-732" to "Check needed", // Love is Blind: same proof failure, not failed acquisition.
-            "dispatch-750" to "In another library", // Spider-Man: Homecoming: held elsewhere.
-            "dispatch-725" to "Removed", // One Hour Photo: deleted, absent actor.
-            "dispatch-723" to "Removed", // A historical play is not a current holding.
-            "dispatch-728" to "Not out yet", // The Body: unreleased.
-            "dispatch-721" to "File health needs attention", // Avatar: playback fault despite a holding.
-            "request-8" to "Waiting for a file", // Partition: no active transfer is established.
-            "dispatch-755" to "Waiting for a file", // Netherlands: primary import not observed.
-        )
-        assertNull(rows.getValue("dispatch-725").comingIn().actor(viewer))
-        expected.forEach { (id, label) -> assertEquals(rows.getValue(id).title, label, rows.getValue(id).comingIn().stage.label) }
-        listOf("request-2", "request-1", "dispatch-732", "dispatch-721").forEach { id ->
-            val source = rows.getValue(id)
-            val projected = source.comingIn()
-            val affected = source.stages.orEmpty().first { it.state == ReadinessStage.State.FAILED }
-            assertEquals(affected.summary, projected.summary)
-            assertFalse(projected.readiness[1] == "Failed")
-        }
-    }
-
-    @Test fun currentHealthSummaryKeepsEpisodeAndSourceScopeEvenWhenVisibilityIsDone() {
-        val row = rows.getValue("dispatch-721")
-        val summary = "S01E15 · primary source: unreadable; S02E08 · mirror source: unreadable."
-        val projected = row.copy(stages = row.stages.orEmpty().map {
-            when (it.name) {
-                ReadinessStage.Name.PLAYBACK -> it.copy(summary = summary)
-                ReadinessStage.Name.VISIBILITY -> it.copy(state = ReadinessStage.State.DONE)
-                else -> it
-            }
-        }).comingIn()
-        assertEquals(ComingInStage.FileHealth, projected.stage)
-        assertEquals(summary, projected.summary)
-    }
-
-    @Test fun absentTransferEvidenceNeverTurnsInProgressIntoDownloading() {
-        val row = rows.getValue("request-8")
-        val projected = row.copy(stages = row.stages.orEmpty().map {
-            if (it.name == ReadinessStage.Name.ACQUISITION) it.copy(summary = "Dispatch accepted.") else it
-        }).comingIn()
-        assertEquals(ComingInStage.Waiting, projected.stage)
-    }
-
-    @Test fun missingMembershipIsNeutralButProvenReadinessStaysReady() {
-        val row = rows.getValue("dispatch-725")
-        val absent = row.copy(stages = row.stages.orEmpty().map {
-            if (it.name == ReadinessStage.Name.ACQUISITION) it.copy(state = ReadinessStage.State.UNKNOWN, summary = "No current observation.") else it
-        })
-        assertEquals(ComingInStage.NotInLibrary, absent.comingIn().stage)
-        val ready = rows.values.first { it.stages.orEmpty().any { stage -> stage.name == ReadinessStage.Name.VISIBILITY && stage.state == ReadinessStage.State.DONE } }
-        assertEquals(ComingInStage.Ready, ready.comingIn().stage)
-    }
-}

app/src/test/java/org/justinvisser/wolfskin/tv/ConductarrProjectionTest.kt

@@ -41,6 +41,7 @@ class ConductarrProjectionTest {
                 assertEquals(ComingInStage.Downloading, request.stage)
                 assertEquals("Mindel", request.requesterName)
                 assertEquals("Shared", request.actor(ShellPerson("shared", "Shared", "S", true)))
+                assertEquals(1, requests.openCount)
             }
         }
     }

app/src/test/java/org/justinvisser/wolfskin/tv/ConductarrTruthCaptureTest.kt

@@ -1,105 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-only
-package org.justinvisser.wolfskin.tv
-
-import android.app.Application
-import android.view.View
-import android.view.WindowManager
-import androidx.activity.ComponentActivity
-import androidx.compose.foundation.layout.requiredSize
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.test.junit4.createAndroidComposeRule
-import androidx.compose.ui.test.onRoot
-import androidx.compose.ui.test.assertCountEquals
-import androidx.compose.ui.test.assertIsDisplayed
-import androidx.compose.ui.test.onAllNodesWithText
-import androidx.compose.ui.test.onNodeWithText
-import com.github.takahirom.roborazzi.captureRoboImage
-import java.io.File
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.flow.last
-import kotlinx.coroutines.runBlocking
-import org.junit.Before
-import org.junit.Rule
-import org.junit.Test
-import org.junit.runner.RunWith
-import org.justinvisser.wolfskin.conductarr.ConductarrClient
-import org.justinvisser.wolfskin.conductarr.MemoryCacheStore
-import org.justinvisser.wolfskin.design.*
-import org.robolectric.RobolectricTestRunner
-import org.robolectric.annotation.Config
-import org.robolectric.annotation.GraphicsMode
-
-/** Native frames exercise recorded activity and Mindel's feed through the shipped provider. */
-@RunWith(RobolectricTestRunner::class)
-@Config(sdk = [34], application = Application::class, qualifiers = "w960dp-h540dp-xhdpi")
-@GraphicsMode(GraphicsMode.Mode.NATIVE)
-class ConductarrTruthCaptureTest {
-    @get:Rule val rule = createAndroidComposeRule<ComponentActivity>()
-    private val people = listOf(ShellPerson("justin", "Justin", "J", false), ShellPerson("mindel", "Mindel", "M", false))
-
-    @Before fun fullscreen() {
-        rule.activity.window.setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN)
-        @Suppress("DEPRECATION")
-        rule.activity.window.decorView.systemUiVisibility = View.SYSTEM_UI_FLAG_FULLSCREEN or View.SYSTEM_UI_FLAG_HIDE_NAVIGATION or View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY
-    }
-
-    @Test fun requestHistory() = requests("requests-history", "request-2")
-    @Test fun requestHealth() = requests("requests-health", "dispatch-721", expanded = true)
-    @Test fun requestProofDetails() = requests("requests-proof", "request-2", expanded = true)
-    @Test fun requestRemoved() = requests("requests-removed", "dispatch-725")
-    @Test fun discoverMovies() = discover("movie")
-    @Test fun discoverSeries() = discover("tv")
-
-    private fun requests(name: String, focused: String, expanded: Boolean = false) {
-        FakeConductarr().use { fake ->
-            fake.activityBody = resource("activity-history.json")
-            ConductarrClient(fake.url, JUSTIN_TOKEN, MemoryCacheStore()).use { client ->
-                val snapshot = runBlocking { ConductarrProvider(client).requests().last() }.let { it.copy(items = it.items.map { row -> row.copy(poster = null) }) }
-                val shell = ShellState(people, "justin").apply {
-                    pickerVisible = false
-                    enterDestination("settings")
-                    requests.update(snapshot)
-                    openRequests()
-                    requests.focus(focused)
-                    if (expanded) requests.key(ShellKey.Right)
-                }
-                rule.setContent { WolfskinTheme { ShellSurface(shell, Modifier.requiredSize(WolfskinTokens.Shell.stageWidth, WolfskinTokens.Shell.stageHeight)) } }
-                capture(name)
-                rule.onAllNodesWithText("by Unknown", substring = true).assertCountEquals(0)
-                rule.onNodeWithText("Requests · 56 requests").assertExists()
-                if (expanded) rule.onNodeWithText(snapshot.items.first { it.id == focused }.summary!!).assertIsDisplayed()
-            }
-        }
-    }
-
-    private fun discover(type: String) {
-        FakeConductarr().use { fake ->
-            fake.feedBody = resource("mindel-feed.json")
-            ConductarrClient(fake.url, MINDEL_TOKEN, MemoryCacheStore()).use { client ->
-                val provider = ConductarrProvider(client)
-                val snapshot = runBlocking { provider.discover("mindel").last() }.let { original ->
-                    fun noArt(title: DiscoverTitle) = title.copy(poster = null, backdrop = null)
-                    original.copy(picks = original.picks.map(::noArt), seeds = original.seeds.map { it.copy(items = it.items.map(::noArt)) })
-                }
-                val shell = ShellState(people, "mindel").apply { pickerVisible = false; enterDestination("discover") }
-                val operator = runBlocking { (client.read(org.justinvisser.wolfskin.conductarr.TvRoutes.operator()).last() as org.justinvisser.wolfskin.conductarr.ReadResult.Value).saved.value }
-                val state = DiscoverState(shell, snapshot, provider.operations(requireNotNull(operator)), CoroutineScope(Dispatchers.Main.immediate))
-                state.filter = type
-                state.focus(state.firstShelf + state.lanes.indexOfFirst { it.title.startsWith("Because you watched") }, 0)
-                rule.setContent { WolfskinTheme { ShellSurface(shell, Modifier.requiredSize(WolfskinTokens.Shell.stageWidth, WolfskinTokens.Shell.stageHeight)) { DiscoverScreen(state, it) } } }
-                capture("discover-$type")
-                rule.onNodeWithText(if (type == "tv") "Because you watched Gilmore Girls" else "Because you watched Locke").assertIsDisplayed()
-            }
-        }
-    }
-
-    private fun capture(name: String) {
-        rule.mainClock.advanceTimeBy(1000)
-        rule.waitForIdle()
-        val directory = File(requireNotNull(System.getProperty("wolfskin.captureDirectory")), "truth").apply { mkdirs() }
-        rule.onRoot().captureRoboImage(File(directory, "$name.png").absolutePath)
-    }
-
-    private fun resource(name: String) = javaClass.getResourceAsStream("/conductarr/$name")!!.bufferedReader().use { it.readText() }
-}

app/src/test/java/org/justinvisser/wolfskin/tv/DiscoverSeedProjectionTest.kt

@@ -1,37 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-only
-package org.justinvisser.wolfskin.tv
-
-import kotlinx.coroutines.flow.last
-import kotlinx.coroutines.runBlocking
-import kotlinx.serialization.json.*
-import org.junit.Assert.*
-import org.junit.Test
-import org.justinvisser.wolfskin.conductarr.ConductarrClient
-import org.justinvisser.wolfskin.conductarr.MemoryCacheStore
-
-/** Equal captions are not equal seed identities; repeated contributions union their evidence. */
-class DiscoverSeedProjectionTest {
-    @Test fun seedIdentitySurvivesTitleCollisionsAndWatchEvidenceAcrossCandidates() = runBlocking {
-        FakeConductarr().use { fake ->
-            val feed = fake.wire.getValue("feed").jsonObject
-            val candidate = feed.getValue("movies").jsonArray.first().jsonObject
-            val first = JsonObject(candidate + ("contributions" to Json.parseToJsonElement("""[
-                {"media_type":"movie","tmdb_id":1,"title":"Same title","watched":true,"added":false},
-                {"media_type":"tv","tmdb_id":1,"title":"Same title","watched":false,"added":true},
-                {"media_type":"movie","tmdb_id":2,"watched":true,"added":false}
-            ]""")))
-            val second = JsonObject(candidate + mapOf("tmdb_id" to JsonPrimitive(43), "contributions" to Json.parseToJsonElement("""[
-                {"media_type":"movie","tmdb_id":1,"title":"Renamed seed","watched":false,"added":true}
-            ]""")))
-            fake.feedBody = JsonObject(feed + ("movies" to JsonArray(listOf(first, second)))).toString()
-            ConductarrClient(fake.url, MINDEL_TOKEN, MemoryCacheStore()).use { client ->
-                val seeds = ConductarrProvider(client).discover("mindel").last().seeds
-                assertEquals(listOf("movie:1", "tv:1"), seeds.map { it.key })
-                assertEquals(listOf(42L, 43L), seeds.first().items.map { it.tmdb })
-                assertTrue(seeds.first().watched && seeds.first().added)
-                assertFalse(seeds.last().watched)
-                assertTrue(seeds.last().added)
-            }
-        }
-    }
-}

app/src/test/java/org/justinvisser/wolfskin/tv/FakeConductarr.kt

@@ -29,8 +29,6 @@ internal class FakeConductarr : Closeable {
     @Volatile var localArt = false
     @Volatile var beforeResponse: ((String) -> Unit)? = null
     @Volatile var audiencesBody: String? = null
-    @Volatile var feedBody: String? = null
-    @Volatile var activityBody: String? = null
     private val imageBytes = java.util.Base64.getDecoder().decode(
         "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+jYioAAAAASUVORK5CYII=")
 
@@ -71,8 +69,6 @@ internal class FakeConductarr : Closeable {
                 if (key == "ratings" && ratingsStatus != 200) return response("", ratingsStatus)
                 if (key == "audiences" && audiencesStatus != 200) return response("", audiencesStatus)
                 if (key == "audiences") audiencesBody?.let { return response(it) }
-                if (key == "feed") feedBody?.let { return response(it) }
-                if (key == "activity") activityBody?.let { return response(it) }
                 if (notModified && request.headers["If-None-Match"] != null) return response("", 304)
                 if (key == "requests" && !existingRequests) return response("{\"requests\":[]}")
                 var body = wire.getValue(key).jsonObject

app/src/wolfskin/java/org/justinvisser/wolfskin/tv/ConductarrProjection.kt

@@ -41,62 +41,20 @@ internal fun DiscoverTitle.homeTitle(): HomeTitle = HomeTitle(
     overview = overview, poster = poster, backdrop = backdrop, genres = genres, tmdbId = tmdb.toInt(),
 )
 
-/** Activity is history; stage evidence must not turn a past dispatch into a live transfer. */
 internal fun RequestProgress.comingIn(): ComingInRequest {
     val stagesByName = stages.orEmpty().associateBy { it.name }
     val acquisition = stagesByName[ReadinessStage.Name.ACQUISITION]
     val visibility = stagesByName[ReadinessStage.Name.VISIBILITY]
-    val playback = stagesByName[ReadinessStage.Name.PLAYBACK]
     val stage = when {
-        acquisition?.summary == "The title was deleted after it was dispatched." -> ComingInStage.Removed
+        stages.orEmpty().any { it.state == ReadinessStage.State.FAILED } -> ComingInStage.Failed
-        acquisition?.summary == "The title is not released yet; there is nothing to acquire." -> ComingInStage.NotOutYet
-        playback?.state == ReadinessStage.State.FAILED || playback?.state == ReadinessStage.State.CONFLICTING -> ComingInStage.FileHealth
-        visibility?.summary?.startsWith("The title is only in libraries this viewer does not see: ") == true -> ComingInStage.HeldElsewhere
-        visibility?.summary == "The title is not in a library this viewer sees." -> ComingInStage.NotInLibrary
-        visibility?.state == ReadinessStage.State.FAILED || visibility?.state == ReadinessStage.State.CONFLICTING -> ComingInStage.CheckNeeded
-        stagesByName[ReadinessStage.Name.REQUEST]?.state == ReadinessStage.State.FAILED || acquisition?.state == ReadinessStage.State.FAILED -> ComingInStage.Failed
         visibility?.state == ReadinessStage.State.DONE -> ComingInStage.Ready
-        awaitingApproval == true || acquisition?.summary == "Waiting for Seerr's approval to reach dispatch." -> ComingInStage.Waiting
+        awaitingApproval == true -> ComingInStage.Waiting
-        acquisition?.summary == "Dispatched; waiting for the Arr to import a file." -> ComingInStage.WaitingForFile
+        visibility?.state in setOf(ReadinessStage.State.IN_PROGRESS, ReadinessStage.State.PARTIAL) || acquisition?.state == ReadinessStage.State.DONE -> ComingInStage.AlmostReady
-        visibility?.state == ReadinessStage.State.IN_PROGRESS || visibility?.state == ReadinessStage.State.PARTIAL || acquisition?.state == ReadinessStage.State.DONE -> ComingInStage.AlmostReady
+        acquisition?.state == ReadinessStage.State.IN_PROGRESS -> ComingInStage.Downloading
-        acquisition?.state == ReadinessStage.State.IN_PROGRESS && acquisition.summary.startsWith("Downloading", ignoreCase = true) -> ComingInStage.Downloading
+        acquisition?.state == ReadinessStage.State.NONE -> ComingInStage.Searching
-        acquisition?.state == ReadinessStage.State.NONE && acquisition.summary.startsWith("Searching", ignoreCase = true) -> ComingInStage.Searching
+        stages.orEmpty().any { it.state in setOf(ReadinessStage.State.UNKNOWN, ReadinessStage.State.STALE, ReadinessStage.State.CONFLICTING) } -> ComingInStage.Checking
-        acquisition?.state == ReadinessStage.State.IN_PROGRESS || acquisition?.state == ReadinessStage.State.NONE -> ComingInStage.Waiting
+        else -> ComingInStage.Waiting
-        else -> ComingInStage.Checking
-    }
-    val detail = when (stage) {
-        ComingInStage.FileHealth -> playback
-        ComingInStage.CheckNeeded, ComingInStage.HeldElsewhere, ComingInStage.NotInLibrary, ComingInStage.Ready -> visibility
-        ComingInStage.Failed -> stages.orEmpty().firstOrNull { it.state == ReadinessStage.State.FAILED }
-        else -> acquisition
     }
     return ComingInRequest(id, mediaType.name.lowercase(), tmdbId, title ?: "Title unavailable", requester.key,
-        requester.name, actor?.requester, actor?.name, stage, summary = detail?.summary,
+        requester.name, actor?.requester, actor?.name, stage)
-        readiness = ReadinessStage.Name.entries.map { stagesByName[it].readinessWord() })
-}
-
-/** Expanded readiness describes each observed stage, not a synthetic download failure. */
-private fun ReadinessStage?.readinessWord(): String = when {
-    this == null -> "Unknown"
-    name == ReadinessStage.Name.PLAYBACK && (state == ReadinessStage.State.FAILED || state == ReadinessStage.State.CONFLICTING) -> "Needs attention"
-    name == ReadinessStage.Name.VISIBILITY && (state == ReadinessStage.State.FAILED || state == ReadinessStage.State.CONFLICTING) -> "Check needed"
-    name == ReadinessStage.Name.ACQUISITION && summary == "The title was deleted after it was dispatched." -> "Removed"
-    name == ReadinessStage.Name.ACQUISITION && summary == "The title is not released yet; there is nothing to acquire." -> "Not out yet"
-    name == ReadinessStage.Name.ACQUISITION && summary.startsWith("Dispatched; the Arr has represented files") -> "Files present"
-    name == ReadinessStage.Name.ACQUISITION && summary == "Dispatched; waiting for the Arr to import a file." -> "Waiting for a file"
-    name == ReadinessStage.Name.VISIBILITY && summary.startsWith("The title is only in libraries this viewer does not see: ") -> "Another library"
-    name == ReadinessStage.Name.VISIBILITY && summary == "The title is not in a library this viewer sees." -> "Not in library"
-    name == ReadinessStage.Name.ACQUISITION && state == ReadinessStage.State.IN_PROGRESS && summary.startsWith("Downloading", ignoreCase = true) -> "Downloading"
-    name == ReadinessStage.Name.PLAYBACK && (state == ReadinessStage.State.DONE || state == ReadinessStage.State.PARTIAL) -> "Recorded play"
-    name == ReadinessStage.Name.PLAYBACK && state == ReadinessStage.State.UNKNOWN -> "Not checked yet"
-    else -> when (state) {
-        ReadinessStage.State.DONE -> "Done"
-        ReadinessStage.State.FAILED -> "Failed"
-        ReadinessStage.State.IN_PROGRESS -> "In progress"
-        ReadinessStage.State.PARTIAL -> "Partial"
-        ReadinessStage.State.NONE -> "Not yet"
-        ReadinessStage.State.UNKNOWN -> "Unknown"
-        ReadinessStage.State.STALE -> "Last observed"
-        ReadinessStage.State.CONFLICTING -> "Check needed"
-    }
 }

app/src/wolfskin/java/org/justinvisser/wolfskin/tv/ConductarrProvider.kt

@@ -57,14 +57,10 @@ class ConductarrProvider(val client: ConductarrClient) : ConductarrTitleProvider
         val loader = catalogue?.takeIf { it.queries == queries } ?: ConductarrCatalogue(client, queries) { libraryAudiences }.also { catalogue = it }
         val lanes = if (trigger == ReadTrigger.CACHE_ONLY) loader.saved() else loader.through(1, force = trigger == ReadTrigger.FORCE)
         val genres = options.flatMap { it.genres.orEmpty() }.associate { it.id to it.name }
-        val candidates = feed?.movies.orEmpty() + feed?.shows.orEmpty()
+        val picks = (feed?.movies.orEmpty() + feed?.shows.orEmpty()).map { it.discoverTitle(genres) }
-        val picks = candidates.map { it.discoverTitle(genres) }
+        val seeds = (feed?.movies.orEmpty() + feed?.shows.orEmpty()).flatMap { candidate ->
-        val seeds = candidates.flatMapIndexed { index, candidate ->
+            candidate.contributions.orEmpty().mapNotNull { seed -> seed.title?.let { it to candidate.discoverTitle(genres) } }
-            candidate.contributions.orEmpty().filter { !it.title.isNullOrBlank() }.map { it to picks[index] }
+        }.groupBy({ it.first }, { it.second }).map { DiscoverSeed(it.key, it.value) }
-        }.groupBy { (seed, _) -> "${seed.mediaType.name.lowercase()}:${seed.tmdbId}" }.map { (key, contributions) ->
-            DiscoverSeed(key, requireNotNull(contributions.first().first.title), contributions.map { it.second },
-                watched = contributions.any { it.first.watched }, added = contributions.any { it.first.added })
-        }
         val hidden = hiddenJob.await()?.dismissals.orEmpty().map {
             DiscoverTitle(it.tmdbId, it.mediaType.name.lowercase(), it.title, it.year.toInt(), poster = catalogueImage(it.posterPath))
         }

app/src/wolfskin/java/org/justinvisser/wolfskin/tv/RequestsRefresh.kt

@@ -28,6 +28,6 @@ internal suspend fun refreshRequestsWhileStarted(state: ShellState, refresh: ()
     refresh()
     while (currentCoroutineContext().isActive) {
         delay(WolfskinTokens.Behaviour.requestsPollSeconds.toLong() * 1000L)
-        if (state.requestsVisible || state.requests.snapshot.hasUnsettledRequests) refresh()
+        if (state.requestsVisible || state.requests.snapshot.openCount > 0) refresh()
     }
 }

docker/README.md

@@ -1,8 +1,8 @@
 # Wolfskin TV container builds
 
 Run from a full Git checkout with the upstream `v*` and `p*` tags available. The
-host needs Docker, GNU Make, Bash, Git, `realpath` (GNU coreutils), and `flock`
+host needs Docker, GNU Make, Bash, Git, and `flock` (util-linux), not Java or the
-(util-linux), not Java or the Android SDK.
+Android SDK.
 
 ```sh
 git fetch origin --tags
@@ -35,9 +35,8 @@ dependency baseline profiles. It changes only signing (the Android debug key),
 package (`org.justinvisser.wolfskin.tv.opt`) and launcher label (`Wolfskin (Opt)`).
 The launcher icon/banner and release-compatible version name are unchanged:
 the shared upgrade/updater parser rejects extra suffixes such as `-opt`.
-`make apk` remains the clean, release-key-signed production build. Debug and
+`make apk` remains the clean, release-key-signed production build; neither its
-optimized containers share the persistent debug key described below; release
+signing flow nor the existing debug build changes.
-signing is unchanged.
 
 Build all four default-flavor outputs in one invocation through the container
 wrapper, without a release keystore. On a host whose Gradle cache already holds
@@ -213,14 +212,6 @@ destination is an explicit title-family integration stub exposing only Discover'
 request and pick actions. Unheld titles have no trailer control until the pinned
 Conductarr title contract supplies a trailer.
 
-Named “Because you watched” shelves require watched contribution evidence.
-Seeds are grouped by media type and TMDB identity, never by caption; repeated
-contributions retain both watched/added flags. The current feed has no per-seed
-watch timestamp, so eligible shelves keep wire order. Added-only contributions
-remain available in the general For-you collections, but make no named shelf.
-Titleless contributions do not make a shelf. Recommendations remain acquisition
-suggestions, not a filter to the viewer's current library.
-
 The debug-only fixture and local art live in
 `app/src/debug/assets/wolfskin-discover/`. The Advanced preview switch selects a
 network-free fixture host; real providers are the default in debug and release.
@@ -359,24 +350,14 @@ are recorded differences, not a claim of browser pixel equality.
 
 ## Requests under Settings
 
-The Requests row and Coming-in sheet share one immutable household history snapshot.
+The Requests row and Coming-in sheet share one immutable household snapshot.
-Settings counts returned requests, including Ready, rather than calling every
+Ready requests do not count as open. Rows sort Failed, Downloading/Almost ready,
-non-Ready row “open”. An unavailable empty snapshot has no count. Deleted rows
+Checking/Searching, Waiting, Ready. The bounded window shows five rows, or four
-read Removed; absent holdings read Not in any library; unreleased titles read
+with readiness expanded. Right expands Request/Download/Library/Playback; Left
-Not out yet; holdings outside the recipient's libraries read In another library.
+collapses; Up/Down collapse while moving. Opening a title preserves the request
-Waiting for an import is not evidence of an active download. Downloading and
+for Back, and closing the sheet restores its opener. Selecting a root or changing
-Searching require explicit acquisition signals. Visibility-proof faults read
+person clears the title-return link. Shared's authenticated actor always reads
-Check needed; playback faults read File health needs attention, even when a
+“by Shared”, never “by you”.
-library holding is present. Right expands the actual stage evidence and the
-relevant summary, including episode/source names when supplied by that summary.
-The activity feed currently supplies only a title-level summary for Avatar.
-
-Attention-needed rows sort first, then active acquisition/checks, waiting and
-settled history. The bounded window shows five rows, or four with readiness
-expanded. Left collapses; Up/Down collapse while moving. Opening a title preserves
-the request for Back, and closing the sheet restores its opener. Selecting a root
-or changing person clears the title-return link. Shared's authenticated actor
-always reads “by Shared”, never “by you”; absent actors have no “by” clause.
 
 The debug fixture switch loads `app/src/debug/assets/wolfskin-requests.json` and
 its eight local posters. Shared and focused-rating records also feed the native
@@ -428,15 +409,6 @@ type and TMDB identity. Back restores the exact Coming-in row and expansion;
 the temporary `request-title/...` placeholder is removed. TV sign-in, release
 and device deployment remain separate.
 
-`ActivityTruthProjectionTest` feeds recorded activity JSON through the TV adapter
-for Steins;Gate, Yu Yu Hakusho, Love is Blind, Spider-Man: Homecoming, deleted
-One Hour Photo, unreleased The Body, Avatar health and Partition waiting.
-`ConductarrTruthCaptureTest` renders those provider snapshots and Mindel's recorded
-recommendation feed on the native Compose surfaces at 1920×1080, writing
-`build/wolfskin-captures/truth/`. Artwork is deliberately omitted to keep these
-captures offline; missing-art rendering, tokens, focus, sheet geometry and shelf
-spacing are the shipped components.
-
 ## Libraries and See all
 
 Movies, Shows and Anime use the shell's retained view and a continuous six-column
@@ -842,41 +814,6 @@ whose parent directory already exists. All callers sharing a volume must use
 the same lock path on the Docker host. Do not delete the file while builds are
 running or waiting. The lock releases automatically when the invocation exits.
 
-## Persistent debug signing
-
-`make apk-debug` and non-release `docker/gradle.sh` invocations (including
-`:app:assembleDefaultOptimized`) use one host keystore, outside the checkout:
-
-```text
-/root/.treehouse/firstmate-7bab20/2/firstmate/data/signing/debug.keystore
-```
-
-Set `WOLFSKIN_DEBUG_KEYSTORE` to another file in a dedicated directory outside
-the checkout when building on another host, for example:
-
-```sh
-WOLFSKIN_DEBUG_KEYSTORE="$HOME/.local/share/wolfskin-signing/debug.keystore" make apk-debug
-```
-
-The wrapper creates a missing key once using the build image's `keytool`: RSA
-2048, 10,000-day validity, alias `androiddebugkey`, store/key passwords `android`,
-and subject `CN=Android Debug`. The containing directory is mode `0700`, the
-file mode `0600`. Existing keys are reused, never regenerated; generation errors
-abort the build rather than falling back to an ephemeral container key.
-The file is bind-mounted read-only at `/tmp/.android/debug.keystore`, with
-`ANDROID_USER_HOME=/tmp/.android`, for every non-release Gradle container.
-Keep and back up this file across clean builds, disposable worktrees, container
-rebuilds and Gradle cache resets. Never commit it. The standard debug passwords
-are public; this key is for local debug/optimized builds, not release signing.
-
-**One-time reinstall:** the first build with the stable key still needs one
-uninstall+reinstall on the box because the signer changes once; later ones
-install in place with `adb install -r`, retaining sign-ins and settings.
-The initial uninstall removes app data, so sign in again once after that switch.
-Deleting/replacing the persistent key or choosing a different override changes
-the signer again and requires another reinstall.
-
-
 ## Release credentials
 
 The default escrow is

docker/gradle.sh

@@ -35,36 +35,5 @@ if [[ $mode == release ]]; then
         exec ./gradlew "$@"
     ' bash "${gradle_arguments[@]}" "$@"
 else
-    debug_keystore=$(realpath -m "${WOLFSKIN_DEBUG_KEYSTORE:-/root/.treehouse/firstmate-7bab20/2/firstmate/data/signing/debug.keystore}")
-    case "$debug_keystore" in
-        "$root"|"$root"/*)
-            printf 'Debug keystore must be outside the checkout: %s\n' "$debug_keystore" >&2
-            exit 1
-            ;;
-    esac
-    signing_directory=$(dirname "$debug_keystore")
-    mkdir -p "$signing_directory"
-    chmod 700 "$signing_directory"
-    if [[ ! -e $debug_keystore ]]; then
-        temporary_directory=$(mktemp -d "$signing_directory/.debug-keystore.XXXXXX")
-        trap 'rm -rf -- "$temporary_directory"' EXIT
-        if ! docker run --rm --platform linux/amd64 --user "$(id -u):$(id -g)" \
-            --mount "type=bind,src=$temporary_directory,dst=/run/signing" \
-            "$image" keytool -genkeypair -noprompt -keystore /run/signing/debug.keystore \
-            -storetype JKS -storepass android -keypass android -alias androiddebugkey \
-            -keyalg RSA -keysize 2048 -validity 10000 -dname "CN=Android Debug"; then
-            printf 'Failed to generate persistent debug keystore: %s\n' "$debug_keystore" >&2
-            exit 1
-        fi
-        chmod 600 "$temporary_directory/debug.keystore"
-        mv "$temporary_directory/debug.keystore" "$debug_keystore"
-    fi
-    if [[ ! -s $debug_keystore ]]; then
-        printf 'Missing or empty persistent debug keystore: %s\n' "$debug_keystore" >&2
-        exit 1
-    fi
-    chmod 600 "$debug_keystore"
-    arguments+=(--env ANDROID_USER_HOME=/tmp/.android
-        --mount "type=bind,src=$debug_keystore,dst=/tmp/.android/debug.keystore,readonly")
     docker run "${arguments[@]}" "$image" ./gradlew "${gradle_arguments[@]}" "$@"
 fi

wolfskin-design/src/main/java/org/justinvisser/wolfskin/design/ComingInSheet.kt

@@ -157,8 +157,7 @@ fun ComingInRow(item: ComingInRequest, viewer: ShellPerson, focused: Boolean, ex
         Column(Modifier.weight(1f)) {
             Text(item.title, Modifier.comingInLineBox(T.titleLineHeight, T.titleBaseline),
                 style = ComingInTypography.listTitle, color = foreground, maxLines = 1, overflow = TextOverflow.Ellipsis)
-            val actor = item.actor(viewer)
+            Text("for ${item.recipient(viewer)} · by ${item.actor(viewer)}", Modifier.comingInLineBox(T.factsLineHeight, T.factsBaseline),
-            Text("for ${item.recipient(viewer)}" + (actor?.let { " · by $it" } ?: ""), Modifier.comingInLineBox(T.factsLineHeight, T.factsBaseline),
                 style = ComingInTypography.caption, color = secondary)
             FlowRow(Modifier.padding(top = T.stageMargin).heightIn(min = T.stageLineHeight), horizontalArrangement = Arrangement.spacedBy(T.readinessGlyph)) {
                 Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(T.stageGap)) {
@@ -169,17 +168,14 @@ fun ComingInRow(item: ComingInRequest, viewer: ShellPerson, focused: Boolean, ex
             }
             if (expanded) FlowRow(Modifier.padding(top = T.readinessMargin),
                 horizontalArrangement = Arrangement.spacedBy(T.readinessGapX), verticalArrangement = Arrangement.spacedBy(T.readinessGapY)) {
-                item.readiness.forEachIndexed { index, word ->
+                item.stage.readiness.forEachIndexed { index, word ->
                     Row {
-                        val glyph = when (word) { "Done", "Files present", "Recorded play", "Another library" -> "check"; "Failed", "Check needed", "Needs attention" -> "alert"; "Not yet", "Unknown", "Not checked yet", "Not in library", "Removed", "Not out yet" -> null; else -> "clock" }
+                        val glyph = when (word) { "Done" -> "check"; "Failed" -> "alert"; "Not yet", "Unknown" -> null; else -> "clock" }
                         if (glyph != null) Glyph(glyph, secondary, Modifier.size(T.readinessGlyph).alignBy { it.measuredHeight })
                         Text("${READINESS_NAMES[index]} · $word", Modifier.alignByBaseline(), style = ComingInTypography.readiness, color = secondary)
                     }
                 }
             }
-            if (expanded) item.summary?.let { summary ->
-                Text(summary, Modifier.padding(top = T.readinessMargin), style = ComingInTypography.readiness, color = secondary)
-            }
         }
         if (focused && !expanded) Glyph("right", foreground.copy(alpha = T.chevronAlpha), Modifier.size(T.chevron))
     }

wolfskin-design/src/main/java/org/justinvisser/wolfskin/design/ComingInState.kt

@@ -6,21 +6,14 @@ import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.setValue
 
 import kotlinx.coroutines.delay
-/** History states distinguish acquisition work from library evidence and playback health. */
+/** Household acquisition stages, ordered independently from their display wording. */
 enum class ComingInStage(val label: String, val rank: Int, val glyph: String, val readiness: List<String>) {
     Failed("Failed", 0, "alert", listOf("Done", "Failed", "Not yet", "Not yet")),
-    FileHealth("File health needs attention", 0, "alert", listOf("Done", "Files present", "See details", "Needs attention")),
-    CheckNeeded("Check needed", 0, "alert", listOf("Done", "Files present", "Check needed", "Not checked yet")),
     Downloading("Downloading", 1, "download", listOf("Done", "Downloading", "Not yet", "Not yet")),
     AlmostReady("Almost ready", 1, "download", listOf("Done", "Done", "Being added", "Not yet")),
     Checking("Checking", 2, "clock", listOf("Checking", "Unknown", "Not yet", "Not yet")),
     Searching("Searching", 2, "clock", listOf("Done", "Searching", "Not yet", "Not yet")),
     Waiting("Waiting", 3, "clock", listOf("Waiting", "Not yet", "Not yet", "Not yet")),
-    WaitingForFile("Waiting for a file", 3, "clock", listOf("Done", "Waiting for a file", "Not yet", "Not checked yet")),
-    NotOutYet("Not out yet", 3, "clock", listOf("Done", "Not out yet", "Not yet", "Not checked yet")),
-    HeldElsewhere("In another library", 4, "check", listOf("Done", "Files present", "Another library", "Not checked yet")),
-    Removed("Removed", 4, "clock", listOf("Done", "Removed", "Not in library", "Not checked yet")),
-    NotInLibrary("Not in any library", 4, "clock", listOf("Done", "Not observed", "Not in library", "Not checked yet")),
     Ready("Ready", 4, "check", listOf("Done", "Done", "Done", "Not checked yet")),
 }
 
@@ -40,15 +33,13 @@ data class ComingInRequest(
     val stage: ComingInStage,
     val poster: Any? = null,
     val ratings: List<ComingInRating> = emptyList(),
-    val summary: String? = null,
-    val readiness: List<String> = stage.readiness,
 ) {
     val ratingKey = "$mediaType:$tmdbId"
     fun recipient(viewer: ShellPerson): String = if (requesterKey == viewer.key) "you" else requesterName
-    fun actor(viewer: ShellPerson): String? = when {
+    fun actor(viewer: ShellPerson): String = when {
         actorKey == "shared" -> "Shared"
         actorKey != null && actorKey == viewer.key -> "you"
-        else -> actorName?.takeIf { it.isNotBlank() }
+        else -> actorName ?: "Unknown"
     }
 }
 
@@ -63,13 +54,7 @@ data class ComingInSnapshot(
     val savedAt: String? = null,
 ) {
     val ordered = items.sortedBy { it.stage.rank }
-    val requestCount: Int? get() = if (status == ComingInStatus.Ready || items.isNotEmpty()) items.size else null
+    val openCount: Int get() = items.count { it.stage != ComingInStage.Ready }
-    val hasUnsettledRequests: Boolean get() = items.any {
-        when (it.stage) {
-            ComingInStage.Ready, ComingInStage.Removed, ComingInStage.NotInLibrary, ComingInStage.HeldElsewhere, ComingInStage.NotOutYet -> false
-            else -> true
-        }
-    }
 }
 
 /** A bounded window and stable request id preserve focus across refreshes and title round trips. */

wolfskin-design/src/main/java/org/justinvisser/wolfskin/design/DiscoverFixture.kt

@@ -35,8 +35,7 @@ class DiscoverFixture(json: String, private val artPath: (String) -> String = {
                 val items = pool.filter { genre in normalizedGenres(it.genres) && (genre !in setOf("Science Fiction", "Horror", "Romance") || it.type == "movie") }
                 DiscoverLane("genre-$genre", genre, items.take(20), items.size, fullTitles = items)
             }
-        return DiscoverSnapshot(picks, groups.map { (key, group) -> DiscoverSeed(key, group.first, group.second.toList(), watched = true, added = false) },
+        return DiscoverSnapshot(picks, groups.values.map { DiscoverSeed(it.first, it.second.toList()) }, services, lanes, status = DiscoverStatus.Ready, reusesFixtureLanes = true)
-            services, lanes, status = DiscoverStatus.Ready, reusesFixtureLanes = true)
     }
 
     fun service(service: DiscoverService, type: String): List<DiscoverLane> {

wolfskin-design/src/main/java/org/justinvisser/wolfskin/design/DiscoverLaneProjection.kt

@@ -10,9 +10,7 @@ internal fun projectDiscoverLanes(snapshot: DiscoverSnapshot, heroes: List<Disco
     val result = mutableListOf<DiscoverLane>()
     fun take(items: List<DiscoverTitle>, limit: Int) = items.filter { matches(it) && it.key !in hidden && it.key !in seen }.take(limit).filter { seen.add(it.key) }
     if (snapshot.status == DiscoverStatus.Ready) {
-        val groups = snapshot.seeds.asSequence().filter { it.watched && it.title.isNotBlank() }
+        val groups = snapshot.seeds.map { seed -> seed.copy(items = seed.items.filter { matches(it) && it.key !in hidden }) }.filter { it.items.isNotEmpty() }.take(3)
-            .map { seed -> seed.copy(items = seed.items.filter { matches(it) && it.key !in hidden }) }
-            .filter { it.items.isNotEmpty() }.take(3).toList()
         for ((type, name) in listOf("movie" to "Movies", "tv" to "Series")) {
             val all = snapshot.picks.filter { it.type == type && matches(it) && it.key !in hidden }
             val count = all.count { it.key !in seen }
@@ -20,9 +18,9 @@ internal fun projectDiscoverLanes(snapshot: DiscoverSnapshot, heroes: List<Disco
             if (items.isNotEmpty()) result += DiscoverLane("pk-$type", "$name for you", items, all.size, pick = true, fullTitles = all)
         }
         val size = if (groups.isEmpty()) 0 else minOf(8, ceil(snapshot.picks.count { matches(it) && it.key !in seen && it.key !in hidden }.toDouble() / groups.size).toInt())
-        groups.forEach { seed ->
+        groups.forEachIndexed { index, seed ->
             val items = take(seed.items, size)
-            if (items.size >= 3) result += DiscoverLane("pk-w-${seed.key}", "Because you watched ${seed.title}", items, seed.items.size, pick = true, fullTitles = seed.items)
+            if (items.size >= 3) result += DiscoverLane("pk-w$index", "Because you watched ${seed.title}", items, seed.items.size, pick = true, fullTitles = seed.items)
         }
     }
     val displayed = heroes.mapTo(mutableSetOf()) { it.key }

wolfskin-design/src/main/java/org/justinvisser/wolfskin/design/DiscoverModel.kt

@@ -26,8 +26,8 @@ data class DiscoverTitle(
 /** Observed source marks keep labels separate from score values. */
 data class DiscoverRating(val source: String, val score: Double, val label: String? = null)
 
-/** A typed seed identity and its contribution evidence retain wire order without inventing recency. */
+/** A contribution group preserves feed order rather than assigning a visible rank. */
-data class DiscoverSeed(val key: String, val title: String, val items: List<DiscoverTitle>, val watched: Boolean, val added: Boolean)
+data class DiscoverSeed(val title: String, val items: List<DiscoverTitle>)
 
 /** Services carry their catalogue id and a text wordmark, never third-party logos. */
 data class DiscoverService(val id: Long, val name: String, val hue: Float)

wolfskin-design/src/main/java/org/justinvisser/wolfskin/design/SettingsList.kt

@@ -52,9 +52,9 @@ val SETTINGS_GROUPS = listOf(
     SettingsGroup("advanced", "Advanced settings", "Ratings display · Backdrop style · Playback backend (ExoPlayer, MPV) · Max resolution and bitrate · Skip segments · Logs and image cache"),
 )
 
-/** The count describes returned request history, not an inferred queue of active downloads. */
+/** The household request count shares the sheet's snapshot and excludes Ready. */
 @Composable
-fun SettingsList(state: ShellState, modifier: Modifier = Modifier, requestCount: Int? = null) {
+fun SettingsList(state: ShellState, modifier: Modifier = Modifier, openRequests: Int? = null) {
     val list = state.view.listState
     val density = LocalDensity.current
     LaunchedEffect(state.settingsRow, state.navFocused) {
@@ -78,7 +78,7 @@ fun SettingsList(state: ShellState, modifier: Modifier = Modifier, requestCount:
         itemsIndexed(SETTINGS_GROUPS, key = { _, group -> group.key }) { index, group ->
             Box(Modifier.height(L.row_srow)) {
                 SettingsRow(group, !state.navFocused && !state.requestsVisible && index == state.settingsRow,
-                    if (group.key == "requests") requestCount else null,
+                    if (group.key == "requests") openRequests else null,
                     Modifier.offset(L.safeSide, S.settingsRowTop)) {
                     state.navFocused = false; state.settingsRow = index; state.key(ShellKey.Ok)
                 }
@@ -89,7 +89,7 @@ fun SettingsList(state: ShellState, modifier: Modifier = Modifier, requestCount:
 
 /** The inverse focus fill has no focus ring and never changes row layout. */
 @Composable
-fun SettingsRow(group: SettingsGroup, focused: Boolean, requestCount: Int?, modifier: Modifier = Modifier, onClick: () -> Unit) {
+fun SettingsRow(group: SettingsGroup, focused: Boolean, openRequests: Int?, modifier: Modifier = Modifier, onClick: () -> Unit) {
     val foreground = if (focused) C.onFocus else C.fg
     Row(modifier.size(L.settingsRowWidth, L.settingsRowHeight).focusScale(focused, WolfskinTokens.Focus.scaleRow)
         .background(if (focused) C.fg else C.listRowRest, RoundedCornerShape(WolfskinTokens.Radius.listRow))
@@ -97,7 +97,7 @@ fun SettingsRow(group: SettingsGroup, focused: Boolean, requestCount: Int?, modi
         verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(S.settingsRowGap)) {
         Glyph(group.key, if (focused) C.onFocus else C.accentText, Modifier.size(S.settingsIcon))
         Column(Modifier.weight(1f)) {
-            val count = requestCount?.let { " · $it ${if (it == 1) "request" else "requests"}" } ?: ""
+            val count = if (openRequests != null && openRequests > 0) " · $openRequests open" else ""
             Text(group.title + count, Modifier.exactLineBox(WolfskinTokens.Type.listTitle), color = foreground, style = WolfskinTokens.Type.listTitle, maxLines = 1)
             Text(group.description, Modifier.exactLineBox(WolfskinTokens.Type.caption), color = if (focused) C.onFocus else C.muted, style = WolfskinTokens.Type.caption, maxLines = 1, overflow = TextOverflow.Ellipsis)
         }

wolfskin-design/src/main/java/org/justinvisser/wolfskin/design/ShellSurface.kt

@@ -55,7 +55,7 @@ fun ShellSurface(
     state: ShellState,
     modifier: Modifier = Modifier,
     handlesContentKeys: Boolean = true,
-    settingsRequestCount: Int? = null,
+    settingsOpenRequests: Int? = null,
     overlay: @Composable () -> Unit = {},
     content: @Composable (Modifier) -> Unit = { ShellPlaceholder(state.route) },
 ) {
@@ -91,7 +91,7 @@ fun ShellSurface(
         if (state.pickerVisible) {
             WhosWatching(state)
         } else {
-            if (state.route == "settings") SettingsList(state, requestCount = settingsRequestCount ?: state.requests.snapshot.requestCount) else content(Modifier.fillMaxSize().focusRequester(contentFocus).focusRestorer().focusGroup())
+            if (state.route == "settings") SettingsList(state, openRequests = settingsOpenRequests ?: state.requests.snapshot.openCount) else content(Modifier.fillMaxSize().focusRequester(contentFocus).focusRestorer().focusGroup())
             NavBar(state, state.view.listState.firstVisibleItemIndex > 0 || state.view.listState.firstVisibleItemScrollOffset > L.navSolidAfter.value * 2)
             if (state.requestsVisible) ComingInSheet(state)
             overlay()

wolfskin-design/src/test/java/org/justinvisser/wolfskin/design/DiscoverLaneProjectionTest.kt

@@ -8,7 +8,7 @@ import org.junit.Test
 class DiscoverLaneProjectionTest {
     @Test fun discardedSeedGroupRemainsAvailableInCatalogue() {
         val titles = (1L..6L).map { DiscoverTitle(it, "movie", "Film $it") }
-        val snapshot = DiscoverSnapshot(picks = titles, seeds = listOf(DiscoverSeed("movie:10", "Seed", titles.subList(3, 5), watched = true, added = false)),
+        val snapshot = DiscoverSnapshot(picks = titles, seeds = listOf(DiscoverSeed("Seed", titles.subList(3, 5))),
             lanes = listOf(DiscoverLane("trending", "Trending", titles)), status = DiscoverStatus.Ready)
         val rows = projectDiscoverLanes(snapshot, emptyList(), "all", emptyMap())
         assertEquals(listOf("pk-movie", "trending"), rows.map { it.id })
@@ -30,25 +30,4 @@ class DiscoverLaneProjectionTest {
         val filtered = projectDiscoverLanes(snapshot, emptyList(), "tv", mapOf(hidden.key to hidden))
         assertEquals(listOf(listOf(series)), filtered.map { it.titles })
     }
-
-    @Test fun addedOnlySeedsKeepTheirPicksWithoutClaimingTheyWereWatched() {
-        val titles = (1L..9L).map { DiscoverTitle(it, "movie", "Film $it") }
-        val snapshot = DiscoverSnapshot(picks = titles, seeds = listOf(
-            DiscoverSeed("movie:10", "Added seed", titles, watched = false, added = true)), status = DiscoverStatus.Ready)
-        val lanes = projectDiscoverLanes(snapshot, emptyList(), "all", emptyMap())
-        assertEquals(listOf("Movies for you"), lanes.map { it.title })
-        assertEquals(titles, lanes.single().fullTitles)
-    }
-
-    @Test fun watchedLanesKeepWireOrderAndStableIdentityWhenTitlesCollide() {
-        val titles = (1L..24L).map { DiscoverTitle(it, "movie", "Film $it") }
-        val snapshot = DiscoverSnapshot(picks = titles, seeds = listOf(
-            DiscoverSeed("movie:50", "Added seed", titles.take(8), watched = false, added = true),
-            DiscoverSeed("tv:70", "Same title", titles.subList(8, 16), watched = true, added = true),
-            DiscoverSeed("movie:70", "Same title", titles.subList(16, 24), watched = true, added = false)),
-            status = DiscoverStatus.Ready)
-        val lanes = projectDiscoverLanes(snapshot, emptyList(), "all", emptyMap())
-        assertEquals(listOf("pk-movie", "pk-w-tv:70", "pk-w-movie:70"), lanes.map { it.id })
-        assertEquals(listOf(titles.subList(8, 16), titles.subList(16, 24)), lanes.drop(1).map { it.titles })
-    }
 }

wolfskin-design/src/test/java/org/justinvisser/wolfskin/design/RequestsKeysTest.kt

@@ -53,6 +53,7 @@ class RequestsKeysTest {
         assertEquals(path.getInt("presses"), presses.length())
         for (index in 0 until presses.length()) send(keys.getValue(presses.getString(index)))
         rule.onNodeWithTag("coming-in").assertExists()
+        rule.onNodeWithText("Requests · 5 open").assertExists()
         assertEquals("settings", state.route)
         assertEquals("x5", state.requests.focusedId)
         assertFalse(state.navFocused)
@@ -143,5 +144,7 @@ class RequestsKeysTest {
         val viewer = fixturePeople().single { it.key == "shared" }
         assertEquals("Shared", shared.actor(viewer))
         assertEquals("Justin", shared.recipient(viewer))
+        assertEquals(5, snapshot.openCount)
+        assertEquals(listOf(0, 1, 1, 2, 3, 4), snapshot.ordered.map { it.stage.rank })
     }
 }

wolfskin-design/src/test/java/org/justinvisser/wolfskin/design/ShellCaptureTest.kt

@@ -38,12 +38,12 @@ class ShellCaptureTest {
         rule.activity.window.decorView.systemUiVisibility = View.SYSTEM_UI_FLAG_FULLSCREEN or View.SYSTEM_UI_FLAG_HIDE_NAVIGATION or View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY
     }
 
-    private fun capture(name: String, requestCount: Int? = null, configure: (ShellState) -> Unit = {}) {
+    private fun capture(name: String, openRequests: Int? = null, configure: (ShellState) -> Unit = {}) {
         val state = ShellState(fixturePeople(), "justin")
         configure(state)
         rule.setContent {
             WolfskinTheme {
-                ShellSurface(state, Modifier.requiredSize(WolfskinTokens.Shell.stageWidth, WolfskinTokens.Shell.stageHeight), settingsRequestCount = requestCount)
+                ShellSurface(state, Modifier.requiredSize(WolfskinTokens.Shell.stageWidth, WolfskinTokens.Shell.stageHeight), settingsOpenRequests = openRequests)
             }
         }
         rule.mainClock.advanceTimeBy(1000)
@@ -67,7 +67,7 @@ class ShellCaptureTest {
     @Test fun st011_rememberedNav() = capture("st-011") { it.pickerVisible = false; it.navFocused = true; it.view.row = 4; it.view.cards["row-4"] = 2 }
     @Test fun st014_discoverNav() = capture("st-014") { it.pickerVisible = false; it.navFocused = true; it.navIndex = 1 }
     @Test fun st091_settings() = capture("st-091") { it.pickerVisible = false; it.enterDestination("settings") }
-    @Test fun st092_requestsCountFixture() = capture("st-092", requestCount = 5) { it.pickerVisible = false; it.enterDestination("settings") }
+    @Test fun st092_requestsCountFixture() = capture("st-092", openRequests = 5) { it.pickerVisible = false; it.enterDestination("settings") }
     @Test fun st093_profileFocus() = capture("st-093") { it.pickerVisible = false; it.enterDestination("settings"); it.settingsRow = 4 }
 }