From 7ebf817fdbf208c898827b561e7963971f3d79f3 Mon Sep 17 00:00:00 2001
From: AE <98699388+A-EDev@users.noreply.github.com>
Date: Sat, 24 Oct 2026 13:44:19 +0300
Subject: [PATCH 1/5] fix(subscriptions): read whether an RSS entry is a Short
 from its link (#1393)

---
 .../flow/data/subscriptions/ChannelRssFeed.kt |  2 ++
 .../data/subscriptions/ChannelRssParser.kt    | 16 ++++++++++
 .../subscriptions/ChannelRssParserTest.kt     | 32 ++++++++++++++++++-
 3 files changed, 49 insertions(+), 1 deletion(-)

diff --git a/app/src/main/java/io/github/aedev/flow/data/subscriptions/ChannelRssFeed.kt b/app/src/main/java/io/github/aedev/flow/data/subscriptions/ChannelRssFeed.kt
index 93c2c54332..22f26beabf 100644
--- a/app/src/main/java/io/github/aedev/flow/data/subscriptions/ChannelRssFeed.kt
+++ b/app/src/main/java/io/github/aedev/flow/data/subscriptions/ChannelRssFeed.kt
@@ -8,6 +8,8 @@ data class ChannelRssEntry(
     val publishedAtMillis: Long = 0L,
     val viewCount: Long = 0L,
     val description: String? = null,
+    /** From the entry's link: YouTube links a reel as `/shorts/`. Null when the link says neither. */
+    val isShort: Boolean? = null,
 )
 
 /**
diff --git a/app/src/main/java/io/github/aedev/flow/data/subscriptions/ChannelRssParser.kt b/app/src/main/java/io/github/aedev/flow/data/subscriptions/ChannelRssParser.kt
index 2e49f60595..531ef5cc73 100644
--- a/app/src/main/java/io/github/aedev/flow/data/subscriptions/ChannelRssParser.kt
+++ b/app/src/main/java/io/github/aedev/flow/data/subscriptions/ChannelRssParser.kt
@@ -52,6 +52,7 @@ object ChannelRssParser {
             var description: String? = null
             var publishedAt = 0L
             var viewCount = 0L
+            var isShort: Boolean? = null
 
             var eventType = parser.eventType
             while (eventType != XmlPullParser.END_DOCUMENT) {
@@ -67,6 +68,7 @@ object ChannelRssParser {
                             description = null
                             publishedAt = 0L
                             viewCount = 0L
+                            isShort = null
                         } else if (insideEntry) {
                             when {
                                 tagName.equals("videoId", ignoreCase = true) -> {
@@ -95,6 +97,10 @@ object ChannelRssParser {
                                 tagName.equals("statistics", ignoreCase = true) && viewCount == 0L -> {
                                     viewCount = parser.getAttributeValue(null, "views")?.toLongOrNull() ?: 0L
                                 }
+
+                                tagName.equals("link", ignoreCase = true) && isShort == null -> {
+                                    isShort = reelVerdict(parser.getAttributeValue(null, "href"))
+                                }
                             }
                         } else if (tagName.equals("name", ignoreCase = true) && channelName == null) {
                             // Only the feed-level <author> carries a <name> in a channel feed.
@@ -116,6 +122,7 @@ object ChannelRssParser {
                                         publishedAtMillis = publishedAt,
                                         viewCount = viewCount,
                                         description = description,
+                                        isShort = isShort,
                                     )
                             }
                         }
@@ -129,6 +136,15 @@ object ChannelRssParser {
         return ChannelRssFeed(channelName = channelName?.takeIf { it.isNotBlank() }, entries = entries)
     }
 
+    private fun reelVerdict(href: String?): Boolean? {
+        val path = href?.substringAfter("://", "")?.substringAfter('/', "") ?: return null
+        return when {
+            path.startsWith("shorts/") -> true
+            path.startsWith("watch") -> false
+            else -> null
+        }
+    }
+
     private fun parseTimestamp(value: String?): Long {
         val text = value?.trim().orEmpty()
         if (text.isEmpty()) return 0L
diff --git a/app/src/test/java/io/github/aedev/flow/data/subscriptions/ChannelRssParserTest.kt b/app/src/test/java/io/github/aedev/flow/data/subscriptions/ChannelRssParserTest.kt
index 031a2aee2a..bd02c00c2b 100644
--- a/app/src/test/java/io/github/aedev/flow/data/subscriptions/ChannelRssParserTest.kt
+++ b/app/src/test/java/io/github/aedev/flow/data/subscriptions/ChannelRssParserTest.kt
@@ -22,7 +22,10 @@ class ChannelRssParserTest {
     private fun entriesOf(xml: String): List<ChannelRssEntry> = parse(xml).entries
 
     /** A channel feed shaped like YouTube's, entries newest first. */
-    private fun feed(vararg ids: String): String =
+    private fun feed(
+        vararg ids: String,
+        links: Map<String, String> = emptyMap(),
+    ): String =
         buildString {
             // No leading whitespace: an XML declaration must start at offset 0.
             append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>")
@@ -32,11 +35,13 @@ class ChannelRssParserTest {
                     "xmlns=\"http://www.w3.org/2005/Atom\">",
             )
             append("<title>Channel Name</title>")
+            append("<link rel=\"alternate\" href=\"https://www.youtube.com/channel/x\"/>")
             append("<author><name>Uploader Name</name><uri>https://www.youtube.com/channel/x</uri></author>")
             ids.forEach { id ->
                 append("<entry>")
                 append("<yt:videoId>$id</yt:videoId>")
                 append("<title>Title $id</title>")
+                links[id]?.let { append("<link rel=\"alternate\" href=\"$it\"/>") }
                 append("<published>2026-05-01T12:00:00+00:00</published>")
                 append("<media:group>")
                 append("<media:title>Title $id</media:title>")
@@ -185,4 +190,29 @@ class ChannelRssParserTest {
     fun `empty feed announces nothing`() {
         assertEquals(emptyList<ChannelRssEntry>(), ChannelRssParser.newEntriesSince(emptyList(), lastVideoId = "aaa"))
     }
+
+    @Test
+    fun `entry link tells a reel from a video`() {
+        val entries =
+            entriesOf(
+                feed(
+                    "reel",
+                    "video",
+                    links =
+                        mapOf(
+                            "reel" to "https://www.youtube.com/shorts/reel",
+                            "video" to "https://www.youtube.com/watch?v=video",
+                        ),
+                ),
+            )
+
+        assertEquals(listOf(true, false), entries.map { it.isShort })
+    }
+
+    @Test
+    fun `entry without a recognised link has no reel verdict`() {
+        val entries = entriesOf(feed("bare", "other", links = mapOf("other" to "https://www.youtube.com/live/other")))
+
+        assertEquals(listOf(null, null), entries.map { it.isShort })
+    }
 }

From 9389c292f8f98f123441b0a7e6aed3161ace375d Mon Sep 17 00:00:00 2001
From: AE <98699388+A-EDev@users.noreply.github.com>
Date: Sat, 24 Oct 2026 13:44:19 +0300
Subject: [PATCH 2/5] fix(subscriptions): classify RSS rows from the link
 before asking the Shorts tab (#1393)

---
 .../data/innertube/RssSubscriptionService.kt  | 28 +++++----
 .../subscriptions/SubscriptionReelVerdicts.kt | 18 ++++++
 .../innertube/RssSubscriptionServiceTest.kt   | 24 ++++++++
 .../SubscriptionReelVerdictsTest.kt           | 61 +++++++++++++++++++
 4 files changed, 118 insertions(+), 13 deletions(-)

diff --git a/app/src/main/java/io/github/aedev/flow/data/innertube/RssSubscriptionService.kt b/app/src/main/java/io/github/aedev/flow/data/innertube/RssSubscriptionService.kt
index 3289fac57b..788a92eaf1 100644
--- a/app/src/main/java/io/github/aedev/flow/data/innertube/RssSubscriptionService.kt
+++ b/app/src/main/java/io/github/aedev/flow/data/innertube/RssSubscriptionService.kt
@@ -6,6 +6,7 @@ import io.github.aedev.flow.data.shorts.ChannelReelIndex
 import io.github.aedev.flow.data.subscriptions.ChannelRssClient
 import io.github.aedev.flow.data.subscriptions.ChannelRssEntry
 import io.github.aedev.flow.data.subscriptions.ChannelUploadsClient
+import io.github.aedev.flow.data.subscriptions.classifiedFromVerdicts
 import io.github.aedev.flow.utils.ThumbnailUrlResolver
 import io.github.aedev.flow.utils.formatYouTubeRelativeTime
 import io.github.aedev.flow.utils.parsePremiereTimestamp
@@ -111,7 +112,7 @@ class RssSubscriptionService
                                 .map { channelId ->
                                     async(Dispatchers.IO) {
                                         val result = fetchRssVideos(channelId, minimumDateMillis, knownVideoIds)
-                                        Triple(channelId, result, knownReels(channelId, result.videos, storedReelVerdicts))
+                                        Triple(channelId, result, knownReels(channelId, result, storedReelVerdicts))
                                     }
                                 }.awaitAll()
                         }
@@ -311,6 +312,7 @@ class RssSubscriptionService
             val videoTimestamps: Map<String, Long>,
             val videos: List<Video>,
             val needsChannelFallback: Boolean,
+            val linkVerdicts: Map<String, Boolean> = emptyMap(),
             /** The feed lists an upload inside the window, whether or not it survived the filters. */
             val hasRecentEntries: Boolean = false,
             val failed: Boolean = false,
@@ -325,7 +327,7 @@ class RssSubscriptionService
 
         /**
          * RSS gives accurate dates for all recent uploads (including Shorts) but never a duration or a
-         * Shorts/live flag, so its timestamps double as the date source for the Phase 2 tab items.
+         * live flag, so its timestamps double as the date source for the Phase 2 tab items.
          */
         private suspend fun fetchRssVideos(
             channelId: String,
@@ -347,6 +349,7 @@ class RssSubscriptionService
 
             val timestamps = mutableMapOf<String, Long>()
             val videos = mutableListOf<Video>()
+            val linkVerdicts = mutableMapOf<String, Boolean>()
             var newestTimestamp = 0L
 
             for (entry in feed.entries) {
@@ -356,6 +359,7 @@ class RssSubscriptionService
                 if (publishedAt > newestTimestamp) newestTimestamp = publishedAt
                 if (publishedAt > minimumDateMillis && !entry.isPaidOrMembersOnly()) {
                     videos += entry.toVideo(channelId = channelId, channelName = feed.channelName)
+                    entry.isShort?.let { linkVerdicts[entry.videoId] = it }
                 }
             }
 
@@ -377,25 +381,23 @@ class RssSubscriptionService
                 videoTimestamps = timestamps,
                 videos = videos,
                 needsChannelFallback = videos.isEmpty() && newestTimestamp > minimumDateMillis,
+                linkVerdicts = linkVerdicts,
                 hasRecentEntries = newestTimestamp > minimumDateMillis,
             )
         }
 
         /**
-         * RSS cannot tell a reel from a video. When the store already classified every entry, or the
-         * Shorts tab was read within the cache window, the answer is reused; otherwise the channel
-         * needs a Shorts check, one full browse, and null holds it for the checks stage.
+         * Each entry's link, else a stored verdict, classifies the slice without a browse. When some
+         * entry has neither, a Shorts tab read within the cache window is reused; otherwise the
+         * channel needs a Shorts check, one full browse, and null holds it for the checks stage.
          */
         private suspend fun knownReels(
             channelId: String,
-            videos: List<Video>,
+            result: RssResult,
             storedReelVerdicts: Map<String, Boolean>,
-        ): List<Video>? {
-            if (videos.isNotEmpty() && videos.all { it.id in storedReelVerdicts }) {
-                return videos.map { it.copy(isShort = storedReelVerdicts.getValue(it.id)) }
-            }
-            return channelReelIndex.markReelsIfCached(channelId, videos)
-        }
+        ): List<Video>? =
+            classifiedFromVerdicts(result.videos, result.linkVerdicts, storedReelVerdicts)
+                ?: channelReelIndex.markReelsIfCached(channelId, result.videos)
 
         private fun ChannelRssEntry.toVideo(
             channelId: String,
@@ -416,7 +418,7 @@ class RssSubscriptionService
                 timestampIsExact = true,
                 channelThumbnailUrl = "",
                 description = description.orEmpty(),
-                isShort = false,
+                isShort = isShort == true,
                 isLive = false,
                 isUpcoming = isUpcoming,
             )
diff --git a/app/src/main/java/io/github/aedev/flow/data/subscriptions/SubscriptionReelVerdicts.kt b/app/src/main/java/io/github/aedev/flow/data/subscriptions/SubscriptionReelVerdicts.kt
index 2612f98d4d..b66fba33f5 100644
--- a/app/src/main/java/io/github/aedev/flow/data/subscriptions/SubscriptionReelVerdicts.kt
+++ b/app/src/main/java/io/github/aedev/flow/data/subscriptions/SubscriptionReelVerdicts.kt
@@ -1,6 +1,7 @@
 package io.github.aedev.flow.data.subscriptions
 
 import io.github.aedev.flow.data.local.entity.SubscriptionFeedEntity
+import io.github.aedev.flow.data.model.Video
 
 /**
  * The stored reel verdicts a refresh may reuse instead of asking a channel's Shorts tab again.
@@ -17,3 +18,20 @@ internal fun trustedReelVerdicts(
     rows
         .filter { row -> row.cachedAt <= (lastFeedFetchAt[row.channelId] ?: 0L) }
         .associate { it.videoId to it.isShort }
+
+/**
+ * Classifies a channel's RSS slice without asking its Shorts tab, or returns null when some entry
+ * has no verdict. The feed's own link outranks a stored verdict, so a row filed wrong by an older
+ * pass is repaired as soon as its entry is read again.
+ */
+internal fun classifiedFromVerdicts(
+    videos: List<Video>,
+    linkVerdicts: Map<String, Boolean>,
+    storedVerdicts: Map<String, Boolean>,
+): List<Video>? {
+    if (videos.isEmpty()) return null
+    return videos.map { video ->
+        val isShort = linkVerdicts[video.id] ?: storedVerdicts[video.id] ?: return null
+        video.copy(isShort = isShort)
+    }
+}
diff --git a/app/src/test/java/io/github/aedev/flow/data/innertube/RssSubscriptionServiceTest.kt b/app/src/test/java/io/github/aedev/flow/data/innertube/RssSubscriptionServiceTest.kt
index 6f94d8d9c1..4e05044583 100644
--- a/app/src/test/java/io/github/aedev/flow/data/innertube/RssSubscriptionServiceTest.kt
+++ b/app/src/test/java/io/github/aedev/flow/data/innertube/RssSubscriptionServiceTest.kt
@@ -56,12 +56,14 @@ class RssSubscriptionServiceTest {
         title: String = "Title $id",
         description: String? = null,
         ageHours: Long = 2L,
+        isShort: Boolean? = null,
     ) = ChannelRssEntry(
         videoId = id,
         title = title,
         thumbnailUrl = null,
         publishedAtMillis = System.currentTimeMillis() - ageHours * hour,
         description = description,
+        isShort = isShort,
     )
 
     private fun rss(
@@ -110,6 +112,28 @@ class RssSubscriptionServiceTest {
             assertThat(sweep("UCa").videos.map { it.id }).containsExactly("v2")
         }
 
+    @Test
+    fun `entries the feed links as reels are filed as Shorts without a Shorts tab lookup (1393)`() =
+        runTest {
+            rss("UCa", entry("v1", isShort = false), entry("r1", ageHours = 3, isShort = true))
+
+            val chunk = sweep("UCa")
+
+            coVerify(exactly = 0) { reelIndex.markReels(any(), any(), any()) }
+            assertThat(chunk.videos.associate { it.id to it.isShort }).containsExactly("v1", false, "r1", true)
+        }
+
+    @Test
+    fun `a reel stays filed as a Short when the lookup for an unlinked entry fails (1393)`() =
+        runTest {
+            coEvery { reelIndex.markReels(any(), any(), any()) } returns null
+            rss("UCa", entry("v1"), entry("r1", ageHours = 3, isShort = true))
+
+            val chunk = sweep("UCa")
+
+            assertThat(chunk.videos.associate { it.id to it.isShort }).containsExactly("v1", false, "r1", true)
+        }
+
     @Test
     fun `a channel whose RSS lists only reels falls back to its tabs`() =
         runTest {
diff --git a/app/src/test/java/io/github/aedev/flow/data/subscriptions/SubscriptionReelVerdictsTest.kt b/app/src/test/java/io/github/aedev/flow/data/subscriptions/SubscriptionReelVerdictsTest.kt
index 2232537adf..644355ac23 100644
--- a/app/src/test/java/io/github/aedev/flow/data/subscriptions/SubscriptionReelVerdictsTest.kt
+++ b/app/src/test/java/io/github/aedev/flow/data/subscriptions/SubscriptionReelVerdictsTest.kt
@@ -2,6 +2,7 @@ package io.github.aedev.flow.data.subscriptions
 
 import com.google.common.truth.Truth.assertThat
 import io.github.aedev.flow.data.local.entity.SubscriptionFeedEntity
+import io.github.aedev.flow.data.model.Video
 import org.junit.Test
 
 /** A reel verdict is reused only when a pass that read its channel in full stored it. */
@@ -52,4 +53,64 @@ class SubscriptionReelVerdictsTest {
     fun `a channel never read in full has no trusted verdicts`() {
         assertThat(trustedReelVerdicts(listOf(row("seeded", "UCb", cachedAt = 10L)), emptyMap())).isEmpty()
     }
+
+    private fun video(id: String) =
+        Video(
+            id = id,
+            title = id,
+            channelName = "UCa",
+            channelId = "UCa",
+            thumbnailUrl = "",
+            duration = 0,
+            viewCount = 0L,
+            uploadDate = "",
+        )
+
+    @Test
+    fun `link verdicts classify the slice without a lookup`() {
+        val classified =
+            classifiedFromVerdicts(
+                videos = listOf(video("reel"), video("video")),
+                linkVerdicts = mapOf("reel" to true, "video" to false),
+                storedVerdicts = emptyMap(),
+            )
+
+        assertThat(classified?.map { it.id to it.isShort }).containsExactly("reel" to true, "video" to false).inOrder()
+    }
+
+    @Test
+    fun `a link verdict repairs a stored one`() {
+        val classified =
+            classifiedFromVerdicts(
+                videos = listOf(video("reel")),
+                linkVerdicts = mapOf("reel" to true),
+                storedVerdicts = mapOf("reel" to false),
+            )
+
+        assertThat(classified?.single()?.isShort).isTrue()
+    }
+
+    @Test
+    fun `a stored verdict fills an entry the link leaves open`() {
+        val classified =
+            classifiedFromVerdicts(
+                videos = listOf(video("reel"), video("old")),
+                linkVerdicts = mapOf("reel" to true),
+                storedVerdicts = mapOf("old" to false),
+            )
+
+        assertThat(classified?.map { it.isShort }).containsExactly(true, false).inOrder()
+    }
+
+    @Test
+    fun `an entry with no verdict at all leaves the slice for a lookup`() {
+        val classified =
+            classifiedFromVerdicts(
+                videos = listOf(video("reel"), video("unknown")),
+                linkVerdicts = mapOf("reel" to true),
+                storedVerdicts = emptyMap(),
+            )
+
+        assertThat(classified).isNull()
+    }
 }

From 361b3a8f0599e1aea738f8422645d8cba15ec94c Mon Sep 17 00:00:00 2001
From: AE <98699388+A-EDev@users.noreply.github.com>
Date: Sat, 24 Oct 2026 13:44:20 +0300
Subject: [PATCH 3/5] fix(notifications): stop announcing and seeding Shorts
 when the Shorts lookup fails

---
 .../2026-10-24-fix-subscription-shorts-rss-link.md        | 3 +++
 .../flow/data/subscriptions/SubscriptionFeedRepository.kt | 6 +++---
 .../aedev/flow/notification/SubscriptionCheckWorker.kt    | 8 +++++++-
 3 files changed, 13 insertions(+), 4 deletions(-)
 create mode 100644 .github/nightly-notes/2026-10-24-fix-subscription-shorts-rss-link.md

diff --git a/.github/nightly-notes/2026-10-24-fix-subscription-shorts-rss-link.md b/.github/nightly-notes/2026-10-24-fix-subscription-shorts-rss-link.md
new file mode 100644
index 0000000000..cb49140cf5
--- /dev/null
+++ b/.github/nightly-notes/2026-10-24-fix-subscription-shorts-rss-link.md
@@ -0,0 +1,3 @@
+## Fixed
+- Shorts no longer show up in Subscriptions when Subscription shorts is turned off (#1393)
+- Shorts no longer slip through as new video notifications when Shorts notifications are off
diff --git a/app/src/main/java/io/github/aedev/flow/data/subscriptions/SubscriptionFeedRepository.kt b/app/src/main/java/io/github/aedev/flow/data/subscriptions/SubscriptionFeedRepository.kt
index 151e7a6862..d7d8077b97 100644
--- a/app/src/main/java/io/github/aedev/flow/data/subscriptions/SubscriptionFeedRepository.kt
+++ b/app/src/main/java/io/github/aedev/flow/data/subscriptions/SubscriptionFeedRepository.kt
@@ -296,9 +296,9 @@ class SubscriptionFeedRepository
          * has already enriched. The channel is deliberately *not* marked as fetched: RSS alone
          * cannot see livestreams, so the feed still owes it a full pass.
          *
-         * [reelVideoIds] is the caller's reel verdict for these entries. RSS marks none of them, so
-         * without it every seeded reel reaches the feed as an ordinary upload and stays there until
-         * the channel's next full refresh — visible even with Shorts switched off (#903).
+         * [reelVideoIds] is the caller's reel verdict for these entries, from their links or the
+         * Shorts tab. Without it every seeded reel reaches the feed as an ordinary upload and stays
+         * there until the channel's next full refresh, visible even with Shorts switched off (#903).
          */
         suspend fun seedFromNotificationCheck(
             channelId: String,
diff --git a/app/src/main/java/io/github/aedev/flow/notification/SubscriptionCheckWorker.kt b/app/src/main/java/io/github/aedev/flow/notification/SubscriptionCheckWorker.kt
index 0d48997a0e..3553f0cf6b 100644
--- a/app/src/main/java/io/github/aedev/flow/notification/SubscriptionCheckWorker.kt
+++ b/app/src/main/java/io/github/aedev/flow/notification/SubscriptionCheckWorker.kt
@@ -222,7 +222,13 @@ class SubscriptionCheckWorker(
         val latestVideo = feed.entries.firstOrNull() ?: return emptyList()
         if (subscription.lastVideoId == latestVideo.videoId) return emptyList()
 
-        val reelVideoIds = dependencies.channelReelIndex().reelIds(subscription.channelId).orEmpty()
+        val linkedReelIds = feed.entries.filter { it.isShort == true }.mapTo(HashSet()) { it.videoId }
+        val reelVideoIds =
+            if (feed.entries.all { it.isShort != null }) {
+                linkedReelIds
+            } else {
+                linkedReelIds + dependencies.channelReelIndex().reelIds(subscription.channelId).orEmpty()
+            }
 
         // The channel moved on, so hand the whole page to the feed cache. Rows land without a
         // duration — the feed's on-demand enrichment fills that in, and the next full refresh of

From 2de358330d7b69cd2e6edec041180100ff832e16 Mon Sep 17 00:00:00 2001
From: AE <98699388+A-EDev@users.noreply.github.com>
Date: Sat, 24 Oct 2026 17:33:05 +0300
Subject: [PATCH 4/5] fix(subscriptions): file cached reels as Shorts once a
 refresh learns they are reels (#1393)

---
 .../data/innertube/RssSubscriptionService.kt  | 22 +++++++++++---
 .../SubscriptionFeedRepository.kt             |  6 ++++
 .../subscriptions/SubscriptionFeedWrite.kt    |  9 ++++--
 .../innertube/RssSubscriptionServiceTest.kt   | 11 +++++++
 .../SubscriptionFeedWriteTest.kt              | 30 +++++++++++++++++++
 5 files changed, 72 insertions(+), 6 deletions(-)

diff --git a/app/src/main/java/io/github/aedev/flow/data/innertube/RssSubscriptionService.kt b/app/src/main/java/io/github/aedev/flow/data/innertube/RssSubscriptionService.kt
index 788a92eaf1..7e5bb0d123 100644
--- a/app/src/main/java/io/github/aedev/flow/data/innertube/RssSubscriptionService.kt
+++ b/app/src/main/java/io/github/aedev/flow/data/innertube/RssSubscriptionService.kt
@@ -60,15 +60,20 @@ data class SubscriptionFeedChunk(
      * on its own. No later chunk changes their slice, so the caller can store them right away.
      */
     val rssSettledChannelIds: Set<String>? = null,
+    /**
+     * Every upload this sweep knows is a reel, including the older ones the feed leaves out (it keeps
+     * a channel's newest reel only). A cached row of one of them is filed as a Short again.
+     */
+    val reelIds: Set<String> = emptySet(),
 )
 
 /**
  * Two-stage subscription extraction.
  *
  * The RSS stage reads every channel's feed: cheap, and the only source with a trustworthy publish
- * timestamp. RSS lists Shorts alongside ordinary uploads without marking either, so an entry is only
- * shown once [ChannelReelIndex] or a stored verdict says what it is; a channel whose verdict is not
- * at hand is held back for the checks stage rather than shown with its reels as videos (#903).
+ * timestamp. Each entry's link says whether it is a reel (#1393); an entry without one is only shown
+ * once [ChannelReelIndex] or a stored verdict says what it is, and a channel whose verdict is not at
+ * hand is held back for the checks stage rather than shown with its reels as videos (#903).
  *
  * The checks stage asks the Shorts tab for those held channels, then reads the channel tabs for the
  * channels RSS could not satisfy, which is also the only way to see livestreams — their upload dates
@@ -242,6 +247,7 @@ class RssSubscriptionService
         private inner class Sweep {
             val regular = mutableListOf<Video>()
             val shorts = mutableListOf<Video>()
+            val reelIds = HashSet<String>()
             val rssDates = mutableMapOf<String, Long>()
             val hasRecent = mutableMapOf<String, Boolean>()
 
@@ -256,7 +262,14 @@ class RssSubscriptionService
             val incomplete = mutableSetOf<String>()
 
             fun add(videos: List<Video>) {
-                videos.forEach { if (it.isShort) shorts += it else regular += it }
+                videos.forEach {
+                    if (it.isShort) {
+                        shorts += it
+                        reelIds += it.id
+                    } else {
+                        regular += it
+                    }
+                }
             }
 
             fun compact() {
@@ -278,6 +291,7 @@ class RssSubscriptionService
                 processedChannels = processed,
                 totalChannels = total,
                 rssSettledChannelIds = rssSettled,
+                reelIds = reelIds.toSet(),
             )
         }
 
diff --git a/app/src/main/java/io/github/aedev/flow/data/subscriptions/SubscriptionFeedRepository.kt b/app/src/main/java/io/github/aedev/flow/data/subscriptions/SubscriptionFeedRepository.kt
index d7d8077b97..82f48b37af 100644
--- a/app/src/main/java/io/github/aedev/flow/data/subscriptions/SubscriptionFeedRepository.kt
+++ b/app/src/main/java/io/github/aedev/flow/data/subscriptions/SubscriptionFeedRepository.kt
@@ -161,6 +161,7 @@ class SubscriptionFeedRepository
             var failedChannelIds = emptySet<String>()
             var failedChannelReasons = emptyMap<String, String>()
             var incompleteChannelIds = emptySet<String>()
+            var reelIds = emptySet<String>()
             val writtenChannelIds = HashSet<String>()
 
             rssSubscriptionService
@@ -173,6 +174,7 @@ class SubscriptionFeedRepository
                     failedChannelIds = chunk.failedChannelIds
                     failedChannelReasons = chunk.failedChannelReasons
                     incompleteChannelIds = chunk.incompleteChannelIds
+                    reelIds = chunk.reelIds
                     if (chunk.videos.isNotEmpty()) {
                         latestChunkVideos = chunk.videos
                         previewVideos =
@@ -194,6 +196,7 @@ class SubscriptionFeedRepository
                             failedChannelIds = emptySet(),
                             refreshTime = System.currentTimeMillis(),
                             dropUnfollowed = false,
+                            reelIds = reelIds,
                         )
                         writtenChannelIds += settled
                         previewVideos = withContext(PerformanceDispatcher.diskIO) { loadCachedFeed(plan.scope) }
@@ -219,6 +222,7 @@ class SubscriptionFeedRepository
                     failedChannelIds = failedChannelIds + incompleteChannelIds,
                     refreshTime = System.currentTimeMillis(),
                     dropUnfollowed = plan.isFullRefresh,
+                    reelIds = reelIds,
                 )
             }
             val done =
@@ -247,6 +251,7 @@ class SubscriptionFeedRepository
             failedChannelIds: Set<String>,
             refreshTime: Long,
             dropUnfollowed: Boolean,
+            reelIds: Set<String>,
         ) {
             val written = channelIds.toHashSet()
             val subscribedChannelIds =
@@ -263,6 +268,7 @@ class SubscriptionFeedRepository
                     now = refreshTime,
                     windowMs = SUBSCRIPTION_CACHE_WINDOW_MS,
                     maxPerChannel = MAX_ROWS_PER_CHANNEL,
+                    reelIds = reelIds,
                 )
 
             val entities = write.rows.map { it.toEntity(refreshTime) }
diff --git a/app/src/main/java/io/github/aedev/flow/data/subscriptions/SubscriptionFeedWrite.kt b/app/src/main/java/io/github/aedev/flow/data/subscriptions/SubscriptionFeedWrite.kt
index 726e472310..5a02478ef5 100644
--- a/app/src/main/java/io/github/aedev/flow/data/subscriptions/SubscriptionFeedWrite.kt
+++ b/app/src/main/java/io/github/aedev/flow/data/subscriptions/SubscriptionFeedWrite.kt
@@ -19,6 +19,9 @@ internal data class SubscriptionFeedWrite(
  * two (#1099). The lookback window still ages rows out, and each channel keeps its newest
  * [maxPerChannel].
  *
+ * A cached row of an upload the pass knows is a reel ([reelIds]) is filed as a Short: an earlier
+ * pass that could not tell may have kept it as a video, and RSS repeats a reel for weeks (#1393).
+ *
  * A channel that failed this pass is not stamped fresh, so the next pass retries it instead of
  * showing it empty for the whole TTL (#1094). A channel unsubscribed while the refresh ran is
  * dropped, fetched rows and all.
@@ -32,9 +35,11 @@ internal fun subscriptionFeedWrite(
     now: Long,
     windowMs: Long,
     maxPerChannel: Int,
+    reelIds: Set<String> = emptySet(),
 ): SubscriptionFeedWrite {
+    val cached = cachedSlice.map { if (!it.isShort && it.id in reelIds) it.copy(isShort = true) else it }
     val priorById =
-        cachedSlice
+        cached
             .filter { it.id.isNotBlank() }
             .groupBy { it.id }
             .mapValues { (_, candidates) -> SubscriptionFeedMerger.mergeDuplicates(candidates, now) }
@@ -42,7 +47,7 @@ internal fun subscriptionFeedWrite(
         SubscriptionFeedMerger
             .mergeSubscriptionFeed(
                 freshVideos = freshVideos.map { fresh -> fresh.preservingEnrichedMetadata(priorById[fresh.id]) },
-                cachedVideos = cachedSlice,
+                cachedVideos = cached,
                 now = now,
                 windowMs = windowMs,
                 maxItems = Int.MAX_VALUE,
diff --git a/app/src/test/java/io/github/aedev/flow/data/innertube/RssSubscriptionServiceTest.kt b/app/src/test/java/io/github/aedev/flow/data/innertube/RssSubscriptionServiceTest.kt
index 4e05044583..981e0898da 100644
--- a/app/src/test/java/io/github/aedev/flow/data/innertube/RssSubscriptionServiceTest.kt
+++ b/app/src/test/java/io/github/aedev/flow/data/innertube/RssSubscriptionServiceTest.kt
@@ -123,6 +123,17 @@ class RssSubscriptionServiceTest {
             assertThat(chunk.videos.associate { it.id to it.isShort }).containsExactly("v1", false, "r1", true)
         }
 
+    @Test
+    fun `every reel the feed links is reported, though the feed keeps only the newest (1393)`() =
+        runTest {
+            rss("UCa", entry("v1", isShort = false), entry("r1", ageHours = 3, isShort = true), entry("r2", ageHours = 4, isShort = true))
+
+            val chunk = sweep("UCa")
+
+            assertThat(chunk.videos.filter { it.isShort }.map { it.id }).containsExactly("r1")
+            assertThat(chunk.reelIds).containsExactly("r1", "r2")
+        }
+
     @Test
     fun `a reel stays filed as a Short when the lookup for an unlinked entry fails (1393)`() =
         runTest {
diff --git a/app/src/test/java/io/github/aedev/flow/data/subscriptions/SubscriptionFeedWriteTest.kt b/app/src/test/java/io/github/aedev/flow/data/subscriptions/SubscriptionFeedWriteTest.kt
index 8a9ba588b2..7bea6b5514 100644
--- a/app/src/test/java/io/github/aedev/flow/data/subscriptions/SubscriptionFeedWriteTest.kt
+++ b/app/src/test/java/io/github/aedev/flow/data/subscriptions/SubscriptionFeedWriteTest.kt
@@ -14,6 +14,7 @@ class SubscriptionFeedWriteTest {
         channelId: String,
         ageHours: Long = 1L,
         duration: Int = 0,
+        isShort: Boolean = false,
     ) = Video(
         id = id,
         title = id,
@@ -24,6 +25,7 @@ class SubscriptionFeedWriteTest {
         viewCount = 0L,
         uploadDate = "",
         timestamp = now - ageHours * hour,
+        isShort = isShort,
     )
 
     private fun write(
@@ -33,6 +35,7 @@ class SubscriptionFeedWriteTest {
         failed: Set<String> = emptySet(),
         subscribed: Set<String> = setOf("UCa", "UCb", "UCc"),
         maxPerChannel: Int = 60,
+        reelIds: Set<String> = emptySet(),
     ) = subscriptionFeedWrite(
         channelIds = channels,
         freshVideos = fresh,
@@ -42,6 +45,7 @@ class SubscriptionFeedWriteTest {
         now = now,
         windowMs = 60L * 24L * hour,
         maxPerChannel = maxPerChannel,
+        reelIds = reelIds,
     )
 
     private val both = listOf("UCa", "UCb")
@@ -154,4 +158,30 @@ class SubscriptionFeedWriteTest {
 
         assertThat(result.rows.single().duration).isEqualTo(321)
     }
+
+    @Test
+    fun `a cached reel kept as a video is filed as a Short when the pass knows it is a reel (1393)`() {
+        val result =
+            write(
+                channels = listOf("UCa"),
+                fresh = listOf(video("newest", "UCa", isShort = true)),
+                cached = listOf(video("older", "UCa", ageHours = 5), video("upload", "UCa", ageHours = 6)),
+                reelIds = setOf("newest", "older"),
+            )
+
+        assertThat(result.rows.associate { it.id to it.isShort })
+            .containsExactly("newest", true, "older", true, "upload", false)
+    }
+
+    @Test
+    fun `a cached Short is never turned back into a video`() {
+        val result =
+            write(
+                channels = listOf("UCa"),
+                fresh = emptyList(),
+                cached = listOf(video("reel", "UCa", isShort = true)),
+            )
+
+        assertThat(result.rows.single().isShort).isTrue()
+    }
 }

From 1e56fa337f90f5c587d527b69a7b39d9be3a3689 Mon Sep 17 00:00:00 2001
From: AE <98699388+A-EDev@users.noreply.github.com>
Date: Sat, 24 Oct 2026 17:40:38 +0300
Subject: [PATCH 5/5] fix(subscriptions): mark collaboration reels from a
 channel's Home tab as Shorts (#1393)

---
 .../pages/renderer/LockupItemParser.kt         |  8 +++++++-
 .../pages/renderer/FeedItemParsersTest.kt      | 18 ++++++++++++++++++
 2 files changed, 25 insertions(+), 1 deletion(-)

diff --git a/app/src/main/java/io/github/aedev/flow/innertube/pages/renderer/LockupItemParser.kt b/app/src/main/java/io/github/aedev/flow/innertube/pages/renderer/LockupItemParser.kt
index cb5965e901..734924aef3 100644
--- a/app/src/main/java/io/github/aedev/flow/innertube/pages/renderer/LockupItemParser.kt
+++ b/app/src/main/java/io/github/aedev/flow/innertube/pages/renderer/LockupItemParser.kt
@@ -15,6 +15,9 @@ import kotlinx.serialization.json.JsonObject
 
 private const val LOCKUP_CONTENT_TYPE_COURSE = "LOCKUP_CONTENT_TYPE_COURSE"
 
+// A channel's Home tab lists the reels it collaborated on as plain video lockups of this type.
+private const val LOCKUP_CONTENT_TYPE_SHORT = "LOCKUP_CONTENT_TYPE_SHORT"
+
 internal fun JsonObject.toLockupItem(owner: FeedItemOwner): FeedItem? {
     val contentId = this["contentId"].stringOrNull()?.takeIf(String::isNotBlank) ?: return null
     val metadata = this["metadata"].objectOrNull()?.get("lockupMetadataViewModel").objectOrNull()
@@ -66,7 +69,10 @@ internal fun JsonObject.toLockupItem(owner: FeedItemOwner): FeedItem? {
 
         else -> {
             FeedItem.VideoItem(
-                lockupVideo(contentId, title, parts, badges, itemOwner, collaborators).copy(membersOnlyText = membersOnly),
+                lockupVideo(contentId, title, parts, badges, itemOwner, collaborators).copy(
+                    membersOnlyText = membersOnly,
+                    isShort = contentType == LOCKUP_CONTENT_TYPE_SHORT,
+                ),
             )
         }
     }
diff --git a/app/src/test/java/io/github/aedev/flow/innertube/pages/renderer/FeedItemParsersTest.kt b/app/src/test/java/io/github/aedev/flow/innertube/pages/renderer/FeedItemParsersTest.kt
index a8a1472deb..b68dca6cea 100644
--- a/app/src/test/java/io/github/aedev/flow/innertube/pages/renderer/FeedItemParsersTest.kt
+++ b/app/src/test/java/io/github/aedev/flow/innertube/pages/renderer/FeedItemParsersTest.kt
@@ -169,6 +169,24 @@ class FeedItemParsersTest {
         assertEquals("https://yt3.test/avatar.jpg", video.channelThumbnailUrl)
     }
 
+    @Test
+    fun `a short lockup on a Home tab stays a video but is marked a Short (1393)`() {
+        val parsed =
+            item(
+                lockup(
+                    "hqr_k5p2KZ8",
+                    "LOCKUP_CONTENT_TYPE_SHORT",
+                    "How to Use Ultrafast Properly",
+                    rows = row("12K views", "10 days ago"),
+                    overlays = durationOverlay("0:28"),
+                ),
+            )
+
+        val video = (parsed as FeedItem.VideoItem).video
+        assertTrue(video.isShort)
+        assertEquals(28, video.duration)
+    }
+
     @Test
     fun `a plural relative date resolves to days rather than seconds`() {
         val fourDays =