Resume Feature Implementation

assets/styles.css

@@ -130,21 +130,55 @@
 }
 
 .progress-details code {
-  background: #f8f9fa;
-  border: 1px solid #e9ecef;
-  border-radius: 4px;
+  background-color: #f8f9fa;
   padding: 2px 6px;
-  font-family: 'SF Mono', Monaco, 'Cascadia Code', 'Roboto Mono', Consolas, 'Courier New', monospace;
+  border-radius: 4px;
   font-size: 11px;
-  letter-spacing: 0.5px;
   color: #495057;
+  border: 1px solid #dee2e6;
+}
+
+/* Progress Position Styles */
+.progress-position {
+  margin-top: 8px;
+  padding: 8px 12px;
+  background: linear-gradient(135deg, #f0f8ff 0%, #e6f3ff 100%);
+  border: 1px solid #b3d9ff;
+  border-radius: 6px;
+  font-size: 13px;
+  color: #0066cc;
+  text-align: center;
+  font-weight: 500;
+}
+
+.progress-position strong {
+  color: #004499;
 }
 
 .remaining-items {
   color: #6c757d;
+  font-size: 12px;
   font-style: italic;
 }
 
+/* Position Info Styles */
+.position-info {
+  background: linear-gradient(135deg, #e3f2fd 0%, #bbdefb 100%);
+  border: 1px solid #90caf9;
+  border-radius: 8px;
+  padding: 12px 16px;
+  margin: 8px 0;
+  box-shadow: 0 2px 6px rgba(33, 150, 243, 0.15);
+  font-family: 'SF Mono', Monaco, 'Cascadia Code', 'Roboto Mono', Consolas, 'Courier New', monospace;
+  text-align: center;
+  color: #1565c0;
+  font-weight: 500;
+}
+
+.position-info strong {
+  color: #0d47a1;
+}
+
 @keyframes pulse {
   0%, 100% { transform: scale(1); }
   50% { transform: scale(1.1); }
@@ -179,4 +213,16 @@
   .remaining-items {
     color: #adb5bd;
   }
+
+  /* Dark mode support for position info */
+  .position-info {
+    background: linear-gradient(135deg, #1e3a5f 0%, #1e4d7b 100%);
+    border-color: #1976d2;
+    color: #90caf9;
+    box-shadow: 0 2px 6px rgba(33, 150, 243, 0.3);
+  }
+  
+  .position-info strong {
+    color: #64b5f6;
+  }
 }

components/review_dashboard_page.py

@@ -3,7 +3,7 @@
 import gradio as gr
 import datetime
 import sentry_sdk
-from sqlalchemy import orm
+from sqlalchemy import orm, func
 
 from components.header import Header
 from utils.logger import Logger
@@ -26,6 +26,10 @@ class ReviewDashboardPage:
             # Review info banner
             with gr.Row():
                 self.review_info = gr.Markdown("", elem_classes="review-banner")
+            
+            # Position info display
+            with gr.Row():
+                self.position_info = gr.Markdown("", elem_classes="position-info")
 
             with gr.Row():
                 # Left Column - Review Content
@@ -68,6 +72,7 @@ class ReviewDashboardPage:
                             min_width=120
                         )
                         self.btn_jump = gr.Button("Go to ID", min_width=70)
+                        self.btn_jump_to_unreviewed = gr.Button("🎯 Jump to Unreviewed", min_width=150, variant="secondary")
 
                 # Right Column - Audio
                 with gr.Column(scale=2):
@@ -100,7 +105,8 @@ class ReviewDashboardPage:
             # List of interactive UI elements for enabling/disabling
             self.interactive_ui_elements = [
                 self.btn_prev, self.btn_next, self.btn_approve, self.btn_reject, 
-                self.btn_skip, self.btn_jump, self.jump_data_id_input, self.btn_load_voice
+                self.btn_skip, self.btn_jump, self.jump_data_id_input, self.btn_load_voice,
+                self.btn_jump_to_unreviewed
             ]
 
     def register_callbacks(self, login_page, session_state: gr.State, root_blocks: gr.Blocks):
@@ -171,13 +177,8 @@ class ReviewDashboardPage:
                         validation_status += f" ({validation.description})"
             
             # For deleted annotations, show special status
-            if is_deleted:
-                if validation_status == "Not Reviewed":
-                    validation_status = "Not Reviewed (Deleted)"
-                elif validation_status == "Approved":
-                    validation_status = "Approved (Deleted)"
-                elif validation_status.startswith("Rejected"):
-                    validation_status = f"Rejected (Deleted{validation_status[8:] if validation_status[8:] else ''})"
+            if is_deleted and validation_status == "Not Reviewed":
+                validation_status = "Not Reviewed (Deleted)"
                 
             return validation_status, is_deleted
 
@@ -223,6 +224,19 @@ class ReviewDashboardPage:
                         Validation.validator_id == user_id
                     ).count()
                     
+                    # Find the first unreviewed item to show current position
+                    first_unreviewed_query = db.query(Annotation.id).outerjoin(
+                        Validation, 
+                        (Annotation.id == Validation.annotation_id) & 
+                        (Validation.validator_id == user_id)
+                    ).filter(
+                        Annotation.annotator_id == target_annotator_obj.id,
+                        Validation.id.is_(None)  # No validation record exists for this reviewer
+                    ).order_by(Annotation.id).limit(1)
+                    
+                    first_unreviewed_result = first_unreviewed_query.first()
+                    current_position = "Completed" if not first_unreviewed_result else f"ID: {first_unreviewed_result.id}"
+                    
                     if total_count > 0:
                         percentage = (reviewed_count / total_count) * 100
                         
@@ -254,7 +268,7 @@ class ReviewDashboardPage:
                         # Estimate remaining items
                         remaining = total_count - reviewed_count
                         
-                        # Create the beautiful progress display
+                        # Create the beautiful progress display with current position
                         progress_html = f"""
                         <div class="progress-container">
                             <div class="progress-header">
@@ -272,6 +286,9 @@ class ReviewDashboardPage:
                                 📊 <code>{progress_bar}</code> 
                                 <span class="remaining-items">({remaining} remaining)</span>
                             </div>
+                            <div class="progress-position">
+                                🎯 <strong>Current Position:</strong> {current_position}
+                            </div>
                         </div>
                         """
                         
@@ -283,18 +300,64 @@ class ReviewDashboardPage:
                     log.error(f"Error calculating review progress for user {user_id}: {e}")
                     return f"⚠️ **Error calculating progress**"
 
+        def get_current_item_position_info(items, current_idx, session):
+            """Get information about the current item's position in the review queue"""
+            if not items or current_idx >= len(items):
+                return ""
+                
+            user_id = session.get("user_id")
+            username = session.get("username")
+            if not user_id or not username:
+                return ""
+                
+            # Find target annotator
+            target_annotator = None
+            for annotator_name, reviewer_name in conf.REVIEW_MAPPING.items():
+                if reviewer_name == username:
+                    target_annotator = annotator_name
+                    break
+                    
+            if not target_annotator:
+                return ""
+                
+            with get_db() as db:
+                try:
+                    # Get target annotator's ID
+                    target_annotator_obj = db.query(Annotator).filter_by(name=target_annotator).first()
+                    if not target_annotator_obj:
+                        return ""
+                    
+                    # Get total count
+                    total_count = db.query(Annotation).filter(
+                        Annotation.annotator_id == target_annotator_obj.id
+                    ).count()
+                    
+                    # Get current item's position in the overall sequence
+                    current_item_id = items[current_idx]["annotation_id"]
+                    position_query = db.query(func.count(Annotation.id)).filter(
+                        Annotation.annotator_id == target_annotator_obj.id,
+                        Annotation.id <= current_item_id
+                    )
+                    current_position = position_query.scalar() or 0
+                    
+                    return f"📍 **Position:** {current_position} of {total_count} items"
+                    
+                except Exception as e:
+                    log.error(f"Error getting current item position: {e}")
+                    return ""
+
         def load_review_items_fn(session):
             user_id = session.get("user_id")
             username = session.get("username")
             
             if not user_id or not username:
                 log.warning("load_review_items_fn: user not found in session")
-                return [], 0, "", "", "", "", "", "", "", "", gr.update(value=None, autoplay=False), gr.update(visible=False, value=""), False, gr.update(value="❌ Reject")
+                return [], 0, "", "", "", "", "", "", "", "", gr.update(value=None, autoplay=False), gr.update(visible=False, value=""), False, gr.update(value="❌ Reject"), ""
 
             # Check if user is in Phase 2 (should be a reviewer)
             if username not in conf.REVIEW_MAPPING.values():
                 log.warning(f"User {username} is not assigned as a reviewer")
-                return [], 0, "", "", "", "", "", "", "", "", gr.update(value=None, autoplay=False), gr.update(visible=False, value=""), False, gr.update(value="❌ Reject")
+                return [], 0, "", "", "", "", "", "", "", "", gr.update(value=None, autoplay=False), gr.update(visible=False, value=""), False, gr.update(value="❌ Reject"), ""
 
             # Find which annotator this user should review
             target_annotator = None
@@ -305,7 +368,7 @@ class ReviewDashboardPage:
 
             if not target_annotator:
                 log.warning(f"No target annotator found for reviewer {username}")
-                return [], 0, "", "", "", "", "", "", "", "", gr.update(value=None, autoplay=False), gr.update(visible=False, value=""), False, gr.update(value="❌ Reject")
+                return [], 0, "", "", "", "", "", "", "", "", gr.update(value=None, autoplay=False), gr.update(visible=False, value=""), False, gr.update(value="❌ Reject"), ""
 
             # Load annotations from target annotator with FAST INITIAL LOADING
             with get_db() as db:
@@ -313,33 +376,99 @@ class ReviewDashboardPage:
                 target_annotator_obj = db.query(Annotator).filter_by(name=target_annotator).first()
                 if not target_annotator_obj:
                     log.error(f"Target annotator {target_annotator} not found in database")
-                    return [], 0, f"Review Target Error: Annotator '{target_annotator}' not found.", "", "", "", "", "", "", "", gr.update(value=None, autoplay=False), gr.update(visible=False, value=""), False, gr.update(value="❌ Reject")
+                    return [], 0, f"Review Target Error: Annotator '{target_annotator}' not found.", "", "", "", "", "", "", "", gr.update(value=None, autoplay=False), gr.update(visible=False, value=""), False, gr.update(value="❌ Reject"), ""
                 
                 log.info(f"Found target annotator with ID: {target_annotator_obj.id}")
 
-                # FAST INITIAL QUERY: Load only essential data without complex validation processing
-                # Reduced batch size for instant loading in HuggingFace spaces
-                INITIAL_BATCH_SIZE = 5  # Load only 5 items initially for instant response
-                
-                # Simple query to get basic annotation data quickly
-                initial_query = db.query(
-                    Annotation,
-                    TTSData.filename,
-                    TTSData.sentence
-                ).join(
-                    TTSData, Annotation.tts_data_id == TTSData.id
-                ).filter(
-                    Annotation.annotator_id == target_annotator_obj.id
-                ).order_by(Annotation.id).limit(INITIAL_BATCH_SIZE)
-
-                initial_results = initial_query.all()
-                
                 # Get total count for progress info (this is fast)
                 total_count = db.query(Annotation).filter(
                     Annotation.annotator_id == target_annotator_obj.id
                 ).count()
 
-                log.info(f"Fast initial load: {len(initial_results)} annotations out of {total_count} total for target annotator ID {target_annotator_obj.id}")
+                # RESUME LOGIC: Find the first unreviewed item by this reviewer
+                # Query to find the first unreviewed annotation for this reviewer
+                first_unreviewed_query = db.query(
+                    Annotation.id,
+                    Annotation.tts_data_id,
+                    Annotation.annotated_sentence,
+                    Annotation.annotated_at
+                ).outerjoin(
+                    Validation, 
+                    (Annotation.id == Validation.annotation_id) & 
+                    (Validation.validator_id == user_id)
+                ).filter(
+                    Annotation.annotator_id == target_annotator_obj.id,
+                    Validation.id.is_(None)  # No validation record exists for this reviewer
+                ).order_by(Annotation.id).limit(1)
+
+                first_unreviewed_result = first_unreviewed_query.first()
+                
+                if first_unreviewed_result:
+                    # Found unreviewed item - start from there
+                    first_unreviewed_id = first_unreviewed_result.id
+                    log.info(f"Found first unreviewed item with ID: {first_unreviewed_id}")
+                    
+                    # Load items starting from the unreviewed item
+                    # Load a batch around the unreviewed item for context
+                    BATCH_SIZE = 10
+                    offset = max(0, first_unreviewed_id - 5)  # Start 5 items before the unreviewed item
+                    
+                    # Query to get items around the unreviewed item
+                    items_query = db.query(
+                        Annotation,
+                        TTSData.filename,
+                        TTSData.sentence
+                    ).join(
+                        TTSData, Annotation.tts_data_id == TTSData.id
+                    ).filter(
+                        Annotation.annotator_id == target_annotator_obj.id,
+                        Annotation.id >= offset
+                    ).order_by(Annotation.id).limit(BATCH_SIZE)
+                    
+                    initial_results = items_query.all()
+                    
+                    # Find the index of the first unreviewed item in our loaded batch
+                    initial_idx = 0
+                    for i, (annotation, filename, sentence) in enumerate(initial_results):
+                        if annotation.id == first_unreviewed_id:
+                            initial_idx = i
+                            break
+                    
+                    log.info(f"Resuming at first unreviewed item, index: {initial_idx} (ID: {first_unreviewed_id})")
+                else:
+                    # No unreviewed items found - all items have been reviewed
+                    log.info(f"All items for {target_annotator} have been reviewed by {username}")
+                    
+                    # Load the last batch of items to show completion
+                    BATCH_SIZE = 10
+                    items_query = db.query(
+                        Annotation,
+                        TTSData.filename,
+                        TTSData.sentence
+                    ).join(
+                        TTSData, Annotation.tts_data_id == TTSData.id
+                    ).filter(
+                        Annotation.annotator_id == target_annotator_obj.id
+                    ).order_by(Annotation.id.desc()).limit(BATCH_SIZE)
+                    
+                    # Reverse the results to maintain chronological order
+                    initial_results = list(reversed(items_query.all()))
+                    initial_idx = len(initial_results) - 1 if initial_results else 0
+                    
+                    log.info(f"All items reviewed, starting at last item, index: {initial_idx}")
+                    
+                    # Set completion message
+                    if initial_results:
+                        review_info_text = f"🎉 **Phase 2 Review Mode** - All annotations for {target_annotator} have been reviewed! Showing last {len(initial_results)} items for reference."
+                    else:
+                        review_info_text = f"🎉 **Phase 2 Review Mode** - All annotations for {target_annotator} have been reviewed! No items to display."
+                    
+                    return (
+                        [], 
+                        0, 
+                        review_info_text,
+                        "", "", "", "", "", "", "", gr.update(value=None, autoplay=False), gr.update(visible=False, value=""), False, gr.update(value="❌ Reject"), ""
+                    )
 
                 # Process items with minimal data - validation status will be loaded on-demand
                 items = []
@@ -360,100 +489,14 @@ class ReviewDashboardPage:
                         "validation_loaded": False  # Track if validation status has been loaded
                     })
 
