feat: the empty front door offers to find what you already subscribe to (387 C6)

B4's on-ramp read "add a credential, add a source" - the manual path, and the one that makes a new installer retype creators they have already told Patreon about. With C4 in place the app can just look them up. This is the step where the milestone's original framing actually lands on screen.

Four rungs, chosen by ONE predicate rather than four independent v-ifs. The rungs are mutually exclusive by construction and the rung shown matches what is actually POSSIBLE:

  no credential            -> Add a credential. Discovery is not offered, because a button that cannot work is worse than its absence.
  credential, never synced -> Find what you already subscribe to. Queues the C3 sweep.
  synced, unmatched > 0    -> the count, linking into C4's bucket 1.
  synced, nothing unmatched-> the manual add, because there is genuinely nothing to discover.

The fifth state is rule 164's. A sweep that has been ATTEMPTED and never succeeded reads as "couldn't reach patreon", with the error type and the manual path still open - not a spinner, not a crash, not a retry button that will fail identically. An install with no outbound network lands here.

That is deliberately narrower than "there is an error": a roster that synced once and failed since is NOT unavailable. It has a roster, just an ageing one, and C4's freshness gate already handles that. Collapsing the two would hide a usable roster behind an error banner.

Still offer, never auto-add. An empty front door is exactly where "just add all thirty" is most tempting and most wrong - thirty backfills on first boot - so the rung carries the count and sends them to the picker.

No new machinery: three existing stores (credentials, membershipSync, membershipReconcile). Reconcile is fetched only once something has synced, since bucket 1's count is meaningless before that. Every load swallows its failure, because this screen renders on an install that can reach nothing.

Ten tests on top of B4's, including the mutual-exclusion property asserted directly. Its phrases are each pinned to a single template line and both sides whitespace-normalised - a phrase spanning a line break would never match, and a mutual-exclusion check whose phrases never match passes vacuously (rule 167).

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01SHQB1YukL3VyvMK8rcbmV9

frontend/src/components/posts/FeedEmptyState.vue

@@ -30,40 +30,140 @@
     </template>
 
     <!-- FRESH INSTALL: the on-ramp, in the order the steps actually depend on
-         each other — a source cannot fetch anything without a credential. -->
+         each other — a source cannot fetch anything without a credential.
+         #387 C6 adds the third rung: once a credential exists, FC can just
+         LOOK UP what the operator already subscribes to instead of making
+         them retype it. Exactly one rung shows, chosen by `rung` below. -->
     <template v-else>
       <p class="fc-empty__lead">Nothing here yet.</p>
