feat(client): Twitter-style social feed UI (Phase C of v2.0.0)

Ships the client side of the v2.0.0 feed feature. Folds client-app/
into the monorepo (was previously .gitignored as "tracked separately"
but no separate repo ever existed — for v2.0.0 the client is
first-class).

Feed screens

  app/(app)/feed.tsx — Feed tab
    - Three-way tab strip: Подписки / Для вас / В тренде backed by
      /feed/timeline, /feed/foryou, /feed/trending respectively
    - Default landing tab is "Для вас" — surfaces discovery without
      requiring the user to follow anyone first
    - FlatList with pull-to-refresh + viewability-driven view counter
      bump (posts visible ≥ 60% for ≥ 1s trigger POST /feed/post/…/view)
    - Floating blue compose button → /compose
    - Per-post liked_by_me fetched in batches of 6 after list load

  app/(app)/compose.tsx — post composer modal
    - Fullscreen, Twitter-like header (✕ left, Опубликовать right)
    - Auto-focused multiline TextInput, 4000 char cap
    - Hashtag preview chips that auto-update as you type
    - expo-image-picker + expo-image-manipulator pipeline: resize to
      1080px max-dim, JPEG Q=50 (client-side first-pass compression
      before the mandatory server-side scrub)
    - Live fee estimate + balance guard with a confirmation modal
      ("Опубликовать пост? Цена: 0.00X T · Размер: N KB")
    - Exif: false passed to ImagePicker as an extra privacy layer

  app/(app)/feed/[id].tsx — post detail
    - Full PostCard rendering + detailed info panel (views, likes,
      size, fee, hosting relay, hashtags as tappable chips)
    - Triggers bumpView on mount
    - 410 (on-chain soft-delete) routes back to the feed

  app/(app)/feed/tag/[tag].tsx — hashtag feed

  app/(app)/profile/[address].tsx — rebuilt
    - Twitter-ish profile: avatar, name, address short-form, post count
    - Posts | Инфо tab strip
    - Follow / Unfollow button for non-self profiles (optimistic UI)
    - Edit button on self profile → settings
    - Secondary actions (chat, copy address) when viewing a known contact

