feat: collapsible threads

lib/src/features/thread/application/thread_collapse_state.dart

···
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+
+part 'thread_collapse_state.g.dart';
+
+/// Manages collapse/expand state for thread posts.
+///
+/// State is session-only and keyed by post URI. Posts are expanded by default.
+@riverpod
+class ThreadCollapseState extends _$ThreadCollapseState {
+  @override
+  Map<String, bool> build() => {};
+
+  /// Check if a post is collapsed.
+  ///
+  /// Returns false (expanded) if post URI is not in the map.
+  bool isCollapsed(String postUri) => state[postUri] ?? false;
+
+  /// Toggle collapse state for a post.
+  void toggle(String postUri) {
+    state = {...state, postUri: !(state[postUri] ?? false)};
+  }
+
+  /// Collapse all posts in the provided list.
+  void collapseAll(List<String> uris) {
+    final newState = {...state};
+    for (final uri in uris) {
+      newState[uri] = true;
+    }
+    state = newState;
+  }
+
+  /// Expand all posts (clear all collapse state).
+  void expandAll() {
+    state = {};
+  }
+
+  /// Collapse a specific post.
+  void collapse(String postUri) {
+    state = {...state, postUri: true};
+  }
+
+  /// Expand a specific post.
+  void expand(String postUri) {
+    state = {...state, postUri: false};
+  }
+}

lib/src/features/thread/application/thread_collapse_state.g.dart

···
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'thread_collapse_state.dart';
+
+// **************************************************************************
+// RiverpodGenerator
+// **************************************************************************
+
+// GENERATED CODE - DO NOT MODIFY BY HAND
+// ignore_for_file: type=lint, type=warning
+/// Manages collapse/expand state for thread posts.
+///
+/// State is session-only and keyed by post URI. Posts are expanded by default.
+
+@ProviderFor(ThreadCollapseState)
+final threadCollapseStateProvider = ThreadCollapseStateProvider._();
+
+/// Manages collapse/expand state for thread posts.
+///
+/// State is session-only and keyed by post URI. Posts are expanded by default.
+final class ThreadCollapseStateProvider
+    extends $NotifierProvider<ThreadCollapseState, Map<String, bool>> {
+  /// Manages collapse/expand state for thread posts.
+  ///
+  /// State is session-only and keyed by post URI. Posts are expanded by default.
+  ThreadCollapseStateProvider._()
+    : super(
+        from: null,
+        argument: null,
+        retry: null,
+        name: r'threadCollapseStateProvider',
+        isAutoDispose: true,
+        dependencies: null,
+        $allTransitiveDependencies: null,
+      );
+
+  @override
+  String debugGetCreateSourceHash() => _$threadCollapseStateHash();
+
+  @$internal
+  @override
+  ThreadCollapseState create() => ThreadCollapseState();
+
+  /// {@macro riverpod.override_with_value}
+  Override overrideWithValue(Map<String, bool> value) {
+    return $ProviderOverride(
+      origin: this,
+      providerOverride: $SyncValueProvider<Map<String, bool>>(value),
+    );
+  }
+}
+
+String _$threadCollapseStateHash() => r'e68ffefdf271e20807ee067a302979b277f3ad5a';
+
+/// Manages collapse/expand state for thread posts.
+///
+/// State is session-only and keyed by post URI. Posts are expanded by default.
+
+abstract class _$ThreadCollapseState extends $Notifier<Map<String, bool>> {
+  Map<String, bool> build();
+  @$mustCallSuper
+  @override
+  void runBuild() {
+    final ref = this.ref as $Ref<Map<String, bool>, Map<String, bool>>;
+    final element =
+        ref.element
+            as $ClassProviderElement<
+              AnyNotifier<Map<String, bool>, Map<String, bool>>,
+              Map<String, bool>,
+              Object?,
+              Object?
+            >;
+    element.handleCreate(ref, build);
+  }
+}

lib/src/features/thread/application/thread_providers.dart

···
 
 import '../infrastructure/thread_repository.dart';
 
+export 'thread_collapse_state.dart';
+
 part 'thread_providers.g.dart';
 
 @riverpod

lib/src/features/thread/domain/thread_layout_calculator.dart

···
+import 'package:lazurite/src/features/thread/domain/thread.dart';
+
+/// Utility class for thread layout calculations.
+///
+/// Provides constants and methods for computing indentation, connector
+/// positioning, and depth management for nested thread rendering.
+class ThreadLayoutCalculator {
+  ThreadLayoutCalculator._();
+
+  /// Base indentation for depth 0 posts
+  static const double baseIndent = 0.0;
+
+  /// Additional indentation per nesting level
+  static const double indentPerLevel = 32.0;
+
+  /// Maximum depth before flattening
+  static const int maxDepth = 5;
+
+  /// Avatar radius in pixels
+  static const double avatarRadius = 20.0;
+
+  /// Offset from left edge to avatar center
+  static const double avatarCenterOffset = 20.0;
+
+  /// Calculate left padding for a post at given depth.
+  ///
+  /// Depth is clamped to [maxDepth] to prevent infinite horizontal scrolling.
+  static double calculateIndent(int depth) {
+    final effectiveDepth = depth.clamp(0, maxDepth);
+    return baseIndent + (effectiveDepth * indentPerLevel);
+  }
+
+  /// Calculate connector line position for a given depth.
+  ///
+  /// Positions the connector at the avatar center, accounting for indentation.
+  static double calculateConnectorLeft(int depth) {
+    return calculateIndent(depth) + avatarCenterOffset;
+  }
+
+  /// Determine if depth should be flattened.
+  ///
+  /// Returns true if depth exceeds [maxDepth], indicating that further
+  /// nesting should be prevented to maintain readability.
+  static bool shouldFlattenDepth(int depth) {
+    return depth > maxDepth;
+  }
+
+  /// Calculate effective depth (accounts for max depth flattening).
+  ///
+  /// Returns the actual depth value that should be used for rendering,
+  /// clamped to [maxDepth].
+  static int calculateEffectiveDepth(int actualDepth) {
+    return actualDepth.clamp(0, maxDepth);
+  }
+
+  /// Get parent context for deep threads.
+  ///
+  /// Returns a string like "@username" to show which post this is replying to
+  /// when depth is flattened.
+  static String getParentContext(ThreadViewPost post) {
+    if (post.parent == null) return '';
+    final handle = post.parent!.post.author.handle;
+    return '@$handle';
+  }
+
+  /// Count total number of replies (including nested).
+  ///
+  /// Recursively counts all descendants of a post.
+  static int countAllReplies(ThreadViewPost post) {
+    var count = post.replies.length;
+    for (final reply in post.replies) {
+      count += countAllReplies(reply);
+    }
+    return count;
+  }
+}