-                # --- RESUME LOGIC: Find first unreviewed item ---
-                initial_idx = 0
-                if items:
-                    log.info(f"Starting resume logic search with {len(items)} items")
-                    # First, try to find the first unreviewed item that is not deleted
-                    found_unreviewed = False
-                    for i, item_data in enumerate(items):
-                        if not item_data.get("is_deleted", False):
-                            # Check if this item has been reviewed by the current validator
-                            validation = db.query(Validation).filter_by(
-                                annotation_id=item_data["annotation_id"],
-                                validator_id=user_id
-                            ).first()
-                            
-                            if not validation:
-                                # This item hasn't been reviewed yet
-                                initial_idx = i
-                                found_unreviewed = True
-                                log.info(f"✅ Resume point found in initial batch: index {initial_idx}, TTS ID {item_data['tts_id']}, filename: {item_data['filename']}")
-                                break
-                            else:
-                                log.info(f"Item {i} (TTS ID {item_data['tts_id']}) already reviewed by validator {user_id}")
-                        else:
-                            log.info(f"Item {i} (TTS ID {item_data['tts_id']}) is deleted, skipping")
-                    
-                    # If no unreviewed non-deleted items found in initial batch, 
-                    # we need to load more items to find the resume point
-                    if not found_unreviewed:
-                        log.info("No unreviewed items found in initial batch, loading more items to find resume point")
-                        
-                        # Load more items to find the resume point
-                        offset = len(items)
-                        additional_query = db.query(
-                            Annotation,
-                            TTSData.filename,
-                            TTSData.sentence
-                        ).join(
-                            TTSData, Annotation.tts_data_id == TTSData.id
-                        ).filter(
-                            Annotation.annotator_id == target_annotator_obj.id
-                        ).order_by(Annotation.id).offset(offset).limit(20)  # Load more to find resume point
-                        
-                        additional_results = additional_query.all()
-                        log.info(f"Loaded {len(additional_results)} additional items to search for resume point")
-                        
-                        # Process additional items
-                        for annotation, filename, sentence in additional_results:
-                            is_deleted = not annotation.annotated_sentence or annotation.annotated_sentence.strip() == ""
-                            annotated_sentence_display = "[DELETED ANNOTATION]" if is_deleted else annotation.annotated_sentence
-                            
-                            items.append({
-                                "annotation_id": annotation.id,
-                                "tts_id": annotation.tts_data_id,
-                                "filename": filename,
-                                "sentence": sentence,
-                                "annotated_sentence": annotated_sentence_display,
-                                "is_deleted": is_deleted,
-                                "annotated_at": annotation.annotated_at.isoformat() if annotation.annotated_at else "",
-                                "validation_status": "Loading...",
-                                "validation_loaded": False
-                            })
-                        
-                        # Now search for the first unreviewed item in the expanded list
-                        log.info(f"Searching expanded list of {len(items)} items for resume point")
-                        for i, item_data in enumerate(items):
-                            if not item_data.get("is_deleted", False):
-                                validation = db.query(Validation).filter_by(
-                                    annotation_id=item_data["annotation_id"],
-                                    validator_id=user_id
-                                ).first()
-                                
-                                if not validation:
-                                    initial_idx = i
-                                    found_unreviewed = True
-                                    log.info(f"✅ Resume point found in expanded list: index {initial_idx}, TTS ID {item_data['tts_id']}, filename: {item_data['filename']}")
-                                    break
-                                else:
-                                    log.info(f"Item {i} (TTS ID {item_data['tts_id']}) already reviewed by validator {user_id}")
-                            else:
-                                log.info(f"Item {i} (TTS ID {item_data['tts_id']}) is deleted, skipping")
-                        
-                        # If still no unreviewed items found, start from the last item
-                        if not found_unreviewed:
-                            initial_idx = len(items) - 1 if items else 0
-                            log.info(f"⚠️ All items reviewed, starting at last item, index: {initial_idx}")
-                    
-                    log.info(f"Final resume decision: starting at index {initial_idx} with {len(items)} total items loaded")
-                
+                log.info(f"Fast initial load: {len(items)} annotations out of {total_count} total for target annotator ID {target_annotator_obj.id}")
+
                 # Set initial display
                 if items:
                     initial_item = items[initial_idx]