Supporting library

  lib/feed.ts — HTTP wrappers + tx builders for every /feed/* endpoint:
    - publishPost (POST /feed/publish, signed)
    - publishAndCommit (publish → on-chain CREATE_POST)
    - fetchPost / fetchStats / bumpView
    - fetchAuthorPosts / fetchTimeline / fetchForYou / fetchTrending /
      fetchHashtag
    - buildCreatePostTx / buildDeletePostTx
    - buildFollowTx / buildUnfollowTx
    - buildLikePostTx / buildUnlikePostTx
    - likePost / unlikePost / followUser / unfollowUser / deletePost
      (high-level helpers that bundle build + submitTx)
    - formatFee, formatRelativeTime, formatCount — Twitter-like display
      helpers

  components/feed/PostCard.tsx — core card component
    - Memoised for performance (N-row re-render on every like elsewhere
      would cost a lot otherwise)
    - Optimistic like toggle with heart-bounce spring animation
    - Hashtag highlighting in body text (tappable → hashtag feed)
    - Long-press context menu (Delete, owner-only)
    - Views / likes / share-link / reply icons in footer row

Navigation cleanup

  - NavBar: removed the SOON pill on the Feed tab (it's shipped now)
  - (app)/_layout: hide NavBar on /compose and /feed/* sub-routes
  - AnimatedSlot: treat /feed/<id>, /feed/tag/<t>, /compose as
    sub-routes so back-swipe-right closes them

Channel removal (client side)

  - lib/types.ts: ContactKind stripped to 'direct' | 'group'; legacy
    'channel' flag removed. `kind` field kept for backward compat with
    existing AsyncStorage records.
  - lib/devSeed.ts: dropped the 5 channel seed contacts.
  - components/ChatTile.tsx: removed channel kindIcon branch.

Dependencies

  - expo-image-manipulator added for client-side image compression.
  - expo-file-system/legacy used for readAsStringAsync (SDK 54 moved
    that API to the legacy sub-path; the new streaming API isn't yet
    stable).

Type check

  - npx tsc --noEmit — clean, 0 errors.

Next (not in this commit)

  - Direct attachment-bytes endpoint on the server so post-detail can
    actually render the image (currently shows placeholder with URL)
  - Cross-relay body fetch via /api/relays + hosting_relay pubkey
  - Mentions (@username) with notifications
  - Full-text search

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

client-app/app/(app)/feed.tsx

@@ -0,0 +1,320 @@
+/**
+ * Feed tab — Twitter-style timeline with three sources:
+ *
+ *   Подписки  → /feed/timeline?follower=me        (posts from people I follow)
+ *   Для вас   → /feed/foryou?pub=me               (recommendations)
+ *   В тренде  → /feed/trending?window=24          (most-engaged in last 24h)
+ *
+ * Floating compose button (bottom-right) → /(app)/compose modal.
+ *
+ * Uses a single FlatList per tab with pull-to-refresh + optimistic
+ * local updates. Stats (likes, likedByMe) are fetched once per refresh
+ * and piggy-backed onto each PostCard via props; the card does the
+ * optimistic toggle locally until the next refresh reconciles.
+ */
+import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import {
+  View, Text, FlatList, Pressable, RefreshControl, ActivityIndicator,
+} from 'react-native';
+import { Ionicons } from '@expo/vector-icons';
+import { useSafeAreaInsets } from 'react-native-safe-area-context';
+import { router } from 'expo-router';
+
+import { TabHeader } from '@/components/TabHeader';
+import { PostCard } from '@/components/feed/PostCard';
+import { useStore } from '@/lib/store';
+import {
+  fetchTimeline, fetchForYou, fetchTrending, fetchStats, bumpView,
+  type FeedPostItem,
+} from '@/lib/feed';
+
+type TabKey = 'following' | 'foryou' | 'trending';
+
+const TAB_LABELS: Record<TabKey, string> = {
+  following: 'Подписки',
+  foryou:    'Для вас',
+  trending:  'В тренде',
+};
+
+export default function FeedScreen() {
+  const insets  = useSafeAreaInsets();
+  const keyFile = useStore(s => s.keyFile);
+
+  const [tab, setTab]         = useState<TabKey>('foryou'); // default: discovery
+  const [posts, setPosts]     = useState<FeedPostItem[]>([]);
+  const [likedSet, setLikedSet] = useState<Set<string>>(new Set());
+  const [loading, setLoading] = useState(false);
+  const [refreshing, setRefreshing] = useState(false);
+  const [error, setError]     = useState<string | null>(null);
+
+  // Guard against rapid tab switches overwriting each other's results.
+  const requestRef = useRef(0);
+
+  const loadPosts = useCallback(async (isRefresh = false) => {
+    if (!keyFile) return;
+    if (isRefresh) setRefreshing(true);
+    else setLoading(true);
+    setError(null);
+
+    const seq = ++requestRef.current;
+    try {
+      let items: FeedPostItem[] = [];
+      switch (tab) {
+        case 'following':
+          items = await fetchTimeline(keyFile.pub_key, 40);
+          break;
+        case 'foryou':
+          items = await fetchForYou(keyFile.pub_key, 40);
+          break;
+        case 'trending':
+          items = await fetchTrending(24, 40);
+          break;
+      }
+      if (seq !== requestRef.current) return;   // stale response
+      setPosts(items);
+
+      // Batch-fetch liked_by_me (bounded concurrency — 6 at a time).
+      const liked = new Set<string>();
+      const chunks = chunk(items, 6);
+      for (const group of chunks) {
+        const results = await Promise.all(
+          group.map(p => fetchStats(p.post_id, keyFile.pub_key)),
+        );
+        results.forEach((s, i) => {
+          if (s?.liked_by_me) liked.add(group[i].post_id);
+        });
+      }
+      if (seq !== requestRef.current) return;
+      setLikedSet(liked);
+    } catch (e: any) {
+      if (seq !== requestRef.current) return;
+      const msg = String(e?.message ?? e);
+      // Silence benign network/404 — just show empty state.
+      if (/Network request failed|→\s*404/.test(msg)) {
+        setPosts([]);
+      } else {
+        setError(msg);
+      }
+    } finally {
+      if (seq !== requestRef.current) return;
+      setLoading(false);
+      setRefreshing(false);
+    }
+  }, [keyFile, tab]);
+
+  useEffect(() => { loadPosts(false); }, [loadPosts]);
+
+  const onStatsChanged = useCallback(async (postID: string) => {
+    if (!keyFile) return;
+    const stats = await fetchStats(postID, keyFile.pub_key);
+    if (!stats) return;
+    setPosts(ps => ps.map(p => p.post_id === postID
+      ? { ...p, likes: stats.likes, views: stats.views }
+      : p));
+    setLikedSet(s => {
+      const next = new Set(s);
+      if (stats.liked_by_me) next.add(postID);
+      else next.delete(postID);
+      return next;
+    });
+  }, [keyFile]);
+
+  const onDeleted = useCallback((postID: string) => {
+    setPosts(ps => ps.filter(p => p.post_id !== postID));
+  }, []);
+
+  // View counter: fire bumpView once when a card scrolls into view.
+  const viewedRef = useRef<Set<string>>(new Set());
+  const onViewableItemsChanged = useRef(({ viewableItems }: { viewableItems: Array<{ item: FeedPostItem; isViewable: boolean }> }) => {
+    for (const { item, isViewable } of viewableItems) {
+      if (isViewable && !viewedRef.current.has(item.post_id)) {
+        viewedRef.current.add(item.post_id);
+        bumpView(item.post_id);
+      }
+    }
+  }).current;
+
+  const viewabilityConfig = useRef({ itemVisiblePercentThreshold: 60, minimumViewTime: 1000 }).current;
+
+  const emptyHint = useMemo(() => {
+    switch (tab) {
+      case 'following': return 'Подпишитесь на кого-нибудь, чтобы увидеть их посты здесь.';
+      case 'foryou':    return 'Пока нет рекомендаций — возвращайтесь позже.';
+      case 'trending':  return 'В этой ленте пока тихо.';
+    }
+  }, [tab]);
+
+  return (
+    <View style={{ flex: 1, backgroundColor: '#000000', paddingTop: insets.top }}>
+      <TabHeader title="Лента" />
+
+      {/* Tab strip */}
+      <View
+        style={{
+          flexDirection: 'row',
+          borderBottomWidth: 1,
+          borderBottomColor: '#141414',
+        }}
+      >
+        {(Object.keys(TAB_LABELS) as TabKey[]).map(key => (
+          <Pressable
+            key={key}
+            onPress={() => setTab(key)}
+            style={({ pressed }) => ({
+              flex: 1,
+              alignItems: 'center',
+              paddingVertical: 14,
+              backgroundColor: pressed ? '#0a0a0a' : 'transparent',
+            })}
+          >
+            <Text
+              style={{
+                color: tab === key ? '#ffffff' : '#6a6a6a',
+                fontWeight: tab === key ? '700' : '500',
+                fontSize: 14,
+              }}
+            >
+              {TAB_LABELS[key]}
+            </Text>
+            {tab === key && (
+              <View
+                style={{
+                  marginTop: 8,
+                  width: 48,
+                  height: 3,
+                  borderRadius: 1.5,
+                  backgroundColor: '#1d9bf0',
+                }}
+              />
+            )}
+          </Pressable>
+        ))}
+      </View>
+
+      {/* Feed list */}
+      <FlatList
+        data={posts}
+        keyExtractor={p => p.post_id}
+        renderItem={({ item }) => (
+          <PostCard
+            post={item}
+            likedByMe={likedSet.has(item.post_id)}
+            onStatsChanged={onStatsChanged}
+            onDeleted={onDeleted}
+          />
+        )}
+        refreshControl={
+          <RefreshControl
+            refreshing={refreshing}
+            onRefresh={() => loadPosts(true)}
+            tintColor="#1d9bf0"
+          />
+        }
+        onViewableItemsChanged={onViewableItemsChanged}
+        viewabilityConfig={viewabilityConfig}
+        ListEmptyComponent={
+          loading ? (
+            <View style={{ paddingTop: 80, alignItems: 'center' }}>
+              <ActivityIndicator color="#1d9bf0" />
+            </View>
+          ) : error ? (
+            <EmptyState
+              icon="alert-circle-outline"
+              title="Не удалось загрузить ленту"
+              subtitle={error}
+              onRetry={() => loadPosts(false)}
+            />
+          ) : (
+            <EmptyState
+              icon="newspaper-outline"
+              title="Здесь пока пусто"
+              subtitle={emptyHint}
+            />
+          )
+        }
+        contentContainerStyle={posts.length === 0 ? { flexGrow: 1 } : undefined}
+      />
+
+      {/* Floating compose button */}
+      <Pressable
+        onPress={() => router.push('/(app)/compose' as never)}
+        style={({ pressed }) => ({
+          position: 'absolute',
+          right: 18,
+          bottom: Math.max(insets.bottom, 12) + 70, // clear the NavBar
+          width: 56, height: 56,
+          borderRadius: 28,
+          backgroundColor: pressed ? '#1a8cd8' : '#1d9bf0',
+          alignItems: 'center', justifyContent: 'center',
+          shadowColor: '#1d9bf0',
+          shadowOffset: { width: 0, height: 4 },
+          shadowOpacity: 0.4,
+          shadowRadius: 8,
+          elevation: 6,
+        })}
+      >
+        <Ionicons name="create-outline" size={24} color="#ffffff" />
+      </Pressable>
+    </View>
+  );
+}
+
+// ── Empty state ─────────────────────────────────────────────────────────
+
+function EmptyState({
+  icon, title, subtitle, onRetry,
+}: {
+  icon: React.ComponentProps<typeof Ionicons>['name'];
+  title: string;
+  subtitle?: string;
+  onRetry?: () => void;
+}) {
+  return (
+    <View style={{
+      flex: 1,
+      alignItems: 'center', justifyContent: 'center',
+      paddingHorizontal: 32, paddingVertical: 80,
+    }}>
+      <View
+        style={{
+          width: 64, height: 64, borderRadius: 16,
+          backgroundColor: '#0a0a0a',
+          borderWidth: 1, borderColor: '#1f1f1f',
+          alignItems: 'center', justifyContent: 'center',
+          marginBottom: 14,
+        }}
+      >
+        <Ionicons name={icon} size={28} color="#6a6a6a" />
+      </View>
+      <Text style={{ color: '#ffffff', fontSize: 16, fontWeight: '700', marginBottom: 6 }}>
+        {title}
+      </Text>
+      {subtitle && (
+        <Text style={{ color: '#8b8b8b', fontSize: 13, textAlign: 'center', lineHeight: 19 }}>
+          {subtitle}
+        </Text>
+      )}
+      {onRetry && (
+        <Pressable
+          onPress={onRetry}
+          style={({ pressed }) => ({
+            marginTop: 16,
+            paddingHorizontal: 20, paddingVertical: 10,
+            borderRadius: 999,
+            backgroundColor: pressed ? '#1a8cd8' : '#1d9bf0',
+          })}
+        >
+          <Text style={{ color: '#ffffff', fontWeight: '700', fontSize: 13 }}>
+            Попробовать снова
+          </Text>
+        </Pressable>
+      )}
+    </View>
+  );
+}
+
+function chunk<T>(arr: T[], size: number): T[][] {
+  const out: T[][] = [];
+  for (let i = 0; i < arr.length; i += size) out.push(arr.slice(i, i + size));
+  return out;
+}