lib/src/features/thread/presentation/thread_screen.dart

···
 import 'package:lazurite/src/features/thread/application/thread_notifier.dart';
 import 'package:lazurite/src/features/thread/application/thread_providers.dart';
 import 'package:lazurite/src/features/thread/domain/thread.dart';
+import 'package:lazurite/src/features/thread/domain/thread_layout_calculator.dart';
 import 'package:lazurite/src/features/thread/presentation/widgets/blocked_post_card.dart';
+import 'package:lazurite/src/features/thread/presentation/widgets/collapsed_reply_preview.dart';
 import 'package:lazurite/src/features/thread/presentation/widgets/not_found_post_card.dart';
 import 'package:lazurite/src/features/thread/presentation/widgets/thread_line_connector.dart';
+import 'package:lazurite/src/features/thread/presentation/widgets/thread_reply_item.dart';
 import 'package:lazurite/src/features/thread/presentation/widgets/threadgate_indicator.dart';
 import 'package:lazurite/src/infrastructure/db/daos/feed_content_dao.dart';
 
···
             tooltip: _flattenedView ? 'Switch to Tree View' : 'Switch to Flattened View',
             onPressed: () => setState(() => _flattenedView = !_flattenedView),
           ),
+          if (!_flattenedView)
+            threadAsync.maybeWhen(
+              data: (thread) => PopupMenuButton<String>(
+                icon: const Icon(Icons.more_vert),
+                tooltip: 'Thread options',
+                onSelected: (value) {
+                  if (value == 'collapse_all') {
+                    _collapseAllReplies(thread);
+                  } else if (value == 'expand_all') {
+                    ref.read(threadCollapseStateProvider.notifier).expandAll();
+                  }
+                },
+                itemBuilder: (context) => [
+                  const PopupMenuItem(
+                    value: 'collapse_all',
+                    child: Row(
+                      children: [
+                        Icon(Icons.unfold_less),
+                        SizedBox(width: 12),
+                        Text('Collapse all replies'),
+                      ],
+                    ),
+                  ),
+                  const PopupMenuItem(
+                    value: 'expand_all',
+                    child: Row(
+                      children: [
+                        Icon(Icons.unfold_more),
+                        SizedBox(width: 12),
+                        Text('Expand all replies'),
+                      ],
+                    ),
+                  ),
+                ],
+              ),
+              orElse: () => const SizedBox.shrink(),
+            ),
         ],
       ),
       body: threadAsync.when(
···
         SliverList(
           delegate: SliverChildBuilderDelegate((context, index) {
             final reply = sortedReplies[index];
-            final position = _getThreadLinePosition(
-              index: index,
-              total: sortedReplies.length,
-              isParentChain: false,
+            return _buildReplyTree(
+              reply,
+              depth: 1,
+              isLastSibling: index == sortedReplies.length - 1,
             );
-            return _buildThreadPost(reply, position: position, isReply: true);
           }, childCount: sortedReplies.length),
         ),
       ],
···
       current = current.parent!;
     }
     return list.reversed.toList();
+  }
+
+  /// Collects all reply URIs for collapse/expand all
+  void _collapseAllReplies(ThreadViewPost thread) {
+    final uris = <String>[];
+    void collectUris(ThreadViewPost post) {
+      if (post.replies.isNotEmpty) {
+        uris.add(post.post.uri);
+        for (final reply in post.replies) {
+          collectUris(reply);
+        }
+      }
+    }
+
+    for (final reply in thread.replies) {
+      collectUris(reply);
+    }
+
+    ref.read(threadCollapseStateProvider.notifier).collapseAll(uris);
+  }
+
+  /// Recursively builds reply tree with nesting and collapse support
+  Widget _buildReplyTree(ThreadViewPost post, {required int depth, bool isLastSibling = false}) {
+    final isCollapsed = ref.watch(
+      threadCollapseStateProvider.select((state) => state[post.post.uri] ?? false),
+    );
+
+    return Column(
+      crossAxisAlignment: CrossAxisAlignment.start,
+      children: [
+        ThreadReplyItem(
+          post: post,
+          depth: depth,
+          isCollapsed: isCollapsed,
+          onToggleCollapse: () {
+            ref.read(threadCollapseStateProvider.notifier).toggle(post.post.uri);
+          },
+          isLastSibling: isLastSibling,
+          hasMoreSiblings: !isLastSibling,
+        ),
+
+        if (!isCollapsed && post.replies.isNotEmpty)
+          ...post.replies.asMap().entries.map((entry) {
+            final index = entry.key;
+            final reply = entry.value;
+            return _buildReplyTree(
+              reply,
+              depth: depth + 1,
+              isLastSibling: index == post.replies.length - 1,
+            );
+          }),
+
+        if (isCollapsed && post.replies.isNotEmpty)
+          CollapsedReplyPreview(
+            firstReply: post.replies.first,
+            totalCount: ThreadLayoutCalculator.countAllReplies(post),
+            onExpand: () {
+              ref.read(threadCollapseStateProvider.notifier).toggle(post.post.uri);
+            },
+            indent: ThreadLayoutCalculator.calculateIndent(depth),
+          ),
+      ],
+    );
   }
 
   /// Helper to flatten replies purely for the list

lib/src/features/thread/presentation/widgets/collapse_toggle.dart

···
+import 'package:flutter/material.dart';
+
+/// A collapsible toggle button with triangle icon and reply count badge.
+///
+/// Displays a triangle icon that rotates 90 degrees when collapsed (pointing right)
+/// vs expanded (pointing down). Shows a reply count badge when provided.
+class CollapseToggle extends StatelessWidget {
+  const CollapseToggle({
+    required this.isCollapsed,
+    required this.onTap,
+    this.replyCount = 0,
+    this.showCount = false,
+    super.key,
+  });
+
+  /// Whether the associated thread is currently collapsed
+  final bool isCollapsed;
+
+  /// Callback when toggle is tapped
+  final VoidCallback onTap;
+
+  /// Number of replies (for badge display)
+  final int replyCount;
+
+  /// Whether to show the reply count badge
+  final bool showCount;
+
+  @override
+  Widget build(BuildContext context) {
+    final theme = Theme.of(context);
+    final colorScheme = theme.colorScheme;
+
+    return InkWell(
+      onTap: onTap,
+      borderRadius: BorderRadius.circular(4),
+      child: Padding(
+        padding: const EdgeInsets.all(4),
+        child: Row(
+          mainAxisSize: MainAxisSize.min,
+          children: [
+            AnimatedRotation(
+              turns: isCollapsed ? -0.25 : 0, // -90° when collapsed, 0° when expanded
+              duration: const Duration(milliseconds: 200),
+              child: Icon(Icons.play_arrow, size: 16, color: colorScheme.onSurfaceVariant),
+            ),
+            if (showCount && replyCount > 0) ...[
+              const SizedBox(width: 4),
+              Container(
+                padding: const EdgeInsets.symmetric(horizontal: 6, vertical: 2),
+                decoration: BoxDecoration(
+                  color: colorScheme.secondaryContainer,
+                  borderRadius: BorderRadius.circular(10),
+                ),
+                child: Text(
+                  replyCount.toString(),
+                  style: theme.textTheme.labelSmall?.copyWith(
+                    color: colorScheme.onSecondaryContainer,
+                    fontSize: 10,
+                    fontWeight: FontWeight.w600,
+                  ),
+                ),
+              ),
+            ],
+          ],
+        ),
+      ),
+    );
+  }
+}