-                    review_info_text = f"🔍 **Phase 2 Review Mode** - Reviewing assigned annotations. Loaded {len(items)} of {total_count} total items."
-                    # Ensure correct order of return values for 12 outputs
-                    # items, idx, review_info, tts_id, filename, sentence, ann_sentence, annotated_at, validation_status, annotator_placeholder, audio_update, rejection_reason_update
+                    review_info_text = f"🔍 **Phase 2 Review Mode** - Reviewing assigned annotations. Loaded {len(items)} of {total_count} total items. Resuming from ID: {initial_item['annotation_id']}"
+                    
+                    # Ensure correct order of return values for 14 outputs
                     rejection_reason_val = ""
                     rejection_visible_val = False
                     if initial_item["validation_status"].startswith("Rejected"):
@@ -477,23 +520,17 @@ class ReviewDashboardPage:
                         gr.update(value=None, autoplay=False), # audio_update
                         gr.update(visible=rejection_visible_val, value=rejection_reason_val), # rejection_reason_input update
                         False,  # Reset rejection mode
-                        gr.update(value="❌ Reject")  # Reset reject button
+                        gr.update(value="❌ Reject"),  # Reset reject button
+                        get_current_item_position_info(items, initial_idx, session)  # Position info
                     )
                 else:
-                    # Ensure correct order and number of return values for empty items (14 outputs)
-                    return [], 0, f"🔍 **Phase 2 Review Mode** - No annotations found for review.", "", "", "", "", "", "", "", gr.update(value=None, autoplay=False), gr.update(visible=False, value=""), False, gr.update(value="❌ Reject")
-
-                # except Exception as e:
-                #     log.error(f"Error loading review items: {e}")
-                #     sentry_sdk.capture_exception(e)
-                #     gr.Error(f"Failed to load review data: {e}")
-                #     # Ensure correct order and number of return values for error case (14 outputs)
-                #     return [], 0, "", "", "", "", "", "", "", "", gr.update(value=None, autoplay=False), gr.update(visible=False, value=""), False, gr.update(value="❌ Reject")
+                    # Ensure correct order and number of return values for empty items (15 outputs)
+                    return [], 0, f"🔍 **Phase 2 Review Mode** - No annotations found for review.", "", "", "", "", "", "", "", gr.update(value=None, autoplay=False), gr.update(visible=False, value=""), False, gr.update(value="❌ Reject"), ""
 
         def show_current_review_item_fn(items, idx, session):
             if not items or idx >= len(items) or idx < 0:
-                # tts_id, filename, sentence, ann_sentence, annotated_at, validation_status, annotator_name_placeholder, audio_update, rejection_reason_update, rejection_mode_reset, btn_reject_update
-                return "", "", "", "", "", "", "", gr.update(value=None, autoplay=False), gr.update(visible=False, value=""), False, gr.update(value="❌ Reject")
+                # tts_id, filename, sentence, ann_sentence, annotated_at, validation_status, annotator_name_placeholder, audio_update, rejection_reason_update, rejection_mode_reset, btn_reject_update, position_info
+                return "", "", "", "", "", "", "", gr.update(value=None, autoplay=False), gr.update(visible=False, value=""), False, gr.update(value="❌ Reject"), ""
             
             current_item = items[idx]
             
@@ -526,7 +563,6 @@ class ReviewDashboardPage:
             # Check if this is a deleted annotation
             is_deleted = current_item.get("is_deleted", False)
             
-            # Handle validation status display
             if current_item["validation_status"].startswith("Rejected"):
                 # Extract reason from status like "Rejected (reason)" or just use empty if no parenthesis
                 start_paren = current_item["validation_status"].find("(")
@@ -534,14 +570,9 @@ class ReviewDashboardPage:
                 if start_paren != -1 and end_paren != -1:
                     rejection_reason = current_item["validation_status"][start_paren+1:end_paren]
                 rejection_visible = True