-      <p class="fc-empty__sub">
-        FabledCurator follows the creators you subscribe to and files what they
-        post. Two steps to start.
-      </p>
-      <div class="fc-empty__actions">
-        <v-btn
-          size="small" variant="tonal" color="accent" prepend-icon="mdi-key-variant"
-          :to="{ path: '/subscriptions', query: { tab: 'settings' } }"
-        >Add a credential</v-btn>
-        <v-btn
-          size="small" variant="text" prepend-icon="mdi-plus"
-          :to="{ path: '/subscriptions' }"
-        >Add a source</v-btn>
-      </div>
-      <p class="fc-empty__hint">
-        A credential comes first — a source can't fetch anything without your
-        logged-in session.
-      </p>
+
+      <!-- 1. No credential. Discovery is not yet possible, so it is not
+              offered — a button that cannot work is worse than its absence. -->
+      <template v-if="rung === 'credential'">
+        <p class="fc-empty__sub">
+          FabledCurator follows the creators you subscribe to and files what
+          they post. Two steps to start.
+        </p>
+        <div class="fc-empty__actions">
+          <v-btn
+            size="small" variant="tonal" color="accent" prepend-icon="mdi-key-variant"
+            :to="{ path: '/subscriptions', query: { tab: 'settings' } }"
+          >Add a credential</v-btn>
+          <v-btn
+            size="small" variant="text" prepend-icon="mdi-plus"
+            :to="{ path: '/subscriptions' }"
+          >Add a source</v-btn>
+        </div>
+        <p class="fc-empty__hint">
+          A credential comes first — a source can't fetch anything without your
+          logged-in session.
+        </p>
+      </template>
+
+      <!-- 2. Credential, roster never synced. The payoff rung. -->
+      <template v-else-if="rung === 'discover'">
+        <p class="fc-empty__sub">
+          You've connected {{ credentialLabel }}. FabledCurator can look up the
+          creators you already subscribe to, so you don't have to add them by
+          hand.
+        </p>
+        <div class="fc-empty__actions">
+          <v-btn
+            size="small" variant="tonal" color="accent"
+            prepend-icon="mdi-account-search-outline"
+            :loading="discovering"
+            @click="discover"
+          >Find what you already subscribe to</v-btn>
+          <v-btn
+            size="small" variant="text" prepend-icon="mdi-plus"
+            :to="{ path: '/subscriptions' }"
+          >Add a source</v-btn>
+        </div>
+        <p class="fc-empty__hint">
+          Nothing is added automatically — you'll get a list to pick from.
+        </p>
+      </template>
+
+      <!-- 3. Synced, and there is something to adopt. The count is the whole
+              message; picking happens in C4's card. -->
+      <template v-else-if="rung === 'adopt'">
+        <p class="fc-empty__sub">
+          {{ unmatchedCount }}
+          {{ unmatchedCount === 1 ? 'creator you subscribe to is' : 'creators you subscribe to are' }}
+          not being followed here yet.
+        </p>
+        <div class="fc-empty__actions">
+          <v-btn
+            size="small" variant="tonal" color="accent"
+            prepend-icon="mdi-account-plus-outline"
+            :to="{ path: '/subscriptions' }"
+          >Choose who to follow</v-btn>
+        </div>
+        <p class="fc-empty__hint">
+          Added one at a time, so a fresh install doesn't start a dozen
+          backfills at once.
+        </p>
+      </template>
+
+      <!-- 4. Discovery was tried and could not reach the platform. Rule #164:
+              say so plainly. Not a spinner, not a crash, not a retry button
+              that will fail the same way. The manual path still works. -->
+      <template v-else-if="rung === 'unavailable'">
+        <p class="fc-empty__sub">
+          FabledCurator couldn't reach {{ credentialLabel }} to look up your
+          subscriptions{{ discoveryError ? ` (${discoveryError})` : '' }}. You
+          can still add creators by hand.
+        </p>
+        <div class="fc-empty__actions">
+          <v-btn
+            size="small" variant="tonal" color="accent" prepend-icon="mdi-plus"
+            :to="{ path: '/subscriptions' }"
+          >Add a source</v-btn>
+          <v-btn
+            size="small" variant="text" prepend-icon="mdi-key-variant"
+            :to="{ path: '/subscriptions', query: { tab: 'settings' } }"
+          >Check the credential</v-btn>
+        </div>
+      </template>
+
+      <!-- 5. Synced and nothing to discover: the roster is fully tracked, or
+              the account subscribes to nothing. Either way the manual path is
+              genuinely the only thing left to offer. -->
+      <template v-else>
+        <p class="fc-empty__sub">
+          Everything you subscribe to on {{ credentialLabel }} is already
+          followed here. Add a creator by hand to start filling the feed.
+        </p>
+        <div class="fc-empty__actions">
+          <v-btn
+            size="small" variant="tonal" color="accent" prepend-icon="mdi-plus"
+            :to="{ path: '/subscriptions' }"
+          >Add a source</v-btn>
+        </div>
+      </template>
     </template>
   </div>
 </template>
 
 <script setup>
-import { computed, onMounted } from 'vue'
+import { computed, onMounted, ref, watch } from 'vue'
 import { storeToRefs } from 'pinia'
 
+import { useCredentialsStore } from '../../stores/credentials.js'
+import { useMembershipReconcileStore } from '../../stores/membershipReconcile.js'
+import { useMembershipSyncStore } from '../../stores/membershipSync.js'
 import { useSourcesStore } from '../../stores/sources.js'
 
 const store = useSourcesStore()
 const { scheduleStatus: status } = storeToRefs(store)
 
+const credentials = useCredentialsStore()
+const syncStore = useMembershipSyncStore()
+const reconcile = useMembershipReconcileStore()
+const { byPlatform } = storeToRefs(credentials)
+const { platforms: syncPlatforms } = storeToRefs(syncStore)
+const { platforms: reconcilePlatforms } = storeToRefs(reconcile)
+
 // Absent status is treated as "fresh install", which is the safe way round:
 // the on-ramp is useful to a first-run operator and merely redundant to an
 // established one, whereas "see what's running" shown to someone with nothing
