diff --git a/src/lib/components/AddDropdownMenu.svelte b/src/lib/components/AddDropdownMenu.svelte
index 05c5def..afafdff 100644
--- a/src/lib/components/AddDropdownMenu.svelte
+++ b/src/lib/components/AddDropdownMenu.svelte
@@ -125,15 +125,7 @@
           role="menuitem"
         >
           <span class="item-icon"><Icon name="rss" size={16} /></span>
-          Add RSS Feed
-        </button>
-        <button
-          class="add-menu-item"
-          onclick={(e) => handleItemClick(() => sidebarStore.openFollowUserModal(), e)}
-          role="menuitem"
-        >
-          <span class="item-icon"><Icon name="users" size={16} /></span>
-          Add Bluesky Account
+          Add Feed
         </button>
         <button
           class="add-menu-item"
diff --git a/src/lib/components/AddFeedModal.svelte b/src/lib/components/AddFeedModal.svelte
index 7eb20a5..2a159cd 100644
--- a/src/lib/components/AddFeedModal.svelte
+++ b/src/lib/components/AddFeedModal.svelte
@@ -1,45 +1,219 @@
 <script lang="ts">
+  import { goto } from '$app/navigation';
   import { subscriptionsStore } from '$lib/stores/subscriptions.svelte';
   import { articlesStore } from '$lib/stores/articles.svelte';
+  import { socialStore } from '$lib/stores/social.svelte';
+  import { sidebarStore } from '$lib/stores/sidebar.svelte';
+  import { auth } from '$lib/stores/auth.svelte';
   import { fetchSingleFeed } from '$lib/services/feedFetcher';
-  import FeedDiscoveryForm from '$lib/components/FeedDiscoveryForm.svelte';
+  import { searchBlueskyActors, type BlueskySearchResult } from '$lib/services/blueskySearch';
+  import { api } from '$lib/services/api';
   import Modal from '$lib/components/common/Modal.svelte';
 
+  interface Publication {
+    uri: string;
+    name: string;
+    url: string;
+    description?: string;
+    iconUrl?: string;
+  }
+
+  type Step = 'input' | 'select-feeds' | 'select-content';
+
   interface Props {
     open: boolean;
     onclose: () => void;
   }
 
   let { open, onclose }: Props = $props();
-  let feedFormRef: { reset: () => void } | undefined = $state();
   let error = $state<string | null>(null);
 
+  // Unified input state
+  let inputValue = $state('');
+  let step = $state<Step>('input');
+  let isDiscovering = $state(false);
+
+  // Bluesky search state
+  let searchResults = $state<BlueskySearchResult[]>([]);
+  let isSearching = $state(false);
+  let searchTimeout: ReturnType<typeof setTimeout> | undefined;
+
+  // Feed discovery state
+  let discoveredFeeds = $state<string[]>([]);
+
+  // Account content state
+  let selectedAccount = $state<BlueskySearchResult | null>(null);
+  let isDetecting = $state(false);
+  let publications = $state<Publication[]>([]);
+  let shareCount = $state(0);
+  let freestandingDocumentCount = $state(0);
+  let selectedPublications = $state<Set<string>>(new Set());
+  let sharesSelected = $state(false);
+  let freestandingDocsSelected = $state(false);
+  let isSubscribing = $state(false);
+  let isStandardSub = $state(false);
+
+  // Standard subscriptions state
+  type StandardSub = {
+    uri: string;
+    publisherDid: string;
+    publication: {
+      uri: string;
+      name: string;
+      url: string;
+      description?: string;
+    };
+  };
+
+  let standardSubs = $state<StandardSub[]>([]);
+  let isLoadingStandardSubs = $state(false);
+  let standardSubsLoaded = $state(false);
+
+  let subscribedPublisherDids = $derived.by(() => {
+    const dids = new Set<string>();
+    for (const sub of subscriptionsStore.subscriptions) {
+      if (sub.subjectDid) {
+        dids.add(sub.subjectDid);
+      }
+    }
+    return dids;
+  });
+
   const isAtLimit = $derived(
     subscriptionsStore.subscriptions.length >= subscriptionsStore.maxSubscriptions
   );
 