-            elif current_item["validation_status"] == "Not Reviewed (Deleted)":
-                # Special handling for deleted annotations that haven't been reviewed
-                rejection_visible = False
-                rejection_reason = ""
-            elif current_item["validation_status"] == "Not Reviewed":
-                # Regular unreviewed items
-                rejection_visible = False
-                rejection_reason = ""
+
+            # Get position info
+            position_info = get_current_item_position_info(items, idx, session)
 
             return (
                 str(current_item["tts_id"]), 
@@ -554,78 +585,18 @@ class ReviewDashboardPage:
                 gr.update(value=None, autoplay=False),
                 gr.update(visible=rejection_visible, value=rejection_reason),
                 False,  # Reset rejection mode
-                gr.update(value="❌ Reject")  # Reset reject button text
+                gr.update(value="❌ Reject"),  # Reset reject button text
+                position_info  # Position info
             )
 
         def update_review_info_fn(items, total_count):
-            """Update the review info banner with current loaded items count"""
+            """Update the review info banner with current loaded items count and position info"""
             if items:
-                return f"🔍 **Phase 2 Review Mode** - Reviewing assigned annotations. Loaded {len(items)} of {total_count} total items."
+                current_item_id = items[0]["annotation_id"] if items else "N/A"
+                return f"🔍 **Phase 2 Review Mode** - Reviewing assigned annotations. Loaded {len(items)} of {total_count} total items. Starting from ID: {current_item_id}"
             else:
                 return f"🔍 **Phase 2 Review Mode** - No annotations found for review."
 
