fix(ui): route paused-row retry through onRetryPaused in SyncErrorsScreen

M3 (round 2): add an optional onRetryPaused callback; the per-row Retry button
now calls it for OutboxState.paused rows (wire to SyncController.retryPaused)
and falls back to onRetry otherwise. Makes the paused-recovery path explicit
at the UI layer. Backward compatible — onRetryPaused is optional.

Author: ankitDhwani

lib/src/ui/screens/sync_errors_screen.dart

@@ -13,9 +13,18 @@ import '../widgets/screen_helpers.dart';
 /// `retryAllRunning` disables per-row Retry buttons (as the engine
 /// drains the queue in priority order) and swaps the header button
 /// from `Retry all` → `Stop`.
+///
+/// For a [OutboxState.paused] row, the per-row Retry uses [onRetryPaused] when
+/// supplied (wire it to `SyncController.retryPaused`) so the paused-row
+/// recovery path is taken explicitly rather than routing through the generic
+/// [onRetry]. When [onRetryPaused] is null, paused rows fall back to [onRetry].
 class SyncErrorsScreen extends StatelessWidget {
   final List<OutboxRow> rows;
   final Future<void> Function(int outboxId) onRetry;
+
+  /// Recovery action for [OutboxState.paused] rows. Optional for backward
+  /// compatibility; falls back to [onRetry] when not provided.
+  final Future<void> Function(int outboxId)? onRetryPaused;
   final Future<void> Function() onRetryAll;
   final Future<void> Function() onStop;
   final void Function(OutboxRow) onOpen;
@@ -26,13 +35,22 @@ class SyncErrorsScreen extends StatelessWidget {
     super.key,
     required this.rows,
     required this.onRetry,
+    this.onRetryPaused,
     required this.onRetryAll,
     required this.onStop,
     required this.onOpen,
     required this.onViewError,
     required this.retryAllRunning,
   });
 
+  /// Routes a row's per-row Retry to the state-appropriate action.
+  Future<void> _retryRow(OutboxRow r) {
+    if (r.state == OutboxState.paused && onRetryPaused != null) {
+      return onRetryPaused!(r.id);
+    }
+    return onRetry(r.id);
+  }
+
   @override
   Widget build(BuildContext context) {
     final byDoctype = <String, List<OutboxRow>>{};
@@ -78,7 +96,7 @@ class SyncErrorsScreen extends StatelessWidget {
                                 ? null
                                 : () => _runAndSurface(
                                     context,
-                                    () => onRetry(r.id),
+                                    () => _retryRow(r),
                                     'Retry',
                                   ),
                             child: const Text('Retry'),

test/ui/sync_errors_screen_test.dart

@@ -3,12 +3,17 @@ import 'package:flutter_test/flutter_test.dart';
 import 'package:frappe_mobile_sdk/src/models/outbox_row.dart';
 import 'package:frappe_mobile_sdk/src/ui/screens/sync_errors_screen.dart';
 
-OutboxRow row(int id, String doctype, ErrorCode code) => OutboxRow(
+OutboxRow row(
+  int id,
+  String doctype,
+  ErrorCode code, {
+  OutboxState state = OutboxState.failed,
+}) => OutboxRow(
   id: id,
   doctype: doctype,
   mobileUuid: '$id',
   operation: OutboxOperation.insert,
-  state: OutboxState.failed,
+  state: state,
   errorCode: code,
   retryCount: 1,
   errorMessage: 'msg',
@@ -59,6 +64,64 @@ void main() {
     expect(tapped, 1);
   });
 
+  testWidgets(
+    'paused row routes Retry to onRetryPaused; failed row uses onRetry (M3)',
+    (tester) async {
+      int? retried;
+      int? retriedPaused;
+      await tester.pumpWidget(
+        MaterialApp(
+          home: SyncErrorsScreen(
+            rows: [
+              row(1, 'X', ErrorCode.VALIDATION, state: OutboxState.paused),
+              row(2, 'X', ErrorCode.NETWORK),
+            ],
+            onRetry: (id) async => retried = id,
+            onRetryPaused: (id) async => retriedPaused = id,
+            onRetryAll: () async {},
+            onStop: () async {},
+            onOpen: (_) {},
+            onViewError: (_) {},
+            retryAllRunning: false,
+          ),
+        ),
+      );
+      final retryButtons = find.widgetWithText(OutlinedButton, 'Retry');
+      // Row order follows insertion: paused row 1 first, failed row 2 second.
+      await tester.tap(retryButtons.at(0));
+      await tester.pump();
+      expect(retriedPaused, 1, reason: 'paused row must use onRetryPaused');
+      expect(retried, isNull);
+
+      await tester.tap(retryButtons.at(1));
+      await tester.pump();
+      expect(retried, 2, reason: 'non-paused row must use onRetry');
+    },
+  );
+
+  testWidgets(
+    'paused row falls back to onRetry when onRetryPaused is not provided (M3)',
+    (tester) async {
+      int? retried;
+      await tester.pumpWidget(
+        MaterialApp(
+          home: SyncErrorsScreen(
+            rows: [row(7, 'X', ErrorCode.VALIDATION, state: OutboxState.paused)],
+            onRetry: (id) async => retried = id,
+            onRetryAll: () async {},
+            onStop: () async {},
+            onOpen: (_) {},
+            onViewError: (_) {},
+            retryAllRunning: false,
+          ),
+        ),
+      );
+      await tester.tap(find.widgetWithText(OutlinedButton, 'Retry'));
+      await tester.pump();
+      expect(retried, 7);
+    },
+  );
+
   testWidgets('per-row Retry disabled while retry-all is running', (
     tester,
   ) async {