-  function handleClose() {
-    feedFormRef?.reset();
+  let subscribedKeys = $derived.by(() => {
+    if (!selectedAccount) return new Set<string>();
+    const keys = new Set<string>();
+    for (const sub of subscriptionsStore.subscriptions) {
+      if (sub.subjectDid === selectedAccount.did) {
+        if (sub.sourceType === 'atproto.shares') {
+          keys.add('shares');
+        } else if (sub.sourceType === 'atproto.documents') {
+          if (sub.feedUrl === '__freestanding__') {
+            keys.add('__freestanding__');
+          } else {
+            keys.add(sub.feedUrl || 'documents-all');
+          }
+        }
+      }
+    }
+    return keys;
+  });
+
+  let selectedCount = $derived(
+    selectedPublications.size + (sharesSelected ? 1 : 0) + (freestandingDocsSelected ? 1 : 0)
+  );
+
+  function looksLikeUrl(value: string): boolean {
+    const trimmed = value.trim();
+    return (
+      trimmed.startsWith('http://') ||
+      trimmed.startsWith('https://') ||
+      (trimmed.includes('.') && !trimmed.includes(' ') && trimmed.length > 4)
+    );
+  }
+
+  function resetAll() {
+    inputValue = '';
+    step = 'input';
     error = null;
+    isDiscovering = false;
+    searchResults = [];
+    isSearching = false;
+    discoveredFeeds = [];
+    selectedAccount = null;
+    isDetecting = false;
+    publications = [];
+    shareCount = 0;
+    freestandingDocumentCount = 0;
+    selectedPublications = new Set();
+    sharesSelected = false;
+    freestandingDocsSelected = false;
+    isSubscribing = false;
+    isStandardSub = false;
+    if (searchTimeout) clearTimeout(searchTimeout);
+  }
+
+  function handleClose() {
+    resetAll();
     onclose();
   }
 
-  async function handleFeedSelected(url: string) {
+  function handleInput() {
+    error = null;
+    if (searchTimeout) clearTimeout(searchTimeout);
+
+    const trimmed = inputValue.trim();
+    if (trimmed.length < 2) {
+      searchResults = [];
+      isSearching = false;
+      return;
+    }
+
+    if (looksLikeUrl(trimmed)) {
+      searchResults = [];
+      isSearching = false;
+      return;
+    }
+
+    isSearching = true;
+    searchTimeout = setTimeout(async () => {
+      try {
+        searchResults = await searchBlueskyActors(trimmed, 5);
+      } catch {
+        searchResults = [];
+      } finally {
+        isSearching = false;
+      }
+    }, 300);
+  }
+
+  async function handleSubmit() {
+    const trimmed = inputValue.trim();
+    if (!trimmed) return;
+
     error = null;
+    isDiscovering = true;
+    discoveredFeeds = [];
 
     try {
-      // Add subscription with URL as temporary title
+      let url = trimmed;
+      if (!url.startsWith('http://') && !url.startsWith('https://')) {
+        url = 'https://' + url;
+      }
+
+      const result = await api.discoverFeedsV2(url);
+      if (result.feeds.length === 0) {
+        error = 'No feeds found at this URL';
+        isDiscovering = false;
+      } else if (result.feeds.length === 1) {
+        await addFeed(result.feeds[0]);
+      } else {
+        discoveredFeeds = result.feeds;
+        step = 'select-feeds';
+        isDiscovering = false;
+      }
+    } catch (e) {
+      error = e instanceof Error ? e.message : 'Failed to discover feeds';
+      isDiscovering = false;
+    }
+  }
+
+  async function addFeed(url: string) {
+    error = null;
+    try {
       const tempTitle = new URL(url).hostname;
       const id = await subscriptionsStore.add(url, tempTitle, {});
       const sub = subscriptionsStore.getById(id);
 
-      // Close modal immediately
       handleClose();
+      goto(`/?feed=${id}`);
+      sidebarStore.closeMobile();
 
-      // Fetch feed in background (updates title and loads articles)
       if (sub) {
         fetchSingleFeed(sub, true, articlesStore.savedGuids).then(async (result) => {
-          // Update subscription with feed metadata from V2 response
           if (result.success && result.title) {
             try {
               await subscriptionsStore.update(id, {
@@ -54,25 +228,873 @@
       }
     } catch (e) {
       error = e instanceof Error ? e.message : 'Failed to add feed';
+      isDiscovering = false;
+    }
+  }
+
+  async function selectAccount(account: BlueskySearchResult) {
+    selectedAccount = account;
+    inputValue = '';
+    searchResults = [];
+    step = 'select-content';
+    isDetecting = true;
+    error = null;
+    publications = [];
+    shareCount = 0;
+    freestandingDocumentCount = 0;
+    selectedPublications = new Set();
+    sharesSelected = false;
+    freestandingDocsSelected = false;
+
+    try {
+      const result = await api.detectContent(account.did);
+      publications = result.publications;
+      shareCount = result.shareCount;
+      freestandingDocumentCount = result.freestandingDocumentCount;
+
+      for (const pub of result.publications) {
+        if (!subscribedKeys.has(pub.uri)) {
+          selectedPublications.add(pub.uri);
+        }
+      }
+      selectedPublications = new Set(selectedPublications);
+      if (result.shareCount > 0 && !subscribedKeys.has('shares')) {
+        sharesSelected = true;
+      }
+      if (result.freestandingDocumentCount > 0 && !subscribedKeys.has('__freestanding__')) {
+        freestandingDocsSelected = true;
+      }
+    } catch (e) {
+      error = e instanceof Error ? e.message : 'Failed to detect content';
+    } finally {
+      isDetecting = false;
+    }
+  }
+
+  function goBackToInput() {
+    step = 'input';
+    selectedAccount = null;
+    publications = [];
+    shareCount = 0;
+    freestandingDocumentCount = 0;
+    selectedPublications = new Set();
+    sharesSelected = false;
+    freestandingDocsSelected = false;
+    discoveredFeeds = [];
+    error = null;
+    isStandardSub = false;
+  }
+
+  function togglePublication(uri: string) {
+    if (subscribedKeys.has(uri)) return;
+    const next = new Set(selectedPublications);
+    if (next.has(uri)) {
+      next.delete(uri);
+    } else {
+      next.add(uri);
+    }
+    selectedPublications = next;
+  }
+
+  function toggleShares() {
+    if (subscribedKeys.has('shares')) return;
+    sharesSelected = !sharesSelected;
+  }
+
+  function toggleFreestandingDocs() {
+    if (subscribedKeys.has('__freestanding__')) return;
+    freestandingDocsSelected = !freestandingDocsSelected;
+  }
+
+  function parseAtUri(atUri: string): { did: string; collection: string; rkey: string } | null {
+    const match = atUri.match(/^at:\/\/(did:[^/]+)\/([^/]+)\/([^/]+)$/);
+    if (!match) return null;
+    return { did: match[1], collection: match[2], rkey: match[3] };
+  }
+
+  async function resolvePdsUrl(did: string): Promise<string | null> {
+    try {
+      if (did.startsWith('did:plc:')) {
+        const res = await fetch(`https://plc.directory/${did}`);
+        if (!res.ok) return null;
+        const doc = (await res.json()) as {
+          service?: Array<{ id: string; type: string; serviceEndpoint: string }>;
+        };
+        const svc = doc.service?.find(
+          (s) => s.id === '#atproto_pds' || s.type === 'AtprotoPersonalDataServer'
+        );
+        return svc?.serviceEndpoint || null;
+      } else if (did.startsWith('did:web:')) {
+        const domain = did.replace('did:web:', '');
+        const res = await fetch(`https://${domain}/.well-known/did.json`);
+        if (!res.ok) return null;
+        const doc = (await res.json()) as {
+          service?: Array<{ id: string; type: string; serviceEndpoint: string }>;
+        };
+        const svc = doc.service?.find(
+          (s) => s.id === '#atproto_pds' || s.type === 'AtprotoPersonalDataServer'
+        );
+        return svc?.serviceEndpoint || null;
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+
+  async function loadStandardSubscriptions() {
+    if (standardSubsLoaded || isLoadingStandardSubs) return;
+    isLoadingStandardSubs = true;
+    try {
+      const pdsUrl = auth.user?.pdsUrl;
+      const did = auth.user?.did;
+      if (!pdsUrl || !did) {
+        standardSubs = [];
+        return;
+      }
+
+      const params = new URLSearchParams({
+        repo: did,
+        collection: 'site.standard.graph.subscription',
+        limit: '100',
+      });
+      const res = await fetch(`${pdsUrl}/xrpc/com.atproto.repo.listRecords?${params}`);
+      if (!res.ok) {
+        standardSubs = [];
+        return;
+      }
+      const data = (await res.json()) as {
+        records: Array<{ uri: string; value: { publication?: string } }>;
+      };
+
+      if (data.records.length === 0) {
+        standardSubs = [];
+        return;
+      }
+
+      const entries = data.records
+        .map((r) => ({ uri: r.uri, pubUri: r.value.publication }))
+        .filter((e): e is { uri: string; pubUri: string } => !!e.pubUri)
+        .map((e) => ({ ...e, parsed: parseAtUri(e.pubUri) }))
+        .filter((e): e is typeof e & { parsed: NonNullable<typeof e.parsed> } => !!e.parsed);
+
+      const uniqueDids = [...new Set(entries.map((e) => e.parsed.did))];
+      const pdsCache = new Map<string, string | null>();
+      await Promise.all(
+        uniqueDids.map(async (d) => {
+          pdsCache.set(d, await resolvePdsUrl(d));
+        })
+      );
+
+      const results = await Promise.allSettled(
+        entries.map(async (entry): Promise<StandardSub | null> => {
+          const pubPds = pdsCache.get(entry.parsed.did);
+          if (!pubPds) return null;
+
+          const pubParams = new URLSearchParams({
+            repo: entry.parsed.did,
+            collection: entry.parsed.collection,
+            rkey: entry.parsed.rkey,
+          });
+          const pubRes = await fetch(`${pubPds}/xrpc/com.atproto.repo.getRecord?${pubParams}`);
+          if (!pubRes.ok) return null;
+
+          const pubData = (await pubRes.json()) as {
+            value: { name?: string; url?: string; description?: string };
+          };
+          const pub = pubData.value;
+          if (!pub.url) return null;
+
+          return {
+            uri: entry.uri,
+            publisherDid: entry.parsed.did,
+            publication: {
+              uri: entry.pubUri,
+              name: pub.name || pub.url,
+              url: pub.url,
+              description: pub.description,
+            },
+          };
+        })
+      );
+
+      standardSubs = results
+        .filter((r): r is PromiseFulfilledResult<StandardSub | null> => r.status === 'fulfilled')
+        .map((r) => r.value)
+        .filter((s): s is StandardSub => s !== null);
+    } catch {
+      // Silently fail - these are just suggestions
+    } finally {
+      isLoadingStandardSubs = false;
+      standardSubsLoaded = true;
+    }
+  }
+
+  function handleSelectStandardSub(sub: StandardSub) {
+    let handle = sub.publisherDid;
+    try {
+      handle = new URL(sub.publication.url).hostname;
+    } catch {
+      // use DID as fallback
+    }
+    isStandardSub = true;
+    selectAccount({
+      did: sub.publisherDid,
+      handle,
+      displayName: sub.publication.name,
+      avatar: undefined,
+    });
+  }
+
+  $effect(() => {
+    if (open) {
+      loadStandardSubscriptions();
+    }
+  });
+
+  async function handleSubscribe() {
+    if (!selectedAccount || selectedCount === 0) return;
+
+    if (!subscriptionsStore.canAddMore) {
+      error = 'Subscription limit reached';
+      return;
+    }
+
+    error = null;
+    isSubscribing = true;
+    let firstAddedId: number | null = null;
+
+    try {
+      for (const pubUri of selectedPublications) {
+        const pub = publications.find((p) => p.uri === pubUri);
+        if (!pub) continue;
+
+        if (!subscriptionsStore.canAddMore) {
+          error = `Subscription limit reached (${subscriptionsStore.maxSubscriptions} max)`;
+          break;
+        }
+
+        const subId = await subscriptionsStore.add(pubUri, pub.name || pub.url, {
+          sourceType: 'atproto.documents',
+          subjectDid: selectedAccount.did,
+          siteUrl: pub.url,
+          feedUrl: pubUri,
+        });
+        if (!firstAddedId) firstAddedId = subId;
+        if (pub.iconUrl) {
+          await subscriptionsStore.updateLocal(subId, { customIconUrl: pub.iconUrl });
+        }
+      }
+
+      if (freestandingDocsSelected && subscriptionsStore.canAddMore) {
+        const docsId = await subscriptionsStore.add(
+          '__freestanding__',
+          `Documents from @${selectedAccount.handle}`,
+          {
+            sourceType: 'atproto.documents',
+            subjectDid: selectedAccount.did,
+            feedUrl: '__freestanding__',
+          }
+        );
+        if (!firstAddedId) firstAddedId = docsId;
+      }
+
+      if (sharesSelected && subscriptionsStore.canAddMore) {
+        const sharesId = await subscriptionsStore.add(
+          undefined,
+          `Shares from @${selectedAccount.handle}`,
+          {
+            sourceType: 'atproto.shares',
+            subjectDid: selectedAccount.did,
+          }
+        );
+        if (!firstAddedId) firstAddedId = sharesId;
+      }
+
+      socialStore.loadFeed(true);
+      handleClose();
+
+      if (firstAddedId) {
+        goto(`/?feed=${firstAddedId}`);
+        sidebarStore.closeMobile();
+      }
+    } catch (e) {
+      error = e instanceof Error ? e.message : 'Failed to subscribe';
+    } finally {
+      isSubscribing = false;
     }
   }
 </script>
 
-<Modal {open} onclose={handleClose} title="Add Feed">
+{#snippet standardSubsList()}
+  {#if isLoadingStandardSubs}
+    <div class="detecting">
+      <span class="spinner"></span>
+      <span>Loading subscriptions...</span>
+    </div>
+  {:else if standardSubs.length > 0}
+    <p class="section-label">Your standard.site subscriptions</p>
+    <div class="standard-subs-list">
+      {#each standardSubs as sub (sub.uri)}
+        {@const isSubscribed = subscribedPublisherDids.has(sub.publisherDid)}
+        <button class="standard-sub-row" onclick={() => handleSelectStandardSub(sub)}>
+          <div class="standard-sub-info">
+            <span class="standard-sub-name">{sub.publication.name}</span>
+            <span class="standard-sub-url">{sub.publication.url}</span>
+            {#if sub.publication.description}
+              <span class="standard-sub-desc">{sub.publication.description}</span>
+            {/if}
+          </div>
+          {#if isSubscribed}
+            <span class="subscribed-badge">Subscribed</span>
+          {/if}
+        </button>
+      {/each}
+    </div>
+  {/if}
+{/snippet}
+
+<Modal {open} onclose={handleClose} title="Add subscription">
   {#if isAtLimit}
     <p class="limit-message">
       You've reached the maximum of {subscriptionsStore.maxSubscriptions} feeds. Remove some feeds to
       add new ones.
     </p>
-  {:else}
-    <FeedDiscoveryForm bind:this={feedFormRef} onFeedSelected={handleFeedSelected} />
-    {#if error}
-      <p class="error-message">{error}</p>
-    {/if}
+  {:else if step === 'input'}
+    <div class="modal-content">
+      <form
+        onsubmit={(e) => {
+          e.preventDefault();
+          handleSubmit();
+        }}
+      >
+        <div class="input-group">
+          <input
+            type="text"
+            class="search-input"
+            placeholder="Add RSS feed, Website URL, @handle..."
+            bind:value={inputValue}
+            oninput={handleInput}
+            disabled={isDiscovering}
+          />
+          <button type="submit" class="add-btn" disabled={isDiscovering || !inputValue.trim()}>
+            {isDiscovering ? 'Adding...' : 'Add'}
+          </button>
+        </div>
+      </form>
+
+      {#if isSearching}
+        <p class="search-status">Searching...</p>
+      {:else if searchResults.length > 0}
+        <div class="search-results">
+          {#each searchResults as result (result.did)}
+            <button class="result-btn" onclick={() => selectAccount(result)}>
+              {#if result.avatar}
+                <img src={result.avatar} alt="" class="result-avatar" />
+              {:else}
+                <span class="result-avatar-placeholder"></span>
+              {/if}
+              <span class="result-info">
+                <span class="result-name">{result.displayName || result.handle}</span>
+                <span class="result-handle">@{result.handle}</span>
+              </span>
+            </button>
+          {/each}
+        </div>
+      {:else if inputValue.trim().length >= 2 && !looksLikeUrl(inputValue.trim()) && !isSearching}
+        <p class="search-status">No results found</p>
+      {:else if inputValue.trim().length === 0}
+        {@render standardSubsList()}
+        {#if !isLoadingStandardSubs && standardSubs.length === 0}
+          <p class="search-hint">Enter a feed URL, website, or Bluesky handle</p>
+        {/if}
+      {/if}
+    </div>
+  {:else if step === 'select-feeds'}
+    <div class="modal-content">
+      <button class="back-btn" onclick={goBackToInput}>&#8249; Back</button>
+      <p class="section-label">Multiple feeds found — select one:</p>
+      <div class="search-results">
+        {#each discoveredFeeds as url}
+          <button class="result-btn" onclick={() => addFeed(url)}>
+            <span class="result-info">
+              <span class="result-name feed-url">{url}</span>
+            </span>
+          </button>
+        {/each}
+      </div>
+    </div>
+  {:else if step === 'select-content' && selectedAccount}
+    <div class="modal-content">
+      <button class="back-btn" onclick={goBackToInput}>&#8249; Back</button>
+
+      <div class="selected-user">
+        {#if selectedAccount.avatar}
+          <img src={selectedAccount.avatar} alt="" class="selected-avatar" />
+        {:else}
+          <span class="selected-avatar-placeholder"></span>
+        {/if}
+        <div class="selected-info">
+          <span class="selected-name">{selectedAccount.displayName || selectedAccount.handle}</span>
+          <span class="selected-handle">@{selectedAccount.handle}</span>
+        </div>
+      </div>
+
+      {#if isDetecting}
+        <div class="detecting">
+          <span class="spinner"></span>
+          <span>Detecting available content...</span>
+        </div>
+      {:else}
+        {#if !isStandardSub}
+          <div class="content-list">
+            <button
+              class="content-item"
+              class:selected={freestandingDocsSelected}
+              class:is-subscribed={subscribedKeys.has('__freestanding__')}
+              onclick={toggleFreestandingDocs}
+              disabled={subscribedKeys.has('__freestanding__')}
+            >
+              <span
+                class="checkbox"
+                class:checked={freestandingDocsSelected || subscribedKeys.has('__freestanding__')}
+              >
+                {#if freestandingDocsSelected || subscribedKeys.has('__freestanding__')}&#10003;{/if}
+              </span>
+              <span class="content-info">
+                <span class="content-name"
+                  >Documents <span class="content-count">({freestandingDocumentCount})</span></span
+                >
+                <span class="content-desc"
+                  >Free-standing documents by @{selectedAccount.handle}</span
+                >
+              </span>
+              {#if subscribedKeys.has('__freestanding__')}
+                <span class="subscribed-badge">Subscribed</span>
+              {/if}
+            </button>
+
+            <button
+              class="content-item"
+              class:selected={sharesSelected}
+              class:is-subscribed={subscribedKeys.has('shares')}
+              onclick={toggleShares}
+              disabled={subscribedKeys.has('shares')}
+            >
+              <span class="checkbox" class:checked={sharesSelected || subscribedKeys.has('shares')}>
+                {#if sharesSelected || subscribedKeys.has('shares')}&#10003;{/if}
+              </span>
+              <span class="content-info">
+                <span class="content-name"
+                  >Shared articles <span class="content-count">({shareCount})</span></span
+                >
+                <span class="content-desc">Articles shared by @{selectedAccount.handle}</span>
+              </span>
+              {#if subscribedKeys.has('shares')}
+                <span class="subscribed-badge">Subscribed</span>
+              {/if}
+            </button>
+          </div>
+        {/if}
+
+        {#if publications.length > 0}
+          <div class="content-list">
+            {#each publications as pub (pub.uri)}
+              {@const isSubscribed = subscribedKeys.has(pub.uri)}
+              <button
+                class="content-item"
+                class:selected={selectedPublications.has(pub.uri)}
+                class:is-subscribed={isSubscribed}
+                onclick={() => togglePublication(pub.uri)}
+                disabled={isSubscribed}
+              >
+                <span
+                  class="checkbox"
+                  class:checked={selectedPublications.has(pub.uri) || isSubscribed}
+                >
+                  {#if selectedPublications.has(pub.uri) || isSubscribed}&#10003;{/if}
+                </span>
+                <span class="content-info">
+                  <span class="content-name">{pub.name || pub.url}</span>
+                  {#if pub.url}
+                    <span class="content-url">{pub.url}</span>
+                  {/if}
+                  {#if pub.description}
+                    <span class="content-desc">{pub.description}</span>
+                  {/if}
+                </span>
+                {#if isSubscribed}
+                  <span class="subscribed-badge">Subscribed</span>
+                {/if}
+              </button>
+            {/each}
+          </div>
+        {/if}
+
+        <button
+          class="subscribe-btn"
+          onclick={handleSubscribe}
+          disabled={selectedCount === 0 || isSubscribing}
+        >
+          {#if isSubscribing}
+            Subscribing...
+          {:else}
+            Subscribe{selectedCount > 0 ? ` (${selectedCount})` : ''}
+          {/if}
+        </button>
+      {/if}
+    </div>
+  {/if}
+
+  {#if error}
+    <p class="error-message">{error}</p>
   {/if}
 </Modal>
 
 <style>
+  .modal-content {
+    display: flex;
+    flex-direction: column;
+    gap: 0.75rem;
+    min-height: 200px;
+  }
+
+  .input-group {
+    display: flex;
+    gap: 0.5rem;
+  }
+
+  .search-input {
+    flex: 1;
+    padding: 0.625rem 0.75rem;
+    border: 1px solid var(--color-border);
+    border-radius: 8px;
+    background: var(--color-bg);
+    color: var(--color-text);
+    font-size: 0.875rem;
+    outline: none;
+    box-sizing: border-box;
+  }
+
+  .search-input:focus {
+    border-color: var(--color-accent, #0085ff);
+  }
+
+  .add-btn {
+    padding: 0.625rem 1rem;
+    border: none;
+    border-radius: 8px;
+    background: var(--color-accent, #0085ff);
+    color: white;
+    font-size: 0.875rem;
+    font-weight: 500;
+    cursor: pointer;
+    flex-shrink: 0;
+    transition: opacity 0.15s;
+  }
+
+  .add-btn:hover:not(:disabled) {
+    opacity: 0.9;
+  }
+
+  .add-btn:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+  }
+
+  .search-status,
+  .search-hint {
+    color: var(--color-text-secondary);
+    font-size: 0.875rem;
+    text-align: center;
+    padding: 0.5rem 0;
+  }
+
+  .search-results {
+    display: flex;
+    flex-direction: column;
+    border: 1px solid var(--color-border);
+    border-radius: 8px;
+    overflow: hidden;
+  }
+
+  .result-btn {
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+    width: 100%;
+    padding: 0.625rem 0.75rem;
+    border: none;
+    border-bottom: 1px solid var(--color-border);
+    background: transparent;
+    cursor: pointer;
+    text-align: left;
+    color: var(--color-text);
+    transition: background-color 0.15s;
+  }
+
+  .result-btn:last-child {
+    border-bottom: none;
+  }
+
+  .result-btn:hover {
+    background: var(--color-bg-secondary);
+  }
+
+  .result-avatar {
+    width: 32px;
+    height: 32px;
+    border-radius: 50%;
+    flex-shrink: 0;
+    object-fit: cover;
+  }
+
+  .result-avatar-placeholder {
+    width: 32px;
+    height: 32px;
+    border-radius: 50%;
+    flex-shrink: 0;
+    background: var(--color-border);
+  }
+
+  .result-info {
+    display: flex;
+    flex-direction: column;
+    min-width: 0;
+  }
+
+  .result-name {
+    font-weight: 500;
+    font-size: 0.875rem;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+
+  .result-handle {
+    font-size: 0.8125rem;
+    color: var(--color-text-secondary);
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+
+  .feed-url {
+    font-weight: 400;
+    word-break: break-all;
+    white-space: normal;
+  }
+
+  .back-btn {
+    align-self: flex-start;
+    padding: 0.25rem 0.5rem;
+    border: none;
+    background: transparent;
+    color: var(--color-text-secondary);
+    font-size: 0.875rem;
+    cursor: pointer;
+  }
+
+  .back-btn:hover {
+    color: var(--color-text);
+  }
+
+  .selected-user {
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+    padding: 0.75rem;
+    background: var(--color-bg-secondary);
+    border-radius: 8px;
+  }
+
+  .selected-avatar {
+    width: 40px;
+    height: 40px;
+    border-radius: 50%;
+    flex-shrink: 0;
+    object-fit: cover;
+  }
+
+  .selected-avatar-placeholder {
+    width: 40px;
+    height: 40px;
+    border-radius: 50%;
+    flex-shrink: 0;
+    background: var(--color-border);
+  }
+
+  .selected-info {
+    display: flex;
+    flex-direction: column;
+    min-width: 0;
+  }
+
+  .selected-name {
+    font-weight: 500;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+
+  .selected-handle {
+    font-size: 0.8125rem;
+    color: var(--color-text-secondary);
+  }
+
+  .detecting {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: 0.5rem;
+    padding: 1.5rem 0;
+    color: var(--color-text-secondary);
+    font-size: 0.875rem;
+  }
+
+  .spinner {
+    width: 1rem;
+    height: 1rem;
+    border: 2px solid var(--color-border);
+    border-top-color: var(--color-accent, #0085ff);
+    border-radius: 50%;
+    animation: spin 0.6s linear infinite;
+  }
+
+  @keyframes spin {
+    to {
+      transform: rotate(360deg);
+    }
+  }
+
+  .no-content {
+    color: var(--color-text-secondary);
+    font-size: 0.875rem;
+    text-align: center;
+    padding: 1rem 0;
+  }
+
+  .content-list {
+    display: flex;
+    flex-direction: column;
+    border: 1px solid var(--color-border);
+    border-radius: 8px;
+    overflow: hidden;
+  }
+
+  .content-item {
+    display: flex;
+    align-items: flex-start;
+    gap: 0.5rem;
+    width: 100%;
+    padding: 0.75rem;
+    border: none;
+    border-bottom: 1px solid var(--color-border);
+    background: transparent;
+    text-align: left;
+    cursor: pointer;
+    color: var(--color-text);
+    transition: background-color 0.15s;
+  }
+
+  .content-item:last-child {
+    border-bottom: none;
+  }
+
+  .content-item:hover:not(:disabled) {
+    background: var(--color-bg-secondary);
+  }
+
+  .content-item.is-subscribed {
+    opacity: 0.6;
+    cursor: default;
+  }
+
+  .checkbox {
+    width: 18px;
+    height: 18px;
+    border: 2px solid var(--color-border);
+    border-radius: 4px;
+    flex-shrink: 0;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 0.75rem;
+    margin-top: 1px;
+    transition:
+      background-color 0.15s,
+      border-color 0.15s;
+  }
+
+  .checkbox.checked {
+    background: var(--color-accent, #0085ff);
+    border-color: var(--color-accent, #0085ff);
+    color: white;
+  }
+
+  .content-info {
+    display: flex;
+    flex-direction: column;
+    min-width: 0;
+    flex: 1;
+    gap: 0.125rem;
+  }
+
+  .content-name {
+    font-weight: 500;
+    font-size: 0.875rem;
+  }
+
+  .content-url {
+    font-size: 0.8125rem;
+    color: var(--color-text-secondary);
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+
+  .content-desc {
+    font-size: 0.8125rem;
+    color: var(--color-text-secondary);
+  }
+
+  .content-count {
+    font-weight: 400;
+    color: var(--color-text-secondary);
+  }
+
+  .subscribed-badge {
+    font-size: 0.75rem;
+    color: var(--color-text-secondary);
+    background: var(--color-bg-secondary);
+    padding: 0.125rem 0.5rem;
+    border-radius: 4px;
+    flex-shrink: 0;
+    align-self: center;
+  }
+
+  .subscribe-btn {
+    width: 100%;
+    padding: 0.625rem;
+    border: none;
+    border-radius: 8px;
+    background: var(--color-accent, #0085ff);
+    color: white;
+    font-size: 0.875rem;
+    font-weight: 500;
+    cursor: pointer;
+    transition: opacity 0.15s;
+  }
+
+  .subscribe-btn:hover:not(:disabled) {
+    opacity: 0.9;
+  }
+
+  .subscribe-btn:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+  }
+
   .limit-message {
     color: var(--color-text-secondary);
     text-align: center;
@@ -84,4 +1106,80 @@
     font-size: 0.875rem;
     margin-top: 0.5rem;
   }
+
+  .section-label {
+    font-size: 0.8125rem;
+    font-weight: 600;
+    color: var(--color-text-secondary);
+    text-transform: uppercase;
+    letter-spacing: 0.03em;
+    margin: 0;
+  }
+
+  .standard-subs-list {
+    display: flex;
+    flex-direction: column;
+    border: 1px solid var(--color-border);
+    border-radius: 8px;
+    overflow: hidden;
+    max-height: 280px;
+    overflow-y: auto;
+  }
+
+  .standard-sub-row {
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+    width: 100%;
+    padding: 0.625rem 0.75rem;
+    background: none;
+    border: none;
+    border-bottom: 1px solid var(--color-border);
+    text-align: left;
+    cursor: pointer;
+    color: var(--color-text);
+    font: inherit;
+    transition: background-color 0.1s;
+  }
+
+  .standard-sub-row:last-child {
+    border-bottom: none;
+  }
+
+  .standard-sub-row:hover {
+    background: var(--color-bg-secondary);
+  }
+
+  .standard-sub-info {
+    flex: 1;
+    min-width: 0;
+    display: flex;
+    flex-direction: column;
+    gap: 0.0625rem;
+  }
+
+  .standard-sub-name {
+    font-size: 0.9375rem;
+    font-weight: 500;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+
+  .standard-sub-url {
+    font-size: 0.75rem;
+    color: var(--color-text-secondary);
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+
+  .standard-sub-desc {
+    font-size: 0.8125rem;
+    color: var(--color-text-secondary);
+    display: -webkit-box;
+    -webkit-line-clamp: 1;
+    -webkit-box-orient: vertical;
+    overflow: hidden;
+  }
 </style>
diff --git a/src/lib/components/EditFeedModal.svelte b/src/lib/components/EditFeedModal.svelte
index e37477c..51d6746 100644
--- a/src/lib/components/EditFeedModal.svelte
+++ b/src/lib/components/EditFeedModal.svelte
@@ -129,6 +129,24 @@
         <p class="help-text">Leave empty to use the auto-detected favicon</p>
       </div>
 
+      {#if subscription.feedUrl}
+        <div class="info-item">
+          <span class="info-label">Feed URL</span>
+          <span class="info-value url">{subscription.feedUrl}</span>
+        </div>
+      {/if}
+
+      <div class="info-row">
+        <div class="info-item">
+          <span class="info-label">Source</span>
+          <span class="info-value">{subscription.source ?? 'manual'}</span>
+        </div>
+        <div class="info-item">
+          <span class="info-label">Type</span>
+          <span class="info-value">{subscription.sourceType ?? 'rss'}</span>
+        </div>
+      </div>
+
       <div class="icon-preview">
         <span class="preview-label">Preview:</span>
         {#if previewUrl}
@@ -241,6 +259,37 @@
     margin: 0;
   }
 
+  .info-row {
+    display: flex;
+    gap: 1.5rem;
+    padding: 0.75rem;
+    background: var(--color-bg-secondary);
+    border-radius: 6px;
+  }
+
+  .info-item {
+    display: flex;
+    flex-direction: column;
+    gap: 0.25rem;
+  }
+
+  .info-label {
+    font-size: 0.75rem;
+    color: var(--color-text-secondary);
+    font-weight: 500;
+  }
+
+  .info-value {
+    font-size: 0.875rem;
+    color: var(--color-text);
+  }
+
+  .info-value.url {
+    word-break: break-all;
+    font-size: 0.8rem;
+    color: var(--color-text-secondary);
+  }
+
   .icon-preview {
     display: flex;
     align-items: center;
diff --git a/src/lib/components/FilteredViewModal.svelte b/src/lib/components/FilteredViewModal.svelte
index 7a2417b..6244182 100644
--- a/src/lib/components/FilteredViewModal.svelte
+++ b/src/lib/components/FilteredViewModal.svelte
@@ -1,7 +1,6 @@
 <script lang="ts">
   import { filteredViewsStore } from '$lib/stores/filteredViews.svelte';
   import { subscriptionsStore } from '$lib/stores/subscriptions.svelte';
-  import { socialStore } from '$lib/stores/social.svelte';
   import { profileService } from '$lib/services/profiles';
   import Modal from '$lib/components/common/Modal.svelte';
   import type { BlueskyProfile } from '$lib/types';
@@ -35,18 +34,29 @@
   let feedSearch = $state('');
   let accountSearch = $state('');
 
+  // Derive unique account DIDs from atproto subscriptions
+  let accountDids = $derived(() => {
+    const dids = new Set<string>();
+    for (const sub of subscriptionsStore.subscriptions) {
+      if (sub.sourceType?.startsWith('atproto.') && sub.subjectDid) {
+        dids.add(sub.subjectDid);
+      }
+    }
+    return [...dids];
+  });
+
   // Account profiles for display
   let accountProfiles = $state<Map<string, BlueskyProfile>>(new Map());
 
-  // Load profiles for followed users
+  // Load profiles for account DIDs
   $effect(() => {
     if (!open) return;
-    const follows = socialStore.inAppFollows;
-    for (const f of follows) {
-      if (!accountProfiles.has(f.did)) {
-        profileService.getProfile(f.did).then((p) => {
+    const dids = accountDids();
+    for (const did of dids) {
+      if (!accountProfiles.has(did)) {
+        profileService.getProfile(did).then((p) => {
           if (p) {
-            accountProfiles = new Map(accountProfiles).set(f.did, p);
+            accountProfiles = new Map(accountProfiles).set(did, p);
           }
         });
       }
@@ -66,21 +76,21 @@
           const term = feedSearch.toLowerCase();
           return (
             (sub.customTitle || sub.title).toLowerCase().includes(term) ||
-            sub.feedUrl.toLowerCase().includes(term)
+            (sub.feedUrl?.toLowerCase().includes(term) ?? false)
           );
         })
       : subscriptionsStore.subscriptions
   );
 
-  // Filtered follows based on search
-  let filteredFollows = $derived(
+  // Filtered accounts based on search
+  let filteredAccounts = $derived(
     accountSearch
-      ? socialStore.inAppFollows.filter((follow) => {
+      ? accountDids().filter((did) => {
           const term = accountSearch.toLowerCase();
-          const displayName = getModalAccountDisplayName(follow.did).toLowerCase();
-          return displayName.includes(term) || follow.did.toLowerCase().includes(term);
+          const displayName = getModalAccountDisplayName(did).toLowerCase();
+          return displayName.includes(term) || did.toLowerCase().includes(term);
         })
-      : socialStore.inAppFollows
+      : accountDids()
   );
 
   // Reset form when modal opens or editingViewId changes
@@ -102,7 +112,7 @@
             const allSubIds = subscriptionsStore.subscriptions
               .map((s) => s.id)
               .filter((id): id is number => id != null);
-            const allDids = socialStore.inAppFollows.map((f) => f.did);
+            const allDids = accountDids();
             const migrated = migrateLegacyView(
               {
                 showArticles: view.showArticles,
@@ -226,7 +236,8 @@
             {#each filteredSubscriptions as sub (sub.id)}
               {#if sub.id != null}
                 {@const key = rssSourceKey(sub.id)}
-                {@const iconUrl = sub.customIconUrl || getFaviconUrl(sub.siteUrl || sub.feedUrl)}
+                {@const iconUrl =
+                  sub.customIconUrl || getFaviconUrl(sub.siteUrl || sub.feedUrl || '')}
                 <label class="checklist-item">
                   <input
                     type="checkbox"
@@ -247,7 +258,7 @@
         {/if}
 
         <!-- Account groups -->
-        {#if socialStore.inAppFollows.length > 0}
+        {#if accountDids().length > 0}
           <div class="source-group-header">Accounts</div>
           <input
             type="text"
@@ -255,8 +266,8 @@
             bind:value={accountSearch}
             class="search-input"
           />
-          {#each filteredFollows as follow (follow.did)}
-            {@const profile = accountProfiles.get(follow.did)}
+          {#each filteredAccounts as did (did)}
+            {@const profile = accountProfiles.get(did)}
             <div class="source-group-header account-header">
               {#if profile?.avatar}
                 <img src={profile.avatar} alt="" class="header-avatar" />
@@ -266,12 +277,12 @@
               {#if profile}
                 {profile.displayName || profile.handle}
               {:else}
-                {follow.did.slice(0, 20)}...
+                {did.slice(0, 20)}...
               {/if}
             </div>
             <div class="checklist account-kind-checklist">
               {#each ACCOUNT_SOURCE_KINDS as { kind, label, keyFn }}
-                {@const key = keyFn(follow.did)}
+                {@const key = keyFn(did)}
                 <label class="checklist-item">
                   <input
                     type="checkbox"
@@ -283,7 +294,7 @@
               {/each}
             </div>
           {/each}
-          {#if accountSearch && filteredFollows.length === 0}
+          {#if accountSearch && filteredAccounts.length === 0}
             <div class="no-results">No accounts match</div>
           {/if}
         {/if}
diff --git a/src/lib/components/FollowLimitModal.svelte b/src/lib/components/FollowLimitModal.svelte
deleted file mode 100644
index 7b6b280..0000000
--- a/src/lib/components/FollowLimitModal.svelte
+++ /dev/null
@@ -1,66 +0,0 @@
-<script lang="ts">
-  import { socialStore } from '$lib/stores/social.svelte';
-  import { auth } from '$lib/stores/auth.svelte';
-  import Modal from '$lib/components/common/Modal.svelte';
-
-  interface Props {
-    open: boolean;
-    onclose: () => void;
-  }
-
-  let { open, onclose }: Props = $props();
-</script>
-
-<Modal {open} {onclose} title="Follow Limit Reached">
-  <div class="limit-modal-content">
-    <p>
-      You can follow up to <strong>{socialStore.followLimit}</strong> accounts.
-    </p>
-    <p class="current-count">
-      You're currently following {socialStore.inAppFollowCount} of {socialStore.followLimit} accounts.
-    </p>
-    {#if auth.user?.tier !== 'supporter'}
-      <p class="sponsor-cta">
-        <a href="https://github.com/sponsors/disnet" target="_blank" rel="noopener noreferrer"
-          >Become a sponsor</a
-        > to get raised limits.
-      </p>
-    {/if}
-  </div>
-  {#snippet footer()}
-    <button class="btn btn-primary" onclick={onclose}>Got it</button>
-  {/snippet}
-</Modal>
-
-<style>
-  .limit-modal-content {
-    text-align: center;
-  }
-
-  .limit-modal-content p {
-    margin: 0 0 1rem;
-    color: var(--color-text-secondary);
-  }
-
-  .limit-modal-content p:last-child {
-    margin-bottom: 0;
-  }
-
-  .limit-modal-content .current-count {
-    font-size: 0.875rem;
-    color: var(--color-text-tertiary);
-  }
-
-  .sponsor-cta {
-    font-size: 0.875rem;
-  }
-
-  .sponsor-cta a {
-    color: var(--color-primary);
-    text-decoration: none;
-  }
-
-  .sponsor-cta a:hover {
-    text-decoration: underline;
-  }
-</style>
diff --git a/src/lib/components/FollowUserModal.svelte b/src/lib/components/FollowUserModal.svelte
deleted file mode 100644
index 6f13621..0000000
--- a/src/lib/components/FollowUserModal.svelte
+++ /dev/null
@@ -1,337 +0,0 @@
-<script lang="ts">
-  import { searchBlueskyActors, type BlueskySearchResult } from '$lib/services/blueskySearch';
-  import { socialStore } from '$lib/stores/social.svelte';
-  import { auth } from '$lib/stores/auth.svelte';
-  import Modal from '$lib/components/common/Modal.svelte';
-
-  interface Props {
-    open: boolean;
-    onclose: () => void;
-  }
-
-  let { open, onclose }: Props = $props();
-
-  let userSearchQuery = $state('');
-  let userSearchResults = $state<BlueskySearchResult[]>([]);
-  let isUserSearching = $state(false);
-  let userSearchDebounceTimer: ReturnType<typeof setTimeout> | null = null;
-  let showFollowLimitWarning = $state(false);
-  let searchInputEl = $state<HTMLInputElement | null>(null);
-
-  // Set of DIDs that user is already following
-  let followedDids = $derived(new Set(socialStore.followedUsers.map((u) => u.did)));
-
-  async function searchUsers(query: string) {
-    if (query.length < 2) {
-      userSearchResults = [];
-      return;
-    }
-
-    isUserSearching = true;
-    try {
-      userSearchResults = await searchBlueskyActors(query, 5);
-    } catch (error) {
-      console.error('Search error:', error);
-      userSearchResults = [];
-    } finally {
-      isUserSearching = false;
-    }
-  }
-
-  function handleUserSearchInput(event: Event) {
-    const target = event.target as HTMLInputElement;
-    userSearchQuery = target.value;
-    showFollowLimitWarning = false;
-
-    if (userSearchDebounceTimer) {
-      clearTimeout(userSearchDebounceTimer);
-    }
-
-    userSearchDebounceTimer = setTimeout(() => {
-      searchUsers(userSearchQuery);
-    }, 300);
-  }
-
-  async function followUser(did: string) {
-    if (followedDids.has(did)) return;
-
-    if (socialStore.isAtFollowLimit) {
-      showFollowLimitWarning = true;
-      return;
-    }
-
-    const success = await socialStore.followUser(did);
-    if (success) {
-      await socialStore.loadFollowedUsers();
-      userSearchQuery = '';
-      userSearchResults = [];
-    }
-  }
-
-  function handleClose() {
-    userSearchQuery = '';
-    userSearchResults = [];
-    showFollowLimitWarning = false;
-    if (userSearchDebounceTimer) {
-      clearTimeout(userSearchDebounceTimer);
-    }
-    onclose();
-  }
-
-  // Focus search input when modal opens
-  $effect(() => {
-    if (open) {
-      requestAnimationFrame(() => {
-        searchInputEl?.focus();
-      });
-    }
-  });
-</script>
-
-<Modal {open} onclose={handleClose} title="Follow User">
-  <div class="follow-user-content">
-    <div class="search-wrapper">
-      <span class="search-icon">@</span>
-      <input
-        bind:this={searchInputEl}
-        type="text"
-        class="search-input"
-        placeholder="Search Bluesky users..."
-        value={userSearchQuery}
-        oninput={handleUserSearchInput}
-      />
-      {#if isUserSearching}
-        <span class="search-spinner"></span>
-      {/if}
-    </div>
-
-    {#if showFollowLimitWarning}
-      <div class="follow-limit-warning">
-        Follow limit reached ({socialStore.followLimit} max).
-        {#if auth.user?.tier !== 'supporter'}
-          <a
-            href="https://github.com/sponsors/disnet"
-            target="_blank"
-            rel="noopener noreferrer"
-            class="sponsor-link">Become a sponsor</a
-          > to get raised limits.
-        {/if}
-      </div>
-    {/if}
-
-    {#if userSearchResults.length > 0}
-      <div class="search-results">
-        {#each userSearchResults as result (result.did)}
-          {@const isFollowed = followedDids.has(result.did)}
-          <button
-            class="search-result"
-            class:is-followed={isFollowed}
-            onclick={() => followUser(result.did)}
-            disabled={isFollowed}
-          >
-            {#if result.avatar}
-              <img src={result.avatar} alt="" class="result-avatar" />
-            {:else}
-              <span class="result-avatar-placeholder"></span>
-            {/if}
-            <span class="result-info">
-              <span class="result-name">{result.displayName || result.handle}</span>
-              <span class="result-handle">@{result.handle}</span>
-            </span>
-            {#if isFollowed}
-              <span class="following-badge">Following</span>
-            {:else}
-              <span class="follow-btn">Follow</span>
-            {/if}
-          </button>
-        {/each}
-      </div>
-    {:else if userSearchQuery.length >= 2 && !isUserSearching}
-      <p class="no-results">No users found</p>
-    {:else if userSearchQuery.length === 0}
-      <p class="hint">Enter a Bluesky handle or name to search</p>
-    {/if}
-  </div>
-</Modal>
-
-<style>
-  .follow-user-content {
-    display: flex;
-    flex-direction: column;
-    gap: 1rem;
-    min-height: 300px;
-  }
-
-  .search-wrapper {
-    position: relative;
-    display: flex;
-    align-items: center;
-  }
-
-  .search-icon {
-    position: absolute;
-    left: 0.75rem;
-    color: var(--color-text-secondary);
-    font-size: 1rem;
-    pointer-events: none;
-  }
-
-  .search-input {
-    width: 100%;
-    padding: 0.75rem 0.75rem 0.75rem 2rem;
-    font-size: 1rem;
-    border: 1px solid var(--color-border);
-    border-radius: 8px;
-    background: var(--color-bg-secondary);
-    color: var(--color-text);
-    font: inherit;
-  }
-
-  .search-input:focus {
-    outline: none;
-    border-color: var(--color-primary);
-  }
-
-  .search-input::placeholder {
-    color: var(--color-text-secondary);
-  }
-
-  .search-spinner {
-    position: absolute;
-    right: 0.75rem;
-    width: 1rem;
-    height: 1rem;
-    border: 2px solid var(--color-border);
-    border-top-color: var(--color-primary);
-    border-radius: 50%;
-    animation: spin 0.6s linear infinite;
-  }
-
-  @keyframes spin {
-    to {
-      transform: rotate(360deg);
-    }
-  }
-
-  .follow-limit-warning {
-    padding: 0.5rem 0.75rem;
-    font-size: 0.875rem;
-    color: var(--color-warning, #ff9800);
-    background: rgba(255, 152, 0, 0.1);
-    border-radius: 6px;
-  }
-
-  .sponsor-link {
-    color: var(--color-primary);
-    text-decoration: none;
-  }
-
-  .sponsor-link:hover {
-    text-decoration: underline;
-  }
-
-  .search-results {
-    display: flex;
-    flex-direction: column;
-    border: 1px solid var(--color-border);
-    border-radius: 8px;
-    overflow: hidden;
-  }
-
-  .search-result {
-    display: flex;
-    align-items: center;
-    gap: 0.75rem;
-    width: 100%;
-    padding: 0.75rem;
-    background: none;
-    border: none;
-    border-bottom: 1px solid var(--color-border);
-    text-align: left;
-    cursor: pointer;
-    color: var(--color-text);
-    font: inherit;
-    transition: background-color 0.1s;
-  }
-
-  .search-result:last-child {
-    border-bottom: none;
-  }
-
-  .search-result:hover:not(.is-followed) {
-    background: var(--color-bg-secondary);
-  }
-
-  .search-result.is-followed {
-    cursor: default;
-    opacity: 0.7;
-  }
-
-  .result-avatar {
-    width: 40px;
-    height: 40px;
-    border-radius: 50%;
-    flex-shrink: 0;
-    object-fit: cover;
-  }
-
-  .result-avatar-placeholder {
-    width: 40px;
-    height: 40px;
-    border-radius: 50%;
-    background: var(--color-border);
-    flex-shrink: 0;
-  }
-
-  .result-info {
-    flex: 1;
-    min-width: 0;
-    display: flex;
-    flex-direction: column;
-    gap: 0.125rem;
-  }
-
-  .result-name {
-    font-size: 0.9375rem;
-    font-weight: 500;
-    overflow: hidden;
-    text-overflow: ellipsis;
-    white-space: nowrap;
-  }
-
-  .result-handle {
-    font-size: 0.8125rem;
-    color: var(--color-text-secondary);
-    overflow: hidden;
-    text-overflow: ellipsis;
-    white-space: nowrap;
-  }
-
-  .following-badge {
-    font-size: 0.75rem;
-    padding: 0.25rem 0.5rem;
-    background: var(--color-sidebar-active);
-    color: var(--color-primary);
-    border-radius: 9999px;
-    font-weight: 500;
-    flex-shrink: 0;
-  }
-
-  .follow-btn {
-    font-size: 0.8125rem;
-    padding: 0.375rem 0.75rem;
-    background: var(--color-primary);
-    color: white;
-    border-radius: 9999px;
-    font-weight: 500;
-    flex-shrink: 0;
-  }
-
-  .no-results,
-  .hint {
-    text-align: center;
-    color: var(--color-text-secondary);
-    font-size: 0.875rem;
-    padding: 1rem;
-  }
-</style>
diff --git a/src/lib/components/ImportOPMLModal.svelte b/src/lib/components/ImportOPMLModal.svelte
index 5796458..5ce0e09 100644
--- a/src/lib/components/ImportOPMLModal.svelte
+++ b/src/lib/components/ImportOPMLModal.svelte
@@ -62,7 +62,9 @@
     }
 
     // Check which feeds already exist
-    const existing = new Set(subscriptionsStore.subscriptions.map((s) => s.feedUrl.toLowerCase()));
+    const existing = new Set(
+      subscriptionsStore.subscriptions.filter((s) => s.feedUrl).map((s) => s.feedUrl!.toLowerCase())
+    );
     existingUrls = existing;
 
     // Pre-select only non-duplicate feeds
diff --git a/src/lib/components/NavigationDropdown.svelte b/src/lib/components/NavigationDropdown.svelte
index 4ba081a..fc315b8 100644
--- a/src/lib/components/NavigationDropdown.svelte
+++ b/src/lib/components/NavigationDropdown.svelte
@@ -2,11 +2,9 @@
   import { goto } from '$app/navigation';
   import { page } from '$app/stores';
   import { onMount, onDestroy } from 'svelte';
-  import { profileService } from '$lib/services/profiles';
   import { getFaviconUrl } from '$lib/utils/favicon';
   import { sidebarStore } from '$lib/stores/sidebar.svelte';
   import { subscriptionsStore } from '$lib/stores/subscriptions.svelte';
-  import { socialStore } from '$lib/stores/social.svelte';
   import { itemLabelsStore } from '$lib/stores/itemLabels.svelte';
   import { sharesStore } from '$lib/stores/shares.svelte';
   import { activityStore } from '$lib/stores/activity.svelte';
@@ -15,7 +13,6 @@
   import { feedViewStore } from '$lib/stores/feedView.svelte';
   import Icon from './Icon.svelte';
   import AddDropdownMenu from './AddDropdownMenu.svelte';
-  import type { BlueskyProfile } from '$lib/types';
 
   interface Props {
     currentTitle: string;
@@ -25,13 +22,9 @@
 
   // Derive data from stores
   let subscriptions = $derived(subscriptionsStore.subscriptions);
-  // Use inAppFollows instead of followedUsers to show ALL followed accounts,
-  // not just those with shares/content
-  let followedUsers = $derived(socialStore.inAppFollows);
 
   let feedUnreadCounts = $derived(unreadCounts.feedCounts);
   let totalUnread = $derived(unreadCounts.totalArticles);
-  let sharerCounts = $derived(unreadCounts.sharerShareCounts);
 
   let savedCount = $derived(itemLabelsStore.savedCount);
   let sharedCount = $derived(sharesStore.userShares.size);
@@ -47,9 +40,6 @@
   // Use store for open state so it can be controlled externally (keyboard shortcut)
   let isOpen = $derived(sidebarStore.navigationDropdownOpen);
 
-  // Profiles cache for followed users
-  let userProfiles = $state<Map<string, BlueskyProfile>>(new Map());
-
   // Check if we're on mobile
   function checkMobile() {
     isMobile = window.matchMedia('(max-width: 1000px)').matches;
@@ -64,21 +54,6 @@
     window.removeEventListener('resize', checkMobile);
   });
 
-  // Load profiles for followed users when they change
-  $effect(() => {
-    const dids = followedUsers.map((u) => u.did);
-    for (const did of dids) {
-      if (!userProfiles.has(did)) {
-        profileService.getProfile(did).then((profile) => {
-          if (profile) {
-            userProfiles.set(did, profile);
-            userProfiles = new Map(userProfiles);
-          }
-        });
-      }
-    }
-  });
-
   // Icon names type (matches Icon.svelte)
   type IconName =
     | 'inbox'
@@ -87,19 +62,16 @@
     | 'search'
     | 'bell'
     | 'settings'
-    | 'users'
     | 'rss'
     | 'newspaper'
     | 'plus'
     | 'filter'
-    | 'layers'
-    | 'share-2';
+    | 'layers';
 
   // Navigation item type
   type NavItem =
     | { type: 'view'; id: string; label: string; count?: number; icon: IconName }
     | { type: 'feed'; id: number; label: string; count: number; iconUrl: string | null }
-    | { type: 'user'; did: string; label: string; count: number; avatarUrl: string | null }
     | { type: 'utility'; id: string; label: string; count?: number; icon: IconName }
     | { type: 'action'; id: string; label: string; icon: IconName }
     | { type: 'filteredView'; id: number; label: string; icon: IconName };
@@ -120,7 +92,6 @@
       { type: 'view', id: 'all', label: 'All', count: totalUnread, icon: 'inbox' },
       { type: 'view', id: 'saved', label: 'Saved', count: savedCount, icon: 'bookmark' },
       { type: 'view', id: 'shared', label: 'Shared', count: sharedCount, icon: 'share' },
-      { type: 'utility', id: 'discover', label: 'Discover', icon: 'share-2' },
       { type: 'utility', id: 'activity', label: 'Activity', count: activityCount, icon: 'bell' },
       { type: 'utility', id: 'settings', label: 'Settings', icon: 'settings' },
     ];
@@ -139,28 +110,18 @@
       icon: 'plus',
     };
 
-    const userItems: NavItem[] = followedUsers.map((u) => {
-      const profile = userProfiles.get(u.did);
-      return {
-        type: 'user' as const,
-        did: u.did,
-        label:
-          profile?.displayName ||
-          u.displayName ||
-          profile?.handle ||
-          u.handle ||
-          u.did.slice(0, 20) + '...',
-        count: sharerCounts.get(u.did) || 0,
-        avatarUrl: profile?.avatar || u.avatarUrl || null,
-      };
-    });
-
     const feedItems: NavItem[] = subscriptions.map((s) => ({
       type: 'feed' as const,
       id: s.id!,
       label: s.customTitle || s.title,
       count: feedUnreadCounts.get(s.id!) || 0,
-      iconUrl: s.customIconUrl || getFaviconUrl(s.siteUrl || s.feedUrl),
+      iconUrl:
+        s.customIconUrl ||
+        (s.sourceType?.startsWith('atproto.')
+          ? s.siteUrl
+            ? getFaviconUrl(s.siteUrl)
+            : '/icons/icon-192.svg'
+          : getFaviconUrl(s.siteUrl || s.feedUrl || '')),
     }));
 
     // Filter by search query
@@ -182,19 +143,6 @@
       sections.push({ section: '', items: allViews });
     }
 
-    const filteredUsers = userItems.filter(filterItem);
-    if (filteredUsers.length > 0 || filterSection('Following')) {
-      sections.push({
-        section: 'Following',
-        icon: 'users',
-        onSectionClick: () => {
-          goto('/following');
-          close();
-        },
-        items: filteredUsers,
-      });
-    }
-
     const filteredFeeds = feedItems.filter(filterItem);
     if (filteredFeeds.length > 0 || filterSection('Feeds')) {
       sections.push({
@@ -215,53 +163,43 @@
   let flatItems = $derived(filteredItems.flatMap((s) => s.items));
 
   // Derive the current view's icon for the trigger button
-  type TriggerIcon =
-    | { type: 'icon'; name: IconName }
-    | { type: 'favicon'; url: string }
-    | { type: 'avatar'; url: string };
+  type TriggerIcon = { type: 'icon'; name: IconName } | { type: 'favicon'; url: string };
 
   let currentIcon = $derived.by((): TriggerIcon => {
     const pathname = $page.url.pathname;
 
     // Utility pages (separate routes)
-    if (pathname === '/discover') return { type: 'icon', name: 'share-2' };
     if (pathname === '/activity') return { type: 'icon', name: 'bell' };
     if (pathname === '/settings') return { type: 'icon', name: 'settings' };
-    if (pathname === '/following') return { type: 'icon', name: 'users' };
 
     // Feed page filters (query params on /)
     const url = $page.url;
     const feed = url.searchParams.get('feed');
     const saved = url.searchParams.get('saved');
     const shared = url.searchParams.get('shared');
-    const sharer = url.searchParams.get('sharer');
-    const following = url.searchParams.get('following');
     const feeds = url.searchParams.get('feeds');
     const view = url.searchParams.get('view');
 
     if (view) return { type: 'icon', name: 'filter' };
     if (saved) return { type: 'icon', name: 'bookmark' };
     if (shared) return { type: 'icon', name: 'share' };
-    if (following) return { type: 'icon', name: 'users' };
     if (feeds) return { type: 'icon', name: 'rss' };
 
     if (feed) {
       const sub = subscriptions.find((s) => s.id === parseInt(feed));
       if (sub) {
-        const iconUrl = sub.customIconUrl || getFaviconUrl(sub.siteUrl || sub.feedUrl);
+        const iconUrl =
+          sub.customIconUrl ||
+          (sub.sourceType?.startsWith('atproto.')
+            ? sub.siteUrl
+              ? getFaviconUrl(sub.siteUrl)
+              : '/icons/icon-192.svg'
+            : getFaviconUrl(sub.siteUrl || sub.feedUrl || ''));
         return { type: 'favicon', url: iconUrl };
       }
       return { type: 'icon', name: 'rss' };
     }
 
-    if (sharer) {
-      const profile = userProfiles.get(sharer);
-      const user = followedUsers.find((u) => u.did === sharer);
-      const avatarUrl = profile?.avatar || user?.avatarUrl;
-      if (avatarUrl) return { type: 'avatar', url: avatarUrl };
-      return { type: 'icon', name: 'users' };
-    }
-
     return { type: 'icon', name: 'inbox' };
   });
 
@@ -271,17 +209,12 @@
     const feed = url.searchParams.get('feed');
     const saved = url.searchParams.get('saved');
     const shared = url.searchParams.get('shared');
-    const sharer = url.searchParams.get('sharer');
-    const following = url.searchParams.get('following');
     const feeds = url.searchParams.get('feeds');
     const view = url.searchParams.get('view');
-    const type = url.searchParams.get('type') as 'shares' | 'documents' | null;
     if (view) return { type: 'filteredView', id: parseInt(view) };
     if (feed) return { type: 'feed', id: parseInt(feed) };
     if (saved) return { type: 'saved' };
     if (shared) return { type: 'shared' };
-    if (sharer) return { type: 'sharer', id: sharer };
-    if (following) return { type: 'following', contentType: type };
     if (feeds) return { type: 'feeds' };
     return { type: 'all' };
   });
@@ -294,10 +227,7 @@
       if (item.id === 'shared' && filter.type === 'shared') return true;
       if (item.id === 'feeds' && filter.type === 'feeds') return true;
     }
-    if (item.type === 'utility' && item.id === 'following' && $page.url.pathname === '/following')
-      return true;
     if (item.type === 'feed' && filter.type === 'feed' && filter.id === item.id) return true;
-    if (item.type === 'user' && filter.type === 'sharer' && filter.id === item.did) return true;
     if (item.type === 'filteredView' && filter.type === 'filteredView' && filter.id === item.id)
       return true;
     return false;
@@ -367,8 +297,6 @@
       url = `/?feed=${item.id}`;
     } else if (item.type === 'filteredView') {
       url = `/?view=${item.id}`;
-    } else if (item.type === 'user') {
-      url = `/?sharer=${item.did}`;
     } else if (item.type === 'utility') {
       url = `/${item.id}`;
     }
@@ -491,8 +419,6 @@
       <span class="trigger-icon"><Icon name={currentIcon.name} size={16} /></span>
     {:else if currentIcon.type === 'favicon'}
       <img src={currentIcon.url} alt="" class="trigger-favicon" />
-    {:else if currentIcon.type === 'avatar'}
-      <img src={currentIcon.url} alt="" class="trigger-avatar" />
     {/if}
     <span class="trigger-title">{currentTitle}</span>
     <svg
@@ -564,12 +490,6 @@
                 {:else}
                   <span class="feed-icon-placeholder"></span>
                 {/if}
-              {:else if item.type === 'user'}
-                {#if item.avatarUrl}
-                  <img src={item.avatarUrl} alt="" class="user-avatar" />
-                {:else}
-                  <span class="user-avatar-placeholder"></span>
-                {/if}
               {/if}
               <span class="item-label">{item.label}</span>
               {#if item.type !== 'action' && item.type !== 'filteredView' && item.count && item.count > 0}
@@ -653,12 +573,6 @@
                 {:else}
                   <span class="feed-icon-placeholder"></span>
                 {/if}
-              {:else if item.type === 'user'}
-                {#if item.avatarUrl}
-                  <img src={item.avatarUrl} alt="" class="user-avatar" />
-                {:else}
-                  <span class="user-avatar-placeholder"></span>
-                {/if}
               {/if}
               <span class="item-label">{item.label}</span>
               {#if item.type !== 'action' && item.type !== 'filteredView' && item.count && item.count > 0}
@@ -717,15 +631,6 @@
     display: block;
   }
 
-  .trigger-avatar {
-    width: 18px;
-    height: 18px;
-    flex-shrink: 0;
-    border-radius: 50%;
-    object-fit: cover;
-    display: block;
-  }
-
   .trigger-title {
     font-size: 1rem;
     font-weight: 600;
@@ -1002,24 +907,6 @@
     display: block;
   }
 
-  .user-avatar {
-    width: 18px;
-    height: 18px;
-    flex-shrink: 0;
-    border-radius: 50%;
-    object-fit: cover;
-    display: block;
-  }
-
-  .user-avatar-placeholder {
-    width: 18px;
-    height: 18px;
-    flex-shrink: 0;
-    background: var(--color-border);
-    border-radius: 50%;
-    display: block;
-  }
-
   .item-label {
     flex: 1;
     overflow: hidden;
@@ -1209,22 +1096,6 @@
     border-radius: 2px;
   }
 
-  :global(.mobile-portal .user-avatar) {
-    width: 18px;
-    height: 18px;
-    flex-shrink: 0;
-    border-radius: 50%;
-    object-fit: cover;
-  }
-
-  :global(.mobile-portal .user-avatar-placeholder) {
-    width: 18px;
-    height: 18px;
-    flex-shrink: 0;
-    background: var(--color-border);
-    border-radius: 50%;
-  }
-
   :global(.mobile-portal .item-label) {
     flex: 1;
     overflow: hidden;
diff --git a/src/lib/components/Sidebar.svelte b/src/lib/components/Sidebar.svelte
index 28fa76b..0f78691 100644
--- a/src/lib/components/Sidebar.svelte
+++ b/src/lib/components/Sidebar.svelte
@@ -4,7 +4,6 @@
   import { auth } from '$lib/stores/auth.svelte';
   import { sidebarStore } from '$lib/stores/sidebar.svelte';
   import { subscriptionsStore } from '$lib/stores/subscriptions.svelte';
-  import { socialStore } from '$lib/stores/social.svelte';
   import { sharesStore } from '$lib/stores/shares.svelte';
   import { feedStatusStore } from '$lib/stores/feedStatus.svelte';
   import { articlesStore } from '$lib/stores/articles.svelte';
@@ -20,11 +19,10 @@
   import AddDropdownMenu from './AddDropdownMenu.svelte';
   import EditFeedModal from './EditFeedModal.svelte';
   import ContextMenu from './sidebar/ContextMenu.svelte';
-  import UserContextMenu from './sidebar/UserContextMenu.svelte';
   import NavSection from './sidebar/NavSection.svelte';
   import FeedItem from './sidebar/FeedItem.svelte';
-  import UserItem from './sidebar/UserItem.svelte';
   import ViewItem from './sidebar/ViewItem.svelte';
+  import SidebarAddFeed from './sidebar/SidebarAddFeed.svelte';
   import Icon from './Icon.svelte';
   import type { Subscription } from '$lib/types';
 
@@ -39,11 +37,6 @@
   let longPressTimer: ReturnType<typeof setTimeout> | null = null;
   let longPressTriggered = $state(false);
 
-  // User context menu state
-  let userContextMenu = $state<{ x: number; y: number; userDid: string } | null>(null);
-  let userLongPressTimer: ReturnType<typeof setTimeout> | null = null;
-  let userLongPressTriggered = $state(false);
-
   // Edit modal state
   let editingSubscription = $state<Subscription | null>(null);
   let editModalOpen = $state(false);
@@ -96,55 +89,10 @@
     contextMenu = null;
   }
 
-  // User context menu handlers
-  function handleUserContextMenu(e: MouseEvent, userDid: string) {
-    e.preventDefault();
-    userContextMenu = { x: e.clientX, y: e.clientY, userDid };
-  }
-
-  function handleUserTouchStart(e: TouchEvent, userDid: string) {
-    userLongPressTriggered = false;
-    const touch = e.touches[0];
-    userLongPressTimer = setTimeout(() => {
-      userLongPressTriggered = true;
-      userContextMenu = { x: touch.clientX, y: touch.clientY, userDid };
-    }, 500);
-  }
-
-  function handleUserTouchEnd(e: TouchEvent) {
-    if (userLongPressTimer) {
-      clearTimeout(userLongPressTimer);
-      userLongPressTimer = null;
-    }
-    if (userLongPressTriggered) {
-      e.preventDefault();
-    }
-  }
-
-  function handleUserTouchMove() {
-    if (userLongPressTimer) {
-      clearTimeout(userLongPressTimer);
-      userLongPressTimer = null;
-    }
-  }
-
-  function closeUserContextMenu() {
-    userContextMenu = null;
-  }
-
-  async function handleUnfollowUser(userDid: string) {
-    if (confirm('Are you sure you want to unfollow this user?')) {
-      await socialStore.unfollowInApp(userDid);
-    }
-  }
-
   function handleClickOutside(e: MouseEvent) {
     if (contextMenu) {
       closeContextMenu();
     }
-    if (userContextMenu) {
-      closeUserContextMenu();
-    }
     if (viewContextMenu) {
       closeViewContextMenu();
     }
@@ -154,9 +102,6 @@
     if (contextMenu && e.key === 'Escape') {
       closeContextMenu();
     }
-    if (userContextMenu && e.key === 'Escape') {
-      closeUserContextMenu();
-    }
     if (viewContextMenu && e.key === 'Escape') {
       closeViewContextMenu();
     }
@@ -176,7 +121,6 @@
     document.removeEventListener('click', handleClickOutside);
     document.removeEventListener('keydown', handleKeydown);
     if (longPressTimer) clearTimeout(longPressTimer);
-    if (userLongPressTimer) clearTimeout(userLongPressTimer);
     if (viewLongPressTimer) clearTimeout(viewLongPressTimer);
     document.body.classList.remove('sidebar-open-mobile');
   });
@@ -193,44 +137,24 @@
 
   let feedUnreadCounts = $derived(unreadCounts.feedCounts);
   let totalUnread = $derived(unreadCounts.totalArticles);
-  let sharerCounts = $derived(() => unreadCounts.sharerShareCounts);
-  let sharerDocCounts = $derived(() => unreadCounts.sharerDocCounts);
 
   // Current filter from URL
   let currentFilter = $derived(() => {
     // Only show feed filters as active on the home page
     if ($page.url.pathname !== '/') {
-      return { type: 'none' as const, contentType: null as 'shares' | 'documents' | null };
+      return { type: 'none' as const };
     }
     const view = $page.url.searchParams.get('view');
     const feed = $page.url.searchParams.get('feed');
     const starred = $page.url.searchParams.get('saved');
     const shared = $page.url.searchParams.get('shared');
-    const sharer = $page.url.searchParams.get('sharer');
-    const following = $page.url.searchParams.get('following');
     const feeds = $page.url.searchParams.get('feeds');
-    const type = $page.url.searchParams.get('type') as 'shares' | 'documents' | null;
-    if (view)
-      return {
-        type: 'view' as const,
-        id: parseInt(view),
-        contentType: null as 'shares' | 'documents' | null,
-      };
-    if (feed)
-      return {
-        type: 'feed' as const,
-        id: parseInt(feed),
-        contentType: null as 'shares' | 'documents' | null,
-      };
-    if (starred)
-      return { type: 'saved' as const, contentType: null as 'shares' | 'documents' | null };
-    if (shared)
-      return { type: 'shared' as const, contentType: null as 'shares' | 'documents' | null };
-    if (following) return { type: 'following' as const, contentType: type };
-    if (sharer) return { type: 'sharer' as const, id: sharer, contentType: type };
-    if (feeds)
-      return { type: 'feeds' as const, contentType: null as 'shares' | 'documents' | null };
-    return { type: 'all' as const, contentType: null as 'shares' | 'documents' | null };
+    if (view) return { type: 'view' as const, id: parseInt(view) };
+    if (feed) return { type: 'feed' as const, id: parseInt(feed) };
+    if (starred) return { type: 'saved' as const };
+    if (shared) return { type: 'shared' as const };
+    if (feeds) return { type: 'feeds' as const };
+    return { type: 'all' as const };
   });
 
   // Sort and optionally filter subscriptions by unread count (descending)
@@ -246,38 +170,6 @@
     return subs;
   });
 
-  // Sort followed users: all in-app follows, sorted by unread items (shares + documents) then by DID
-  let sortedFollowedUsers = $derived(() => {
-    const shareCounts = sharerCounts();
-    const docCounts = sharerDocCounts();
-    // Use inAppFollows which includes ALL users we follow on Skyreader (not just those with shares)
-    let users = socialStore.inAppFollows
-      .map((f) => ({ did: f.did, source: 'inapp' as const }))
-      .sort((a, b) => {
-        const countA = (shareCounts.get(a.did) || 0) + (docCounts.get(a.did) || 0);
-        const countB = (shareCounts.get(b.did) || 0) + (docCounts.get(b.did) || 0);
-        const hasUnreadA = countA > 0;
-        const hasUnreadB = countB > 0;
-
-        // Tier 1: accounts with unread items (shares or documents)
-        if (hasUnreadA && !hasUnreadB) return -1;
-        if (!hasUnreadA && hasUnreadB) return 1;
-
-        // Within unread tier, sort by count descending
-        if (hasUnreadA && hasUnreadB) {
-          return countB - countA;
-        }
-
-        // Tier 2: by DID (stable sort - profiles are fetched async in UserItem)
-        return a.did.localeCompare(b.did);
-      });
-    if (sidebarStore.showOnlyUnread.shared) {
-      const totalCount = (did: string) => (shareCounts.get(did) || 0) + (docCounts.get(did) || 0);
-      users = users.filter((u) => totalCount(u.did) > 0);
-    }
-    return users;
-  });
-
   // Update sorted IDs in store for keyboard navigation
   $effect(() => {
     const sorted = sortedSubscriptions();
@@ -285,12 +177,6 @@
     sidebarStore.setSortedFeedIds(ids);
   });
 
-  $effect(() => {
-    const sorted = sortedFollowedUsers();
-    const dids = sorted.map((u) => u.did);
-    sidebarStore.setSortedUserDids(dids);
-  });
-
   // View context menu state
   let viewContextMenu = $state<{ x: number; y: number; viewId: number } | null>(null);
   let viewLongPressTimer: ReturnType<typeof setTimeout> | null = null;
@@ -342,19 +228,13 @@
     }
   }
 
-  function selectFilter(type: string, id?: string | number, contentType?: 'shares' | 'documents') {
+  function selectFilter(type: string, id?: string | number) {
     const params = new URLSearchParams();
     if (type === 'view' && id) params.set('view', String(id));
     else if (type === 'feed' && id) params.set('feed', String(id));
     else if (type === 'saved') params.set('saved', 'true');
     else if (type === 'shared') params.set('shared', 'true');
-    else if (type === 'following') {
-      params.set('following', 'true');
-      if (contentType) params.set('type', contentType);
-    } else if (type === 'sharer' && id) {
-      params.set('sharer', String(id));
-      if (contentType) params.set('type', contentType);
-    } else if (type === 'feeds') params.set('feeds', 'true');
+    else if (type === 'feeds') params.set('feeds', 'true');
 
     const query = params.toString();
     goto(query ? `/?${query}` : '/');
@@ -429,16 +309,6 @@
       {/if}
     </button>
 
-    <a
-      href="/discover"
-      class="nav-item nav-link"
-      class:active={$page.url.pathname === '/discover'}
-      onclick={() => sidebarStore.closeMobile()}
-    >
-      <span class="nav-icon"><Icon name="share-2" /></span>
-      <span class="nav-label">Discover</span>
-    </a>
-
     <a
       href="/activity"
       class="nav-item nav-link"
@@ -517,55 +387,6 @@
 
     <div class="nav-separator"></div>
 
-    <!-- Following section -->
-    <NavSection
-      title="Following"
-      icon="users"
-      isExpanded={sidebarStore.expandedSections.shared}
-      showOnlyUnread={sidebarStore.showOnlyUnread.shared}
-      isActive={$page.url.pathname === '/following'}
-      onToggle={() => sidebarStore.toggleSection('shared')}
-      onLabelClick={() => {
-        goto('/following');
-        sidebarStore.closeMobile();
-      }}
-      onUnreadToggle={() => sidebarStore.toggleShowOnlyUnread('shared')}
-      onAdd={() => sidebarStore.openFollowUserModal()}
-    >
-      {@const totalShareCount = Array.from(sharerCounts().values()).reduce((a, b) => a + b, 0)}
-      {@const totalDocCount = Array.from(sharerDocCounts().values()).reduce((a, b) => a + b, 0)}
-      {@const filter = currentFilter()}
-      {@const allUsers = sortedFollowedUsers()}
-      {@const displayedUsers = allUsers.slice(0, 10)}
-      {#each displayedUsers as user (user.did)}
-        {@const shareCount = sharerCounts().get(user.did) || 0}
-        {@const docCount = sharerDocCounts().get(user.did) || 0}
-        {@const filter = currentFilter()}
-        <UserItem
-          {user}
-          {shareCount}
-          documentCount={docCount}
-          isActive={filter.type === 'sharer' && filter.id === user.did}
-          contentType={filter.type === 'sharer' && filter.id === user.did
-            ? filter.contentType
-            : null}
-          onSelect={() => selectFilter('sharer', user.did)}
-          onSelectShares={() => selectFilter('sharer', user.did, 'shares')}
-          onSelectDocuments={() => selectFilter('sharer', user.did, 'documents')}
-          onContextMenu={(e) => handleUserContextMenu(e, user.did)}
-          onTouchStart={(e) => handleUserTouchStart(e, user.did)}
-          onTouchEnd={handleUserTouchEnd}
-          onTouchMove={handleUserTouchMove}
-          onMoreClick={(e) => handleUserContextMenu(e, user.did)}
-        />
-      {:else}
-        <div class="empty-section">No followed users</div>
-      {/each}
-      {#if allUsers.length > 10}
-        <div class="more-indicator">...</div>
-      {/if}
-    </NavSection>
-
     <!-- Feeds section -->
     <NavSection
       title="Feeds"
@@ -578,17 +399,20 @@
       onUnreadToggle={() => sidebarStore.toggleShowOnlyUnread('feeds')}
       onAdd={() => sidebarStore.openAddFeedModal()}
     >
+      <SidebarAddFeed />
       {#each sortedSubscriptions() as sub (sub.id)}
         {@const count = feedUnreadCounts.get(sub.id!) || 0}
-        {@const status = feedStatusStore.getStatus(sub.feedUrl)}
+        {@const status = sub.feedUrl ? feedStatusStore.getStatus(sub.feedUrl) : undefined}
         {@const loadingState =
           status?.status === 'pending'
             ? 'loading'
             : status?.status === 'error' || status?.status === 'circuit-open'
               ? 'error'
               : undefined}
-        {@const feedError = feedStatusStore.getStatusMessage(sub.feedUrl)}
-        {@const errorDetails = feedStatusStore.getErrorDetails(sub.feedUrl)}
+        {@const feedError = sub.feedUrl ? feedStatusStore.getStatusMessage(sub.feedUrl) : undefined}
+        {@const errorDetails = sub.feedUrl
+          ? feedStatusStore.getErrorDetails(sub.feedUrl)
+          : undefined}
         <FeedItem
           subscription={sub}
           unreadCount={count}
@@ -632,16 +456,6 @@
   />
 {/if}
 
-{#if userContextMenu}
-  {@const userDid = userContextMenu.userDid}
-  <UserContextMenu
-    x={userContextMenu.x}
-    y={userContextMenu.y}
-    onUnfollow={() => handleUnfollowUser(userDid)}
-    onClose={closeUserContextMenu}
-  />
-{/if}
-
 <EditFeedModal open={editModalOpen} subscription={editingSubscription} onclose={closeEditModal} />
 
 {#if viewContextMenu}
@@ -824,12 +638,6 @@
     height: 0.5rem;
   }
 
-  .more-indicator {
-    padding: 0.25rem 0.75rem;
-    font-size: 0.8125rem;
-    color: var(--color-text-secondary);
-  }
-
   /* Mobile styles */
   @media (max-width: 1000px) {
     .sidebar-backdrop {
diff --git a/src/lib/components/feed/FilterToolbar.svelte b/src/lib/components/feed/FilterToolbar.svelte
index 49da46a..9976ea3 100644
--- a/src/lib/components/feed/FilterToolbar.svelte
+++ b/src/lib/components/feed/FilterToolbar.svelte
@@ -4,7 +4,6 @@
   import { feedViewStore } from '$lib/stores/feedView.svelte';
   import { filteredViewsStore } from '$lib/stores/filteredViews.svelte';
   import { subscriptionsStore } from '$lib/stores/subscriptions.svelte';
-  import { socialStore } from '$lib/stores/social.svelte';
   import { profileService } from '$lib/services/profiles';
   import { getFaviconUrl } from '$lib/utils/favicon';
   import { itemLabelsStore } from '$lib/stores/itemLabels.svelte';
@@ -22,38 +21,39 @@
   } from '$lib/utils/sourceKeys';
   import type { BlueskyProfile } from '$lib/types';
 
+  // Derive unique account DIDs from atproto subscriptions
+  let accountDids = $derived(() => {
+    const dids = new Set<string>();
+    for (const sub of subscriptionsStore.subscriptions) {
+      if (sub.sourceType?.startsWith('atproto.') && sub.subjectDid) {
+        dids.add(sub.subjectDid);
+      }
+    }
+    return [...dids];
+  });
+
   // Resolved profiles for accounts that only have DIDs
   let resolvedProfiles = $state<Map<string, BlueskyProfile>>(new Map());
 
-  // Resolve profiles when inAppFollows changes
+  // Resolve profiles when account DIDs change
   $effect(() => {
-    const follows = socialStore.inAppFollows;
-    const needsResolving = follows.filter(
-      (f) => !f.displayName && (!f.handle || f.handle === f.did || f.handle.startsWith('did:'))
-    );
+    const dids = accountDids();
+    const needsResolving = dids.filter((did) => !resolvedProfiles.has(did));
     if (needsResolving.length > 0) {
-      profileService.getProfiles(needsResolving.map((f) => f.did)).then((profiles) => {
+      profileService.getProfiles(needsResolving).then((profiles) => {
         resolvedProfiles = profiles;
       });
     }
   });
 
-  function getAccountDisplayName(follow: {
-    did: string;
-    handle?: string;
-    displayName?: string;
-  }): string {
-    if (follow.displayName) return follow.displayName;
-    if (follow.handle && follow.handle !== follow.did && !follow.handle.startsWith('did:'))
-      return follow.handle;
-    const resolved = resolvedProfiles.get(follow.did);
+  function getAccountDisplayName(did: string): string {
+    const resolved = resolvedProfiles.get(did);
     if (resolved) return resolved.displayName || resolved.handle;
-    return follow.did;
+    return did;
   }
 
-  function getAccountAvatarUrl(follow: { did: string; avatarUrl?: string }): string | undefined {
-    if (follow.avatarUrl) return follow.avatarUrl;
-    const resolved = resolvedProfiles.get(follow.did);
+  function getAccountAvatarUrl(did: string): string | undefined {
+    const resolved = resolvedProfiles.get(did);
     return resolved?.avatar;
   }
 
@@ -91,21 +91,21 @@
           const term = feedSearch.toLowerCase();
           return (
             (sub.customTitle || sub.title).toLowerCase().includes(term) ||
-            sub.feedUrl.toLowerCase().includes(term)
+            (sub.feedUrl?.toLowerCase().includes(term) ?? false)
           );
         })
       : subscriptionsStore.subscriptions
   );
 
-  // Filtered follows based on search
-  let filteredFollows = $derived(
+  // Filtered accounts based on search
+  let filteredAccounts = $derived(
     accountSearch
-      ? socialStore.inAppFollows.filter((follow) => {
+      ? accountDids().filter((did) => {
           const term = accountSearch.toLowerCase();
-          const displayName = getAccountDisplayName(follow).toLowerCase();
-          return displayName.includes(term) || follow.did.toLowerCase().includes(term);
+          const displayName = getAccountDisplayName(did).toLowerCase();
+          return displayName.includes(term) || did.toLowerCase().includes(term);
         })
-      : socialStore.inAppFollows
+      : accountDids()
   );
 
   // Tag filter state
@@ -155,7 +155,7 @@
 
   // All possible account keys
   let allAccountKeys = $derived(
-    socialStore.inAppFollows.flatMap((f) => ACCOUNT_SOURCE_KINDS.map(({ keyFn }) => keyFn(f.did)))
+    accountDids().flatMap((did) => ACCOUNT_SOURCE_KINDS.map(({ keyFn }) => keyFn(did)))
   );
 
   let allFeedsSelected = $derived(
@@ -450,7 +450,7 @@
                     {#if sub.id != null}
                       {@const key = rssSourceKey(sub.id)}
                       {@const iconUrl =
-                        sub.customIconUrl || getFaviconUrl(sub.siteUrl || sub.feedUrl)}
+                        sub.customIconUrl || getFaviconUrl(sub.siteUrl || sub.feedUrl || '')}
                       <label class="check-label">
                         <input
                           type="checkbox"
@@ -471,7 +471,7 @@
               {/if}
 
               <!-- Account groups -->
-              {#if socialStore.inAppFollows.length > 0}
+              {#if accountDids().length > 0}
                 <div class="popover-group-header">
                   <span>Accounts</span>
                   <button
@@ -489,19 +489,19 @@
                     class="search-input"
                   />
                 </div>
-                {#each filteredFollows as follow}
-                  {@const avatarUrl = getAccountAvatarUrl(follow)}
+                {#each filteredAccounts as did}
+                  {@const avatarUrl = getAccountAvatarUrl(did)}
                   <div class="popover-group-header account-group-header">
                     {#if avatarUrl}
                       <img src={avatarUrl} alt="" class="group-avatar" />
                     {:else}
                       <div class="group-avatar-placeholder"></div>
                     {/if}
-                    {getAccountDisplayName(follow)}
+                    {getAccountDisplayName(did)}
                   </div>
                   <div class="popover-list account-kind-list">
                     {#each ACCOUNT_SOURCE_KINDS as { kind, label, keyFn }}
-                      {@const key = keyFn(follow.did)}
+                      {@const key = keyFn(did)}
                       <label class="check-label">
                         <input
                           type="checkbox"
@@ -513,7 +513,7 @@
                     {/each}
                   </div>
                 {/each}
-                {#if accountSearch && filteredFollows.length === 0}
+                {#if accountSearch && filteredAccounts.length === 0}
                   <div class="no-results">No accounts match</div>
                 {/if}
               {/if}
diff --git a/src/lib/components/following/FollowingUserRow.svelte b/src/lib/components/following/FollowingUserRow.svelte
deleted file mode 100644
index 45addd4..0000000
--- a/src/lib/components/following/FollowingUserRow.svelte
+++ /dev/null
@@ -1,328 +0,0 @@
-<script lang="ts">
-  import UserCard from '$lib/components/common/UserCard.svelte';
-  import Icon from '$lib/components/Icon.svelte';
-  import logo from '$lib/assets/logo.svg';
-  import type { BlueskyProfile, FollowedUserDetailed } from '$lib/types';
-
-  interface Props {
-    user: FollowedUserDetailed;
-    profile?: BlueskyProfile;
-    mode: 'skyreader' | 'bluesky';
-    isExpanded: boolean;
-    isActionInProgress: boolean;
-    onToggleExpanded: () => void;
-    onFollow: (user: FollowedUserDetailed) => void;
-    onUnfollow: (user: FollowedUserDetailed) => void;
-  }
-
-  let {
-    user,
-    profile,
-    mode,
-    isExpanded,
-    isActionInProgress,
-    onToggleExpanded,
-    onFollow,
-    onUnfollow,
-  }: Props = $props();
-
-  function formatRelativeTime(dateString: string | null, prefix: string = 'Last active'): string {
-    if (!dateString) return 'No activity';
-    const date = new Date(dateString);
-    const now = new Date();
-    const diffMs = now.getTime() - date.getTime();
-    const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
-
-    if (diffDays === 0) return `${prefix} today`;
-    if (diffDays === 1) return `${prefix} yesterday`;
-    if (diffDays < 7) return `${prefix} ${diffDays} days ago`;
-    if (diffDays < 30) return `${prefix} ${Math.floor(diffDays / 7)} weeks ago`;
-    if (diffDays < 365) return `${prefix} ${Math.floor(diffDays / 30)} months ago`;
-    return `${prefix} ${Math.floor(diffDays / 365)} years ago`;
-  }
-
-  function getLastActivityDate(u: FollowedUserDetailed): string | null {
-    const dates: number[] = [];
-    if (u.lastSharedAt) dates.push(new Date(u.lastSharedAt).getTime());
-    if (u.lastPublishedAt) dates.push(new Date(u.lastPublishedAt).getTime());
-    if (dates.length === 0) return null;
-    return new Date(Math.max(...dates)).toISOString();
-  }
-
-  let hasShares = $derived(user.recentShares && user.recentShares.length > 0);
-  let hasDocuments = $derived(user.recentDocuments && user.recentDocuments.length > 0);
-  let hasContent = $derived(hasShares || hasDocuments);
-</script>
-
-<div class="user-row card">
-  <div class="user-main">
-    <div class="user-info">
-      <UserCard
-        avatarUrl={profile?.avatar}
-        displayName={profile?.displayName}
-        handle={profile?.handle || user.did}
-        size="large"
-      />
-      {#if mode === 'skyreader'}
-        <div class="user-stats">
-          {#if user.shareCount > 0}
-            <span class="share-count">
-              <img src={logo} alt="" class="stat-icon" />
-              {user.shareCount}
-              {user.shareCount === 1 ? 'share' : 'shares'}
-            </span>
-          {/if}
-          {#if user.documentCount && user.documentCount > 0}
-            <span class="document-count">
-              <Icon name="newspaper" size={14} />
-              {user.documentCount}
-              {user.documentCount === 1 ? 'article' : 'articles'}
-            </span>
-          {/if}
-          {#if getLastActivityDate(user)}
-            <span class="last-shared">{formatRelativeTime(getLastActivityDate(user))}</span>
-          {/if}
-        </div>
-      {/if}
-    </div>
-
-    <div class="user-actions">
-      {#if mode === 'skyreader'}
-        <button
-          class="btn btn-outline unfollow-btn"
-          disabled={isActionInProgress}
-          onclick={() => onUnfollow(user)}
-        >
-          {isActionInProgress ? 'Unfollowing...' : 'Unfollow'}
-        </button>
-      {:else if user.source === 'both'}
-        <span class="already-following">Following on Skyreader</span>
-      {:else}
-        <button
-          class="btn btn-primary follow-btn"
-          disabled={isActionInProgress}
-          onclick={() => onFollow(user)}
-        >
-          {isActionInProgress ? 'Following...' : 'Follow on Skyreader'}
-        </button>
-      {/if}
-      <a
-        href="https://bsky.app/profile/{profile?.handle || user.did}"
-        target="_blank"
-        rel="noopener"
-        class="btn btn-outline bluesky-link"
-      >
-        Bluesky Profile
-      </a>
-    </div>
-  </div>
-
-  {#if hasContent}
-    <button class="disclosure-toggle" onclick={onToggleExpanded}>
-      <span class="disclosure-icon">{isExpanded ? '▼' : '▶'}</span>
-      <span>Recent activity</span>
-    </button>
-
-    {#if isExpanded}
-      {#if hasShares}
-        <div class="recent-section">
-          <h4 class="recent-section-title">
-            <img src={logo} alt="" class="section-icon" />
-            Shares
-          </h4>
-          <ul class="recent-items">
-            {#each user.recentShares! as share}
-              <li>
-                <a href={share.itemUrl} target="_blank" rel="noopener">
-                  {share.itemTitle || share.itemUrl}
-                </a>
-              </li>
-            {/each}
-          </ul>
-        </div>
-      {/if}
-      {#if hasDocuments}
-        <div class="recent-section">
-          <h4 class="recent-section-title">
-            <Icon name="newspaper" size={12} />
-            Articles
-          </h4>
-          <ul class="recent-items">
-            {#each user.recentDocuments! as doc}
-              <li>
-                <a href={doc.url} target="_blank" rel="noopener">
-                  {doc.title || doc.url}
-                </a>
-              </li>
-            {/each}
-          </ul>
-        </div>
-      {/if}
-    {/if}
-  {/if}
-</div>
-
-<style>
-  .user-row {
-    display: flex;
-    flex-direction: column;
-    padding: 1rem;
-    gap: 0.75rem;
-  }
-
-  .user-main {
-    display: flex;
-    justify-content: space-between;
-    align-items: center;
-    gap: 1rem;
-    width: 100%;
-  }
-
-  .user-info {
-    display: flex;
-    flex-direction: column;
-    gap: 0.5rem;
-    min-width: 0;
-    flex: 1;
-  }
-
-  .user-stats {
-    display: flex;
-    gap: 1rem;
-    font-size: 0.875rem;
-    color: var(--color-text-secondary);
-    padding-left: 3.5rem;
-  }
-
-  .share-count,
-  .document-count {
-    display: flex;
-    align-items: center;
-    gap: 0.25rem;
-    font-weight: 500;
-  }
-
-  .stat-icon {
-    width: 14px;
-    height: 14px;
-  }
-
-  .user-actions {
-    display: flex;
-    flex-direction: column;
-    gap: 0.5rem;
-    flex-shrink: 0;
-  }
-
-  .disclosure-toggle {
-    display: flex;
-    align-items: center;
-    gap: 0.5rem;
-    background: none;
-    border: none;
-    padding: 0.5rem 0;
-    font: inherit;
-    font-size: 0.875rem;
-    color: var(--color-text-secondary);
-    cursor: pointer;
-    transition: color 0.15s;
-  }
-
-  .disclosure-toggle:hover {
-    color: var(--color-primary);
-  }
-
-  .disclosure-icon {
-    font-size: 0.625rem;
-    width: 1rem;
-  }
-
-  .recent-section {
-    margin-top: 0.5rem;
-  }
-
-  .recent-section-title {
-    display: flex;
-    align-items: center;
-    gap: 0.375rem;
-    font-size: 0.75rem;
-    font-weight: 600;
-    color: var(--color-text-secondary);
-    text-transform: uppercase;
-    letter-spacing: 0.05em;
-    margin: 0 0 0.25rem 1.5rem;
-  }
-
-  .section-icon {
-    width: 12px;
-    height: 12px;
-  }
-
-  .recent-items {
-    list-style: none;
-    margin: 0;
-    padding: 0 0 0 1.5rem;
-    display: flex;
-    flex-direction: column;
-    gap: 0.5rem;
-  }
-
-  .recent-items li {
-    font-size: 0.875rem;
-  }
-
-  .recent-items a {
-    color: var(--color-text);
-    text-decoration: none;
-    display: block;
-    overflow: hidden;
-    text-overflow: ellipsis;
-    white-space: nowrap;
-  }
-
-  .recent-items a:hover {
-    color: var(--color-primary);
-    text-decoration: underline;
-  }
-
-  .follow-btn,
-  .unfollow-btn {
-    min-width: 150px;
-  }
-
-  .bluesky-link {
-    text-align: center;
-    text-decoration: none;
-    font-size: 0.875rem;
-  }
-
-  .already-following {
-    font-size: 0.875rem;
-    color: var(--color-text-secondary);
-    padding: 0.5rem;
-    text-align: center;
-  }
-
-  @media (max-width: 600px) {
-    .user-main {
-      flex-direction: column;
-      align-items: stretch;
-    }
-
-    .user-stats {
-      padding-left: 0;
-    }
-
-    .user-actions {
-      flex-direction: row;
-      flex-wrap: wrap;
-    }
-
-    .follow-btn,
-    .unfollow-btn,
-    .bluesky-link {
-      flex: 1;
-      min-width: 120px;
-    }
-  }
-</style>
diff --git a/src/lib/components/following/StandardSubscriptionsTab.svelte b/src/lib/components/following/StandardSubscriptionsTab.svelte
deleted file mode 100644
index 273c42f..0000000
--- a/src/lib/components/following/StandardSubscriptionsTab.svelte
+++ /dev/null
@@ -1,481 +0,0 @@
-<script lang="ts">
-  import { onMount } from 'svelte';
-  import { auth } from '$lib/stores/auth.svelte';
-  import { subscriptionsStore } from '$lib/stores/subscriptions.svelte';
-  import { articlesStore } from '$lib/stores/articles.svelte';
-  import { api } from '$lib/services/api';
-  import { fetchSingleFeed } from '$lib/services/feedFetcher';
-  import StateView from '$lib/components/common/StateView.svelte';
-  import Modal from '$lib/components/common/Modal.svelte';
-  import Icon from '$lib/components/Icon.svelte';
-
-  type StandardSub = {
-    uri: string;
-    publication: {
-      uri: string;
-      name: string;
-      url: string;
-      description?: string;
-    };
-  };
-
-  let standardSubscriptions = $state<StandardSub[]>([]);
-  let isLoadingStandard = $state(false);
-  let standardError = $state<string | null>(null);
-  let addingFeeds = $state<Set<string>>(new Set());
-  let addedFeeds = $state<Set<string>>(new Set());
-  let feedPickerSub = $state<StandardSub | null>(null);
-  let discoveredFeeds = $state<string[]>([]);
-  let isAddingAll = $state(false);
-  let addAllProgress = $state<{ done: number; total: number } | null>(null);
-
-  function isAlreadySubscribed(pubUrl: string): boolean {
-    if (addedFeeds.has(pubUrl)) return true;
-    const subs = subscriptionsStore.subscriptions;
-    const pubLower = pubUrl.toLowerCase();
-    let pubHostname: string | null = null;
-    try {
-      pubHostname = new URL(pubUrl).hostname;
-    } catch {
-      // invalid URL, skip hostname matching
-    }
-    return subs.some((s) => {
-      if (s.feedUrl.toLowerCase() === pubLower) return true;
-      if (s.siteUrl?.toLowerCase() === pubLower) return true;
-      if (pubHostname) {
-        try {
-          if (new URL(s.feedUrl).hostname === pubHostname) return true;
-        } catch {
-          /* skip */
-        }
-        if (s.siteUrl) {
-          try {
-            if (new URL(s.siteUrl).hostname === pubHostname) return true;
-          } catch {
-            /* skip */
-          }
-        }
-      }
-      return false;
-    });
-  }
-
-  function parseAtUri(atUri: string): { did: string; collection: string; rkey: string } | null {
-    const match = atUri.match(/^at:\/\/(did:[^/]+)\/([^/]+)\/([^/]+)$/);
-    if (!match) return null;
-    return { did: match[1], collection: match[2], rkey: match[3] };
-  }
-
-  async function resolvePdsUrl(did: string): Promise<string | null> {
-    try {
-      if (did.startsWith('did:plc:')) {
-        const res = await fetch(`https://plc.directory/${did}`);
-        if (!res.ok) return null;
-        const doc = (await res.json()) as {
-          service?: Array<{ id: string; type: string; serviceEndpoint: string }>;
-        };
-        const svc = doc.service?.find(
-          (s) => s.id === '#atproto_pds' || s.type === 'AtprotoPersonalDataServer'
-        );
-        return svc?.serviceEndpoint || null;
-      } else if (did.startsWith('did:web:')) {
-        const domain = did.replace('did:web:', '');
-        const res = await fetch(`https://${domain}/.well-known/did.json`);
-        if (!res.ok) return null;
-        const doc = (await res.json()) as {
-          service?: Array<{ id: string; type: string; serviceEndpoint: string }>;
-        };
-        const svc = doc.service?.find(
-          (s) => s.id === '#atproto_pds' || s.type === 'AtprotoPersonalDataServer'
-        );
-        return svc?.serviceEndpoint || null;
-      }
-      return null;
-    } catch {
-      return null;
-    }
-  }
-
-  async function loadStandardSubscriptions() {
-    isLoadingStandard = true;
-    standardError = null;
-    try {
-      const pdsUrl = auth.user?.pdsUrl;
-      const did = auth.user?.did;
-      if (!pdsUrl || !did) {
-        standardSubscriptions = [];
-        return;
-      }
-
-      const params = new URLSearchParams({
-        repo: did,
-        collection: 'site.standard.graph.subscription',
-        limit: '100',
-      });
-      const res = await fetch(`${pdsUrl}/xrpc/com.atproto.repo.listRecords?${params}`);
-      if (!res.ok) {
-        standardSubscriptions = [];
-        return;
-      }
-      const data = (await res.json()) as {
-        records: Array<{ uri: string; value: { publication?: string } }>;
-      };
-
-      if (data.records.length === 0) {
-        standardSubscriptions = [];
-        return;
-      }
-
-      const entries = data.records
-        .map((r) => ({ uri: r.uri, pubUri: r.value.publication }))
-        .filter((e): e is { uri: string; pubUri: string } => !!e.pubUri)
-        .map((e) => ({ ...e, parsed: parseAtUri(e.pubUri) }))
-        .filter((e): e is typeof e & { parsed: NonNullable<typeof e.parsed> } => !!e.parsed);
-
-      const uniqueDids = [...new Set(entries.map((e) => e.parsed.did))];
-      const pdsCache = new Map<string, string | null>();
-      await Promise.all(
-        uniqueDids.map(async (d) => {
-          pdsCache.set(d, await resolvePdsUrl(d));
-        })
-      );
-
-      const results = await Promise.allSettled(
-        entries.map(async (entry): Promise<StandardSub | null> => {
-          const pubPds = pdsCache.get(entry.parsed.did);
-          if (!pubPds) return null;
-
-          const pubParams = new URLSearchParams({
-            repo: entry.parsed.did,
-            collection: entry.parsed.collection,
-            rkey: entry.parsed.rkey,
-          });
-          const pubRes = await fetch(`${pubPds}/xrpc/com.atproto.repo.getRecord?${pubParams}`);
-          if (!pubRes.ok) return null;
-
-          const pubData = (await pubRes.json()) as {
-            value: { name?: string; url?: string; description?: string };
-          };
-          const pub = pubData.value;
-          if (!pub.url) return null;
-
-          return {
-            uri: entry.uri,
-            publication: {
-              uri: entry.pubUri,
-              name: pub.name || pub.url,
-              url: pub.url,
-              description: pub.description,
-            },
-          };
-        })
-      );
-
-      standardSubscriptions = results
-        .filter((r): r is PromiseFulfilledResult<StandardSub | null> => r.status === 'fulfilled')
-        .map((r) => r.value)
-        .filter((s): s is StandardSub => s !== null);
-      addedFeeds = new Set();
-    } catch (e) {
-      standardError = e instanceof Error ? e.message : 'Failed to load subscriptions';
-    } finally {
-      isLoadingStandard = false;
-    }
-  }
-
-  async function addAndFetch(feedUrl: string, title: string, siteUrl: string) {
-    const id = await subscriptionsStore.add(feedUrl, title, { siteUrl });
-    const sub = subscriptionsStore.getById(id);
-    if (sub) {
-      // Fetch feed in background so articles appear immediately
-      fetchSingleFeed(sub, true, articlesStore.savedGuids);
-    }
-    return id;
-  }
-
-  async function handleAddSubscription(sub: StandardSub) {
-    const pubUrl = sub.publication.url;
-    addingFeeds.add(pubUrl);
-    addingFeeds = new Set(addingFeeds);
-
-    try {
-      const result = await api.discoverFeedsV2(pubUrl);
-      const feeds = result.feeds;
-
-      if (feeds.length === 0) {
-        standardError = `No RSS feed found for ${sub.publication.name}`;
-      } else if (feeds.length === 1) {
-        await addAndFetch(feeds[0], sub.publication.name, pubUrl);
-        addedFeeds.add(pubUrl);
-        addedFeeds = new Set(addedFeeds);
-      } else {
-        feedPickerSub = sub;
-        discoveredFeeds = feeds;
-      }
-    } catch (e) {
-      standardError = e instanceof Error ? e.message : 'Failed to add subscription';
-    } finally {
-      addingFeeds.delete(pubUrl);
-      addingFeeds = new Set(addingFeeds);
-    }
-  }
-
-  async function handlePickFeed(feedUrl: string) {
-    if (!feedPickerSub) return;
-
-    const sub = feedPickerSub;
-    const pubUrl = sub.publication.url;
-    feedPickerSub = null;
-    discoveredFeeds = [];
-
-    addingFeeds.add(pubUrl);
-    addingFeeds = new Set(addingFeeds);
-
-    try {
-      await addAndFetch(feedUrl, sub.publication.name, pubUrl);
-      addedFeeds.add(pubUrl);
-      addedFeeds = new Set(addedFeeds);
-    } catch (e) {
-      standardError = e instanceof Error ? e.message : 'Failed to add subscription';
-    } finally {
-      addingFeeds.delete(pubUrl);
-      addingFeeds = new Set(addingFeeds);
-    }
-  }
-
-  let unaddedStandardSubs = $derived(
-    standardSubscriptions.filter((sub) => !isAlreadySubscribed(sub.publication.url))
-  );
-
-  async function handleAddAll() {
-    const toAdd = unaddedStandardSubs;
-    if (toAdd.length === 0) return;
-
-    isAddingAll = true;
-    addAllProgress = { done: 0, total: toAdd.length };
-    standardError = null;
-
-    let skipped = 0;
-    for (const sub of toAdd) {
-      const pubUrl = sub.publication.url;
-      try {
-        const result = await api.discoverFeedsV2(pubUrl);
-        const feeds = result.feeds;
-
-        if (feeds.length >= 1) {
-          await addAndFetch(feeds[0], sub.publication.name, pubUrl);
-          addedFeeds.add(pubUrl);
-          addedFeeds = new Set(addedFeeds);
-        } else {
-          skipped++;
-        }
-      } catch {
-        skipped++;
-      }
-      addAllProgress = { done: addAllProgress!.done + 1, total: toAdd.length };
-    }
-
-    if (skipped > 0) {
-      standardError = `${skipped} subscription${skipped === 1 ? '' : 's'} could not be added (no RSS feed found).`;
-    }
-
-    isAddingAll = false;
-    addAllProgress = null;
-  }
-
-  onMount(() => {
-    loadStandardSubscriptions();
-  });
-</script>
-
-{#if standardError}
-  <p class="error">{standardError}</p>
-{/if}
-
-<StateView
-  isLoading={isLoadingStandard}
-  isEmpty={standardSubscriptions.length === 0}
-  loadingMessage="Loading subscriptions..."
-  emptyTitle="No subscriptions found"
-  emptyDescription="Subscribe to publications on standard.site or other AT Protocol publishing tools to see them here."
->
-  {#if unaddedStandardSubs.length > 0}
-    <div class="subscribe-all-bar">
-      <button class="btn btn-primary" disabled={isAddingAll} onclick={handleAddAll}>
-        {#if addAllProgress}
-          Adding... ({addAllProgress.done}/{addAllProgress.total})
-        {:else}
-          Add All to Skyreader ({unaddedStandardSubs.length})
-        {/if}
-      </button>
-    </div>
-  {/if}
-
-  <div class="subscriptions-list">
-    {#each standardSubscriptions as sub (sub.uri)}
-      {@const alreadyAdded = isAlreadySubscribed(sub.publication.url)}
-      <div class="subscription-row card">
-        <div class="subscription-info">
-          <h3 class="subscription-name">{sub.publication.name}</h3>
-          <a href={sub.publication.url} target="_blank" rel="noopener" class="subscription-url">
-            {sub.publication.url}
-          </a>
-          {#if sub.publication.description}
-            <p class="subscription-description">{sub.publication.description}</p>
-          {/if}
-        </div>
-        <div class="subscription-actions">
-          {#if alreadyAdded}
-            <span class="already-added-badge">
-              <Icon name="check" size={14} />
-              Added
-            </span>
-          {:else}
-            <button
-              class="btn btn-primary"
-              disabled={addingFeeds.has(sub.publication.url) || isAddingAll}
-              onclick={() => handleAddSubscription(sub)}
-            >
-              {addingFeeds.has(sub.publication.url) ? 'Finding feed...' : 'Add to Skyreader'}
-            </button>
-          {/if}
-        </div>
-      </div>
-    {/each}
-  </div>
-</StateView>
-
-<Modal
-  open={feedPickerSub !== null}
-  onclose={() => {
-    feedPickerSub = null;
-    discoveredFeeds = [];
-  }}
-  title="Choose a Feed"
->
-  <div class="feed-picker-content">
-    <p>Multiple RSS feeds were found for <strong>{feedPickerSub?.publication.name}</strong>:</p>
-    <div class="feed-picker-list">
-      {#each discoveredFeeds as feed}
-        <button class="feed-picker-option btn btn-outline" onclick={() => handlePickFeed(feed)}>
-          {feed}
-        </button>
-      {/each}
-    </div>
-  </div>
-</Modal>
-
-<style>
-  .error {
-    color: var(--color-error, #dc3545);
-    padding: 1rem;
-    background: var(--color-error-bg, #f8d7da);
-    border-radius: 8px;
-    margin-bottom: 1rem;
-  }
-
-  .subscribe-all-bar {
-    display: flex;
-    justify-content: flex-end;
-    margin-bottom: 0.75rem;
-  }
-
-  .subscriptions-list {
-    display: flex;
-    flex-direction: column;
-    gap: 0.75rem;
-  }
-
-  .subscription-row {
-    display: flex;
-    justify-content: space-between;
-    align-items: center;
-    padding: 1rem;
-    gap: 1rem;
-  }
-
-  .subscription-info {
-    flex: 1;
-    min-width: 0;
-  }
-
-  .subscription-name {
-    margin: 0;
-    font-size: 1rem;
-    font-weight: 600;
-    color: var(--color-text);
-  }
-
-  .subscription-url {
-    display: block;
-    font-size: 0.875rem;
-    color: var(--color-text-secondary);
-    text-decoration: none;
-    overflow: hidden;
-    text-overflow: ellipsis;
-    white-space: nowrap;
-    margin-top: 0.25rem;
-  }
-
-  .subscription-url:hover {
-    color: var(--color-primary);
-    text-decoration: underline;
-  }
-
-  .subscription-description {
-    margin: 0.5rem 0 0;
-    font-size: 0.875rem;
-    color: var(--color-text-secondary);
-    display: -webkit-box;
-    -webkit-line-clamp: 2;
-    -webkit-box-orient: vertical;
-    overflow: hidden;
-  }
-
-  .subscription-actions {
-    flex-shrink: 0;
-  }
-
-  .already-added-badge {
-    display: inline-flex;
-    align-items: center;
-    gap: 0.375rem;
-    font-size: 0.875rem;
-    color: var(--color-success, #28a745);
-    padding: 0.5rem 0.75rem;
-    border: 1px solid var(--color-success, #28a745);
-    border-radius: 6px;
-  }
-
-  .feed-picker-content p {
-    margin: 0 0 1rem;
-    color: var(--color-text-secondary);
-  }
-
-  .feed-picker-list {
-    display: flex;
-    flex-direction: column;
-    gap: 0.5rem;
-  }
-
-  .feed-picker-option {
-    text-align: left;
-    word-break: break-all;
-    font-size: 0.875rem;
-  }
-
-  @media (max-width: 600px) {
-    .subscription-row {
-      flex-direction: column;
-      align-items: stretch;
-    }
-
-    .subscription-actions {
-      display: flex;
-    }
-
-    .subscription-actions .btn {
-      flex: 1;
-    }
-  }
-</style>
diff --git a/src/lib/components/sidebar/FeedItem.svelte b/src/lib/components/sidebar/FeedItem.svelte
index 0f83500..fec4705 100644
--- a/src/lib/components/sidebar/FeedItem.svelte
+++ b/src/lib/components/sidebar/FeedItem.svelte
@@ -41,8 +41,15 @@
     onMoreClick,
   }: Props = $props();
 
+  let isAtProto = $derived(subscription.sourceType?.startsWith('atproto.') ?? false);
+
   let faviconUrl = $derived(
-    subscription.customIconUrl || getFaviconUrl(subscription.siteUrl || subscription.feedUrl)
+    subscription.customIconUrl ||
+      (isAtProto
+        ? subscription.siteUrl
+          ? getFaviconUrl(subscription.siteUrl)
+          : '/icons/icon-192.svg'
+        : getFaviconUrl(subscription.siteUrl || subscription.feedUrl || ''))
   );
   let faviconLoaded = $state(false);
 
diff --git a/src/lib/components/sidebar/SidebarAddFeed.svelte b/src/lib/components/sidebar/SidebarAddFeed.svelte
new file mode 100644
index 0000000..7d01078
--- /dev/null
+++ b/src/lib/components/sidebar/SidebarAddFeed.svelte
@@ -0,0 +1,886 @@
+<script lang="ts">
+  import { goto } from '$app/navigation';
+  import { subscriptionsStore } from '$lib/stores/subscriptions.svelte';
+  import { articlesStore } from '$lib/stores/articles.svelte';
+  import { socialStore } from '$lib/stores/social.svelte';
+  import { sidebarStore } from '$lib/stores/sidebar.svelte';
+  import { fetchSingleFeed } from '$lib/services/feedFetcher';
+  import { searchBlueskyActors, type BlueskySearchResult } from '$lib/services/blueskySearch';
+  import { api } from '$lib/services/api';
+  import Icon from '../Icon.svelte';
+
+  interface Publication {
+    uri: string;
+    name: string;
+    url: string;
+    description?: string;
+    iconUrl?: string;
+  }
+
+  type Mode = 'idle' | 'searching-actors' | 'discovering-feeds' | 'select-feeds' | 'select-content';
+
+  let inputValue = $state('');
+  let mode = $state<Mode>('idle');
+  let error = $state<string | null>(null);
+
+  // Bluesky search state
+  let searchResults = $state<BlueskySearchResult[]>([]);
+  let searchTimeout: ReturnType<typeof setTimeout> | undefined;
+
+  // Feed discovery state
+  let discoveredFeeds = $state<string[]>([]);
+
+  // Account content state
+  let selectedAccount = $state<BlueskySearchResult | null>(null);
+  let isDetecting = $state(false);
+  let publications = $state<Publication[]>([]);
+  let shareCount = $state(0);
+  let freestandingDocumentCount = $state(0);
+  let selectedPublications = $state<Set<string>>(new Set());
+  let sharesSelected = $state(false);
+  let freestandingDocsSelected = $state(false);
+  let isSubscribing = $state(false);
+
+  let inputEl: HTMLInputElement | undefined = $state();
+  let dropdownEl: HTMLDivElement | undefined = $state();
+
+  // Track subscribed keys for the selected account
+  let subscribedKeys = $derived.by(() => {
+    if (!selectedAccount) return new Set<string>();
+    const keys = new Set<string>();
+    for (const sub of subscriptionsStore.subscriptions) {
+      if (sub.subjectDid === selectedAccount.did) {
+        if (sub.sourceType === 'atproto.shares') {
+          keys.add('shares');
+        } else if (sub.sourceType === 'atproto.documents') {
+          if (sub.feedUrl === '__freestanding__') {
+            keys.add('__freestanding__');
+          } else {
+            keys.add(sub.feedUrl || 'documents-all');
+          }
+        }
+      }
+    }
+    return keys;
+  });
+
+  let selectedCount = $derived(
+    selectedPublications.size + (sharesSelected ? 1 : 0) + (freestandingDocsSelected ? 1 : 0)
+  );
+
+  function looksLikeUrl(value: string): boolean {
+    const trimmed = value.trim();
+    return (
+      trimmed.startsWith('http://') ||
+      trimmed.startsWith('https://') ||
+      (trimmed.includes('.') && !trimmed.includes(' ') && trimmed.length > 4)
+    );
+  }
+
+  function reset() {
+    inputValue = '';
+    mode = 'idle';
+    error = null;
+    searchResults = [];
+    discoveredFeeds = [];
+    selectedAccount = null;
+    isDetecting = false;
+    publications = [];
+    shareCount = 0;
+    freestandingDocumentCount = 0;
+    selectedPublications = new Set();
+    sharesSelected = false;
+    freestandingDocsSelected = false;
+    isSubscribing = false;
+    if (searchTimeout) clearTimeout(searchTimeout);
+  }
+
+  function handleInput() {
+    error = null;
+
+    if (searchTimeout) clearTimeout(searchTimeout);
+
+    const trimmed = inputValue.trim();
+    if (trimmed.length < 2) {
+      searchResults = [];
+      mode = 'idle';
+      return;
+    }
+
+    // If it looks like a URL, don't search actors
+    if (looksLikeUrl(trimmed)) {
+      searchResults = [];
+      mode = 'idle';
+      return;
+    }
+
+    // Search for bluesky actors
+    mode = 'searching-actors';
+    searchTimeout = setTimeout(async () => {
+      try {
+        searchResults = await searchBlueskyActors(trimmed, 5);
+      } catch {
+        searchResults = [];
+      } finally {
+        if (mode === 'searching-actors') {
+          mode = searchResults.length > 0 ? 'searching-actors' : 'idle';
+        }
+      }
+    }, 300);
+  }
+
+  async function handleSubmit() {
+    const trimmed = inputValue.trim();
+    if (!trimmed) return;
+
+    // If it looks like a URL or we're in idle mode with text, try feed discovery
+    error = null;
+    mode = 'discovering-feeds';
+    discoveredFeeds = [];
+
+    try {
+      // Ensure the URL has a protocol
+      let url = trimmed;
+      if (!url.startsWith('http://') && !url.startsWith('https://')) {
+        url = 'https://' + url;
+      }
+
+      const result = await api.discoverFeedsV2(url);
+      if (result.feeds.length === 0) {
+        error = 'No feeds found at this URL';
+        mode = 'idle';
+      } else if (result.feeds.length === 1) {
+        await addFeed(result.feeds[0]);
+      } else {
+        discoveredFeeds = result.feeds;
+        mode = 'select-feeds';
+      }
+    } catch (e) {
+      error = e instanceof Error ? e.message : 'Failed to discover feeds';
+      mode = 'idle';
+    }
+  }
+
+  async function addFeed(url: string) {
+    error = null;
+    try {
+      const tempTitle = new URL(url).hostname;
+      const id = await subscriptionsStore.add(url, tempTitle, {});
+      const sub = subscriptionsStore.getById(id);
+
+      reset();
+      goto(`/?feed=${id}`);
+      sidebarStore.closeMobile();
+
+      if (sub) {
+        fetchSingleFeed(sub, true, articlesStore.savedGuids).then(async (result) => {
+          if (result.success && result.title) {
+            try {
+              await subscriptionsStore.update(id, {
+                title: result.title,
+                siteUrl: result.siteUrl,
+              });
+            } catch {
+              // Ignore errors updating title
+            }
+          }
+        });
+      }
+    } catch (e) {
+      error = e instanceof Error ? e.message : 'Failed to add feed';
+      mode = 'idle';
+    }
+  }
+
+  async function selectAccount(account: BlueskySearchResult) {
+    selectedAccount = account;
+    inputValue = '';
+    searchResults = [];
+    mode = 'select-content';
+    isDetecting = true;
+    error = null;
+    publications = [];
+    shareCount = 0;
+    freestandingDocumentCount = 0;
+    selectedPublications = new Set();
+    sharesSelected = false;
+    freestandingDocsSelected = false;
+
+    try {
+      const result = await api.detectContent(account.did);
+      publications = result.publications;
+      shareCount = result.shareCount;
+      freestandingDocumentCount = result.freestandingDocumentCount;
+
+      // Pre-select unsubscribed items
+      for (const pub of result.publications) {
+        if (!subscribedKeys.has(pub.uri)) {
+          selectedPublications.add(pub.uri);
+        }
+      }
+      selectedPublications = new Set(selectedPublications);
+      if (result.shareCount > 0 && !subscribedKeys.has('shares')) {
+        sharesSelected = true;
+      }
+      if (result.freestandingDocumentCount > 0 && !subscribedKeys.has('__freestanding__')) {
+        freestandingDocsSelected = true;
+      }
+    } catch (e) {
+      error = e instanceof Error ? e.message : 'Failed to detect content';
+    } finally {
+      isDetecting = false;
+    }
+  }
+
+  function togglePublication(uri: string) {
+    if (subscribedKeys.has(uri)) return;
+    const next = new Set(selectedPublications);
+    if (next.has(uri)) {
+      next.delete(uri);
+    } else {
+      next.add(uri);
+    }
+    selectedPublications = next;
+  }
+
+  function toggleShares() {
+    if (subscribedKeys.has('shares')) return;
+    sharesSelected = !sharesSelected;
+  }
+
+  function toggleFreestandingDocs() {
+    if (subscribedKeys.has('__freestanding__')) return;
+    freestandingDocsSelected = !freestandingDocsSelected;
+  }
+
+  async function handleSubscribe() {
+    if (!selectedAccount || selectedCount === 0) return;
+    if (!subscriptionsStore.canAddMore) {
+      error = 'Subscription limit reached';
+      return;
+    }
+
+    error = null;
+    isSubscribing = true;
+    let firstAddedId: number | null = null;
+
+    try {
+      for (const pubUri of selectedPublications) {
+        const pub = publications.find((p) => p.uri === pubUri);
+        if (!pub) continue;
+        if (!subscriptionsStore.canAddMore) {
+          error = `Subscription limit reached (${subscriptionsStore.maxSubscriptions} max)`;
+          break;
+        }
+
+        const subId = await subscriptionsStore.add(pubUri, pub.name || pub.url, {
+          sourceType: 'atproto.documents',
+          subjectDid: selectedAccount.did,
+          siteUrl: pub.url,
+          feedUrl: pubUri,
+        });
+        if (!firstAddedId) firstAddedId = subId;
+        if (pub.iconUrl) {
+          await subscriptionsStore.updateLocal(subId, { customIconUrl: pub.iconUrl });
+        }
+      }
+
+      if (freestandingDocsSelected && subscriptionsStore.canAddMore) {
+        const docsId = await subscriptionsStore.add(
+          '__freestanding__',
+          `Documents from @${selectedAccount.handle}`,
+          {
+            sourceType: 'atproto.documents',
+            subjectDid: selectedAccount.did,
+            feedUrl: '__freestanding__',
+          }
+        );
+        if (!firstAddedId) firstAddedId = docsId;
+      }
+
+      if (sharesSelected && subscriptionsStore.canAddMore) {
+        const sharesId = await subscriptionsStore.add(
+          undefined,
+          `Shares from @${selectedAccount.handle}`,
+          {
+            sourceType: 'atproto.shares',
+            subjectDid: selectedAccount.did,
+          }
+        );
+        if (!firstAddedId) firstAddedId = sharesId;
+      }
+
+      socialStore.loadFeed(true);
+      reset();
+
+      if (firstAddedId) {
+        goto(`/?feed=${firstAddedId}`);
+        sidebarStore.closeMobile();
+      }
+    } catch (e) {
+      error = e instanceof Error ? e.message : 'Failed to subscribe';
+    } finally {
+      isSubscribing = false;
+    }
+  }
+
+  function handleKeydown(e: KeyboardEvent) {
+    if (e.key === 'Escape') {
+      reset();
+      inputEl?.blur();
+    }
+  }
+
+  function handleClickOutside(e: MouseEvent) {
+    if (
+      dropdownEl &&
+      !dropdownEl.contains(e.target as Node) &&
+      inputEl &&
+      !inputEl.contains(e.target as Node)
+    ) {
+      if (mode === 'searching-actors') {
+        searchResults = [];
+        mode = 'idle';
+      }
+    }
+  }
+
+  $effect(() => {
+    document.addEventListener('mousedown', handleClickOutside);
+    return () => document.removeEventListener('mousedown', handleClickOutside);
+  });
+
+  let showDropdown = $derived(
+    searchResults.length > 0 ||
+      discoveredFeeds.length > 0 ||
+      mode === 'select-content' ||
+      mode === 'discovering-feeds'
+  );
+</script>
+
+<div class="sidebar-add-feed">
+  <form
+    class="add-feed-form"
+    onsubmit={(e) => {
+      e.preventDefault();
+      handleSubmit();
+    }}
+  >
+    <input
+      bind:this={inputEl}
+      type="text"
+      class="add-feed-input"
+      placeholder="Add feed, URL, or @handle..."
+      bind:value={inputValue}
+      oninput={handleInput}
+      onkeydown={handleKeydown}
+      disabled={mode === 'discovering-feeds' || mode === 'select-content'}
+    />
+    {#if inputValue || mode !== 'idle'}
+      <button type="button" class="clear-btn" onclick={reset} title="Clear">
+        <Icon name="x" size={12} strokeWidth={2.5} />
+      </button>
+    {/if}
+  </form>
+
+  {#if error}
+    <div class="inline-error">{error}</div>
+  {/if}
+
+  {#if showDropdown}
+    <div class="dropdown" bind:this={dropdownEl}>
+      {#if mode === 'discovering-feeds'}
+        <div class="dropdown-status">
+          <span class="spinner"></span>
+          <span>Discovering feeds...</span>
+        </div>
+      {/if}
+
+      {#if searchResults.length > 0}
+        {#each searchResults as result (result.did)}
+          <button class="dropdown-item actor-item" onclick={() => selectAccount(result)}>
+            {#if result.avatar}
+              <img src={result.avatar} alt="" class="actor-avatar" />
+            {:else}
+              <span class="actor-avatar-placeholder"></span>
+            {/if}
+            <span class="actor-info">
+              <span class="actor-name">{result.displayName || result.handle}</span>
+              <span class="actor-handle">@{result.handle}</span>
+            </span>
+          </button>
+        {/each}
+      {/if}
+
+      {#if discoveredFeeds.length > 1}
+        <div class="dropdown-label">Multiple feeds found:</div>
+        {#each discoveredFeeds as url}
+          <button class="dropdown-item feed-item" onclick={() => addFeed(url)}>
+            <Icon name="rss" size={14} />
+            <span class="feed-url">{url}</span>
+          </button>
+        {/each}
+      {/if}
+
+      {#if mode === 'select-content' && selectedAccount}
+        <div class="content-section">
+          <div class="content-header">
+            <button class="back-link" onclick={reset}>
+              <Icon name="arrow-left" size={14} strokeWidth={2} />
+              Back
+            </button>
+            <div class="content-account">
+              {#if selectedAccount.avatar}
+                <img src={selectedAccount.avatar} alt="" class="actor-avatar-sm" />
+              {/if}
+              <span class="actor-handle-sm">@{selectedAccount.handle}</span>
+            </div>
+          </div>
+
+          {#if isDetecting}
+            <div class="dropdown-status">
+              <span class="spinner"></span>
+              <span>Detecting content...</span>
+            </div>
+          {:else}
+            <div class="content-group">
+              <button
+                class="dropdown-item content-item"
+                class:selected={freestandingDocsSelected}
+                class:is-subscribed={subscribedKeys.has('__freestanding__')}
+                onclick={toggleFreestandingDocs}
+                disabled={subscribedKeys.has('__freestanding__')}
+              >
+                <span
+                  class="check"
+                  class:checked={freestandingDocsSelected || subscribedKeys.has('__freestanding__')}
+                >
+                  {#if freestandingDocsSelected || subscribedKeys.has('__freestanding__')}&#10003;{/if}
+                </span>
+                <span class="content-info">
+                  <span class="content-name"
+                    >Documents <span class="content-count">({freestandingDocumentCount})</span
+                    ></span
+                  >
+                  <span class="content-desc"
+                    >Free-standing documents by @{selectedAccount.handle}</span
+                  >
+                </span>
+                {#if subscribedKeys.has('__freestanding__')}
+                  <span class="sub-badge">Subscribed</span>
+                {/if}
+              </button>
+
+              <button
+                class="dropdown-item content-item"
+                class:selected={sharesSelected}
+                class:is-subscribed={subscribedKeys.has('shares')}
+                onclick={toggleShares}
+                disabled={subscribedKeys.has('shares')}
+              >
+                <span class="check" class:checked={sharesSelected || subscribedKeys.has('shares')}>
+                  {#if sharesSelected || subscribedKeys.has('shares')}&#10003;{/if}
+                </span>
+                <span class="content-info">
+                  <span class="content-name"
+                    >Shared articles <span class="content-count">({shareCount})</span></span
+                  >
+                  <span class="content-desc">Articles shared by @{selectedAccount.handle}</span>
+                </span>
+                {#if subscribedKeys.has('shares')}
+                  <span class="sub-badge">Subscribed</span>
+                {/if}
+              </button>
+            </div>
+
+            {#if publications.length > 0}
+              <div class="content-group">
+                {#each publications as pub (pub.uri)}
+                  {@const isSubscribed = subscribedKeys.has(pub.uri)}
+                  <button
+                    class="dropdown-item content-item"
+                    class:selected={selectedPublications.has(pub.uri)}
+                    class:is-subscribed={isSubscribed}
+                    onclick={() => togglePublication(pub.uri)}
+                    disabled={isSubscribed}
+                  >
+                    <span
+                      class="check"
+                      class:checked={selectedPublications.has(pub.uri) || isSubscribed}
+                    >
+                      {#if selectedPublications.has(pub.uri) || isSubscribed}&#10003;{/if}
+                    </span>
+                    <span class="content-info">
+                      <span class="content-name">{pub.name || pub.url}</span>
+                      {#if pub.description}
+                        <span class="content-desc">{pub.description}</span>
+                      {/if}
+                    </span>
+                    {#if isSubscribed}
+                      <span class="sub-badge">Subscribed</span>
+                    {/if}
+                  </button>
+                {/each}
+              </div>
+            {/if}
+
+            {#if selectedCount > 0}
+              <button class="subscribe-btn" onclick={handleSubscribe} disabled={isSubscribing}>
+                {isSubscribing ? 'Subscribing...' : `Subscribe (${selectedCount})`}
+              </button>
+            {/if}
+          {/if}
+        </div>
+      {/if}
+    </div>
+  {/if}
+</div>
+
+<style>
+  .sidebar-add-feed {
+    position: relative;
+    padding: 0.25rem 0.25rem 0.125rem;
+  }
+
+  .add-feed-form {
+    display: flex;
+    align-items: center;
+    position: relative;
+  }
+
+  .add-feed-input {
+    width: 100%;
+    padding: 0.375rem 1.5rem 0.375rem 0.625rem;
+    border: 1px solid var(--color-border);
+    border-radius: 8px;
+    background: var(--color-bg);
+    color: var(--color-text);
+    font-size: 0.8125rem;
+    outline: none;
+    box-sizing: border-box;
+    transition: border-color 0.15s;
+  }
+
+  .add-feed-input::placeholder {
+    color: var(--color-text-secondary);
+    opacity: 0.7;
+    font-size: 0.75rem;
+  }
+
+  .add-feed-input:focus {
+    border-color: var(--color-accent, #0085ff);
+  }
+
+  .clear-btn {
+    position: absolute;
+    right: 0.25rem;
+    top: 50%;
+    transform: translateY(-50%);
+    background: none;
+    border: none;
+    cursor: pointer;
+    padding: 0.125rem;
+    color: var(--color-text-secondary);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    border-radius: 4px;
+  }
+
+  .clear-btn:hover {
+    color: var(--color-text);
+  }
+
+  .inline-error {
+    font-size: 0.75rem;
+    color: var(--color-error, #e53e3e);
+    padding: 0.125rem 0.5rem;
+    margin-top: 0.125rem;
+  }
+
+  .dropdown {
+    position: absolute;
+    left: 0.25rem;
+    right: 0.25rem;
+    top: 100%;
+    z-index: 100;
+    background: var(--color-bg);
+    border: 1px solid var(--color-border);
+    border-radius: 8px;
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.12);
+    max-height: 320px;
+    overflow-y: auto;
+    margin-top: 0.25rem;
+  }
+
+  .dropdown-status {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: 0.375rem;
+    padding: 0.625rem 0.5rem;
+    color: var(--color-text-secondary);
+    font-size: 0.8125rem;
+  }
+
+  .dropdown-label {
+    font-size: 0.75rem;
+    color: var(--color-text-secondary);
+    padding: 0.375rem 0.625rem 0.125rem;
+    font-weight: 500;
+  }
+
+  .dropdown-item {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    width: 100%;
+    padding: 0.5rem 0.625rem;
+    border: none;
+    border-bottom: 1px solid var(--color-border);
+    background: transparent;
+    cursor: pointer;
+    text-align: left;
+    color: var(--color-text);
+    font: inherit;
+    transition: background-color 0.1s;
+  }
+
+  .dropdown-item:last-child {
+    border-bottom: none;
+  }
+
+  .dropdown-item:hover:not(:disabled) {
+    background: var(--color-bg-hover, rgba(0, 0, 0, 0.04));
+  }
+
+  .dropdown-item.is-subscribed {
+    opacity: 0.5;
+    cursor: default;
+  }
+
+  /* Actor items */
+  .actor-avatar {
+    width: 24px;
+    height: 24px;
+    border-radius: 50%;
+    flex-shrink: 0;
+    object-fit: cover;
+  }
+
+  .actor-avatar-placeholder {
+    width: 24px;
+    height: 24px;
+    border-radius: 50%;
+    flex-shrink: 0;
+    background: var(--color-border);
+  }
+
+  .actor-info {
+    display: flex;
+    flex-direction: column;
+    min-width: 0;
+  }
+
+  .actor-name {
+    font-size: 0.8125rem;
+    font-weight: 500;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+
+  .actor-handle {
+    font-size: 0.75rem;
+    color: var(--color-text-secondary);
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+
+  /* Feed URL items */
+  .feed-url {
+    font-size: 0.75rem;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    min-width: 0;
+  }
+
+  /* Content selection */
+  .content-section {
+    display: flex;
+    flex-direction: column;
+  }
+
+  .content-header {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 0.375rem 0.625rem;
+    border-bottom: 1px solid var(--color-border);
+  }
+
+  .back-link {
+    display: flex;
+    align-items: center;
+    gap: 0.125rem;
+    background: none;
+    border: none;
+    cursor: pointer;
+    color: var(--color-text-secondary);
+    font-size: 0.75rem;
+    padding: 0.125rem 0.25rem;
+    border-radius: 4px;
+  }
+
+  .back-link:hover {
+    color: var(--color-text);
+  }
+
+  .content-account {
+    display: flex;
+    align-items: center;
+    gap: 0.375rem;
+    min-width: 0;
+  }
+
+  .actor-avatar-sm {
+    width: 18px;
+    height: 18px;
+    border-radius: 50%;
+    flex-shrink: 0;
+    object-fit: cover;
+  }
+
+  .actor-handle-sm {
+    font-size: 0.75rem;
+    color: var(--color-text-secondary);
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+
+  .content-item {
+    align-items: flex-start;
+  }
+
+  .check {
+    width: 14px;
+    height: 14px;
+    border: 1.5px solid var(--color-border);
+    border-radius: 3px;
+    flex-shrink: 0;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 0.625rem;
+    margin-top: 1px;
+    transition:
+      background-color 0.15s,
+      border-color 0.15s;
+  }
+
+  .check.checked {
+    background: var(--color-accent, #0085ff);
+    border-color: var(--color-accent, #0085ff);
+    color: white;
+  }
+
+  .content-info {
+    display: flex;
+    flex-direction: column;
+    min-width: 0;
+    flex: 1;
+    gap: 0.0625rem;
+  }
+
+  .content-name {
+    font-size: 0.8125rem;
+    font-weight: 500;
+  }
+
+  .content-desc {
+    font-size: 0.6875rem;
+    color: var(--color-text-secondary);
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+
+  .content-count {
+    font-weight: 400;
+    color: var(--color-text-secondary);
+  }
+
+  .content-group {
+    border: 1px solid var(--color-border);
+    border-radius: 6px;
+    margin: 0.25rem 0.375rem;
+    overflow: hidden;
+  }
+
+  .content-group .dropdown-item {
+    border-bottom: 1px solid var(--color-border);
+  }
+
+  .content-group .dropdown-item:last-child {
+    border-bottom: none;
+  }
+
+  .sub-badge {
+    font-size: 0.625rem;
+    color: var(--color-text-secondary);
+    background: var(--color-bg-secondary);
+    padding: 0.0625rem 0.375rem;
+    border-radius: 3px;
+    flex-shrink: 0;
+  }
+
+  .subscribe-btn {
+    margin: 0.375rem 0.5rem;
+    padding: 0.375rem 0.5rem;
+    border: none;
+    border-radius: 6px;
+    background: var(--color-accent, #0085ff);
+    color: white;
+    font-size: 0.75rem;
+    font-weight: 500;
+    cursor: pointer;
+    transition: opacity 0.15s;
+  }
+
+  .subscribe-btn:hover:not(:disabled) {
+    opacity: 0.9;
+  }
+
+  .subscribe-btn:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+  }
+
+  .spinner {
+    width: 0.75rem;
+    height: 0.75rem;
+    border: 1.5px solid var(--color-border);
+    border-top-color: var(--color-accent, #0085ff);
+    border-radius: 50%;
+    animation: spin 0.6s linear infinite;
+  }
+
+  @keyframes spin {
+    to {
+      transform: rotate(360deg);
+    }
+  }
+
+  @media (prefers-color-scheme: dark) {
+    .dropdown {
+      box-shadow: 0 4px 12px rgba(0, 0, 0, 0.3);
+    }
+
+    .dropdown-item:hover:not(:disabled) {
+      background: var(--color-bg-hover, rgba(255, 255, 255, 0.05));
+    }
+  }
+</style>
diff --git a/src/lib/components/sidebar/UserContextMenu.svelte b/src/lib/components/sidebar/UserContextMenu.svelte
deleted file mode 100644
index 44b42f1..0000000
--- a/src/lib/components/sidebar/UserContextMenu.svelte
+++ /dev/null
@@ -1,115 +0,0 @@
-<script lang="ts">
-  import { tick } from 'svelte';
-  import Icon from '../Icon.svelte';
-
-  interface Props {
-    x: number;
-    y: number;
-    onUnfollow: () => void;
-    onClose: () => void;
-  }
-
-  let { x, y, onUnfollow, onClose }: Props = $props();
-
-  let menuRef: HTMLDivElement | null = $state(null);
-  let adjustedX = $state(0);
-  let adjustedY = $state(0);
-
-  $effect(() => {
-    // Track x and y as dependencies
-    const targetX = x;
-    const targetY = y;
-
-    tick().then(() => {
-      if (menuRef) {
-        const rect = menuRef.getBoundingClientRect();
-        const viewportWidth = window.innerWidth;
-        const viewportHeight = window.innerHeight;
-        const padding = 8;
-
-        let newX = targetX;
-        let newY = targetY;
-
-        // Adjust horizontal position if menu would overflow right edge
-        if (targetX + rect.width > viewportWidth - padding) {
-          newX = Math.max(padding, viewportWidth - rect.width - padding);
-        }
-
-        // Adjust vertical position if menu would overflow bottom edge
-        if (targetY + rect.height > viewportHeight - padding) {
-          newY = Math.max(padding, viewportHeight - rect.height - padding);
-        }
-
-        adjustedX = newX;
-        adjustedY = newY;
-      } else {
-        adjustedX = targetX;
-        adjustedY = targetY;
-      }
-    });
-  });
-
-  function handleUnfollow() {
-    onUnfollow();
-    onClose();
-  }
-</script>
-
-<div
-  bind:this={menuRef}
-  class="context-menu"
-  style="left: {adjustedX}px; top: {adjustedY}px;"
-  role="menu"
->
-  <button class="context-menu-item danger" onclick={handleUnfollow} role="menuitem">
-    <span class="context-menu-icon"><Icon name="users" size={16} /></span>
-    Unfollow
-  </button>
-</div>
-
-<style>
-  .context-menu {
-    position: fixed;
-    background: var(--color-bg);
-    border: 1px solid var(--color-border);
-    border-radius: 8px;
-    padding: 0.25rem;
-    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
-    z-index: 1000;
-    min-width: 120px;
-  }
-
-  .context-menu-item {
-    display: flex;
-    align-items: center;
-    gap: 0.5rem;
-    width: 100%;
-    padding: 0.5rem 0.75rem;
-    border: none;
-    background: none;
-    text-align: left;
-    cursor: pointer;
-    border-radius: 4px;
-    font-size: 0.875rem;
-    color: var(--color-text);
-  }
-
-  .context-menu-item:hover {
-    background: var(--color-bg-secondary);
-  }
-
-  .context-menu-item.danger {
-    color: var(--color-error, #dc2626);
-  }
-
-  .context-menu-item.danger:hover {
-    background: rgba(220, 38, 38, 0.1);
-  }
-
-  .context-menu-icon {
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    width: 1rem;
-  }
-</style>
diff --git a/src/lib/components/sidebar/UserItem.svelte b/src/lib/components/sidebar/UserItem.svelte
deleted file mode 100644
index 9e60ed7..0000000
--- a/src/lib/components/sidebar/UserItem.svelte
+++ /dev/null
@@ -1,261 +0,0 @@
-<script lang="ts">
-  import type { FollowedUser } from '$lib/stores/social.svelte';
-  import { profileService } from '$lib/services/profiles';
-  import type { BlueskyProfile } from '$lib/types';
-  import Icon from '../Icon.svelte';
-
-  interface Props {
-    user: FollowedUser;
-    shareCount: number;
-    documentCount: number;
-    isActive: boolean;
-    contentType: 'shares' | 'documents' | null;
-    onSelect: () => void;
-    onSelectShares: () => void;
-    onSelectDocuments: () => void;
-    onContextMenu: (e: MouseEvent) => void;
-    onTouchStart: (e: TouchEvent) => void;
-    onTouchEnd: (e: TouchEvent) => void;
-    onTouchMove: () => void;
-    onMoreClick: (e: MouseEvent) => void;
-  }
-
-  let {
-    user,
-    shareCount,
-    documentCount,
-    isActive,
-    contentType,
-    onSelect,
-    onSelectShares,
-    onSelectDocuments,
-    onContextMenu,
-    onTouchStart,
-    onTouchEnd,
-    onTouchMove,
-    onMoreClick,
-  }: Props = $props();
-
-  let profile = $state<BlueskyProfile | null>(null);
-
-  $effect(() => {
-    profileService.getProfile(user.did).then((p) => {
-      profile = p;
-    });
-  });
-
-  let displayName = $derived(profile?.displayName || profile?.handle || user.did);
-  let isInApp = $derived(user.source === 'inapp' || user.source === 'both');
-  let totalCount = $derived(shareCount + documentCount);
-</script>
-
-<div class="user-item-wrapper">
-  <button
-    class="nav-item"
-    class:active={isActive && contentType === null}
-    class:not-on-app={!isInApp}
-    onclick={onSelect}
-    oncontextmenu={onContextMenu}
-    ontouchstart={onTouchStart}
-    ontouchend={onTouchEnd}
-    ontouchmove={onTouchMove}
-  >
-    {#if profile?.avatar}
-      <img src={profile.avatar} alt="" class="small-avatar" />
-    {:else}
-      <div class="small-avatar-placeholder"></div>
-    {/if}
-    <span class="nav-label">{displayName}</span>
-    <span
-      class="more-btn"
-      role="button"
-      tabindex="0"
-      onclick={(e) => {
-        e.stopPropagation();
-        onMoreClick(e);
-      }}
-      onkeydown={(e) => {
-        if (e.key === 'Enter' || e.key === ' ') {
-          e.preventDefault();
-          e.stopPropagation();
-          onMoreClick(e as unknown as MouseEvent);
-        }
-      }}
-      title="More options"
-    >
-      <Icon name="more-horizontal" size={14} />
-    </span>
-    {#if totalCount > 0}
-      <span class="nav-count">{totalCount}</span>
-    {/if}
-  </button>
-
-  <button
-    class="sub-item"
-    class:active={isActive && contentType === 'shares'}
-    onclick={onSelectShares}
-  >
-    <span class="sub-item-icon-wrapper"><Icon name="share" size={14} /></span>
-    <span class="nav-label">Shares</span>
-    {#if shareCount > 0}
-      <span class="nav-count">{shareCount}</span>
-    {/if}
-  </button>
-  <button
-    class="sub-item"
-    class:active={isActive && contentType === 'documents'}
-    onclick={onSelectDocuments}
-  >
-    <span class="sub-item-icon-wrapper"><Icon name="newspaper" size={14} /></span>
-    <span class="nav-label">Articles</span>
-    {#if documentCount > 0}
-      <span class="nav-count">{documentCount}</span>
-    {/if}
-  </button>
-</div>
-
-<style>
-  .user-item-wrapper {
-    display: flex;
-    flex-direction: column;
-  }
-
-  .nav-item {
-    display: flex;
-    align-items: center;
-    gap: 0.75rem;
-    width: 100%;
-    padding: 0.5rem 0.75rem;
-    padding-left: 0.75rem;
-    background: none;
-    border: none;
-    border-radius: 12px;
-    cursor: pointer;
-    text-align: left;
-    font: inherit;
-    color: var(--color-text);
-    transition: background-color 0.15s;
-  }
-
-  .nav-item:hover {
-    background-color: var(--color-bg-hover, rgba(0, 0, 0, 0.05));
-  }
-
-  .nav-item.active {
-    background-color: var(--color-sidebar-active, rgba(0, 102, 204, 0.1));
-    color: var(--color-primary);
-  }
-
-  .nav-item.not-on-app {
-    opacity: 0.5;
-  }
-
-  .nav-label {
-    flex: 1;
-    overflow: hidden;
-    text-overflow: ellipsis;
-    white-space: nowrap;
-    font-size: 0.875rem;
-  }
-
-  .nav-count {
-    flex-shrink: 0;
-    font-size: 0.75rem;
-    color: var(--color-text-secondary);
-  }
-
-  .nav-item.active .nav-count,
-  .sub-item.active .nav-count {
-    color: var(--color-primary);
-  }
-
-  .more-btn {
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    width: 1.25rem;
-    height: 1.25rem;
-    background: none;
-    border: none;
-    cursor: pointer;
-    color: var(--color-text-secondary);
-    font-size: 1rem;
-    padding: 0;
-    line-height: 1;
-    opacity: 0;
-    transition: opacity 0.15s;
-    flex-shrink: 0;
-    -webkit-tap-highlight-color: transparent;
-    touch-action: manipulation;
-  }
-
-  .nav-item:hover .more-btn,
-  .more-btn:focus {
-    opacity: 1;
-  }
-
-  .more-btn:hover {
-    color: var(--color-text);
-    background-color: var(--color-bg-hover, rgba(0, 0, 0, 0.1));
-    border-radius: 4px;
-  }
-
-  .small-avatar {
-    width: 20px;
-    height: 20px;
-    border-radius: 50%;
-    flex-shrink: 0;
-  }
-
-  .small-avatar-placeholder {
-    width: 20px;
-    height: 20px;
-    border-radius: 50%;
-    background: var(--color-border);
-    flex-shrink: 0;
-  }
-
-  .sub-item {
-    display: flex;
-    align-items: center;
-    gap: 0.75rem;
-    width: 100%;
-    padding: 0.4rem 0.75rem;
-    padding-left: 1.5rem;
-    background: none;
-    border: none;
-    border-radius: 12px;
-    cursor: pointer;
-    text-align: left;
-    font: inherit;
-    font-size: 0.8125rem;
-    color: var(--color-text-secondary);
-    transition: background-color 0.15s;
-  }
-
-  .sub-item:hover {
-    background-color: var(--color-bg-hover, rgba(0, 0, 0, 0.05));
-    color: var(--color-text);
-  }
-
-  .sub-item.active {
-    background-color: var(--color-sidebar-active, rgba(0, 102, 204, 0.1));
-    color: var(--color-primary);
-  }
-
-  .sub-item-icon-wrapper {
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    width: 14px;
-    height: 14px;
-    flex-shrink: 0;
-  }
-
-  @media (prefers-color-scheme: dark) {
-    .nav-item:hover,
-    .sub-item:hover {
-      background-color: var(--color-bg-hover, rgba(255, 255, 255, 0.05));
-    }
-  }
-</style>
diff --git a/src/lib/components/sidebar/UserSearchCompact.svelte b/src/lib/components/sidebar/UserSearchCompact.svelte
deleted file mode 100644
index d845de8..0000000
--- a/src/lib/components/sidebar/UserSearchCompact.svelte
+++ /dev/null
@@ -1,377 +0,0 @@
-<script lang="ts">
-  import { searchBlueskyActors, type BlueskySearchResult } from '$lib/services/blueskySearch';
-  import { socialStore } from '$lib/stores/social.svelte';
-  import { auth } from '$lib/stores/auth.svelte';
-
-  interface Props {
-    followedDids: Set<string>;
-    onFollow: (did: string) => void;
-  }
-
-  let { followedDids, onFollow }: Props = $props();
-
-  let query = $state('');
-  let results = $state<BlueskySearchResult[]>([]);
-  let isSearching = $state(false);
-  let isOpen = $state(false);
-  let selectedIndex = $state(-1);
-  let showLimitWarning = $state(false);
-  let debounceTimer: ReturnType<typeof setTimeout> | null = null;
-  let containerRef: HTMLDivElement | undefined = $state();
-  let inputRef: HTMLInputElement | undefined = $state();
-
-  async function search(searchQuery: string) {
-    if (searchQuery.length < 2) {
-      results = [];
-      isOpen = false;
-      return;
-    }
-
-    isSearching = true;
-    try {
-      const searchResults = await searchBlueskyActors(searchQuery, 6);
-      results = searchResults;
-      isOpen = searchResults.length > 0;
-      selectedIndex = -1;
-    } catch (error) {
-      console.error('Search error:', error);
-      results = [];
-    } finally {
-      isSearching = false;
-    }
-  }
-
-  function handleInput(event: Event) {
-    const target = event.target as HTMLInputElement;
-    query = target.value;
-    showLimitWarning = false;
-
-    if (debounceTimer) {
-      clearTimeout(debounceTimer);
-    }
-
-    debounceTimer = setTimeout(() => {
-      search(query);
-    }, 300);
-  }
-
-  function handleKeydown(event: KeyboardEvent) {
-    if (!isOpen || results.length === 0) {
-      return;
-    }
-
-    switch (event.key) {
-      case 'ArrowDown':
-        event.preventDefault();
-        selectedIndex = Math.min(selectedIndex + 1, results.length - 1);
-        break;
-      case 'ArrowUp':
-        event.preventDefault();
-        selectedIndex = Math.max(selectedIndex - 1, -1);
-        break;
-      case 'Enter':
-        event.preventDefault();
-        if (selectedIndex >= 0 && selectedIndex < results.length) {
-          selectUser(results[selectedIndex]);
-        }
-        break;
-      case 'Escape':
-        event.preventDefault();
-        closeDropdown();
-        break;
-    }
-  }
-
-  function selectUser(user: BlueskySearchResult) {
-    if (followedDids.has(user.did)) {
-      return;
-    }
-
-    // Check follow limit
-    if (socialStore.isAtFollowLimit) {
-      showLimitWarning = true;
-      return;
-    }
-
-    onFollow(user.did);
-    closeDropdown();
-  }
-
-  function closeDropdown() {
-    isOpen = false;
-    selectedIndex = -1;
-    query = '';
-    results = [];
-    showLimitWarning = false;
-  }
-
-  function handleClickOutside(event: MouseEvent) {
-    if (containerRef && !containerRef.contains(event.target as Node)) {
-      closeDropdown();
-    }
-  }
-
-  function handleFocus() {
-    if (results.length > 0) {
-      isOpen = true;
-    }
-  }
-
-  $effect(() => {
-    if (isOpen) {
-      document.addEventListener('click', handleClickOutside);
-      return () => {
-        document.removeEventListener('click', handleClickOutside);
-      };
-    }
-  });
-
-  $effect(() => {
-    return () => {
-      if (debounceTimer) {
-        clearTimeout(debounceTimer);
-      }
-    };
-  });
-</script>
-
-<div class="user-search-compact" bind:this={containerRef}>
-  <div class="search-input-wrapper">
-    <span class="search-icon">@</span>
-    <input
-      bind:this={inputRef}
-      type="text"
-      class="search-input"
-      placeholder="Follow user..."
-      value={query}
-      oninput={handleInput}
-      onkeydown={handleKeydown}
-      onfocus={handleFocus}
-    />
-    {#if isSearching}
-      <div class="search-spinner"></div>
-    {/if}
-  </div>
-
-  {#if showLimitWarning}
-    <div class="limit-warning">
-      Follow limit reached ({socialStore.followLimit} max).
-      {#if auth.user?.tier !== 'supporter'}
-        <a
-          href="https://github.com/sponsors/disnet"
-          target="_blank"
-          rel="noopener noreferrer"
-          class="sponsor-link">Become a sponsor</a
-        > to get raised limits.
-      {/if}
-    </div>
-  {/if}
-
-  {#if isOpen && results.length > 0}
-    <div class="dropdown">
-      {#each results as user, index (user.did)}
-        {@const isFollowed = followedDids.has(user.did)}
-        <button
-          class="result-item"
-          class:selected={index === selectedIndex}
-          class:is-followed={isFollowed}
-          onclick={() => selectUser(user)}
-          onmouseenter={() => (selectedIndex = index)}
-        >
-          {#if user.avatar}
-            <img src={user.avatar} alt="" class="result-avatar" />
-          {:else}
-            <div class="result-avatar-placeholder"></div>
-          {/if}
-          <div class="result-info">
-            <span class="result-name">{user.displayName || user.handle}</span>
-            <span class="result-handle">@{user.handle}</span>
-          </div>
-          {#if isFollowed}
-            <span class="following-badge">Following</span>
-          {/if}
-        </button>
-      {/each}
-    </div>
-  {/if}
-</div>
-
-<style>
-  .user-search-compact {
-    position: relative;
-    padding: 0.25rem 0.75rem;
-    padding-left: 1.5rem;
-  }
-
-  .search-input-wrapper {
-    position: relative;
-    display: flex;
-    align-items: center;
-  }
-
-  .search-icon {
-    position: absolute;
-    left: 0.5rem;
-    color: var(--color-text-secondary);
-    display: flex;
-    align-items: center;
-    pointer-events: none;
-  }
-
-  .search-input {
-    width: 100%;
-    padding: 0.375rem 0.5rem;
-    padding-left: 1.75rem;
-    font-size: 0.8125rem;
-    border: 1px solid var(--color-border);
-    border-radius: 6px;
-    background: var(--color-bg);
-    color: var(--color-text);
-    transition: border-color 0.15s;
-  }
-
-  .search-input:focus {
-    outline: none;
-    border-color: var(--color-primary);
-  }
-
-  .search-input::placeholder {
-    color: var(--color-text-secondary);
-  }
-
-  .search-spinner {
-    position: absolute;
-    right: 0.5rem;
-    width: 0.75rem;
-    height: 0.75rem;
-    border: 2px solid var(--color-border);
-    border-top-color: var(--color-primary);
-    border-radius: 50%;
-    animation: spin 0.6s linear infinite;
-  }
-
-  @keyframes spin {
-    to {
-      transform: rotate(360deg);
-    }
-  }
-
-  .limit-warning {
-    margin-top: 0.25rem;
-    padding: 0.25rem 0.5rem;
-    font-size: 0.75rem;
-    color: var(--color-warning, #ff9800);
-    background: rgba(255, 152, 0, 0.1);
-    border-radius: 4px;
-  }
-
-  .sponsor-link {
-    color: var(--color-primary);
-    text-decoration: none;
-  }
-
-  .sponsor-link:hover {
-    text-decoration: underline;
-  }
-
-  .dropdown {
-    position: absolute;
-    top: 100%;
-    left: 0.75rem;
-    right: 0.75rem;
-    margin-top: 4px;
-    background: var(--color-bg);
-    border: 1px solid var(--color-border);
-    border-radius: 8px;
-    box-shadow: 0 4px 12px var(--color-shadow, rgba(0, 0, 0, 0.15));
-    max-height: 240px;
-    overflow-y: auto;
-    z-index: 100;
-  }
-
-  .result-item {
-    display: flex;
-    align-items: center;
-    gap: 0.5rem;
-    width: 100%;
-    padding: 0.5rem;
-    background: none;
-    border: none;
-    text-align: left;
-    cursor: pointer;
-    color: var(--color-text);
-    font: inherit;
-    transition: background-color 0.1s;
-  }
-
-  .result-item:first-child {
-    border-radius: 7px 7px 0 0;
-  }
-
-  .result-item:last-child {
-    border-radius: 0 0 7px 7px;
-  }
-
-  .result-item:only-child {
-    border-radius: 7px;
-  }
-
-  .result-item:hover,
-  .result-item.selected {
-    background: var(--color-bg-secondary);
-  }
-
-  .result-item.is-followed {
-    cursor: default;
-    opacity: 0.6;
-  }
-
-  .result-avatar {
-    width: 24px;
-    height: 24px;
-    border-radius: 50%;
-    flex-shrink: 0;
-  }
-
-  .result-avatar-placeholder {
-    width: 24px;
-    height: 24px;
-    border-radius: 50%;
-    background: var(--color-border);
-    flex-shrink: 0;
-  }
-
-  .result-info {
-    flex: 1;
-    min-width: 0;
-    display: flex;
-    flex-direction: column;
-    gap: 0.125rem;
-  }
-
-  .result-name {
-    font-size: 0.8125rem;
-    font-weight: 500;
-    overflow: hidden;
-    text-overflow: ellipsis;
-    white-space: nowrap;
-  }
-
-  .result-handle {
-    font-size: 0.75rem;
-    color: var(--color-text-secondary);
-    overflow: hidden;
-    text-overflow: ellipsis;
-    white-space: nowrap;
-  }
-
-  .following-badge {
-    font-size: 0.625rem;
-    padding: 0.125rem 0.375rem;
-    background: var(--color-sidebar-active);
-    color: var(--color-primary);
-    border-radius: 9999px;
-    font-weight: 500;
-    flex-shrink: 0;
-  }
-</style>
diff --git a/src/lib/hooks/useFeedKeyboardShortcuts.svelte.ts b/src/lib/hooks/useFeedKeyboardShortcuts.svelte.ts
index 2865f36..5f8ff7c 100644
--- a/src/lib/hooks/useFeedKeyboardShortcuts.svelte.ts
+++ b/src/lib/hooks/useFeedKeyboardShortcuts.svelte.ts
@@ -184,7 +184,7 @@ export function useFeedKeyboardShortcuts(params: KeyboardShortcutsParams) {
     } else {
       sharesStore.share(
         sub.rkey,
-        sub.feedUrl,
+        sub.feedUrl || '',
         article.guid,
         article.url,
         article.title,
diff --git a/src/lib/services/api.ts b/src/lib/services/api.ts
index b9ff564..a79abac 100644
--- a/src/lib/services/api.ts
+++ b/src/lib/services/api.ts
@@ -1,7 +1,5 @@
 import type {
-  DiscoverUser,
   FeedItem,
-  FollowedUserDetailed,
   GroupedShare,
   ItemLabel,
   ItemLabelType,
@@ -198,43 +196,6 @@ class ApiClient {
     return this.fetch(`/api/activity/reshares?${params}`);
   }
 
-  async getFollowedUsers(
-    cursor?: string,
-    limit?: number
-  ): Promise<{
-    users: Array<{
-      did: string;
-      source: 'bluesky' | 'inapp' | 'both';
-    }>;
-    cursor: string | null;
-  }> {
-    const params = new URLSearchParams();
-    if (cursor) params.set('cursor', cursor);
-    if (limit) params.set('limit', limit.toString());
-    const query = params.toString();
-    return this.fetch(`/api/social/following${query ? `?${query}` : ''}`);
-  }
-
-  async getFollowingDetailed(
-    limit = 50,
-    offset = 0
-  ): Promise<{
-    users: FollowedUserDetailed[];
-    nextOffset: number | null;
-  }> {
-    const params = new URLSearchParams({
-      source: 'skyreader',
-      limit: limit.toString(),
-      offset: offset.toString(),
-    });
-    return this.fetch(`/api/social/following-detailed?${params}`);
-  }
-
-  async getDiscoverUsers(limit = 20): Promise<{ users: DiscoverUser[] }> {
-    const params = new URLSearchParams({ limit: limit.toString() });
-    return this.fetch(`/api/discover?${params}`);
-  }
-
   async getPopularShares(
     period: 'day' | 'week' | 'month' = 'week',
     cursor?: string,
@@ -274,15 +235,34 @@ class ApiClient {
     return this.fetch('/api/shares/my');
   }
 
+  // Content detection
+  async detectContent(did: string): Promise<{
+    did: string;
+    publications: Array<{
+      uri: string;
+      name: string;
+      url: string;
+      description?: string;
+      iconUrl?: string;
+    }>;
+    shareCount: number;
+    freestandingDocumentCount: number;
+  }> {
+    return this.fetch(`/api/social/detect-content?did=${encodeURIComponent(did)}`);
+  }
+
   // Subscriptions
   async createSubscription(data: {
     rkey: string;
-    feedUrl: string;
+    feedUrl?: string;
     title?: string;
     siteUrl?: string;
     category?: string;
     tags?: string[];
     source?: string;
+    sourceType?: string;
+    subjectDid?: string;
+    collectionNsid?: string;
   }): Promise<{ rkey: string; uri: string }> {
     return this.fetch('/api/subscriptions', {
       method: 'POST',
@@ -319,33 +299,6 @@ class ApiClient {
     });
   }
 
-  // Follows
-  async followUser(rkey: string, subject: string): Promise<{ rkey: string; uri: string }> {
-    return this.fetch('/api/social/follow', {
-      method: 'POST',
-      body: JSON.stringify({ rkey, subject }),
-    });
-  }
-
-  async unfollowUser(rkey: string): Promise<{ success: boolean }> {
-    return this.fetch(`/api/social/follow/${rkey}`, {
-      method: 'DELETE',
-    });
-  }
-
-  async listInAppFollows(): Promise<{
-    follows: Array<{
-      rkey: string;
-      did: string;
-      handle?: string;
-      displayName?: string;
-      avatarUrl?: string;
-      createdAt: number;
-    }>;
-  }> {
-    return this.fetch('/api/social/follows');
-  }
-
   // Shares
   async createShare(data: {
     rkey: string;
diff --git a/src/lib/services/db.ts b/src/lib/services/db.ts
index 8c2dd02..0c7b9c0 100644
--- a/src/lib/services/db.ts
+++ b/src/lib/services/db.ts
@@ -276,6 +276,12 @@ class SkyreaderDatabase extends Dexie {
           await tx.table('saved').bulkAdd(oldRows);
         }
       });
+
+    // Add sourceType and subjectDid indexes to subscriptions for AT Proto content streams
+    this.version(25).stores({
+      subscriptions:
+        '++id, rkey, feedUrl, category, fetchStatus, source, localUpdatedAt, sourceType, subjectDid',
+    });
   }
 }
 
diff --git a/src/lib/services/feedFetcher.ts b/src/lib/services/feedFetcher.ts
index 2b3d384..0ca6663 100644
--- a/src/lib/services/feedFetcher.ts
+++ b/src/lib/services/feedFetcher.ts
@@ -11,16 +11,20 @@ const GUIDS_PER_FEED = 10;
  * Returns true when the current title is a fallback (URL, hostname, etc.)
  * and the feed provides a real title.
  */
-function shouldUpdateTitle(currentTitle: string, feedUrl: string, fetchedTitle: string): boolean {
+function shouldUpdateTitle(
+  currentTitle: string,
+  feedUrl: string | undefined,
+  fetchedTitle: string
+): boolean {
   if (!fetchedTitle || fetchedTitle === 'Untitled Feed') return false;
   if (currentTitle === fetchedTitle) return false;
 
   // Update if current title is the feed URL
-  if (currentTitle === feedUrl) return true;
+  if (feedUrl && currentTitle === feedUrl) return true;
 
   // Update if current title is just a hostname
   try {
-    const hostname = new URL(feedUrl).hostname;
+    const hostname = feedUrl ? new URL(feedUrl).hostname : '';
     if (currentTitle === hostname) return true;
   } catch {
     // ignore invalid URL
@@ -64,7 +68,10 @@ export async function fetchAllFeeds(
   const feedRequests: Array<{ url: string; since_guids?: string[]; subscriptionId: number }> = [];
 
   for (const sub of subscriptions) {
-    if (!sub.id) continue;
+    if (!sub.id || !sub.feedUrl) continue;
+
+    // Skip AT Proto subscriptions (they don't have RSS feeds)
+    if (sub.sourceType && sub.sourceType.startsWith('atproto.')) continue;
 
     // Skip feeds in circuit-breaker cooldown
     if (!feedStatusStore.canFetch(sub.feedUrl)) {
@@ -168,7 +175,7 @@ export async function fetchSingleFeed(
   force = false,
   savedGuids: Set<string> = new Set()
 ): Promise<FetchSingleFeedResult> {
-  if (!subscription.id) {
+  if (!subscription.id || !subscription.feedUrl) {
     return { success: false, newArticles: 0 };
   }
 
@@ -208,7 +215,7 @@ export async function fetchSingleFeed(
     };
   } catch (e) {
     const errorMessage = e instanceof Error ? e.message : 'Failed to fetch feed';
-    feedStatusStore.markError(subscription.feedUrl, errorMessage);
+    if (subscription.feedUrl) feedStatusStore.markError(subscription.feedUrl, errorMessage);
     return { success: false, newArticles: 0 };
   }
 }
diff --git a/src/lib/services/liveDb.svelte.ts b/src/lib/services/liveDb.svelte.ts
index 5207222..50fe5d8 100644
--- a/src/lib/services/liveDb.svelte.ts
+++ b/src/lib/services/liveDb.svelte.ts
@@ -264,7 +264,7 @@ class LiveDatabase {
    * Get a subscription by feed URL
    */
   getSubscriptionByUrl(feedUrl: string): Subscription | undefined {
-    return this._subscriptions.find((s) => s.feedUrl.toLowerCase() === feedUrl.toLowerCase());
+    return this._subscriptions.find((s) => s.feedUrl?.toLowerCase() === feedUrl.toLowerCase());
   }
 
   /**
diff --git a/src/lib/services/sync-queue.ts b/src/lib/services/sync-queue.ts
index a5cd04f..a7dfd04 100644
--- a/src/lib/services/sync-queue.ts
+++ b/src/lib/services/sync-queue.ts
@@ -9,7 +9,6 @@ export type SyncCollection =
   | 'shares'
   | 'shareReading'
   | 'socialReading'
-  | 'follows'
   | 'label'
   | 'saved';
 
@@ -55,11 +54,6 @@ export interface SocialReadingPayload {
   itemTitle?: string;
 }
 
-export interface FollowPayload {
-  rkey: string;
-  did: string;
-}
-
 export interface LabelPayload {
   itemKey: string;
   itemType: string;
@@ -86,7 +80,6 @@ type SyncPayload =
   | SharePayload
   | ShareReadingPayload
   | SocialReadingPayload
-  | FollowPayload
   | LabelPayload
   | SavedPayload;
 
@@ -416,9 +409,6 @@ class SyncQueue {
       case 'socialReading':
         await this.executeSocialReadingOperation(entry.operation, payload as SocialReadingPayload);
         break;
-      case 'follows':
-        await this.executeFollowOperation(entry.operation, payload as FollowPayload);
-        break;
       case 'label':
         await this.executeLabelOperation(entry.operation, payload as LabelPayload);
         break;
@@ -529,20 +519,6 @@ class SyncQueue {
     }
   }
 
-  private async executeFollowOperation(
-    operation: SyncOperation,
-    payload: FollowPayload
-  ): Promise<void> {
-    switch (operation) {
-      case 'create':
-        await api.followUser(payload.rkey, payload.did);
-        break;
-      case 'delete':
-        await api.unfollowUser(payload.rkey);
-        break;
-    }
-  }
-
   private async executeLabelOperation(
     operation: SyncOperation,
     payload: LabelPayload
diff --git a/src/lib/stores/app.svelte.ts b/src/lib/stores/app.svelte.ts
index f3d43d9..c4159a0 100644
--- a/src/lib/stores/app.svelte.ts
+++ b/src/lib/stores/app.svelte.ts
@@ -68,7 +68,10 @@ function createAppManager() {
       ]);
 
       // Initialize feed statuses for existing subscriptions
-      const feedUrls = liveDb.subscriptions.map((s) => s.feedUrl);
+      const feedUrls = liveDb.subscriptions
+        .filter((s) => !s.sourceType?.startsWith('atproto.'))
+        .map((s) => s.feedUrl)
+        .filter((u): u is string => !!u);
       feedStatusStore.initializeFeeds(feedUrls);
 
       // Initialize pending count and process queue if online
@@ -113,8 +116,6 @@ function createAppManager() {
         syncSubscriptions(),
         itemLabelsStore.load(),
         shareReadingStore.load(),
-        socialStore.loadFollowedUsers(),
-        socialStore.loadInAppFollowCount(),
         socialStore.loadFeed(true),
       ]);
 
@@ -155,13 +156,16 @@ function createAppManager() {
 
     try {
       const response = await api.listRecords<{
-        feedUrl: string;
+        feedUrl?: string;
         title?: string;
         siteUrl?: string;
         category?: string;
         tags?: string[];
         createdAt: string;
         updatedAt?: string;
+        sourceType?: string;
+        subjectDid?: string;
+        collectionNsid?: string;
       }>('app.skyreader.feed.subscription');
 
       // Build maps for comparison
@@ -171,23 +175,28 @@ function createAppManager() {
       // Find added subscriptions (in remote but not local)
       for (const [rkey, record] of remoteByRkey) {
         if (!localByRkey.has(rkey)) {
+          const isAtProto = record.value.sourceType?.startsWith('atproto.');
           const subscription: Subscription = {
             rkey,
             feedUrl: record.value.feedUrl,
-            title: record.value.title || record.value.feedUrl,
+            title:
+              record.value.title || record.value.feedUrl || record.value.subjectDid || 'Untitled',
             siteUrl: record.value.siteUrl,
             category: record.value.category,
             tags: record.value.tags || [],
             createdAt: record.value.createdAt,
             updatedAt: record.value.updatedAt,
             localUpdatedAt: Date.now(),
-            fetchStatus: 'pending',
+            fetchStatus: isAtProto ? 'ready' : 'pending',
+            sourceType: record.value.sourceType as Subscription['sourceType'],
+            subjectDid: record.value.subjectDid,
+            collectionNsid: record.value.collectionNsid,
           };
 
           const id = await liveDb.addSubscription(subscription);
-          result.added.push(subscription.feedUrl);
+          result.added.push(subscription.feedUrl || '');
           result.addedSubs.push({ ...subscription, id });
-          feedStatusStore.markPending(subscription.feedUrl);
+          if (subscription.feedUrl) feedStatusStore.markPending(subscription.feedUrl);
         }
       }
 
@@ -197,8 +206,8 @@ function createAppManager() {
           if (sub.id) {
             await liveDb.deleteSubscription(sub.id);
           }
-          result.removed.push(sub.feedUrl);
-          feedStatusStore.clearStatus(sub.feedUrl);
+          result.removed.push(sub.feedUrl || '');
+          if (sub.feedUrl) feedStatusStore.clearStatus(sub.feedUrl);
         }
       }
 
@@ -207,15 +216,17 @@ function createAppManager() {
         const local = localByRkey.get(rkey);
         if (local?.id) {
           // Check if anything changed
+          // Preserve local siteUrl if PDS record doesn't have it
+          const resolvedSiteUrl = record.value.siteUrl || local.siteUrl;
           const hasChanges =
             local.title !== (record.value.title || record.value.feedUrl) ||
-            local.siteUrl !== record.value.siteUrl ||
+            local.siteUrl !== resolvedSiteUrl ||
             local.category !== record.value.category;
 
           if (hasChanges) {
             await liveDb.updateSubscription(local.id, {
               title: record.value.title || record.value.feedUrl,
-              siteUrl: record.value.siteUrl,
+              siteUrl: resolvedSiteUrl,
               category: record.value.category,
               tags: record.value.tags || [],
               updatedAt: record.value.updatedAt,
diff --git a/src/lib/stores/feedView.svelte.ts b/src/lib/stores/feedView.svelte.ts
index 5ca063e..02f4fa1 100644
--- a/src/lib/stores/feedView.svelte.ts
+++ b/src/lib/stores/feedView.svelte.ts
@@ -153,7 +153,13 @@ function createFeedViewStore() {
   }
 
   function getAllFollowDids(): string[] {
-    return socialStore.inAppFollows.map((f) => f.did);
+    const dids = new Set<string>();
+    for (const sub of subscriptionsStore.subscriptions) {
+      if (sub.sourceType?.startsWith('atproto.') && sub.subjectDid) {
+        dids.add(sub.subjectDid);
+      }
+    }
+    return [...dids];
   }
 
   // Derived: effective filters (always uses toolbar state as the working copy)
@@ -191,12 +197,27 @@ function createFeedViewStore() {
     return false;
   });
 
+  // Derived: the subscription selected by feedFilter (if any)
+  let feedFilterSubscription = $derived.by(() => {
+    if (!feedFilter) return null;
+    const id = parseInt(feedFilter);
+    return subscriptionsStore.getById(id) ?? null;
+  });
+
   // Derived: view mode
   let viewMode = $derived.by((): ViewMode => {
     if (activeFilteredView) return 'combined';
     if (sharedFilter) return 'userShares';
     if (sharerFilter || followingFilter) return 'shares';
-    if (feedFilter || savedFilter || feedsFilter) return 'articles';
+    if (feedFilter) {
+      // AT Proto subscriptions show shares/documents, not articles
+      const sub = feedFilterSubscription;
+      if (sub?.sourceType === 'atproto.shares' || sub?.sourceType === 'atproto.documents') {
+        return 'shares';
+      }
+      return 'articles';
+    }
+    if (savedFilter || feedsFilter) return 'articles';
     return 'combined';
   });
 
@@ -305,11 +326,18 @@ function createFeedViewStore() {
     // Return empty if contentTypeFilter is 'documents'
     if (contentTypeFilter === 'documents') return [];
 
+    // When feedFilter points to an atproto.documents subscription, hide shares
+    const feedSub = feedFilterSubscription;
+    if (feedSub?.sourceType === 'atproto.documents') return [];
+
     const shares = socialStore.shares;
     const sortOrder = fv.sortOrder;
 
     let filtered: SocialShare[];
-    if (sharerFilter) {
+    if (feedSub?.sourceType === 'atproto.shares' && feedSub.subjectDid) {
+      // Filter to shares from this subscription's subject
+      filtered = shares.filter((s) => s.authorDid === feedSub.subjectDid);
+    } else if (sharerFilter) {
       filtered = shares.filter((s) => s.authorDid === sharerFilter);
     } else {
       filtered = [...shares];
@@ -364,13 +392,27 @@ function createFeedViewStore() {
     // Return empty if contentTypeFilter is 'shares'
     if (contentTypeFilter === 'shares') return [];
 
+    // When feedFilter points to an atproto.shares subscription, hide documents
+    const feedSub = feedFilterSubscription;
+    if (feedSub?.sourceType === 'atproto.shares') return [];
+
     const docs = socialStore.documents;
     const sortOrder = fv.sortOrder;
 
     let filtered = [...docs];
 
-    // Filter by author if sharerFilter is set
-    if (sharerFilter) {
+    if (feedSub?.sourceType === 'atproto.documents' && feedSub.subjectDid) {
+      // Filter to documents from this subscription's subject
+      filtered = filtered.filter((d) => d.authorDid === feedSub.subjectDid);
+      // If freestanding, only show documents not associated with a publication
+      if (feedSub.feedUrl === '__freestanding__') {
+        filtered = filtered.filter((d) => !d.siteUri || !d.siteUri.startsWith('at://'));
+      } else if (feedSub.feedUrl && feedSub.feedUrl.startsWith('at://')) {
+        // If publication-scoped (feedUrl is a publication AT URI), also filter by siteUri
+        filtered = filtered.filter((d) => d.siteUri === feedSub.feedUrl);
+      }
+    } else if (sharerFilter) {
+      // Filter by author if sharerFilter is set
       filtered = filtered.filter((d) => d.authorDid === sharerFilter);
     }
 
diff --git a/src/lib/stores/sidebar.svelte.ts b/src/lib/stores/sidebar.svelte.ts
index 107b1c2..3de44be 100644
--- a/src/lib/stores/sidebar.svelte.ts
+++ b/src/lib/stores/sidebar.svelte.ts
@@ -3,7 +3,6 @@ import { browser } from '$app/environment';
 interface SidebarState {
   isOpen: boolean; // For mobile overlay
   addFeedModalOpen: boolean;
-  followUserModalOpen: boolean; // For follow user modal
   saveArticleModalOpen: boolean; // For save article by URL modal
   navigationDropdownOpen: boolean; // For navigation dropdown
   expandedSections: {
@@ -16,16 +15,12 @@ interface SidebarState {
   };
   // Sorted IDs for keyboard navigation (matches visual sidebar order)
   sortedFeedIds: number[];
-  sortedUserDids: string[];
-  // Expanded users in Following section
-  expandedUsers: Set<string>;
 }
 
 function createSidebarStore() {
   let state = $state<SidebarState>({
     isOpen: false,
     addFeedModalOpen: false,
-    followUserModalOpen: false,
     saveArticleModalOpen: false,
     navigationDropdownOpen: false,
     expandedSections: {
@@ -37,8 +32,6 @@ function createSidebarStore() {
       feeds: false,
     },
     sortedFeedIds: [],
-    sortedUserDids: [],
-    expandedUsers: new Set(),
   });
 
   // Restore from localStorage on init
@@ -53,7 +46,6 @@ function createSidebarStore() {
           ...parsed.expandedSections,
         };
         state.showOnlyUnread = parsed.showOnlyUnread ?? { shared: false, feeds: false };
-        state.expandedUsers = new Set(parsed.expandedUsers ?? []);
       } catch {
         // Ignore parse errors
       }
@@ -67,7 +59,6 @@ function createSidebarStore() {
         JSON.stringify({
           expandedSections: state.expandedSections,
           showOnlyUnread: state.showOnlyUnread,
-          expandedUsers: Array.from(state.expandedUsers),
         })
       );
     }
@@ -99,14 +90,6 @@ function createSidebarStore() {
     state.addFeedModalOpen = false;
   }
 
-  function openFollowUserModal() {
-    state.followUserModalOpen = true;
-  }
-
-  function closeFollowUserModal() {
-    state.followUserModalOpen = false;
-  }
-
   function openSaveArticleModal() {
     state.saveArticleModalOpen = true;
   }
@@ -127,24 +110,6 @@ function createSidebarStore() {
     state.sortedFeedIds = ids;
   }
 
-  function setSortedUserDids(dids: string[]) {
-    state.sortedUserDids = dids;
-  }
-
-  function toggleUserExpanded(did: string) {
-    if (state.expandedUsers.has(did)) {
-      state.expandedUsers.delete(did);
-    } else {
-      state.expandedUsers.add(did);
-    }
-    state.expandedUsers = new Set(state.expandedUsers); // Trigger reactivity
-    persist();
-  }
-
-  function isUserExpanded(did: string) {
-    return state.expandedUsers.has(did);
-  }
-
   return {
     get isOpen() {
       return state.isOpen;
@@ -152,9 +117,6 @@ function createSidebarStore() {
     get addFeedModalOpen() {
       return state.addFeedModalOpen;
     },
-    get followUserModalOpen() {
-      return state.followUserModalOpen;
-    },
     get saveArticleModalOpen() {
       return state.saveArticleModalOpen;
     },
@@ -170,28 +132,17 @@ function createSidebarStore() {
     get sortedFeedIds() {
       return state.sortedFeedIds;
     },
-    get sortedUserDids() {
-      return state.sortedUserDids;
-    },
-    get expandedUsers() {
-      return state.expandedUsers;
-    },
     toggleMobile,
     closeMobile,
     toggleSection,
     toggleShowOnlyUnread,
     openAddFeedModal,
     closeAddFeedModal,
-    openFollowUserModal,
-    closeFollowUserModal,
     openSaveArticleModal,
     closeSaveArticleModal,
     toggleNavigationDropdown,
     closeNavigationDropdown,
     setSortedFeedIds,
-    setSortedUserDids,
-    toggleUserExpanded,
-    isUserExpanded,
   };
 }
 
diff --git a/src/lib/stores/social.svelte.ts b/src/lib/stores/social.svelte.ts
index 5eb7a4f..9cbc08e 100644
--- a/src/lib/stores/social.svelte.ts
+++ b/src/lib/stores/social.svelte.ts
@@ -1,57 +1,18 @@
 import { db } from '$lib/services/db';
-import { safeBulkAdd } from '$lib/services/safeDb.svelte';
+import { safeBulkPut } from '$lib/services/safeDb.svelte';
 import { api } from '$lib/services/api';
 import { profileService } from '$lib/services/profiles';
-import { syncQueue, type FollowPayload } from '$lib/services/sync-queue';
-import { syncStore } from './sync.svelte';
 import { itemLabelsStore } from './itemLabels.svelte';
-import type { DiscoverUser, FollowedUserDetailed, SocialDocument, SocialShare } from '$lib/types';
-import { generateTid } from '$lib/utils/tid';
-import { auth } from './auth.svelte';
-
-export interface FollowedUser {
-  did: string;
-  source: 'bluesky' | 'inapp' | 'both';
-}
+import type { SocialDocument, SocialShare } from '$lib/types';
 
 function createSocialStore() {
   let shares = $state<SocialShare[]>([]);
   let documents = $state<SocialDocument[]>([]);
   let popularShares = $state<(SocialShare & { shareCount: number })[]>([]);
-  let followedUsers = $state<FollowedUser[]>([]);
-  let discoverUsers = $state<DiscoverUser[]>([]);
-  let skyreaderFollows = $state<FollowedUserDetailed[]>([]);
-  let blueskyFollows = $state<FollowedUserDetailed[]>([]);
-  let skyreaderFollowsNextOffset = $state<number | null>(null);
-  let blueskyFollowsCursor = $state<string | null>(null);
   let isLoadingFeed = $state(false);
-  let isLoadingUsers = $state(false);
-  let isLoadingSkyreaderFollows = $state(false);
-  let isLoadingBlueskyFollows = $state(false);
-  let isDiscoverLoading = $state(false);
   let cursor = $state<string | null>(null);
   let hasMore = $state(true);
   let error = $state<string | null>(null);
-  let inAppFollowCount = $state(0);
-  let inAppFollows = $state<
-    Array<{
-      rkey: string;
-      did: string;
-      handle?: string;
-      displayName?: string;
-      avatarUrl?: string;
-      createdAt: number;
-    }>
-  >([]);
-
-  // Derived: any loading operation in progress
-  let isLoading = $derived(isLoadingFeed || isLoadingUsers);
-
-  // Derived: follow limit from user tier (fallback to 50 for free)
-  let followLimit = $derived(auth.user?.limits?.maxFollows ?? 50);
-
-  // Derived: whether we've hit the follow limit
-  let isAtFollowLimit = $derived(inAppFollowCount >= followLimit);
 
   async function loadFeed(reset = false) {
     if (isLoadingFeed || (!hasMore && !reset)) {
@@ -69,17 +30,17 @@ function createSocialStore() {
         documents = result.documents || [];
         // Cache in IndexedDB
         await db.socialShares.clear();
-        await safeBulkAdd(db.socialShares, result.shares);
+        await safeBulkPut(db.socialShares, result.shares);
         await db.socialDocuments.clear();
         if (result.documents && result.documents.length > 0) {
-          await safeBulkAdd(db.socialDocuments, result.documents);
+          await safeBulkPut(db.socialDocuments, result.documents);
         }
       } else {
         shares = [...shares, ...result.shares];
         documents = [...documents, ...(result.documents || [])];
-        await safeBulkAdd(db.socialShares, result.shares);
+        await safeBulkPut(db.socialShares, result.shares);
         if (result.documents && result.documents.length > 0) {
-          await safeBulkAdd(db.socialDocuments, result.documents);
+          await safeBulkPut(db.socialDocuments, result.documents);
         }
       }
 
@@ -121,348 +82,10 @@ function createSocialStore() {
     }
   }
 
-  async function loadFollowedUsers() {
-    isLoadingUsers = true;
-    error = null;
-
-    try {
-      const result = await api.getFollowedUsers();
-      followedUsers = result.users;
-      // Prefetch profiles from Bluesky (fire and forget)
-      profileService.prefetch(result.users.map((u) => u.did));
-    } catch (e) {
-      error = e instanceof Error ? e.message : 'Failed to load followed users';
-    } finally {
-      isLoadingUsers = false;
-    }
-  }
-
-  async function loadInAppFollowCount() {
-    try {
-      const result = await api.listInAppFollows();
-      inAppFollowCount = result.follows.length;
-      inAppFollows = result.follows;
-
-      // Prefetch profiles for follows that only have a DID as their handle
-      const needsProfile = result.follows
-        .filter((f) => !f.handle || f.handle === f.did || f.handle.startsWith('did:'))
-        .map((f) => f.did);
-      if (needsProfile.length > 0) {
-        profileService.prefetch(needsProfile);
-      }
-    } catch (e) {
-      // Silently fail - the count will stay at its previous value
-      console.error('Failed to load in-app follow count:', e);
-    }
-  }
-
-  async function loadDiscoverUsers() {
-    isDiscoverLoading = true;
-    error = null;
-
-    try {
-      const result = await api.getDiscoverUsers();
-      discoverUsers = result.users;
-    } catch (e) {
-      error = e instanceof Error ? e.message : 'Failed to load discover users';
-    } finally {
-      isDiscoverLoading = false;
-    }
-  }
-
-  async function loadSkyreaderFollows(reset = true) {
-    if (isLoadingSkyreaderFollows) return;
-    if (!reset && skyreaderFollowsNextOffset === null) return;
-
-    isLoadingSkyreaderFollows = true;
-    error = null;
-
-    try {
-      const offset = reset ? 0 : (skyreaderFollowsNextOffset ?? 0);
-      const result = await api.getFollowingDetailed(50, offset);
-
-      if (reset) {
-        skyreaderFollows = result.users;
-      } else {
-        skyreaderFollows = [...skyreaderFollows, ...result.users];
-      }
-      skyreaderFollowsNextOffset = result.nextOffset;
-
-      // Prefetch profiles from Bluesky
-      profileService.prefetch(result.users.map((u) => u.did));
-    } catch (e) {
-      error = e instanceof Error ? e.message : 'Failed to load Skyreader follows';
-    } finally {
-      isLoadingSkyreaderFollows = false;
-    }
-  }
-
-  async function loadBlueskyFollows(reset = true, userDid?: string) {
-    if (isLoadingBlueskyFollows) return;
-    if (!reset && blueskyFollowsCursor === null) return;
-    if (!userDid) return;
-
-    isLoadingBlueskyFollows = true;
-    error = null;
-
-    try {
-      const params = new URLSearchParams({
-        actor: userDid,
-        limit: '50',
-      });
-      if (!reset && blueskyFollowsCursor) {
-        params.set('cursor', blueskyFollowsCursor);
-      }
-
-      const response = await fetch(
-        `https://public.api.bsky.app/xrpc/app.bsky.graph.getFollows?${params}`
-      );
-      if (!response.ok) {
-        throw new Error(`Failed to fetch Bluesky follows: ${response.status}`);
-      }
-
-      const data = (await response.json()) as {
-        follows: Array<{
-          did: string;
-          handle: string;
-          displayName?: string;
-          avatar?: string;
-        }>;
-        cursor?: string;
-      };
-
-      // Map Bluesky follows into FollowedUserDetailed shape
-      // Check which are also followed in-app
-      const inappDids = new Set(inAppFollows.map((f) => f.did));
-      const inappRkeys = new Map(inAppFollows.map((f) => [f.did, f.rkey]));
-
-      const users: FollowedUserDetailed[] = data.follows.map((f) => ({
-        did: f.did,
-        source: inappDids.has(f.did) ? 'both' : 'bluesky',
-        shareCount: 0,
-        lastSharedAt: null,
-        followedAt: 0,
-        rkey: inappRkeys.get(f.did),
-      }));
-
-      if (reset) {
-        blueskyFollows = users;
-      } else {
-        blueskyFollows = [...blueskyFollows, ...users];
-      }
-      blueskyFollowsCursor = data.cursor || null;
-
-      // Prefetch profiles from Bluesky
-      profileService.prefetch(users.map((u) => u.did));
-    } catch (e) {
-      error = e instanceof Error ? e.message : 'Failed to load Bluesky follows';
-    } finally {
-      isLoadingBlueskyFollows = false;
-    }
-  }
-
-  async function followUser(did: string): Promise<boolean> {
-    const rkey = generateTid();
-
-    // Optimistic update - remove from discover
-    discoverUsers = discoverUsers.filter((u) => u.did !== did);
-
-    // Optimistic update - add to followed users for sidebar
-    const existingUser = followedUsers.find((u) => u.did === did);
-    if (existingUser) {
-      // Update source to 'both' if already following on Bluesky
-      followedUsers = followedUsers.map((u) =>
-        u.did === did ? { ...u, source: 'both' as const } : u
-      );
-    } else {
-      // Add new follow
-      followedUsers = [...followedUsers, { did, source: 'inapp' as const }];
-    }
-
-    // Optimistic update - update blueskyFollows source to 'both'
-    const originalBlueskyFollow = blueskyFollows.find((u) => u.did === did);
-    if (originalBlueskyFollow) {
-      blueskyFollows = blueskyFollows.map((u) =>
-        u.did === did ? { ...u, source: 'both' as const } : u
-      );
-    }
-
-    // Optimistic update - increment follow count
-    inAppFollowCount++;
-
-    const payload: FollowPayload = { rkey, did };
-
-    if (syncStore.isOnline) {
-      try {
-        await api.followUser(rkey, did);
-        // Refresh followed users to get accurate data
-        await loadFollowedUsers();
-        await loadInAppFollowCount();
-        // Load social feed and read positions to include the new user's shares/articles
-        try {
-          await Promise.all([loadFeed(true), itemLabelsStore.load()]);
-        } catch (e) {
-          console.error('Failed to reload social feed after follow:', e);
-          // Don't propagate - follow succeeded, feed will load on next refresh
-        }
-        return true;
-      } catch (e) {
-        error = e instanceof Error ? e.message : 'Failed to follow user';
-        // Revert optimistic update on error
-        if (existingUser) {
-          followedUsers = followedUsers.map((u) =>
-            u.did === did ? { ...u, source: existingUser.source } : u
-          );
-        } else {
-          followedUsers = followedUsers.filter((u) => u.did !== did);
-        }
-        // Revert blueskyFollows
-        if (originalBlueskyFollow) {
-          blueskyFollows = blueskyFollows.map((u) =>
-            u.did === did ? { ...u, source: originalBlueskyFollow.source } : u
-          );
-        }
-        // Revert count
-        inAppFollowCount--;
-        // Queue for retry
-        await syncQueue.enqueue('create', 'follows', did, payload);
-        return false;
-      }
-    } else {
-      // Offline - queue the operation
-      await syncQueue.enqueue('create', 'follows', did, payload);
-      return true; // Optimistically return success
-    }
-  }
-
-  async function unfollowInApp(did: string): Promise<boolean> {
-    // Need to get the rkey first - this requires being online
-    if (!syncStore.isOnline) {
-      error = 'Cannot unfollow while offline';
-      return false;
-    }
-
-    // Store original state for potential rollback
-    const originalUser = followedUsers.find((u) => u.did === did);
-    const originalCount = inAppFollowCount;
-
-    // Optimistic update - update source or remove from followed users
-    if (originalUser?.source === 'both') {
-      // If following on both, change to bluesky-only
-      followedUsers = followedUsers.map((u) =>
-        u.did === did ? { ...u, source: 'bluesky' as const } : u
-      );
-    } else {
-      // If only following in-app, remove entirely
-      followedUsers = followedUsers.filter((u) => u.did !== did);
-    }
-
-    // Optimistic update - remove from skyreaderFollows
-    const originalSkyreaderFollows = skyreaderFollows;
-    skyreaderFollows = skyreaderFollows.filter((u) => u.did !== did);
-
-    // Optimistic update - update blueskyFollows source
-    const originalBlueskyFollowForUnfollow = blueskyFollows.find((u) => u.did === did);
-    if (originalBlueskyFollowForUnfollow) {
-      blueskyFollows = blueskyFollows.map((u) =>
-        u.did === did ? { ...u, source: 'bluesky' as const } : u
-      );
-    }
-
-    // Optimistic update - decrement follow count
-    inAppFollowCount = Math.max(0, inAppFollowCount - 1);
-
-    try {
-      // Get in-app follows with rkeys
-      const { follows } = await api.listInAppFollows();
-      const followRecord = follows.find((f) => f.did === did);
-
-      if (!followRecord) {
-        // Revert optimistic update
-        if (originalUser) {
-          if (originalUser.source === 'both') {
-            followedUsers = followedUsers.map((u) =>
-              u.did === did ? { ...u, source: 'both' as const } : u
-            );
-          } else {
-            followedUsers = [...followedUsers, originalUser];
-          }
-        }
-        skyreaderFollows = originalSkyreaderFollows;
-        if (originalBlueskyFollowForUnfollow) {
-          blueskyFollows = blueskyFollows.map((u) =>
-            u.did === did ? { ...u, source: originalBlueskyFollowForUnfollow.source } : u
-          );
-        }
-        inAppFollowCount = originalCount;
-        error = 'Follow record not found';
-        return false;
-      }
-
-      const payload: FollowPayload = { rkey: followRecord.rkey, did };
-
-      try {
-        await api.unfollowUser(followRecord.rkey);
-        // Refresh followed users to get accurate data
-        await loadFollowedUsers();
-        await loadInAppFollowCount();
-        return true;
-      } catch (e) {
-        error = e instanceof Error ? e.message : 'Failed to unfollow user';
-        // Revert optimistic update
-        if (originalUser) {
-          if (originalUser.source === 'both') {
-            followedUsers = followedUsers.map((u) =>
-              u.did === did ? { ...u, source: 'both' as const } : u
-            );
-          } else {
-            followedUsers = [...followedUsers, originalUser];
-          }
-        }
-        skyreaderFollows = originalSkyreaderFollows;
-        if (originalBlueskyFollowForUnfollow) {
-          blueskyFollows = blueskyFollows.map((u) =>
-            u.did === did ? { ...u, source: originalBlueskyFollowForUnfollow.source } : u
-          );
-        }
-        inAppFollowCount = originalCount;
-        // Queue for retry
-        await syncQueue.enqueue('delete', 'follows', did, payload);
-        return false;
-      }
-    } catch (e) {
-      // Revert optimistic update
-      if (originalUser) {
-        if (originalUser.source === 'both') {
-          followedUsers = followedUsers.map((u) =>
-            u.did === did ? { ...u, source: 'both' as const } : u
-          );
-        } else {
-          followedUsers = [...followedUsers, originalUser];
-        }
-      }
-      skyreaderFollows = originalSkyreaderFollows;
-      if (originalBlueskyFollowForUnfollow) {
-        blueskyFollows = blueskyFollows.map((u) =>
-          u.did === did ? { ...u, source: originalBlueskyFollowForUnfollow.source } : u
-        );
-      }
-      inAppFollowCount = originalCount;
-      error = e instanceof Error ? e.message : 'Failed to unfollow user';
-      return false;
-    }
-  }
-
   function reset() {
     shares = [];
     documents = [];
     popularShares = [];
-    followedUsers = [];
-    discoverUsers = [];
-    skyreaderFollows = [];
-    blueskyFollows = [];
-    skyreaderFollowsNextOffset = null;
-    blueskyFollowsCursor = null;
     cursor = null;
     hasMore = true;
     error = null;
@@ -482,35 +105,8 @@ function createSocialStore() {
     get popularShares() {
       return popularShares;
     },
-    get followedUsers() {
-      return followedUsers;
-    },
-    get discoverUsers() {
-      return discoverUsers;
-    },
-    get skyreaderFollows() {
-      return skyreaderFollows;
-    },
-    get blueskyFollows() {
-      return blueskyFollows;
-    },
-    get hasMoreSkyreaderFollows() {
-      return skyreaderFollowsNextOffset !== null;
-    },
-    get hasMoreBlueskyFollows() {
-      return blueskyFollowsCursor !== null;
-    },
     get isLoading() {
-      return isLoading;
-    },
-    get isLoadingSkyreaderFollows() {
-      return isLoadingSkyreaderFollows;
-    },
-    get isLoadingBlueskyFollows() {
-      return isLoadingBlueskyFollows;
-    },
-    get isDiscoverLoading() {
-      return isDiscoverLoading;
+      return isLoadingFeed;
     },
     get hasMore() {
       return hasMore;
@@ -518,27 +114,8 @@ function createSocialStore() {
     get error() {
       return error;
     },
-    get inAppFollowCount() {
-      return inAppFollowCount;
-    },
-    get inAppFollows() {
-      return inAppFollows;
-    },
-    get isAtFollowLimit() {
-      return isAtFollowLimit;
-    },
-    get followLimit() {
-      return followLimit;
-    },
     loadFeed,
     loadPopular,
-    loadFollowedUsers,
-    loadInAppFollowCount,
-    loadDiscoverUsers,
-    loadSkyreaderFollows,
-    loadBlueskyFollows,
-    followUser,
-    unfollowInApp,
     reset,
     getSharesByAuthor,
   };
diff --git a/src/lib/stores/subscriptions.svelte.ts b/src/lib/stores/subscriptions.svelte.ts
index 0ec1186..736cba8 100644
--- a/src/lib/stores/subscriptions.svelte.ts
+++ b/src/lib/stores/subscriptions.svelte.ts
@@ -2,7 +2,7 @@ import { liveDb } from '$lib/services/liveDb.svelte';
 import { feedStatusStore } from './feedStatus.svelte';
 import { api } from '$lib/services/api';
 import { auth } from './auth.svelte';
-import type { Subscription } from '$lib/types';
+import type { Subscription, SubscriptionSourceType } from '$lib/types';
 
 // Generate a TID (Timestamp Identifier) for AT Protocol records
 function generateTid(): string {
@@ -53,10 +53,10 @@ function createSubscriptionsStore() {
   }
 
   /**
-   * Add a new subscription
+   * Add a new subscription (RSS or AT Proto content stream)
    */
   async function add(
-    feedUrl: string,
+    feedUrl: string | undefined,
     title: string,
     options?: Partial<Subscription>
   ): Promise<number> {
@@ -64,9 +64,24 @@ function createSubscriptionsStore() {
       throw new Error(`Feed limit reached. You can have up to ${maxSubscriptions} feeds.`);
     }
 
+    const isAtProto = options?.sourceType && options.sourceType.startsWith('atproto.');
+
     // Check for duplicate
-    if (liveDb.getSubscriptionByUrl(feedUrl)) {
-      throw new Error('You are already subscribed to this feed');
+    if (isAtProto && options?.subjectDid && options?.sourceType) {
+      // For AT Proto subs, check by subjectDid + sourceType + feedUrl (publication URI)
+      const existing = subscriptions.find(
+        (s) =>
+          s.sourceType === options.sourceType &&
+          s.subjectDid === options.subjectDid &&
+          (s.feedUrl || '') === (options.feedUrl || feedUrl || '')
+      );
+      if (existing) {
+        throw new Error('You are already subscribed to this content stream');
+      }
+    } else if (feedUrl) {
+      if (liveDb.getSubscriptionByUrl(feedUrl)) {
+        throw new Error('You are already subscribed to this feed');
+      }
     }
 
     const rkey = generateTid();
@@ -75,11 +90,14 @@ function createSubscriptionsStore() {
     // Sync to backend first
     await api.createSubscription({
       rkey,
-      feedUrl,
+      feedUrl: feedUrl || undefined,
       title,
       siteUrl: options?.siteUrl,
       category: options?.category,
       tags: options?.tags,
+      sourceType: options?.sourceType,
+      subjectDid: options?.subjectDid,
+      collectionNsid: options?.collectionNsid,
     });
 
     // Store locally after successful backend sync
@@ -92,12 +110,17 @@ function createSubscriptionsStore() {
       tags: options?.tags || [],
       createdAt: now,
       localUpdatedAt: Date.now(),
-      fetchStatus: 'pending',
+      fetchStatus: isAtProto ? 'ready' : 'pending',
       source: options?.source,
+      sourceType: options?.sourceType,
+      subjectDid: options?.subjectDid,
+      collectionNsid: options?.collectionNsid,
     };
 
     const id = await liveDb.addSubscription(subscription);
-    feedStatusStore.markPending(feedUrl);
+    if (!isAtProto && feedUrl) {
+      feedStatusStore.markPending(feedUrl);
+    }
 
     return id;
   }
@@ -127,7 +150,9 @@ function createSubscriptionsStore() {
     const source = options?.source || 'manual';
 
     // Get existing feed URLs for duplicate detection
-    const existingUrls = new Set(subscriptions.map((s) => s.feedUrl.toLowerCase()));
+    const existingUrls = new Set(
+      subscriptions.filter((s) => s.feedUrl).map((s) => s.feedUrl!.toLowerCase())
+    );
 
     // Filter out duplicates first
     let feedsToAdd = feeds.filter((feed) => {
@@ -270,7 +295,7 @@ function createSubscriptionsStore() {
 
     // Delete locally (includes articles)
     await liveDb.deleteSubscription(id);
-    feedStatusStore.clearStatus(sub.feedUrl);
+    if (sub.feedUrl) feedStatusStore.clearStatus(sub.feedUrl);
   }
 
   /**
diff --git a/src/lib/types/index.ts b/src/lib/types/index.ts
index 5103515..fdc5435 100644
--- a/src/lib/types/index.ts
+++ b/src/lib/types/index.ts
@@ -7,15 +7,20 @@ export interface User {
   tier?: string;
   limits?: {
     maxSubscriptions: number;
-    maxFollows: number;
     maxUrlSavesPerMonth: number;
   };
 }
 
+export type SubscriptionSourceType =
+  | 'rss'
+  | 'atproto.shares'
+  | 'atproto.documents'
+  | 'atproto.collection';
+
 export interface Subscription {
   id?: number;
   rkey: string;
-  feedUrl: string;
+  feedUrl?: string; // Required for RSS, optional for AT Proto subscriptions
   title: string;
   siteUrl?: string;
   category?: string;
@@ -29,6 +34,9 @@ export interface Subscription {
   source?: 'manual' | 'opml';
   customTitle?: string; // User-set title override (local only)
   customIconUrl?: string; // User-set icon override (local only)
+  sourceType?: SubscriptionSourceType; // Content source type; omitted = RSS
+  subjectDid?: string; // AT Protocol account DID; required for atproto.* types
+  collectionNsid?: string; // Collection NSID for atproto.collection (future)
 }
 
 export interface Article {
@@ -717,44 +725,3 @@ export interface Highlight {
   selector: TextQuoteSelector;
   createdAt: number; // epoch ms
 }
-
-export interface DiscoverUser {
-  did: string;
-  handle: string;
-  displayName?: string;
-  avatarUrl?: string;
-  shareCount: number;
-  recentShares?: Array<{
-    itemUrl: string;
-    itemTitle?: string;
-    createdAt: string;
-  }>;
-}
-
-export interface InappFollow {
-  id?: number;
-  rkey?: string;
-  subjectDid: string;
-  createdAt: string;
-}
-
-export interface FollowedUserDetailed {
-  did: string;
-  source: 'bluesky' | 'inapp' | 'both';
-  shareCount: number;
-  lastSharedAt: string | null;
-  followedAt: number;
-  rkey?: string;
-  recentShares?: Array<{
-    itemUrl: string;
-    itemTitle?: string;
-    createdAt: string;
-  }>;
-  documentCount?: number;
-  lastPublishedAt?: string | null;
-  recentDocuments?: Array<{
-    url: string;
-    title: string;
-    publishedAt: string;
-  }>;
-}
diff --git a/src/lib/utils/opml-exporter.ts b/src/lib/utils/opml-exporter.ts
index 410852f..13333f4 100644
--- a/src/lib/utils/opml-exporter.ts
+++ b/src/lib/utils/opml-exporter.ts
@@ -51,8 +51,8 @@ export function generateOPML(subscriptions: Subscription[]): string {
 }
 
 function buildOutline(sub: Subscription): string {
-  const title = sub.customTitle || sub.title || sub.feedUrl;
-  let outline = `<outline type="rss" text="${escapeXml(title)}" title="${escapeXml(title)}" xmlUrl="${escapeXml(sub.feedUrl)}"`;
+  const title = sub.customTitle || sub.title || sub.feedUrl || '';
+  let outline = `<outline type="rss" text="${escapeXml(title)}" title="${escapeXml(title)}" xmlUrl="${escapeXml(sub.feedUrl || '')}"`;
 
   if (sub.siteUrl) {
     outline += ` htmlUrl="${escapeXml(sub.siteUrl)}"`;
diff --git a/src/routes/+layout.svelte b/src/routes/+layout.svelte
index 334e965..e4f9b3c 100644
--- a/src/routes/+layout.svelte
+++ b/src/routes/+layout.svelte
@@ -10,7 +10,6 @@
   import { keyboardStore } from '$lib/stores/keyboard.svelte';
   import Sidebar from '$lib/components/Sidebar.svelte';
   import KeyboardShortcutsModal from '$lib/components/KeyboardShortcutsModal.svelte';
-  import FollowUserModal from '$lib/components/FollowUserModal.svelte';
   import Logo from '$lib/assets/logo.svg';
   import '../app.css';
 
@@ -24,22 +23,14 @@
     return count > 0 ? `(${count}) ${suffix}` : suffix;
   });
 
-  // Helper functions for feed/user cycling
-  function getCurrentFeedId(): number | null {
-    const feedParam = $page.url.searchParams.get('feed');
-    return feedParam ? parseInt(feedParam) : null;
-  }
-
-  function getCurrentSharerId(): string | null {
-    return $page.url.searchParams.get('sharer');
-  }
-
+  // Helper function for feed cycling
   function cycleFeeds(direction: 1 | -1) {
     // Use sorted feed IDs from sidebar store (matches visual order)
     const feedIds = sidebarStore.sortedFeedIds;
     if (feedIds.length === 0) return;
 
-    const currentFeedId = getCurrentFeedId();
+    const feedParam = $page.url.searchParams.get('feed');
+    const currentFeedId = feedParam ? parseInt(feedParam) : null;
     if (currentFeedId === null) {
       // Not on a feed view, go to first/last feed
       const targetId = direction === 1 ? feedIds[0] : feedIds[feedIds.length - 1];
@@ -58,45 +49,6 @@
     goto(`/?feed=${feedIds[newIndex]}`);
   }
 
-  function cycleUsers(direction: 1 | -1) {
-    // Use sorted user DIDs from sidebar store (matches visual order)
-    const userDids = sidebarStore.sortedUserDids;
-    if (userDids.length === 0) return;
-
-    const currentSharerId = getCurrentSharerId();
-    if (currentSharerId === null) {
-      // Not on a sharer view, go to first/last user
-      const targetDid = direction === 1 ? userDids[0] : userDids[userDids.length - 1];
-      goto(`/?sharer=${targetDid}`);
-      return;
-    }
-
-    const currentIndex = userDids.indexOf(currentSharerId);
-    if (currentIndex === -1) {
-      // Current user not found in sorted list, go to first
-      goto(`/?sharer=${userDids[0]}`);
-      return;
-    }
-
-    const newIndex = (currentIndex + direction + userDids.length) % userDids.length;
-    goto(`/?sharer=${userDids[newIndex]}`);
-  }
-
-  // Determine whether to cycle feeds or users based on current view
-  function cycleSidebar(direction: 1 | -1) {
-    const feedParam = $page.url.searchParams.get('feed');
-    const sharerParam = $page.url.searchParams.get('sharer');
-    const followingParam = $page.url.searchParams.get('following');
-
-    // If on a specific sharer or following view, cycle users
-    if (sharerParam || followingParam) {
-      cycleUsers(direction);
-    } else {
-      // Otherwise cycle feeds
-      cycleFeeds(direction);
-    }
-  }
-
   // Register global keyboard shortcuts on mount
   onMount(() => {
     // View switching shortcuts
@@ -132,22 +84,6 @@
       condition: () => auth.isAuthenticated,
     });
 
-    keyboardStore.register({
-      key: '5',
-      description: 'Following',
-      category: 'Views',
-      action: () => goto('/?following=true'),
-      condition: () => auth.isAuthenticated,
-    });
-
-    keyboardStore.register({
-      key: '6',
-      description: 'Discover',
-      category: 'Views',
-      action: () => goto('/discover'),
-      condition: () => auth.isAuthenticated,
-    });
-
     keyboardStore.register({
       key: '0',
       description: 'Settings',
@@ -159,17 +95,17 @@
     // Feed/user cycling shortcuts
     keyboardStore.register({
       key: '[',
-      description: 'Previous feed/user',
-      category: 'Feed/User',
-      action: () => cycleSidebar(-1),
+      description: 'Previous feed',
+      category: 'Feed',
+      action: () => cycleFeeds(-1),
       condition: () => auth.isAuthenticated,
     });
 
     keyboardStore.register({
       key: ']',
-      description: 'Next feed/user',
-      category: 'Feed/User',
-      action: () => cycleSidebar(1),
+      description: 'Next feed',
+      category: 'Feed',
+      action: () => cycleFeeds(1),
       condition: () => auth.isAuthenticated,
     });
 
@@ -246,10 +182,6 @@
 </svelte:head>
 
 <KeyboardShortcutsModal />
-<FollowUserModal
-  open={sidebarStore.followUserModalOpen}
-  onclose={() => sidebarStore.closeFollowUserModal()}
-/>
 
 <div class="app">
   {#if !auth.isLoading}
diff --git a/src/routes/+page.svelte b/src/routes/+page.svelte
index a1fe83f..e477244 100644
--- a/src/routes/+page.svelte
+++ b/src/routes/+page.svelte
@@ -506,7 +506,7 @@
         onShare={(article, sub) =>
           sharesStore.share(
             sub.rkey,
-            sub.feedUrl,
+            sub.feedUrl || '',
             article.guid,
             article.url,
             article.title,
diff --git a/src/routes/discover/+page.svelte b/src/routes/discover/+page.svelte
deleted file mode 100644
index d7bfbab..0000000
--- a/src/routes/discover/+page.svelte
+++ /dev/null
@@ -1,305 +0,0 @@
-<script lang="ts">
-  import { onMount } from 'svelte';
-  import { goto } from '$app/navigation';
-  import { auth } from '$lib/stores/auth.svelte';
-  import { socialStore } from '$lib/stores/social.svelte';
-  import PageHeader from '$lib/components/common/PageHeader.svelte';
-  import StateView from '$lib/components/common/StateView.svelte';
-  import UserCard from '$lib/components/common/UserCard.svelte';
-  import FollowLimitModal from '$lib/components/FollowLimitModal.svelte';
-  import { viewTitleStore } from '$lib/stores/viewTitle.svelte';
-
-  $effect(() => {
-    viewTitleStore.set('Discover');
-    return () => viewTitleStore.set('');
-  });
-
-  let followingDids = $state<Set<string>>(new Set());
-  let expandedUsers = $state<Set<string>>(new Set());
-  let showLimitModal = $state(false);
-
-  function toggleExpanded(did: string) {
-    if (expandedUsers.has(did)) {
-      expandedUsers.delete(did);
-    } else {
-      expandedUsers.add(did);
-    }
-    expandedUsers = new Set(expandedUsers);
-  }
-
-  onMount(async () => {
-    if (!auth.isAuthenticated) {
-      goto('/auth/login?returnUrl=/discover');
-      return;
-    }
-    await Promise.all([
-      socialStore.loadDiscoverUsers(),
-      socialStore.loadFollowedUsers(),
-      socialStore.loadInAppFollowCount(),
-    ]);
-  });
-
-  async function shuffle() {
-    await socialStore.loadDiscoverUsers();
-  }
-
-  async function handleFollow(did: string) {
-    // Check if already at follow limit
-    if (socialStore.isAtFollowLimit) {
-      showLimitModal = true;
-      return;
-    }
-
-    followingDids.add(did);
-    followingDids = new Set(followingDids);
-    const success = await socialStore.followUser(did);
-    if (!success) {
-      followingDids.delete(did);
-      followingDids = new Set(followingDids);
-    }
-  }
-
-  function isFollowing(did: string): boolean {
-    return followingDids.has(did) || socialStore.followedUsers.some((u) => u.did === did);
-  }
-</script>
-
-<div class="discover-page">
-  <PageHeader title="Discover" subtitle="Find active Skyreader users to follow">
-    <button class="btn btn-secondary" onclick={shuffle} disabled={socialStore.isDiscoverLoading}>
-      {socialStore.isDiscoverLoading ? 'Loading...' : 'Shuffle'}
-    </button>
-  </PageHeader>
-
-  {#if socialStore.error}
-    <p class="error">{socialStore.error}</p>
-  {/if}
-
-  <StateView
-    isLoading={socialStore.isDiscoverLoading && socialStore.discoverUsers.length === 0}
-    isEmpty={socialStore.discoverUsers.length === 0}
-    loadingMessage="Finding active users..."
-    emptyTitle="No users to discover"
-    emptyDescription="Check back later when more users have shared articles"
-  >
-    <div class="users-list">
-      {#each socialStore.discoverUsers as user (user.did)}
-        {@const isExpanded = expandedUsers.has(user.did)}
-        {@const hasShares = user.recentShares && user.recentShares.length > 0}
-        <div class="user-row card">
-          <div class="user-main">
-            <div class="user-info">
-              <UserCard
-                avatarUrl={user.avatarUrl}
-                displayName={user.displayName}
-                handle={user.handle}
-                size="large"
-              />
-              <div class="user-stats">
-                <span class="share-count">
-                  {user.shareCount}
-                  {user.shareCount === 1 ? 'share' : 'shares'}
-                </span>
-                <span class="time-period">in last 30 days</span>
-              </div>
-            </div>
-
-            <div class="user-actions">
-              <button
-                class="btn follow-btn"
-                class:btn-primary={!isFollowing(user.did)}
-                class:btn-secondary={isFollowing(user.did)}
-                disabled={isFollowing(user.did) || followingDids.has(user.did)}
-                onclick={() => handleFollow(user.did)}
-              >
-                {#if isFollowing(user.did)}
-                  Following
-                {:else if followingDids.has(user.did)}
-                  Following...
-                {:else}
-                  Follow on Skyreader
-                {/if}
-              </button>
-              <a
-                href="https://bsky.app/profile/{user.handle}"
-                target="_blank"
-                rel="noopener"
-                class="btn btn-outline bluesky-link"
-              >
-                Bluesky Profile
-              </a>
-            </div>
-          </div>
-
-          {#if hasShares}
-            <button class="disclosure-toggle" onclick={() => toggleExpanded(user.did)}>
-              <span class="disclosure-icon">{isExpanded ? '▼' : '▶'}</span>
-              <span>Recent shares</span>
-            </button>
-
-            {#if isExpanded}
-              <ul class="recent-shares">
-                {#each user.recentShares! as share}
-                  <li>
-                    <a href={share.itemUrl} target="_blank" rel="noopener">
-                      {share.itemTitle || share.itemUrl}
-                    </a>
-                  </li>
-                {/each}
-              </ul>
-            {/if}
-          {/if}
-        </div>
-      {/each}
-    </div>
-  </StateView>
-</div>
-
-<FollowLimitModal open={showLimitModal} onclose={() => (showLimitModal = false)} />
-
-<style>
-  .discover-page {
-    max-width: 800px;
-    margin: 0 auto;
-    padding: 0 1rem;
-  }
-
-  .users-list {
-    display: flex;
-    flex-direction: column;
-    gap: 0.75rem;
-    margin-top: 1rem;
-  }
-
-  .user-row {
-    display: flex;
-    flex-direction: column;
-    padding: 1rem;
-    gap: 0.75rem;
-  }
-
-  .user-main {
-    display: flex;
-    justify-content: space-between;
-    align-items: center;
-    gap: 1rem;
-    width: 100%;
-  }
-
-  .user-info {
-    display: flex;
-    flex-direction: column;
-    gap: 0.5rem;
-    min-width: 0;
-    flex: 1;
-  }
-
-  .user-stats {
-    display: flex;
-    gap: 0.5rem;
-    font-size: 0.875rem;
-    color: var(--color-text-secondary);
-    padding-left: 3.5rem;
-  }
-
-  .share-count {
-    font-weight: 500;
-  }
-
-  .user-actions {
-    display: flex;
-    flex-direction: column;
-    gap: 0.5rem;
-    flex-shrink: 0;
-  }
-
-  .follow-btn {
-    min-width: 150px;
-  }
-
-  .bluesky-link {
-    text-align: center;
-    text-decoration: none;
-    font-size: 0.875rem;
-  }
-
-  .disclosure-toggle {
-    display: flex;
-    align-items: center;
-    gap: 0.5rem;
-    background: none;
-    border: none;
-    padding: 0.5rem 0;
-    font: inherit;
-    font-size: 0.875rem;
-    color: var(--color-text-secondary);
-    cursor: pointer;
-    transition: color 0.15s;
-  }
-
-  .disclosure-toggle:hover {
-    color: var(--color-primary);
-  }
-
-  .disclosure-icon {
-    font-size: 0.625rem;
-    width: 1rem;
-  }
-
-  .recent-shares {
-    list-style: none;
-    margin: 0;
-    padding: 0 0 0 1.5rem;
-    display: flex;
-    flex-direction: column;
-    gap: 0.5rem;
-  }
-
-  .recent-shares li {
-    font-size: 0.875rem;
-  }
-
-  .recent-shares a {
-    color: var(--color-text);
-    text-decoration: none;
-    display: block;
-    overflow: hidden;
-    text-overflow: ellipsis;
-    white-space: nowrap;
-  }
-
-  .recent-shares a:hover {
-    color: var(--color-primary);
-    text-decoration: underline;
-  }
-
-  .error {
-    color: var(--color-error, #dc3545);
-    padding: 1rem;
-    background: var(--color-error-bg, #f8d7da);
-    border-radius: 8px;
-    margin-bottom: 1rem;
-  }
-
-  @media (max-width: 600px) {
-    .user-main {
-      flex-direction: column;
-      align-items: stretch;
-    }
-
-    .user-stats {
-      padding-left: 0;
-    }
-
-    .user-actions {
-      flex-direction: row;
-      flex-wrap: wrap;
-    }
-
-    .follow-btn,
-    .bluesky-link {
-      flex: 1;
-      min-width: 120px;
-    }
-  }
-</style>
diff --git a/src/routes/following/+page.svelte b/src/routes/following/+page.svelte
deleted file mode 100644
index 8274d1d..0000000
--- a/src/routes/following/+page.svelte
+++ /dev/null
@@ -1,260 +0,0 @@
-<script lang="ts">
-  import { onMount } from 'svelte';
-  import { goto } from '$app/navigation';
-  import { auth } from '$lib/stores/auth.svelte';
-  import { socialStore } from '$lib/stores/social.svelte';
-  import { profileService } from '$lib/services/profiles';
-  import InfiniteScrollSentinel from '$lib/components/common/InfiniteScrollSentinel.svelte';
-  import PageHeader from '$lib/components/common/PageHeader.svelte';
-  import StateView from '$lib/components/common/StateView.svelte';
-  import UserSearch from '$lib/components/UserSearch.svelte';
-  import FollowLimitModal from '$lib/components/FollowLimitModal.svelte';
-  import FollowingUserRow from '$lib/components/following/FollowingUserRow.svelte';
-  import StandardSubscriptionsTab from '$lib/components/following/StandardSubscriptionsTab.svelte';
-  import type { BlueskyProfile, FollowedUserDetailed } from '$lib/types';
-  import { viewTitleStore } from '$lib/stores/viewTitle.svelte';
-
-  $effect(() => {
-    viewTitleStore.set('Following');
-    return () => viewTitleStore.set('');
-  });
-
-  let activeTab = $state<'skyreader' | 'bluesky' | 'standard'>('skyreader');
-  let profiles = $state<Map<string, BlueskyProfile>>(new Map());
-  let actionInProgress = $state<Set<string>>(new Set());
-  let expandedUsers = $state<Set<string>>(new Set());
-  let showLimitModal = $state(false);
-
-  function toggleExpanded(did: string) {
-    if (expandedUsers.has(did)) {
-      expandedUsers.delete(did);
-    } else {
-      expandedUsers.add(did);
-    }
-    expandedUsers = new Set(expandedUsers);
-  }
-
-  onMount(async () => {
-    if (!auth.isAuthenticated) {
-      goto('/auth/login?returnUrl=/following');
-      return;
-    }
-    await Promise.all([
-      loadCurrentTab(true),
-      socialStore.loadFollowedUsers(),
-      socialStore.loadInAppFollowCount(),
-    ]);
-  });
-
-  async function loadCurrentTab(reset = true) {
-    if (activeTab === 'skyreader') {
-      await socialStore.loadSkyreaderFollows(reset);
-      const dids = socialStore.skyreaderFollows.map((u) => u.did);
-      const fetched = await profileService.getProfiles(dids);
-      profiles = new Map([...profiles, ...fetched]);
-    } else if (activeTab === 'bluesky') {
-      await socialStore.loadBlueskyFollows(reset, auth.user?.did);
-      const dids = socialStore.blueskyFollows.map((u) => u.did);
-      const fetched = await profileService.getProfiles(dids);
-      profiles = new Map([...profiles, ...fetched]);
-    }
-    // standard tab manages its own loading via onMount
-  }
-
-  async function switchTab(tab: 'skyreader' | 'bluesky' | 'standard') {
-    if (activeTab === tab) return;
-    activeTab = tab;
-    if (tab !== 'standard') {
-      await loadCurrentTab(true);
-    }
-  }
-
-  async function loadMore() {
-    await loadCurrentTab(false);
-  }
-
-  async function handleUnfollow(user: FollowedUserDetailed) {
-    if (!user.rkey) return;
-    actionInProgress.add(user.did);
-    actionInProgress = new Set(actionInProgress);
-
-    await socialStore.unfollowInApp(user.did);
-
-    actionInProgress.delete(user.did);
-    actionInProgress = new Set(actionInProgress);
-  }
-
-  async function handleFollow(user: FollowedUserDetailed) {
-    if (socialStore.isAtFollowLimit) {
-      showLimitModal = true;
-      return;
-    }
-
-    actionInProgress.add(user.did);
-    actionInProgress = new Set(actionInProgress);
-
-    await socialStore.followUser(user.did);
-
-    actionInProgress.delete(user.did);
-    actionInProgress = new Set(actionInProgress);
-  }
-
-  function getProfile(did: string): BlueskyProfile | undefined {
-    return profiles.get(did);
-  }
-
-  let isLoading = $derived(
-    activeTab === 'skyreader'
-      ? socialStore.isLoadingSkyreaderFollows
-      : socialStore.isLoadingBlueskyFollows
-  );
-
-  let currentUsers = $derived(
-    activeTab === 'skyreader' ? socialStore.skyreaderFollows : socialStore.blueskyFollows
-  );
-
-  let hasMore = $derived(
-    activeTab === 'skyreader'
-      ? socialStore.hasMoreSkyreaderFollows
-      : activeTab === 'bluesky'
-        ? socialStore.hasMoreBlueskyFollows
-        : false
-  );
-
-  let followedDids = $derived(new Set(socialStore.followedUsers.map((u) => u.did)));
-
-  async function handleSearchFollow(did: string) {
-    if (socialStore.isAtFollowLimit) {
-      showLimitModal = true;
-      return;
-    }
-
-    await socialStore.followUser(did);
-  }
-</script>
-
-<div class="following-page">
-  <PageHeader title="Following" subtitle="Manage who you follow on Skyreader" />
-
-  <div class="search-section">
-    <UserSearch {followedDids} onFollow={handleSearchFollow} />
-  </div>
-
-  {#if socialStore.error}
-    <p class="error">{socialStore.error}</p>
-  {/if}
-
-  <div class="tabs">
-    <button
-      class="tab"
-      class:active={activeTab === 'skyreader'}
-      onclick={() => switchTab('skyreader')}
-    >
-      Following on Skyreader
-    </button>
-    <button class="tab" class:active={activeTab === 'bluesky'} onclick={() => switchTab('bluesky')}>
-      Following on Bluesky
-    </button>
-    <button
-      class="tab"
-      class:active={activeTab === 'standard'}
-      onclick={() => switchTab('standard')}
-    >
-      Subscriptions
-    </button>
-  </div>
-
-  {#if activeTab === 'standard'}
-    <StandardSubscriptionsTab />
-  {:else}
-    <StateView
-      {isLoading}
-      isEmpty={currentUsers.length === 0}
-      loadingMessage="Loading follows..."
-      emptyTitle={activeTab === 'skyreader'
-        ? 'Not following anyone on Skyreader'
-        : 'No Bluesky follows found'}
-      emptyDescription={activeTab === 'skyreader'
-        ? 'Follow users from the Discover page to see their shared articles'
-        : 'Sync your Bluesky follows from Settings to see them here'}
-      emptyActionHref={activeTab === 'skyreader' ? '/discover' : '/settings'}
-      emptyActionText={activeTab === 'skyreader' ? 'Discover Users' : 'Go to Settings'}
-    >
-      <div class="users-list">
-        {#each currentUsers as user (user.did)}
-          <FollowingUserRow
-            {user}
-            profile={getProfile(user.did)}
-            mode={activeTab}
-            isExpanded={expandedUsers.has(user.did)}
-            isActionInProgress={actionInProgress.has(user.did)}
-            onToggleExpanded={() => toggleExpanded(user.did)}
-            onFollow={handleFollow}
-            onUnfollow={handleUnfollow}
-          />
-        {/each}
-      </div>
-
-      <InfiniteScrollSentinel {hasMore} {isLoading} onLoadMore={loadMore} />
-    </StateView>
-  {/if}
-</div>
-
-<FollowLimitModal open={showLimitModal} onclose={() => (showLimitModal = false)} />
-
-<style>
-  .search-section {
-    margin: 1rem 0;
-  }
-
-  .following-page {
-    max-width: 800px;
-    margin: 0 auto;
-    padding: 0 1rem;
-  }
-
-  .tabs {
-    display: flex;
-    gap: 0;
-    margin: 1rem 0;
-    border-bottom: 1px solid var(--color-border);
-  }
-
-  .tab {
-    background: none;
-    border: none;
-    padding: 0.75rem 1rem;
-    font: inherit;
-    font-size: 0.875rem;
-    color: var(--color-text-secondary);
-    cursor: pointer;
-    border-bottom: 2px solid transparent;
-    margin-bottom: -1px;
-    transition:
-      color 0.15s,
-      border-color 0.15s;
-  }
-
-  .tab:hover {
-    color: var(--color-text);
-  }
-
-  .tab.active {
-    color: var(--color-primary);
-    border-bottom-color: var(--color-primary);
-  }
-
-  .users-list {
-    display: flex;
-    flex-direction: column;
-    gap: 0.75rem;
-  }
-
-  .error {
-    color: var(--color-error, #dc3545);
-    padding: 1rem;
-    background: var(--color-error-bg, #f8d7da);
-    border-radius: 8px;
-    margin-bottom: 1rem;
-  }
-</style>
diff --git a/src/routes/settings/+page.svelte b/src/routes/settings/+page.svelte
index 671869e..2d68bcd 100644
--- a/src/routes/settings/+page.svelte
+++ b/src/routes/settings/+page.svelte
@@ -3,7 +3,6 @@
   import { goto } from '$app/navigation';
   import { auth } from '$lib/stores/auth.svelte';
   import { subscriptionsStore } from '$lib/stores/subscriptions.svelte';
-  import { socialStore } from '$lib/stores/social.svelte';
   import { savesStore } from '$lib/stores/saves.svelte';
   import {
     preferences,
@@ -55,9 +54,6 @@
       await subscriptionsStore.load();
     }
 
-    // Load follow count for plan usage
-    socialStore.loadInAppFollowCount();
-
     // Load PDS sync settings
     await loadSyncSettings();
   });
@@ -245,8 +241,6 @@
       {#if auth.user.limits}
         {@const subCount = subscriptionsStore.subscriptions.length}
         {@const subLimit = auth.user.limits.maxSubscriptions}
-        {@const followCount = socialStore.inAppFollowCount}
-        {@const followLimit = auth.user.limits.maxFollows}
         {@const urlSaveLimit = auth.user.limits.maxUrlSavesPerMonth}
         {@const monthStart = new Date(
           Date.UTC(new Date().getUTCFullYear(), new Date().getUTCMonth(), 1)
@@ -270,21 +264,6 @@
             </div>
           </div>
 
-          <div class="limit-row">
-            <div class="limit-label">
-              <span>Follows</span>
-              <span class="limit-numbers">{followCount} / {followLimit}</span>
-            </div>
-            <div class="limit-bar">
-              <div
-                class="limit-bar-fill"
-                class:limit-bar-warning={followCount / followLimit > 0.8}
-                class:limit-bar-full={followCount >= followLimit}
-                style:width="{Math.min((followCount / followLimit) * 100, 100)}%"
-              ></div>
-            </div>
-          </div>
-
           <div class="limit-row">
             <div class="limit-label">
               <span>URL saves this month</span>