@@ -75,11 +175,91 @@ const sourceCountLabel = computed(() => {
   return `${n} ${n === 1 ? 'source' : 'sources'}`
 })
 
+// --- #387 C6: which on-ramp rung this install is actually on ---------------
+//
+// ONE predicate, not four independent v-ifs. The rungs are mutually exclusive
+// by construction — an install is at exactly one point in the loop — and four
+// separate conditions would eventually let two of them render at once, which
+// on the first screen a new installer ever sees is the worst place for it.
+
+const hasCredential = computed(() => byPlatform.value.size > 0)
+
+// Any platform that has ever completed a sweep. NULL last_success_at means
+// NEVER, which the C3 endpoint is deliberately careful to preserve — rendering
+// it as 0 is the conflation that whole surface exists to prevent.
+const syncedPlatform = computed(
+  () => syncPlatforms.value.find((p) => p.last_success_at) || null,
+)
+
+// Errored WITHOUT ever having succeeded. A platform that synced once and
+// failed since is not "unavailable" — it has a roster, just an ageing one, and
+// C4's freshness gate is what handles that. This is specifically the
+// never-worked case, which is what an install with no outbound network looks
+// like (rule #164).
+const discoveryError = computed(() => {
+  if (syncedPlatform.value) return null
+  const failed = syncPlatforms.value.find((p) => p.last_error_type)
+  return failed ? failed.last_error_type : null
+})
+
+const unmatchedCount = computed(() =>
+  reconcilePlatforms.value.reduce(
+    (n, p) => n + (p.subscribed_not_tracked?.length || 0), 0,
+  ),
+)
+
+// Which platforms the operator has connected, for the copy. Named rather than
+// counted: "you've connected patreon" is a sentence about their setup, where
+// "1 credential" is a sentence about our data model.
+const credentialLabel = computed(() => {
+  const names = [...byPlatform.value.keys()]
+  if (names.length === 0) return 'your platform'
+  if (names.length === 1) return names[0]
+  return `${names.slice(0, -1).join(', ')} and ${names[names.length - 1]}`
+})
+
+const rung = computed(() => {
+  // Absent data reads as "no credential", the same safe-direction default B4
+  // chose for hasSources: the first rung is useful to a genuine fresh install
+  // and merely redundant to anyone further along, whereas a discovery button
+  // shown to someone with no credential is a dead end.
+  if (!hasCredential.value) return 'credential'
+  if (discoveryError.value) return 'unavailable'
+  if (!syncedPlatform.value) return 'discover'
+  return unmatchedCount.value > 0 ? 'adopt' : 'manual'
+})
+
+const discovering = ref(false)
+
+async function discover () {
+  // The sweep is queued, not inline (C3) — so this cannot report a result, and
+  // must not pretend to. syncNow() raises a toast saying it runs in the
+  // background; re-reading the state is what eventually moves the rung.
+  discovering.value = true
+  try {
+    await syncStore.syncNow()
+    await syncStore.load().catch(() => {})
+  } finally {
+    discovering.value = false
+  }
+}
+
+// Bucket 1's count is only meaningful once something has synced, so it is
+// fetched then rather than on every empty render. `immediate` covers the case
+// where the sync state arrived before this watcher was set up.
+watch(syncedPlatform, (p) => {
+  if (p && reconcilePlatforms.value.length === 0) reconcile.load().catch(() => {})
+}, { immediate: true })
+
 onMounted(() => {
   // The ribbon may already have loaded this on the front door; in Browse's
   // Posts tab nothing has. Failure is swallowed — an empty feed must still
-  // explain itself when the status call is unavailable (rule #164).
+  // explain itself when the status call is unavailable (rule #164). The same
+  // goes for every call below: this screen renders on an install that can
+  // reach nothing, and a rejected promise here would leave it blank.
   if (!status.value) store.loadScheduleStatus().catch(() => {})
+  if (byPlatform.value.size === 0) credentials.loadAll().catch(() => {})
+  if (syncPlatforms.value.length === 0) syncStore.load().catch(() => {})
 })
 </script>