lib/src/features/thread/presentation/widgets/collapsed_reply_preview.dart

···
+import 'dart:convert';
+
+import 'package:flutter/material.dart';
+import 'package:lazurite/src/features/thread/domain/thread.dart';
+
+/// Shows a preview of collapsed replies.
+///
+/// Displays the first reply's text (truncated) and total reply count,
+/// similar to Reddit's collapsed thread preview.
+class CollapsedReplyPreview extends StatelessWidget {
+  const CollapsedReplyPreview({
+    required this.firstReply,
+    required this.totalCount,
+    required this.onExpand,
+    required this.indent,
+    super.key,
+  });
+
+  /// First reply to show preview from
+  final ThreadViewPost firstReply;
+
+  /// Total number of all nested replies
+  final int totalCount;
+
+  /// Callback when preview is tapped to expand
+  final VoidCallback onExpand;
+
+  /// Left indent for alignment with parent
+  final double indent;
+
+  @override
+  Widget build(BuildContext context) {
+    final theme = Theme.of(context);
+    final colorScheme = theme.colorScheme;
+
+    final previewText = _extractPreviewText(firstReply, maxLength: 100);
+    final authorHandle = firstReply.post.author.handle;
+
+    return InkWell(
+      onTap: onExpand,
+      child: Container(
+        margin: EdgeInsets.only(left: indent + 24, right: 8, top: 4, bottom: 8),
+        padding: const EdgeInsets.all(12),
+        decoration: BoxDecoration(
+          color: colorScheme.surfaceContainerHighest.withValues(alpha: 0.5),
+          borderRadius: BorderRadius.circular(8),
+          border: Border.all(color: colorScheme.outlineVariant, width: 1),
+        ),
+        child: Column(
+          crossAxisAlignment: CrossAxisAlignment.start,
+          children: [
+            Row(
+              children: [
+                Icon(Icons.unfold_more, size: 16, color: colorScheme.onSurfaceVariant),
+                const SizedBox(width: 8),
+                Expanded(
+                  child: Text(
+                    '@$authorHandle: $previewText',
+                    style: theme.textTheme.bodySmall?.copyWith(
+                      color: colorScheme.onSurfaceVariant,
+                    ),
+                    maxLines: 2,
+                    overflow: TextOverflow.ellipsis,
+                  ),
+                ),
+              ],
+            ),
+
+            const SizedBox(height: 4),
+            Text(
+              _formatReplyCount(totalCount),
+              style: theme.textTheme.labelSmall?.copyWith(
+                color: colorScheme.primary,
+                fontWeight: FontWeight.w600,
+              ),
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+
+  String _extractPreviewText(ThreadViewPost post, {int maxLength = 100}) {
+    if (post.isBlocked) return 'Blocked post';
+    if (post.isNotFound) return 'Post not found';
+
+    try {
+      final record = jsonDecode(post.post.record['text'] as String? ?? '{}');
+      if (record is String) {
+        final text = record.trim();
+        if (text.length <= maxLength) return text;
+        return '${text.substring(0, maxLength)}...';
+      }
+    } catch (_) {
+      /* Failed to parse, try direct text access */
+    }
+
+    final text = (post.post.record['text'] as String? ?? '').trim();
+    if (text.isEmpty) return 'No preview available';
+
+    if (text.length <= maxLength) return text;
+    return '${text.substring(0, maxLength)}...';
+  }
+
+  String _formatReplyCount(int count) {
+    if (count == 1) return '1 reply hidden';
+    return '$count replies hidden';
+  }
+}

lib/src/features/thread/presentation/widgets/deep_thread_indicator.dart

···
+import 'package:flutter/material.dart';
+
+/// Indicator shown when thread depth exceeds maximum nesting level.
+///
+/// Displays parent context (e.g., "Replying to @username") to maintain
+/// conversation context when nesting is flattened.
+class DeepThreadIndicator extends StatelessWidget {
+  const DeepThreadIndicator({required this.parentHandle, super.key});
+
+  /// Handle of the parent post author
+  final String parentHandle;
+
+  @override
+  Widget build(BuildContext context) {
+    if (parentHandle.isEmpty) {
+      return const SizedBox.shrink();
+    }
+
+    final theme = Theme.of(context);
+    final colorScheme = theme.colorScheme;
+
+    return Container(
+      margin: const EdgeInsets.only(top: 4, bottom: 8, right: 8),
+      padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 6),
+      decoration: BoxDecoration(
+        color: colorScheme.secondaryContainer.withValues(alpha: 0.5),
+        borderRadius: BorderRadius.circular(4),
+        border: Border.all(color: colorScheme.outline.withValues(alpha: 0.3), width: 1),
+      ),
+      child: Row(
+        mainAxisSize: MainAxisSize.min,
+        children: [
+          Icon(Icons.subdirectory_arrow_right, size: 14, color: colorScheme.onSecondaryContainer),
+          const SizedBox(width: 6),
+          Text(
+            'Replying to @$parentHandle',
+            style: theme.textTheme.labelSmall?.copyWith(
+              color: colorScheme.onSecondaryContainer,
+              fontStyle: FontStyle.italic,
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+}

lib/src/features/thread/presentation/widgets/thread_curved_connector.dart

···
+import 'package:flutter/material.dart';
+
+/// Style of connector line to render.
+enum ConnectorStyle {
+  /// Parent to child connection with curve (for posts with children)
+  parentToChild,
+
+  /// Straight vertical line (for middle siblings in a chain)
+  continuation,
+
+  /// Terminal line ending at post (for last child or childless post)
+  terminal,
+}
+
+/// A curved connector widget for thread relationships with rust-analyzer style.
+///
+/// Renders smooth bezier curves connecting posts at different nesting levels,
+/// providing visual hierarchy similar to rust-analyzer error displays.
+class ThreadCurvedConnector extends StatelessWidget {
+  const ThreadCurvedConnector({
+    required this.style,
+    required this.depth,
+    this.width = 2,
+    this.color,
+    this.height,
+    super.key,
+  });
+
+  /// Style of connector to render
+  final ConnectorStyle style;
+
+  /// Current nesting depth (used for positioning calculations)
+  final int depth;
+
+  /// Width of the connector line
+  final double width;
+
+  /// Color of the connector line (defaults to theme divider color)
+  final Color? color;
+
+  /// Explicit height (if null, uses constraints)
+  final double? height;
+
+  @override
+  Widget build(BuildContext context) {
+    final lineColor = color ?? Theme.of(context).dividerColor;
+
+    return CustomPaint(
+      size: Size(width, height ?? double.infinity),
+      painter: _ThreadCurvedConnectorPainter(
+        color: lineColor,
+        strokeWidth: width,
+        style: style,
+        depth: depth,
+      ),
+    );
+  }
+}
+
+class _ThreadCurvedConnectorPainter extends CustomPainter {
+  _ThreadCurvedConnectorPainter({
+    required this.color,
+    required this.strokeWidth,
+    required this.style,
+    required this.depth,
+  });
+
+  final Color color;
+  final double strokeWidth;
+  final ConnectorStyle style;
+  final int depth;
+
+  @override
+  void paint(Canvas canvas, Size size) {
+    final paint = Paint()
+      ..color = color
+      ..strokeWidth = strokeWidth
+      ..style = PaintingStyle.stroke
+      ..strokeCap = StrokeCap.round;
+
+    final centerX = size.width / 2;
+    const curveOffset = 32.0;
+
+    switch (style) {
+      case ConnectorStyle.parentToChild:
+        final curveStartY = size.height * 0.3;
+        canvas.drawLine(Offset(centerX, 0), Offset(centerX, curveStartY), paint);
+
+        final path = Path()
+          ..moveTo(centerX, curveStartY)
+          ..quadraticBezierTo(centerX, size.height * 0.5, centerX + curveOffset, size.height * 0.7)
+          ..lineTo(centerX + curveOffset, size.height);
+
+        canvas.drawPath(path, paint);
+
+      case ConnectorStyle.continuation:
+        canvas.drawLine(Offset(centerX, 0), Offset(centerX, size.height), paint);
+
+      case ConnectorStyle.terminal:
+        final endY = size.height * 0.3;
+        canvas.drawLine(Offset(centerX, 0), Offset(centerX, endY), paint);
+        canvas.drawLine(Offset(centerX, endY), Offset(centerX + 20, endY), paint);
+    }
+  }
+
+  @override
+  bool shouldRepaint(covariant _ThreadCurvedConnectorPainter oldDelegate) {
+    return oldDelegate.color != color ||
+        oldDelegate.strokeWidth != strokeWidth ||
+        oldDelegate.style != style ||
+        oldDelegate.depth != depth;
+  }
+}

lib/src/features/thread/presentation/widgets/thread_reply_item.dart

···
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:lazurite/src/features/feeds/presentation/screens/widgets/feed_post_card.dart';
+import 'package:lazurite/src/features/thread/domain/thread.dart';
+import 'package:lazurite/src/features/thread/domain/thread_layout_calculator.dart';
+import 'package:lazurite/src/features/thread/presentation/widgets/blocked_post_card.dart';
+import 'package:lazurite/src/features/thread/presentation/widgets/collapse_toggle.dart';
+import 'package:lazurite/src/features/thread/presentation/widgets/deep_thread_indicator.dart';
+import 'package:lazurite/src/features/thread/presentation/widgets/not_found_post_card.dart';
+import 'package:lazurite/src/features/thread/presentation/widgets/thread_curved_connector.dart';
+
+/// A recursive reply item widget that renders nested thread replies.
+///
+/// Handles indentation based on depth, collapse/expand state, and renders
+/// child replies recursively.
+class ThreadReplyItem extends ConsumerWidget {
+  const ThreadReplyItem({
+    required this.post,
+    required this.depth,
+    required this.isCollapsed,
+    required this.onToggleCollapse,
+    this.isLastSibling = false,
+    this.hasMoreSiblings = false,
+    super.key,
+  });
+
+  /// The thread post to render
+  final ThreadViewPost post;
+
+  /// Current nesting depth (0-based)
+  final int depth;
+
+  /// Whether this post's replies are collapsed
+  final bool isCollapsed;
+
+  /// Callback when collapse toggle is tapped
+  final VoidCallback onToggleCollapse;
+
+  /// Whether this is the last sibling in its parent's reply list
+  final bool isLastSibling;
+
+  /// Whether there are more siblings after this one
+  final bool hasMoreSiblings;
+
+  @override
+  Widget build(BuildContext context, WidgetRef ref) {
+    final indent = ThreadLayoutCalculator.calculateIndent(depth);
+    final shouldFlatten = ThreadLayoutCalculator.shouldFlattenDepth(depth);
+    final hasReplies = post.replies.isNotEmpty;
+    final connectorStyle = _determineConnectorStyle(hasReplies, isLastSibling);
+
+    return Column(
+      crossAxisAlignment: CrossAxisAlignment.start,
+      children: [
+        if (shouldFlatten && depth > 0)
+          Padding(
+            padding: EdgeInsets.only(left: indent),
+            child: DeepThreadIndicator(
+              parentHandle: post.parent != null ? post.parent!.post.author.handle : '',
+            ),
+          ),
+
+        Stack(
+          children: [
+            if (depth > 0)
+              Positioned(
+                left: ThreadLayoutCalculator.calculateConnectorLeft(depth - 1),
+                top: 0,
+                bottom: hasMoreSiblings ? 0 : null,
+                height: hasMoreSiblings ? null : 60,
+                child: ThreadCurvedConnector(style: connectorStyle, depth: depth),
+              ),
+
+            Padding(
+              padding: EdgeInsets.only(left: indent),
+              child: Row(
+                crossAxisAlignment: CrossAxisAlignment.start,
+                children: [
+                  if (hasReplies)
+                    CollapseToggle(
+                      isCollapsed: isCollapsed,
+                      onTap: onToggleCollapse,
+                      replyCount: ThreadLayoutCalculator.countAllReplies(post),
+                      showCount: isCollapsed,
+                    )
+                  else
+                    const SizedBox(width: 24),
+                  Expanded(child: _buildPostCard()),
+                ],
+              ),
+            ),
+          ],
+        ),
+      ],
+    );
+  }
+
+  Widget _buildPostCard() {
+    if (post.isBlocked) {
+      return const BlockedPostCard();
+    }
+
+    if (post.isNotFound) {
+      return const NotFoundPostCard();
+    }
+
+    return FeedPostCard(item: post.post.toFeedPost());
+  }
+
+  ConnectorStyle _determineConnectorStyle(bool hasReplies, bool isLast) {
+    if (hasReplies && !isCollapsed) {
+      return ConnectorStyle.parentToChild;
+    }
+    if (isLast) {
+      return ConnectorStyle.terminal;
+    }
+    return ConnectorStyle.continuation;
+  }
+}

test/src/features/thread/application/thread_collapse_state_test.dart

···
+import 'package:flutter_test/flutter_test.dart';
+import 'package:lazurite/src/features/thread/application/thread_collapse_state.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+
+void main() {
+  group('ThreadCollapseState', () {
+    late ProviderContainer container;
+
+    setUp(() {
+      container = ProviderContainer();
+    });
+
+    tearDown(() {
+      container.dispose();
+    });
+
+    test('initial state is empty map', () {
+      final state = container.read(threadCollapseStateProvider);
+      expect(state, isEmpty);
+    });
+
+    group('isCollapsed', () {
+      test('returns false for posts not in state', () {
+        final notifier = container.read(threadCollapseStateProvider.notifier);
+        expect(notifier.isCollapsed('at://user/post/1'), false);
+      });
+
+      test('returns true for collapsed posts', () {
+        final notifier = container.read(threadCollapseStateProvider.notifier);
+        notifier.collapse('at://user/post/1');
+        expect(notifier.isCollapsed('at://user/post/1'), true);
+      });
+
+      test('returns false for expanded posts', () {
+        final notifier = container.read(threadCollapseStateProvider.notifier);
+        notifier.expand('at://user/post/1');
+        expect(notifier.isCollapsed('at://user/post/1'), false);
+      });
+    });
+
+    group('toggle', () {
+      test('collapses expanded post', () {
+        final notifier = container.read(threadCollapseStateProvider.notifier);
+        notifier.toggle('at://user/post/1');
+        expect(notifier.isCollapsed('at://user/post/1'), true);
+      });
+
+      test('expands collapsed post', () {
+        final notifier = container.read(threadCollapseStateProvider.notifier);
+        notifier.collapse('at://user/post/1');
+        notifier.toggle('at://user/post/1');
+        expect(notifier.isCollapsed('at://user/post/1'), false);
+      });
+
+      test('toggles multiple posts independently', () {
+        final notifier = container.read(threadCollapseStateProvider.notifier);
+        notifier.toggle('at://user/post/1');
+        notifier.toggle('at://user/post/2');
+
+        expect(notifier.isCollapsed('at://user/post/1'), true);
+        expect(notifier.isCollapsed('at://user/post/2'), true);
+
+        notifier.toggle('at://user/post/1');
+        expect(notifier.isCollapsed('at://user/post/1'), false);
+        expect(notifier.isCollapsed('at://user/post/2'), true);
+      });
+    });
+
+    group('collapse', () {
+      test('collapses post', () {
+        final notifier = container.read(threadCollapseStateProvider.notifier);
+        notifier.collapse('at://user/post/1');
+        expect(notifier.isCollapsed('at://user/post/1'), true);
+      });
+
+      test('keeps post collapsed when called multiple times', () {
+        final notifier = container.read(threadCollapseStateProvider.notifier);
+        notifier.collapse('at://user/post/1');
+        notifier.collapse('at://user/post/1');
+        expect(notifier.isCollapsed('at://user/post/1'), true);
+      });
+    });
+
+    group('expand', () {
+      test('expands post', () {
+        final notifier = container.read(threadCollapseStateProvider.notifier);
+        notifier.collapse('at://user/post/1');
+        notifier.expand('at://user/post/1');
+        expect(notifier.isCollapsed('at://user/post/1'), false);
+      });
+
+      test('keeps post expanded when called multiple times', () {
+        final notifier = container.read(threadCollapseStateProvider.notifier);
+        notifier.expand('at://user/post/1');
+        notifier.expand('at://user/post/1');
+        expect(notifier.isCollapsed('at://user/post/1'), false);
+      });
+    });
+
+    group('collapseAll', () {
+      test('collapses all posts in list', () {
+        final notifier = container.read(threadCollapseStateProvider.notifier);
+        notifier.collapseAll(['at://user/post/1', 'at://user/post/2', 'at://user/post/3']);
+
+        expect(notifier.isCollapsed('at://user/post/1'), true);
+        expect(notifier.isCollapsed('at://user/post/2'), true);
+        expect(notifier.isCollapsed('at://user/post/3'), true);
+      });
+
+      test('preserves state of posts not in list', () {
+        final notifier = container.read(threadCollapseStateProvider.notifier);
+        notifier.collapse('at://user/post/existing');
+
+        notifier.collapseAll(['at://user/post/1', 'at://user/post/2']);
+
+        expect(notifier.isCollapsed('at://user/post/existing'), true);
+        expect(notifier.isCollapsed('at://user/post/1'), true);
+        expect(notifier.isCollapsed('at://user/post/2'), true);
+      });
+
+      test('handles empty list', () {
+        final notifier = container.read(threadCollapseStateProvider.notifier);
+        notifier.collapse('at://user/post/1');
+        notifier.collapseAll([]);
+
+        expect(notifier.isCollapsed('at://user/post/1'), true);
+      });
+    });
+
+    group('expandAll', () {
+      test('clears all collapse state', () {
+        final notifier = container.read(threadCollapseStateProvider.notifier);
+        notifier.collapseAll(['at://user/post/1', 'at://user/post/2', 'at://user/post/3']);
+
+        notifier.expandAll();
+
+        expect(notifier.isCollapsed('at://user/post/1'), false);
+        expect(notifier.isCollapsed('at://user/post/2'), false);
+        expect(notifier.isCollapsed('at://user/post/3'), false);
+      });
+
+      test('works when state is already empty', () {
+        final notifier = container.read(threadCollapseStateProvider.notifier);
+        notifier.expandAll();
+
+        final state = container.read(threadCollapseStateProvider);
+        expect(state, isEmpty);
+      });
+    });
+
+    test('state updates trigger rebuilds', () {
+      var buildCount = 0;
+      container.listen(threadCollapseStateProvider, (previous, next) => buildCount++);
+
+      final notifier = container.read(threadCollapseStateProvider.notifier);
+
+      notifier.toggle('at://user/post/1');
+      expect(buildCount, 1);
+
+      notifier.collapse('at://user/post/2');
+      expect(buildCount, 2);
+
+      notifier.expandAll();
+      expect(buildCount, 3);
+    });
+  });
+}

test/src/features/thread/domain/thread_layout_calculator_test.dart

···
+import 'package:flutter_test/flutter_test.dart';
+import 'package:lazurite/src/features/thread/domain/thread.dart';
+import 'package:lazurite/src/features/thread/domain/thread_layout_calculator.dart';
+
+void main() {
+  group('ThreadLayoutCalculator', () {
+    group('calculateIndent', () {
+      test('returns 0 for depth 0', () {
+        expect(ThreadLayoutCalculator.calculateIndent(0), 0.0);
+      });
+
+      test('calculates indent for various depths', () {
+        expect(ThreadLayoutCalculator.calculateIndent(1), 32.0);
+        expect(ThreadLayoutCalculator.calculateIndent(2), 64.0);
+        expect(ThreadLayoutCalculator.calculateIndent(3), 96.0);
+        expect(ThreadLayoutCalculator.calculateIndent(4), 128.0);
+        expect(ThreadLayoutCalculator.calculateIndent(5), 160.0);
+      });
+
+      test('clamps indent at maxDepth', () {
+        expect(ThreadLayoutCalculator.calculateIndent(6), 160.0);
+        expect(ThreadLayoutCalculator.calculateIndent(10), 160.0);
+        expect(ThreadLayoutCalculator.calculateIndent(100), 160.0);
+      });
+
+      test('handles negative depth gracefully', () {
+        expect(ThreadLayoutCalculator.calculateIndent(-1), 0.0);
+        expect(ThreadLayoutCalculator.calculateIndent(-10), 0.0);
+      });
+    });
+
+    group('calculateConnectorLeft', () {
+      test('positions connector at avatar center for depth 0', () {
+        expect(
+          ThreadLayoutCalculator.calculateConnectorLeft(0),
+          20.0, // 0 + avatarCenterOffset
+        );
+      });
+
+      test('calculates connector position relative to indent', () {
+        expect(
+          ThreadLayoutCalculator.calculateConnectorLeft(1),
+          52.0, // 32 + 20
+        );
+        expect(
+          ThreadLayoutCalculator.calculateConnectorLeft(2),
+          84.0, // 64 + 20
+        );
+        expect(
+          ThreadLayoutCalculator.calculateConnectorLeft(3),
+          116.0, // 96 + 20
+        );
+      });
+
+      test('clamps connector position at maxDepth', () {
+        final maxConnectorLeft = ThreadLayoutCalculator.calculateConnectorLeft(
+          ThreadLayoutCalculator.maxDepth,
+        );
+        expect(ThreadLayoutCalculator.calculateConnectorLeft(10), maxConnectorLeft);
+      });
+    });
+
+    group('shouldFlattenDepth', () {
+      test('returns false for depths within maxDepth', () {
+        expect(ThreadLayoutCalculator.shouldFlattenDepth(0), false);
+        expect(ThreadLayoutCalculator.shouldFlattenDepth(3), false);
+        expect(ThreadLayoutCalculator.shouldFlattenDepth(5), false);
+      });
+
+      test('returns true for depths exceeding maxDepth', () {
+        expect(ThreadLayoutCalculator.shouldFlattenDepth(6), true);
+        expect(ThreadLayoutCalculator.shouldFlattenDepth(10), true);
+        expect(ThreadLayoutCalculator.shouldFlattenDepth(100), true);
+      });
+    });
+
+    group('calculateEffectiveDepth', () {
+      test('returns actual depth when within bounds', () {
+        expect(ThreadLayoutCalculator.calculateEffectiveDepth(0), 0);
+        expect(ThreadLayoutCalculator.calculateEffectiveDepth(3), 3);
+        expect(ThreadLayoutCalculator.calculateEffectiveDepth(5), 5);
+      });
+
+      test('clamps to maxDepth when exceeding', () {
+        expect(ThreadLayoutCalculator.calculateEffectiveDepth(6), ThreadLayoutCalculator.maxDepth);
+        expect(
+          ThreadLayoutCalculator.calculateEffectiveDepth(10),
+          ThreadLayoutCalculator.maxDepth,
+        );
+      });
+
+      test('clamps to 0 for negative depths', () {
+        expect(ThreadLayoutCalculator.calculateEffectiveDepth(-1), 0);
+      });
+    });
+
+    group('getParentContext', () {
+      test('returns empty string when no parent', () {
+        final post = _createThreadViewPost(handle: 'user1');
+        expect(ThreadLayoutCalculator.getParentContext(post), '');
+      });
+
+      test('returns parent handle with @ prefix', () {
+        final parent = _createThreadViewPost(handle: 'parentuser');
+        final post = _createThreadViewPost(handle: 'user1', parent: parent);
+        expect(ThreadLayoutCalculator.getParentContext(post), '@parentuser');
+      });
+    });
+
+    group('countAllReplies', () {
+      test('returns 0 for post with no replies', () {
+        final post = _createThreadViewPost(handle: 'user1');
+        expect(ThreadLayoutCalculator.countAllReplies(post), 0);
+      });
+
+      test('counts direct replies', () {
+        final post = _createThreadViewPost(
+          handle: 'user1',
+          replies: [
+            _createThreadViewPost(handle: 'reply1'),
+            _createThreadViewPost(handle: 'reply2'),
+            _createThreadViewPost(handle: 'reply3'),
+          ],
+        );
+        expect(ThreadLayoutCalculator.countAllReplies(post), 3);
+      });
+
+      test('counts nested replies recursively', () {
+        final post = _createThreadViewPost(
+          handle: 'user1',
+          replies: [
+            _createThreadViewPost(
+              handle: 'reply1',
+              replies: [
+                _createThreadViewPost(handle: 'nested1'),
+                _createThreadViewPost(handle: 'nested2'),
+              ],
+            ),
+            _createThreadViewPost(
+              handle: 'reply2',
+              replies: [_createThreadViewPost(handle: 'nested3')],
+            ),
+          ],
+        );
+
+        expect(ThreadLayoutCalculator.countAllReplies(post), 5);
+      });
+
+      test('counts deeply nested replies', () {
+        final deepPost = _createThreadViewPost(
+          handle: 'root',
+          replies: [
+            _createThreadViewPost(
+              handle: 'level1',
+              replies: [
+                _createThreadViewPost(
+                  handle: 'level2',
+                  replies: [
+                    _createThreadViewPost(
+                      handle: 'level3',
+                      replies: [_createThreadViewPost(handle: 'level4')],
+                    ),
+                  ],
+                ),
+              ],
+            ),
+          ],
+        );
+
+        expect(ThreadLayoutCalculator.countAllReplies(deepPost), 4);
+      });
+    });
+  });
+}
+
+/// Helper to create test ThreadViewPost instances
+ThreadViewPost _createThreadViewPost({
+  required String handle,
+  ThreadViewPost? parent,
+  List<ThreadViewPost>? replies,
+}) {
+  return ThreadViewPost(
+    post: ThreadPost(
+      uri: 'at://$handle/post',
+      cid: 'cid-$handle',
+      author: ThreadAuthor(did: 'did:$handle', handle: handle),
+      record: {'text': 'Test post'},
+    ),
+    parent: parent,
+    replies: replies ?? [],
+  );
+}

test/src/features/thread/presentation/widgets/collapse_toggle_test.dart

···
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:lazurite/src/features/thread/presentation/widgets/collapse_toggle.dart';
+
+void main() {
+  group('CollapseToggle', () {
+    testWidgets('renders with expanded state', (tester) async {
+      var tapped = false;
+
+      await tester.pumpWidget(
+        MaterialApp(
+          home: Scaffold(body: CollapseToggle(isCollapsed: false, onTap: () => tapped = true)),
+        ),
+      );
+
+      expect(find.byType(CollapseToggle), findsOneWidget);
+      expect(find.byType(Icon), findsOneWidget);
+      expect(find.byIcon(Icons.play_arrow), findsOneWidget);
+
+      await tester.tap(find.byType(CollapseToggle));
+      await tester.pump();
+
+      expect(tapped, true);
+    });
+
+    testWidgets('renders with collapsed state', (tester) async {
+      await tester.pumpWidget(
+        MaterialApp(
+          home: Scaffold(body: CollapseToggle(isCollapsed: true, onTap: () {})),
+        ),
+      );
+
+      expect(find.byType(CollapseToggle), findsOneWidget);
+      expect(find.byIcon(Icons.play_arrow), findsOneWidget);
+    });
+
+    testWidgets('shows reply count badge when showCount is true', (tester) async {
+      await tester.pumpWidget(
+        MaterialApp(
+          home: Scaffold(
+            body: CollapseToggle(isCollapsed: false, onTap: () {}, replyCount: 5, showCount: true),
+          ),
+        ),
+      );
+
+      expect(find.text('5'), findsOneWidget);
+    });
+
+    testWidgets('hides reply count badge when showCount is false', (tester) async {
+      await tester.pumpWidget(
+        MaterialApp(
+          home: Scaffold(
+            body: CollapseToggle(
+              isCollapsed: false,
+              onTap: () {},
+              replyCount: 5,
+              showCount: false,
+            ),
+          ),
+        ),
+      );
+
+      expect(find.text('5'), findsNothing);
+    });
+
+    testWidgets('hides badge when replyCount is 0', (tester) async {
+      await tester.pumpWidget(
+        MaterialApp(
+          home: Scaffold(
+            body: CollapseToggle(isCollapsed: false, onTap: () {}, replyCount: 0, showCount: true),
+          ),
+        ),
+      );
+
+      expect(find.byType(Container), findsNothing);
+    });
+
+    testWidgets('icon rotates when toggling collapse state', (tester) async {
+      var isCollapsed = false;
+
+      await tester.pumpWidget(
+        MaterialApp(
+          home: Scaffold(
+            body: StatefulBuilder(
+              builder: (context, setState) {
+                return CollapseToggle(
+                  isCollapsed: isCollapsed,
+                  onTap: () => setState(() => isCollapsed = !isCollapsed),
+                );
+              },
+            ),
+          ),
+        ),
+      );
+
+      var rotation = tester.widget<AnimatedRotation>(find.byType(AnimatedRotation));
+      expect(rotation.turns, 0);
+
+      await tester.tap(find.byType(CollapseToggle));
+      await tester.pump();
+
+      rotation = tester.widget<AnimatedRotation>(find.byType(AnimatedRotation));
+      expect(rotation.turns, -0.25);
+    });
+
+    testWidgets('displays different reply counts', (tester) async {
+      for (final count in [1, 10, 100, 999]) {
+        await tester.pumpWidget(
+          MaterialApp(
+            home: Scaffold(
+              body: CollapseToggle(
+                isCollapsed: false,
+                onTap: () {},
+                replyCount: count,
+                showCount: true,
+              ),
+            ),
+          ),
+        );
+
+        expect(find.text(count.toString()), findsOneWidget);
+      }
+    });
+  });
+}

test/src/features/thread/presentation/widgets/thread_curved_connector_test.dart

···
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:lazurite/src/features/thread/presentation/widgets/thread_curved_connector.dart';
+
+void main() {
+  group('ThreadCurvedConnector', () {
+    testWidgets('renders with parentToChild style', (tester) async {
+      await tester.pumpWidget(
+        const MaterialApp(
+          home: Scaffold(
+            body: SizedBox(
+              width: 100,
+              height: 200,
+              child: ThreadCurvedConnector(style: ConnectorStyle.parentToChild, depth: 1),
+            ),
+          ),
+        ),
+      );
+
+      expect(find.byType(ThreadCurvedConnector), findsOneWidget);
+    });
+
+    testWidgets('renders with continuation style', (tester) async {
+      await tester.pumpWidget(
+        const MaterialApp(
+          home: Scaffold(
+            body: SizedBox(
+              width: 100,
+              height: 200,
+              child: ThreadCurvedConnector(style: ConnectorStyle.continuation, depth: 2),
+            ),
+          ),
+        ),
+      );
+
+      expect(find.byType(ThreadCurvedConnector), findsOneWidget);
+    });
+
+    testWidgets('renders with terminal style', (tester) async {
+      await tester.pumpWidget(
+        const MaterialApp(
+          home: Scaffold(
+            body: SizedBox(
+              width: 100,
+              height: 200,
+              child: ThreadCurvedConnector(style: ConnectorStyle.terminal, depth: 3),
+            ),
+          ),
+        ),
+      );
+
+      expect(find.byType(ThreadCurvedConnector), findsOneWidget);
+    });
+
+    testWidgets('uses custom color when provided', (tester) async {
+      const customColor = Colors.red;
+
+      await tester.pumpWidget(
+        const MaterialApp(
+          home: Scaffold(
+            body: SizedBox(
+              width: 100,
+              height: 200,
+              child: ThreadCurvedConnector(
+                style: ConnectorStyle.parentToChild,
+                depth: 1,
+                color: customColor,
+              ),
+            ),
+          ),
+        ),
+      );
+
+      final connector = tester.widget<ThreadCurvedConnector>(find.byType(ThreadCurvedConnector));
+      expect(connector.color, customColor);
+    });
+
+    testWidgets('uses custom width when provided', (tester) async {
+      const customWidth = 4.0;
+
+      await tester.pumpWidget(
+        const MaterialApp(
+          home: Scaffold(
+            body: SizedBox(
+              width: 100,
+              height: 200,
+              child: ThreadCurvedConnector(
+                style: ConnectorStyle.parentToChild,
+                depth: 1,
+                width: customWidth,
+              ),
+            ),
+          ),
+        ),
+      );
+
+      final connector = tester.widget<ThreadCurvedConnector>(find.byType(ThreadCurvedConnector));
+      expect(connector.width, customWidth);
+    });
+
+    testWidgets('accepts different depth values', (tester) async {
+      for (var depth = 0; depth <= 5; depth++) {
+        await tester.pumpWidget(
+          MaterialApp(
+            home: Scaffold(
+              body: SizedBox(
+                width: 100,
+                height: 200,
+                child: ThreadCurvedConnector(style: ConnectorStyle.parentToChild, depth: depth),
+              ),
+            ),
+          ),
+        );
+
+        final connector = tester.widget<ThreadCurvedConnector>(find.byType(ThreadCurvedConnector));
+        expect(connector.depth, depth);
+      }
+    });
+  });
+}

test/src/features/thread/presentation/widgets/thread_reply_item_test.dart

···
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:lazurite/src/features/thread/domain/thread.dart';
+import 'package:lazurite/src/features/thread/presentation/widgets/thread_reply_item.dart';
+
+void main() {
+  group('ThreadReplyItem', () {
+    testWidgets('renders post at depth 0', (tester) async {
+      final post = _createThreadViewPost(handle: 'user1');
+
+      await tester.pumpWidget(
+        ProviderScope(
+          child: MaterialApp(
+            home: Scaffold(
+              body: ThreadReplyItem(
+                post: post,
+                depth: 0,
+                isCollapsed: false,
+                onToggleCollapse: () {},
+              ),
+            ),
+          ),
+        ),
+      );
+
+      expect(find.byType(ThreadReplyItem), findsOneWidget);
+    });
+
+    testWidgets('renders post with replies shows collapse toggle', (tester) async {
+      final post = _createThreadViewPost(
+        handle: 'user1',
+        replies: [
+          _createThreadViewPost(handle: 'reply1'),
+          _createThreadViewPost(handle: 'reply2'),
+        ],
+      );
+
+      await tester.pumpWidget(
+        ProviderScope(
+          child: MaterialApp(
+            home: Scaffold(
+              body: ThreadReplyItem(
+                post: post,
+                depth: 0,
+                isCollapsed: false,
+                onToggleCollapse: () {},
+              ),
+            ),
+          ),
+        ),
+      );
+
+      expect(find.byType(ThreadReplyItem), findsOneWidget);
+    });
+
+    testWidgets('renders post without replies shows no toggle', (tester) async {
+      final post = _createThreadViewPost(handle: 'user1');
+
+      await tester.pumpWidget(
+        ProviderScope(
+          child: MaterialApp(
+            home: Scaffold(
+              body: ThreadReplyItem(
+                post: post,
+                depth: 0,
+                isCollapsed: false,
+                onToggleCollapse: () {},
+              ),
+            ),
+          ),
+        ),
+      );
+
+      expect(find.byType(ThreadReplyItem), findsOneWidget);
+    });
+
+    testWidgets('renders at different depth levels', (tester) async {
+      for (var depth = 0; depth <= 5; depth++) {
+        final post = _createThreadViewPost(handle: 'user$depth');
+
+        await tester.pumpWidget(
+          ProviderScope(
+            child: MaterialApp(
+              home: Scaffold(
+                body: ThreadReplyItem(
+                  post: post,
+                  depth: depth,
+                  isCollapsed: false,
+                  onToggleCollapse: () {},
+                ),
+              ),
+            ),
+          ),
+        );
+
+        final item = tester.widget<ThreadReplyItem>(find.byType(ThreadReplyItem));
+        expect(item.depth, depth);
+      }
+    });
+
+    testWidgets('shows deep thread indicator when depth exceeds max', (tester) async {
+      final parent = _createThreadViewPost(handle: 'parent');
+      final post = _createThreadViewPost(handle: 'user1', parent: parent);
+
+      await tester.pumpWidget(
+        ProviderScope(
+          child: MaterialApp(
+            home: Scaffold(
+              body: ThreadReplyItem(
+                post: post,
+                depth: 6, // Exceeds MAX_DEPTH of 5
+                isCollapsed: false,
+                onToggleCollapse: () {},
+              ),
+            ),
+          ),
+        ),
+      );
+
+      expect(find.text('Replying to @parent'), findsOneWidget);
+    });
+
+    testWidgets('renders blocked post card', (tester) async {
+      final post = _createThreadViewPost(handle: 'user1', isBlocked: true);
+
+      await tester.pumpWidget(
+        ProviderScope(
+          child: MaterialApp(
+            home: Scaffold(
+              body: ThreadReplyItem(
+                post: post,
+                depth: 0,
+                isCollapsed: false,
+                onToggleCollapse: () {},
+              ),
+            ),
+          ),
+        ),
+      );
+
+      expect(find.byType(ThreadReplyItem), findsOneWidget);
+    });
+
+    testWidgets('renders not found post card', (tester) async {
+      final post = _createThreadViewPost(handle: 'user1', isNotFound: true);
+
+      await tester.pumpWidget(
+        ProviderScope(
+          child: MaterialApp(
+            home: Scaffold(
+              body: ThreadReplyItem(
+                post: post,
+                depth: 0,
+                isCollapsed: false,
+                onToggleCollapse: () {},
+              ),
+            ),
+          ),
+        ),
+      );
+
+      expect(find.byType(ThreadReplyItem), findsOneWidget);
+    });
+  });
+}
+
+ThreadViewPost _createThreadViewPost({
+  required String handle,
+  ThreadViewPost? parent,
+  List<ThreadViewPost>? replies,
+  bool isBlocked = false,
+  bool isNotFound = false,
+}) {
+  return ThreadViewPost(
+    post: ThreadPost(
+      uri: 'at://$handle/post',
+      cid: 'cid-$handle',
+      author: ThreadAuthor(did: 'did:$handle', handle: handle),
+      record: {'text': 'Test post from $handle'},
+    ),
+    parent: parent,
+    replies: replies ?? [],
+    isBlocked: isBlocked,
+    isNotFound: isNotFound,
+  );
+}