-        def find_next_unreviewed_item(items, current_idx, session):
-            """Find the next unreviewed item starting from current_idx"""
-            if not items or current_idx >= len(items):
-                log.warning(f"find_next_unreviewed_item: Invalid items or current_idx. items: {len(items) if items else 0}, current_idx: {current_idx}")
-                return current_idx
-                
-            user_id = session.get("user_id")
-            if not user_id:
-                log.warning("find_next_unreviewed_item: No user_id in session")
-                return current_idx
-                
-            log.info(f"Searching for next unreviewed item starting from index {current_idx} (TTS ID: {items[current_idx]['tts_id'] if current_idx < len(items) else 'N/A'})")
-                
-            # Start searching from the next item
-            start_idx = current_idx + 1
-            if start_idx >= len(items):
-                start_idx = 0  # Wrap around to beginning
-                log.info("Wrapping around to beginning of items list")
-                
-            # Search forward from start_idx
-            for i in range(len(items)):
-                check_idx = (start_idx + i) % len(items)
-                item_data = items[check_idx]
-                
-                log.info(f"Checking item {check_idx} (TTS ID: {item_data['tts_id']}, filename: {item_data['filename']})")
-                
-                # Skip deleted annotations
-                if item_data.get("is_deleted", False):
-                    log.info(f"Item {check_idx} is deleted, skipping")
-                    continue
-                    
-                # Check if this item has been reviewed
-                if not item_data.get("validation_loaded", False):
-                    # Load validation status on-demand
-                    with get_db() as db:
-                        try:
-                            validation = db.query(Validation).filter_by(
-                                annotation_id=item_data["annotation_id"],
-                                validator_id=user_id
-                            ).first()
-                            item_data["validation_loaded"] = True
-                            if validation:
-                                item_data["validation_status"] = "Approved" if validation.validated else f"Rejected ({validation.description})" if validation.description else "Rejected"
-                                log.info(f"Item {check_idx} validation status loaded: {item_data['validation_status']}")
-                            else:
-                                item_data["validation_status"] = "Not Reviewed"
-                                log.info(f"Item {check_idx} has no validation record - unreviewed")
-                        except Exception as e:
-                            log.error(f"Error loading validation status for item {check_idx}: {e}")
-                            item_data["validation_status"] = "Error loading status"
-                
-                # If not reviewed, this is our target
-                if item_data["validation_status"] == "Not Reviewed":
-                    log.info(f"✅ Found next unreviewed item at index {check_idx} (TTS ID: {item_data['tts_id']}, filename: {item_data['filename']})")
-                    return check_idx
-                else:
-                    log.info(f"Item {check_idx} already reviewed with status: {item_data['validation_status']}")
-                    
-            # If no unreviewed items found, return current index
-            log.info("⚠️ No unreviewed items found, staying at current position")
-            return current_idx
-
         def navigate_and_load_fn(items, current_idx, direction, session):
             """Combined navigation and loading function"""
             if not items:
@@ -787,18 +758,32 @@ class ReviewDashboardPage:
                 ).count()
                     
                 # Load next batch starting from where we left off
-                offset = len(items)
-                
-                # FAST LOADING: Use same strategy as initial load - simple query without complex JOINs
-                query = db.query(
-                    Annotation,
-                    TTSData.filename,
-                    TTSData.sentence
-                ).join(
-                    TTSData, Annotation.tts_data_id == TTSData.id
-                ).filter(
-                    Annotation.annotator_id == target_annotator_obj.id
-                ).order_by(Annotation.id).offset(offset).limit(current_batch_size)
+                if items:
+                    # Get the last loaded annotation ID to continue from there
+                    last_loaded_id = items[-1]["annotation_id"]
+                    
+                    # Load next batch starting after the last loaded item
+                    query = db.query(
+                        Annotation,
+                        TTSData.filename,
+                        TTSData.sentence
+                    ).join(
+                        TTSData, Annotation.tts_data_id == TTSData.id
+                    ).filter(
+                        Annotation.annotator_id == target_annotator_obj.id,
+                        Annotation.id > last_loaded_id  # Continue from where we left off
+                    ).order_by(Annotation.id).limit(current_batch_size)
+                else:
+                    # No items loaded yet, start from the beginning
+                    query = db.query(
+                        Annotation,
+                        TTSData.filename,
+                        TTSData.sentence
+                    ).join(
+                        TTSData, Annotation.tts_data_id == TTSData.id
+                    ).filter(
+                        Annotation.annotator_id == target_annotator_obj.id
+                    ).order_by(Annotation.id).limit(current_batch_size)
                 
                 results = query.all()
                 
@@ -824,17 +809,66 @@ class ReviewDashboardPage:
                 # Combine with existing items
                 all_items = items + new_items
                 log.info(f"Loaded {len(new_items)} more items, total now: {len(all_items)}")
-                
-                # If this is the first time loading more items, we might need to find the resume point
-                # This ensures that even if the initial batch didn't find unreviewed items, 
-                # we can still resume from the correct position
-                if len(items) == 5 and len(all_items) > 5:  # Initial batch was 5 items
-                    log.info("First load_more call, checking if we need to find resume point")
-                    # The resume logic in load_review_items_fn should have already handled this,
-                    # but we can add additional safety here if needed
-                
                 return all_items, total_count
 
+        def _jump_to_next_unreviewed_fn(items, session):
+            """Helper function to jump to the next unreviewed item in the review queue."""
+            user_id = session.get("user_id")
+            username = session.get("username")
+            if not user_id or not username:
+                gr.Error("User not logged in")
+                return items, 0, ""
+
+            # Find target annotator
+            target_annotator = None
+            for annotator_name, reviewer_name in conf.REVIEW_MAPPING.items():
+                if reviewer_name == username:
+                    target_annotator = annotator_name
+                    break
+
+            if not target_annotator:
+                gr.Error("User is not assigned as a reviewer")
+                return items, 0, ""
+
+            with get_db() as db:
+                try:
+                    # Get target annotator's ID
+                    target_annotator_obj = db.query(Annotator).filter_by(name=target_annotator).first()
+                    if not target_annotator_obj:
+                        return items, 0, f"⚠️ **Error:** Annotator '{target_annotator}' not found"
+
+                    # Find the first unreviewed annotation for this reviewer
+                    first_unreviewed_query = db.query(Annotation.id).outerjoin(
+                        Validation, 
+                        (Annotation.id == Validation.annotation_id) & 
+                        (Validation.validator_id == user_id)
+                    ).filter(
+                        Annotation.annotator_id == target_annotator_obj.id,
+                        Validation.id.is_(None)  # No validation record exists for this reviewer
+                    ).order_by(Annotation.id).limit(1)
+
+                    first_unreviewed_result = first_unreviewed_query.first()
+
+                    if first_unreviewed_result:
+                        target_id = first_unreviewed_result.id
+                        log.info(f"Jumping to next unreviewed item with ID: {target_id}")
+                        
+                        # Find this item in the current loaded items
+                        for i, item in enumerate(items):
+                            if item["annotation_id"] == target_id:
+                                return items, i, f"🎯 **Jumped to unreviewed item ID: {target_id}**"
+                        
+                        # If not found in current items, we need to load more items
+                        # For now, just show a message
+                        return items, 0, f"🎯 **Next unreviewed item ID: {target_id}** - Use navigation to reach it"
+                    else:
+                        log.info(f"No unreviewed items found for user {user_id}. Review queue is empty.")
+                        return items, 0, "🎉 **Phase 2 Review Mode** - All annotations for your assigned annotators have been reviewed! Your review queue is empty."
+                except Exception as e:
+                    log.error(f"Error jumping to next unreviewed item: {e}")
+                    sentry_sdk.capture_exception(e)
+                    return items, 0, f"⚠️ **Error:** Could not find next unreviewed item. Error: {e}"
+
         # Output definitions
         review_display_outputs = [
             self.tts_id, self.filename, self.sentence, self.ann_sentence,
@@ -844,7 +878,8 @@ class ReviewDashboardPage:
             self.audio,
             self.rejection_reason_input, # Added rejection reason input to display outputs
             self.rejection_mode_active,  # Added rejection mode state
-            self.btn_reject  # Added reject button to display outputs
+            self.btn_reject,  # Added reject button to display outputs
+            self.position_info  # Added position info to display outputs
         ]
 
         # Trigger data loading when load_trigger changes (after successful login for a reviewer)
