Fixed feed and back gesture issue

.gitignore

@@ -43,4 +43,6 @@ graph/
 # Python / Agent
 
 context.md 
-i-want-you-to-spicy-dusk.md
+i-want-you-to-spicy-dusk.md
+CACHY_OVERVIEW.md
+presenter

app/lib/ui/core/home_shell.dart

@@ -14,7 +14,7 @@ import 'package:provider/provider.dart';
 import '../features/actions/views/actions_screen.dart';
 import '../features/capture/views/capture_sheet.dart';
 import '../features/collections/views/collections_screen.dart';
-import '../features/graph/views/graph_screen.dart';
+import '../features/feed/views/knowledge_feed_screen.dart';
 import '../features/library/view_models/library_view_model.dart';
 import '../features/library/views/library_screen.dart';
 import '../features/profile/views/profile_screen.dart';
@@ -41,7 +41,7 @@ const _navItems = [
   _NavDef(icon: PhosphorIconsRegular.house,      activeIcon: PhosphorIconsFill.house,      label: 'HOME'),
   _NavDef(icon: PhosphorIconsRegular.folder,     activeIcon: PhosphorIconsFill.folder,     label: 'FOLDERS'),
   _NavDef(icon: PhosphorIconsRegular.listChecks, activeIcon: PhosphorIconsFill.listChecks, label: 'TO-DO'),
-  _NavDef(icon: PhosphorIconsRegular.graph,      activeIcon: PhosphorIconsFill.graph,      label: 'GRAPH'),
+  _NavDef(icon: PhosphorIconsRegular.cardsThree, activeIcon: PhosphorIconsFill.cardsThree, label: 'FEED'),
   _NavDef(icon: PhosphorIconsRegular.user,       activeIcon: PhosphorIconsFill.user,       label: 'YOU'),
 ];
 
@@ -61,7 +61,7 @@ class _HomeShellState extends State<HomeShell> {
     LibraryScreen(),     // 0 — HOME
     CollectionsScreen(), // 1 — FOLDERS
     ActionsScreen(),     // 2 — TO-DO
-    GraphScreen(),       // 3 — GRAPH
+    KnowledgeFeedScreen(inShell: true), // 3 — FEED
     ProfileScreen(),     // 4 — YOU
   ];
 

app/lib/ui/core/ios_back_gesture.dart