@@ -912,9 +947,9 @@ class ReviewDashboardPage:
             fn=lambda: gr.update(value="❌ Reject"),  # Reset reject button
             outputs=[self.btn_reject]
         ).then(
-            fn=lambda items, idx, session: find_next_unreviewed_item(items, idx, session),
+            fn=lambda items, idx, session: navigate_and_load_fn(items, idx, "next", session),
             inputs=[self.items_state, self.idx_state, session_state],
-            outputs=[self.idx_state]
+            outputs=[self.items_state, self.idx_state, self.review_info]
         ).then(
             fn=show_current_review_item_fn,
             inputs=[self.items_state, self.idx_state, session_state],
@@ -935,9 +970,9 @@ class ReviewDashboardPage:
             inputs=[self.items_state, self.idx_state, session_state, self.rejection_mode_active],
             outputs=[self.header.progress_display]
         ).then(
-            fn=lambda items, idx, session, rejection_mode: find_next_unreviewed_item(items, idx, session) if not rejection_mode else idx,
+            fn=lambda items, idx, session, rejection_mode: navigate_and_load_fn(items, idx, "next", session) if not rejection_mode else (items, idx, ""),
             inputs=[self.items_state, self.idx_state, session_state, self.rejection_mode_active],
-            outputs=[self.idx_state]
+            outputs=[self.items_state, self.idx_state, self.review_info]
         ).then(
             fn=lambda items, idx, session, rejection_mode: show_current_review_item_fn(items, idx, session) if not rejection_mode else (
                 str(items[idx]["tts_id"]) if items and idx < len(items) else "",
@@ -963,9 +998,9 @@ class ReviewDashboardPage:
 
         # Skip button (just navigate to next)
         self.btn_skip.click(
-            fn=lambda items, idx, session: find_next_unreviewed_item(items, idx, session),
+            fn=lambda items, idx, session: navigate_and_load_fn(items, idx, "next", session),
             inputs=[self.items_state, self.idx_state, session_state],
-            outputs=[self.idx_state]
+            outputs=[self.items_state, self.idx_state, self.review_info]
         ).then(
             fn=show_current_review_item_fn,
             inputs=[self.items_state, self.idx_state, session_state],
@@ -996,6 +1031,28 @@ class ReviewDashboardPage:
             outputs=self.jump_data_id_input
         )
 
+        # Jump to Unreviewed button
+        self.btn_jump_to_unreviewed.click(
+            fn=lambda: update_ui_interactive_state(False),
+            outputs=self.interactive_ui_elements
+        ).then(
+            fn=lambda items, session: _jump_to_next_unreviewed_fn(items, session),
+            inputs=[self.items_state, session_state],
+            outputs=[self.items_state, self.idx_state, self.review_info]
+        ).then(
+            fn=show_current_review_item_fn,
+            inputs=[self.items_state, self.idx_state, session_state],
+            outputs=review_display_outputs
+        ).then(
+            # Auto-load audio with autoplay after jumping
+            fn=download_voice_fn,
+            inputs=[self.filename],
+            outputs=[self.audio, self.original_audio_state, self.audio]
+        ).then(
+            fn=lambda: update_ui_interactive_state(True),
+            outputs=self.interactive_ui_elements
+        )
+
         # Load audio button
         self.btn_load_voice.click(
             fn=lambda: update_ui_interactive_state(False),