@@ -0,0 +1,260 @@
+/// A genuine iOS-style interactive back gesture for all platforms.
+///
+/// Unlike a plain "swipe → pop" (which fires instantly with no feedback), this
+/// drives the route's transition animation directly: the top screen tracks your
+/// finger, the previous screen parallax-slides in behind it, and the gesture
+/// commits (pops) or springs back based on how far / how fast you dragged — the
+/// real iOS "back screen" feel.
+///
+/// Adapted from Flutter's private CupertinoPageTransitionsBuilder internals
+/// (flutter/lib/src/cupertino/route.dart), with two deliberate changes:
+///   1. it's used on every platform (the app wants iOS transitions everywhere), and
+///   2. the edge activation zone is a little wider than iOS's 20dp for an easier
+///      grab — but still EDGE-based, so it never fights horizontal content like
+///      the library's tab swipe or horizontal lists.
+library;
+
+import 'dart:math';
+import 'dart:ui' show lerpDouble;
+
+import 'package:flutter/cupertino.dart';
+import 'package:flutter/gestures.dart';
+
+/// Width of the left-edge zone that starts the back gesture. iOS uses ~20; a bit
+/// wider is easier to hit without interfering with centre-screen content.
+const double _kBackGestureWidth = 44.0;
+const double _kMinFlingVelocity = 1.0; // screen widths per second
+const int _kMaxDroppedSwipePageForwardAnimationTime = 800; // ms
+const int _kMaxPageBackAnimationTime = 300; // ms
+
+/// Routes whose back gesture is mid-drag — used to switch the transition to a
+/// linear curve so it tracks the finger 1:1 while dragging.
+final Set<PageRoute<dynamic>> _gesturesInProgress = <PageRoute<dynamic>>{};
+
+class IOSPageTransitionsBuilder extends PageTransitionsBuilder {
+  const IOSPageTransitionsBuilder();
+
+  @override
+  Widget buildTransitions<T>(
+    PageRoute<T> route,
+    BuildContext context,
+    Animation<double> animation,
+    Animation<double> secondaryAnimation,
+    Widget child,
+  ) {
+    return CupertinoPageTransition(
+      primaryRouteAnimation: animation,
+      secondaryRouteAnimation: secondaryAnimation,
+      // Linear (no easing) while the user is actively dragging so the page
+      // stays glued to the finger; eased otherwise.
+      linearTransition: _gesturesInProgress.contains(route),
+      child: _BackGestureDetector<T>(
+        enabledCallback: () => _isPopGestureEnabled<T>(route),
+        onStartPopGesture: () => _startPopGesture<T>(route),
+        child: child,
+      ),
+    );
+  }
+}
+
+bool _isPopGestureEnabled<T>(PageRoute<T> route) {
+  // Can't go back from the first route, or one handling its own pop, or a
+  // fullscreen dialog; and only when the route is settled and idle.
+  if (route.isFirst) return false;
+  if (route.willHandlePopInternally) return false;
+  if (route.popDisposition == RoutePopDisposition.doNotPop) return false;
+  if (route.fullscreenDialog) return false;
+  if (route.animation!.status != AnimationStatus.completed) return false;
+  if (route.secondaryAnimation!.status != AnimationStatus.dismissed) return false;
+  if (_gesturesInProgress.contains(route)) return false;
+  return true;
+}
+
+_BackGestureController<T> _startPopGesture<T>(PageRoute<T> route) {
+  _gesturesInProgress.add(route);
+  return _BackGestureController<T>(
+    navigator: route.navigator!,
+    // The transition animation the route is driven by. Protected on
+    // TransitionRoute, but reading it here mirrors what Cupertino does internally.
+    // ignore: invalid_use_of_protected_member
+    controller: route.controller!,
+    onEnded: () => _gesturesInProgress.remove(route),
+  );
+}
+
+/// Drives the route's [AnimationController] from drag input, then settles it
+/// forward (cancel) or in reverse (pop) on release. Mirrors Cupertino's
+/// `_CupertinoBackGestureController`.
+class _BackGestureController<T> {
+  _BackGestureController({
+    required this.navigator,
+    required this.controller,
+    required this.onEnded,
+  }) {
+    navigator.didStartUserGesture();
+  }
+
+  final AnimationController controller;
+  final NavigatorState navigator;
+  final VoidCallback onEnded;
+
+  /// Fraction of screen width dragged this frame (positive = toward dismiss).
+  void dragUpdate(double delta) {
+    controller.value -= delta;
+  }
+
+  void dragEnd(double velocity) {
+    const Curve animationCurve = Curves.fastLinearToSlowEaseIn;
+
+    final bool animateForward;
+    if (velocity.abs() >= _kMinFlingVelocity) {
+      // A fling: direction wins over position.
+      animateForward = velocity <= 0;
+    } else {
+      // Released: past the halfway point commits the pop.
+      animateForward = controller.value > 0.5;
+    }
+
+    if (animateForward) {
+      final int droppedPageForwardAnimationTime = min(
+        lerpDouble(
+          _kMaxDroppedSwipePageForwardAnimationTime,
+          0,
+          controller.value,
+        )!.floor(),
+        _kMaxPageBackAnimationTime,
+      );
+      controller.animateTo(
+        1.0,
+        duration: Duration(milliseconds: droppedPageForwardAnimationTime),
+        curve: animationCurve,
+      );
+    } else {
+      navigator.pop();
+      if (controller.isAnimating) {
+        final int droppedPageBackAnimationTime = lerpDouble(
+          0,
+          _kMaxDroppedSwipePageForwardAnimationTime,
+          controller.value,
+        )!.floor();
+        controller.animateBack(
+          0.0,
+          duration: Duration(milliseconds: droppedPageBackAnimationTime),
+          curve: animationCurve,
+        );
+      }
+    }
+
+    if (controller.isAnimating) {
+      late AnimationStatusListener animationStatusCallback;
+      animationStatusCallback = (AnimationStatus status) {
+        _finish();
+        controller.removeStatusListener(animationStatusCallback);
+      };
+      controller.addStatusListener(animationStatusCallback);
+    } else {
+      _finish();
+    }
+  }
+
+  void _finish() {
+    onEnded();
+    navigator.didStopUserGesture();
+  }
+}
+
+/// Left-edge drag recognizer that hands input to a [_BackGestureController].
+class _BackGestureDetector<T> extends StatefulWidget {
+  const _BackGestureDetector({
+    required this.enabledCallback,
+    required this.onStartPopGesture,
+    required this.child,
+  });
+
+  final ValueGetter<bool> enabledCallback;
+  final ValueGetter<_BackGestureController<T>> onStartPopGesture;
+  final Widget child;
+
+  @override
+  State<_BackGestureDetector<T>> createState() => _BackGestureDetectorState<T>();
+}
+
+class _BackGestureDetectorState<T> extends State<_BackGestureDetector<T>> {
+  _BackGestureController<T>? _backGestureController;
+  late HorizontalDragGestureRecognizer _recognizer;
+
+  @override
+  void initState() {
+    super.initState();
+    _recognizer = HorizontalDragGestureRecognizer(debugOwner: this)
+      ..onStart = _handleDragStart
+      ..onUpdate = _handleDragUpdate
+      ..onEnd = _handleDragEnd
+      ..onCancel = _handleDragCancel;
+  }
+
+  @override
+  void dispose() {
+    _recognizer.dispose();
+    super.dispose();
+  }
+
+  void _handleDragStart(DragStartDetails details) {
+    _backGestureController = widget.onStartPopGesture();
+  }
+
+  void _handleDragUpdate(DragUpdateDetails details) {
+    _backGestureController?.dragUpdate(
+      _convertToLogical(details.primaryDelta! / context.size!.width),
+    );
+  }
+
+  void _handleDragEnd(DragEndDetails details) {
+    _backGestureController?.dragEnd(
+      _convertToLogical(details.velocity.pixelsPerSecond.dx / context.size!.width),
+    );
+    _backGestureController = null;
+  }
+
+  void _handleDragCancel() {
+    _backGestureController?.dragEnd(0.0);
+    _backGestureController = null;
+  }
+
+  void _handlePointerDown(PointerDownEvent event) {
+    if (widget.enabledCallback()) {
+      _recognizer.addPointer(event);
+    }
+  }
+
+  double _convertToLogical(double value) {
+    return switch (Directionality.of(context)) {
+      TextDirection.rtl => -value,
+      TextDirection.ltr => value,
+    };
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final double dragAreaWidth = Directionality.of(context) == TextDirection.ltr
+        ? MediaQuery.paddingOf(context).left + _kBackGestureWidth
+        : MediaQuery.paddingOf(context).right + _kBackGestureWidth;
+
+    return Stack(
+      fit: StackFit.passthrough,
+      children: [
+        widget.child,
+        PositionedDirectional(
+          start: 0,
+          width: dragAreaWidth,
+          top: 0,
+          bottom: 0,
+          child: Listener(
+            onPointerDown: _handlePointerDown,
+            behavior: HitTestBehavior.translucent,
+          ),
+        ),
+      ],
+    );
+  }
+}

app/lib/ui/core/theme.dart

@@ -5,6 +5,7 @@ library;
 import 'package:flutter/material.dart';
 
 import 'brand.dart';
+import 'ios_back_gesture.dart';
 
 class AppTheme {
   static ThemeData light() => _build(Brightness.light);
@@ -165,59 +166,5 @@ class Insets {
   static const splitPane = 1100.0;
 }
 
-/// Custom transition builder allowing swipe-right-to-go-back from ANYWHERE
-/// on the screen, while preserving iOS slide transitions.
-class IOSPageTransitionsBuilder extends PageTransitionsBuilder {
-  const IOSPageTransitionsBuilder();
-
-  @override
-  Widget buildTransitions<T>(
-    PageRoute<T> route,
-    BuildContext context,
-    Animation<double> animation,
-    Animation<double> secondaryAnimation,
-    Widget child,
-  ) {
-    return const CupertinoPageTransitionsBuilder().buildTransitions<T>(
-      route,
-      context,
-      animation,
-      secondaryAnimation,
-      _SwipeBackGate(child: child),
-    );
-  }
-}
-
-class _SwipeBackGate extends StatefulWidget {
-  const _SwipeBackGate({required this.child});
-  final Widget child;
-
-  @override
-  State<_SwipeBackGate> createState() => _SwipeBackGateState();
-}
-
-class _SwipeBackGateState extends State<_SwipeBackGate> {
-  double _dragDistance = 0;
-
-  @override
-  Widget build(BuildContext context) {
-    return GestureDetector(
-      behavior: HitTestBehavior.translucent,
-      onHorizontalDragStart: (_) => _dragDistance = 0,
-      onHorizontalDragUpdate: (details) {
-        _dragDistance += details.delta.dx;
-      },
-      onHorizontalDragEnd: (details) {
-        final velocity = details.primaryVelocity ?? 0;
-        if ((velocity > 300 || _dragDistance > 70) && _dragDistance > 0) {
-          final nav = Navigator.of(context);
-          if (nav.canPop()) {
-            nav.pop();
-          }
-        }
-        _dragDistance = 0;
-      },
-      child: widget.child,
-    );
-  }
-}
+// The iOS-style interactive back gesture + transition lives in
+// ios_back_gesture.dart (IOSPageTransitionsBuilder), imported above.

app/lib/ui/features/feed/views/knowledge_feed_screen.dart

@@ -8,7 +8,9 @@
 /// not a filing cabinet.
 library;
 
+import 'package:flutter/gestures.dart';
 import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
 import 'package:flutter_animate/flutter_animate.dart';
 import 'package:phosphor_flutter/phosphor_flutter.dart';
 import 'package:provider/provider.dart';
@@ -26,20 +28,25 @@ import '../../reader/views/reader_screen.dart';
 import '../view_models/knowledge_feed_view_model.dart';
 
 class KnowledgeFeedScreen extends StatelessWidget {
-  const KnowledgeFeedScreen({super.key});
+  const KnowledgeFeedScreen({super.key, this.inShell = false});
+
+  /// True when hosted as a bottom-nav tab (vs pushed as its own route): hides the
+  /// close button and pads content clear of the floating nav bar.
+  final bool inShell;
 
   @override
   Widget build(BuildContext context) {
     return ChangeNotifierProvider(
       create: (ctx) =>
           KnowledgeFeedViewModel(repository: ctx.read<CardRepository>())..load(),
-      child: const _FeedView(),
+      child: _FeedView(inShell: inShell),
     );
   }
 }
 
 class _FeedView extends StatefulWidget {
-  const _FeedView();
+  const _FeedView({this.inShell = false});
+  final bool inShell;
 
   @override
   State<_FeedView> createState() => _FeedViewState();
@@ -47,31 +54,80 @@ class _FeedView extends StatefulWidget {
 
 class _FeedViewState extends State<_FeedView> {
   final _controller = PageController();
+  final _focusNode = FocusNode(debugLabel: 'KnowledgeFeed');
   int _page = 0;
 
   @override
   void dispose() {
     _controller.dispose();
+    _focusNode.dispose();
     super.dispose();
   }
 
+  void _goTo(int page, int total) {
+    final target = page.clamp(0, total - 1);
+    if (target == _page || !_controller.hasClients) return;
+    _controller.animateToPage(
+      target,
+      duration: const Duration(milliseconds: 320),
+      curve: Curves.easeOutCubic,
+    );
+  }
+
+  void _next(int total) => _goTo(_page + 1, total);
+  void _prev(int total) => _goTo(_page - 1, total);
+
   @override
   Widget build(BuildContext context) {
     final vm = context.watch<KnowledgeFeedViewModel>();
     final scheme = Theme.of(context).colorScheme;
+    final total = vm.items.length;
+    // Show explicit prev/next controls on pointer-first (wide / web) layouts.
+    final showControls = total > 1 &&
+        MediaQuery.sizeOf(context).width >= Insets.desktop;
 
     return Scaffold(
       backgroundColor: scheme.surface,
-      body: Stack(
-        children: [
-          _content(context, vm),
-          _TopBar(
-            index: _page,
-            total: vm.items.length,
-            onClose: () => Navigator.of(context).maybePop(),
-            onRefresh: vm.loading ? null : vm.refresh,
+      // Keyboard navigation (arrows / page keys) for web + desktop. Focus is
+      // grabbed on hover so keys work without an explicit click, and autofocus
+      // only when pushed as its own route (not as a background shell tab).
+      body: CallbackShortcuts(
+        bindings: {
+          const SingleActivator(LogicalKeyboardKey.arrowDown): () => _next(total),
+          const SingleActivator(LogicalKeyboardKey.arrowUp): () => _prev(total),
+          const SingleActivator(LogicalKeyboardKey.pageDown): () => _next(total),
+          const SingleActivator(LogicalKeyboardKey.pageUp): () => _prev(total),
+          const SingleActivator(LogicalKeyboardKey.arrowRight): () => _next(total),
+          const SingleActivator(LogicalKeyboardKey.arrowLeft): () => _prev(total),
+        },
+        child: Focus(
+          focusNode: _focusNode,
+          autofocus: !widget.inShell,
+          child: MouseRegion(
+            onEnter: (_) {
+              if (!_focusNode.hasFocus) _focusNode.requestFocus();
+            },
+            child: Stack(
+              children: [
+                _content(context, vm),
+                _TopBar(
+                  index: _page,
+                  total: total,
+                  showClose: !widget.inShell,
+                  onClose: () => Navigator.of(context).maybePop(),
+                  onRefresh: vm.loading ? null : vm.refresh,
+                ),
+                if (showControls)
+                  _NavButtons(
+                    canPrev: _page > 0,
+                    canNext: _page < total - 1,
+                    onPrev: () => _prev(total),
+                    onNext: () => _next(total),
+                  ),
+              ],
+            ),
           ),
-        ],
+        ),
       ),
     );
   }
@@ -101,14 +157,106 @@ class _FeedViewState extends State<_FeedView> {
       );
     }
 
-    return PageView.builder(
-      controller: _controller,
-      scrollDirection: Axis.vertical,
-      itemCount: vm.items.length,
-      onPageChanged: (i) => setState(() => _page = i),
-      itemBuilder: (ctx, i) => _MomentPage(
-        item: vm.items[i],
-        showSwipeHint: i == 0 && vm.items.length > 1,
+    // Enable click-drag + trackpad paging in the browser (Flutter disables mouse
+    // drag on scrollables by default), on top of the native touch swipe + wheel.
+    return ScrollConfiguration(
+      behavior: const _FeedScrollBehavior(),
+      child: PageView.builder(
+        controller: _controller,
+        scrollDirection: Axis.vertical,
+        itemCount: vm.items.length,
+        onPageChanged: (i) => setState(() => _page = i),
+        itemBuilder: (ctx, i) => _MomentPage(
+          item: vm.items[i],
+          showSwipeHint: i == 0 && vm.items.length > 1,
+          bottomInset: widget.inShell ? 84 : 0,
+        ),
+      ),
+    );
+  }
+}
+
+/// Lets the vertical feed be dragged with a mouse / trackpad in the browser —
+/// Flutter excludes those pointer kinds from drag-scrolling by default. Touch
+/// swipe and scroll-wheel/trackpad paging keep working alongside this.
+class _FeedScrollBehavior extends MaterialScrollBehavior {
+  const _FeedScrollBehavior();
+
+  @override
+  Set<PointerDeviceKind> get dragDevices => PointerDeviceKind.values.toSet();
+}
+
+/// On-screen previous/next controls, shown on pointer-first (web / desktop)
+/// layouts so mouse users have an obvious affordance beyond swiping.
+class _NavButtons extends StatelessWidget {
+  const _NavButtons({
+    required this.canPrev,
+    required this.canNext,
+    required this.onPrev,
+    required this.onNext,
+  });
+  final bool canPrev;
+  final bool canNext;
+  final VoidCallback onPrev;
+  final VoidCallback onNext;
+
+  @override
+  Widget build(BuildContext context) {
+    return Positioned(
+      right: 16,
+      top: 0,
+      bottom: 0,
+      child: Center(
+        child: Column(
+          mainAxisSize: MainAxisSize.min,
+          children: [
+            _NavButton(
+              icon: PhosphorIconsRegular.caretUp,
+              tooltip: 'Previous',
+              onTap: canPrev ? onPrev : null,
+            ),
+            const SizedBox(height: 12),
+            _NavButton(
+              icon: PhosphorIconsRegular.caretDown,
+              tooltip: 'Next',
+              onTap: canNext ? onNext : null,
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+}
+
+class _NavButton extends StatelessWidget {
+  const _NavButton({required this.icon, required this.onTap, required this.tooltip});
+  final IconData icon;
+  final VoidCallback? onTap;
+  final String tooltip;
+
+  @override
+  Widget build(BuildContext context) {
+    final scheme = Theme.of(context).colorScheme;
+    final enabled = onTap != null;
+    return Tooltip(
+      message: tooltip,
+      child: Material(
+        color: scheme.surfaceContainerHighest.withValues(alpha: enabled ? 0.9 : 0.35),
+        shape: const CircleBorder(),
+        clipBehavior: Clip.antiAlias,
+        child: InkWell(
+          onTap: onTap,
+          child: Padding(
+            padding: const EdgeInsets.all(10),
+            child: PhosphorIcon(
+              icon,
+              size: 20,
+              color: enabled
+                  ? scheme.onSurface
+                  : scheme.onSurfaceVariant.withValues(alpha: 0.4),
+            ),
+          ),
+        ),
       ),
     );
   }
@@ -120,11 +268,13 @@ class _TopBar extends StatelessWidget {
   const _TopBar({
     required this.index,
     required this.total,
+    required this.showClose,
     required this.onClose,
     required this.onRefresh,
   });
   final int index;
   final int total;
+  final bool showClose;
   final VoidCallback onClose;
   final VoidCallback? onRefresh;
 
@@ -136,11 +286,14 @@ class _TopBar extends StatelessWidget {
         padding: const EdgeInsets.symmetric(horizontal: 8, vertical: 4),
         child: Row(
           children: [
-            IconButton(
-              onPressed: onClose,
-              icon: const PhosphorIcon(PhosphorIconsRegular.x),
-              tooltip: 'Close',
-            ),
+            if (showClose)
+              IconButton(
+                onPressed: onClose,
+                icon: const PhosphorIcon(PhosphorIconsRegular.x),
+                tooltip: 'Close',
+              )
+            else
+              const SizedBox(width: 48),
             const Spacer(),
             if (total > 0)
               Text('${index + 1} / $total',
@@ -162,10 +315,13 @@ class _TopBar extends StatelessWidget {
 // ── One moment (a single full-screen page) ──────────────────────────────── //
 
 class _MomentPage extends StatelessWidget {
-  const _MomentPage({required this.item, this.showSwipeHint = false});
+  const _MomentPage({required this.item, this.showSwipeHint = false, this.bottomInset = 0});
   final FeedItem item;
   final bool showSwipeHint;
 
+  /// Extra bottom padding to clear the floating nav bar when hosted as a tab.
+  final double bottomInset;
+
   @override
   Widget build(BuildContext context) {
     final accent = ContentAccent.of(item.card.contentType);
@@ -185,20 +341,36 @@ class _MomentPage extends StatelessWidget {
         ),
       ),
       child: SafeArea(
-        child: Padding(
-          padding: const EdgeInsets.fromLTRB(28, 64, 28, 28),
-          child: Column(
-            crossAxisAlignment: CrossAxisAlignment.start,
-            children: [
-              _Eyebrow(item: item, accent: accent),
-              Expanded(child: _MomentBody(item: item, accent: accent)),
-              _SourceFooter(item: item, accent: accent),
-              if (showSwipeHint) ...[
-                const SizedBox(height: 10),
-                const Center(child: _SwipeHint()),
-              ],
-            ],
-          ),
+        child: LayoutBuilder(
+          builder: (context, constraints) {
+            // Constrain the content to a centered reading column so it doesn't
+            // stretch edge-to-edge on a wide browser window (the gradient stays
+            // full-bleed behind it). Full width on narrow / mobile layouts.
+            final width = constraints.maxWidth > Insets.readingColumn
+                ? Insets.readingColumn
+                : constraints.maxWidth;
+            return Center(
+              child: SizedBox(
+                width: width,
+                height: constraints.maxHeight,
+                child: Padding(
+                  padding: EdgeInsets.fromLTRB(28, 64, 28, 28 + bottomInset),
+                  child: Column(
+                    crossAxisAlignment: CrossAxisAlignment.start,
+                    children: [
+                      _Eyebrow(item: item, accent: accent),
+                      Expanded(child: _MomentBody(item: item, accent: accent)),
+                      _SourceFooter(item: item, accent: accent),
+                      if (showSwipeHint) ...[
+                        const SizedBox(height: 10),
+                        const Center(child: _SwipeHint()),
+                      ],
+                    ],
+                  ),
+                ),
+              ),
+            );
+          },
         ),
       ),
     );

app/lib/ui/features/library/views/library_screen.dart

@@ -31,7 +31,7 @@ import '../../../core/widgets/spot_art.dart';
 import '../../capture/views/capture_sheet.dart';
 import '../../catalog/views/catalog_screen.dart';
 import '../../concepts/views/concepts_screen.dart';
-import '../../feed/views/knowledge_feed_screen.dart';
+import '../../graph/views/graph_screen.dart';
 import '../../library/views/library_chat_screen.dart';
 import '../../reader/views/reader_screen.dart';
 import '../../search/views/search_screen.dart';
@@ -76,10 +76,10 @@ class _LibraryView extends StatelessWidget {
                 ),
               ),
             IconButton(
-              tooltip: 'Feed',
-              icon: const PhosphorIcon(PhosphorIconsRegular.cardsThree),
+              tooltip: 'Graph',
+              icon: const PhosphorIcon(PhosphorIconsRegular.graph),
               onPressed: () => Navigator.of(context).push(
-                MaterialPageRoute(builder: (_) => const KnowledgeFeedScreen()),
+                MaterialPageRoute(builder: (_) => const GraphScreen()),
               ),
             ),
             IconButton(