diff --git a/public/index.html b/public/index.html
index c217ae4..5d9e6a1 100644
--- a/public/index.html
+++ b/public/index.html
@@ -1688,6 +1688,8 @@ <h3 class="text-xl font-semibold text-slate-900 dark:text-slate-100">${emptyTitl
             };
 
             const refreshApiCalls = Math.ceil(allPrs.length / 50);
+            const uniqueRepoCount = new Set(allPrs.map(p => p.repo_owner + '/' + p.repo_name)).size;
+            const repoApiCalls = uniqueRepoCount * 2;
             // Each readiness check fetches at least 4 GitHub endpoints in parallel:
             // commits, reviews, review_comments, issue_comments
             // NOTE: This is a lower-bound estimate; pagination can require additional API calls per PR.
@@ -1709,8 +1711,14 @@ <h3 class="text-xl font-semibold text-slate-900 dark:text-slate-100">${emptyTitl
                     <button 
                         id="refreshPrsBtn" 
                         class="rounded px-2 py-1 text-xs font-medium text-slate-600 hover:bg-slate-100 dark:text-slate-400 dark:hover:bg-slate-700 border border-slate-300 dark:border-slate-600"
-                        title="Refresh essential PR data from GitHub API (uses GraphQL batch: 1 call per 50 PRs)">
-                        <i class="fas fa-sync-alt"></i> Refresh All Essential <span class="font-semibold text-slate-500 dark:text-slate-400">(${refreshApiCalls} API call${refreshApiCalls !== 1 ? 's' : ''})</span>
+                        title="Refresh per-PR data from GitHub API (uses GraphQL batch: 2 calls per 50 PRs). Updates reviews, check runs, conversations, and branch comparison for every tracked PR.">
+                        <i class="fas fa-sync-alt"></i> Refresh All PRs <span class="font-semibold text-slate-500 dark:text-slate-400">(${refreshApiCalls * 2} API call${refreshApiCalls * 2 !== 1 ? 's' : ''})</span>
+                    </button>
+                    <button 
+                        id="refreshRepoBtn" 
+                        class="rounded px-2 py-1 text-xs font-medium text-slate-600 hover:bg-slate-100 dark:text-slate-400 dark:hover:bg-slate-700 border border-slate-300 dark:border-slate-600"
+                        title="Refresh repo-level data (behind_by) for all unique repositories. Efficient: 2 GraphQL calls per repo regardless of PR count. Use after a PR is merged to update how far behind other PRs are.">
+                        <i class="fas fa-code-branch"></i> Refresh Repo Data <span class="font-semibold text-slate-500 dark:text-slate-400">(${repoApiCalls} API call${repoApiCalls !== 1 ? 's' : ''})</span>
                     </button>
                     <button 
                         id="analyzeAllBtn" 
@@ -2746,6 +2754,46 @@ <h3 class="text-xl font-semibold text-slate-900 dark:text-slate-100">${emptyTitl
                 return;
             }
 
+            // Handle Refresh Repo Data button (update behind_by for all repos, 2 API calls per repo)
+            if (e.target.closest('#refreshRepoBtn')) {
+                const btn = e.target.closest('#refreshRepoBtn');
+                const originalHtml = btn.innerHTML;
+                btn.disabled = true;
+                btn.innerHTML = '<i class="fas fa-spinner fa-spin"></i> Refreshing repos...';
+                btn.classList.add('opacity-70', 'cursor-not-allowed');
+                try {
+                    // Get unique repos from the current PR list
+                    const uniqueRepos = [...new Map(allPrs.map(pr => [
+                        pr.repo_owner + '/' + pr.repo_name,
+                        { repo_owner: pr.repo_owner, repo_name: pr.repo_name }
+                    ])).values()];
+                    let refreshed = 0;
+                    for (const repo of uniqueRepos) {
+                        btn.innerHTML = `<i class="fas fa-spinner fa-spin"></i> Refreshing ${repo.repo_owner}/${repo.repo_name}...`;
+                        const resp = await fetch('/api/refresh-repo', {
+                            method: 'POST',
+                            headers: { 'Content-Type': 'application/json' },
+                            body: JSON.stringify(repo)
+                        });
+                        if (!resp.ok) {
+                            const errData = await resp.json().catch(() => ({}));
+                            throw new Error(errData.error || `Refresh-repo failed (${resp.status})`);
+                        }
+                        const data = await resp.json();
+                        if (data.error) throw new Error(data.error);
+                        refreshed += data.updated || 0;
+                    }
+                    await loadPrs(true);
+                } catch (err) {
+                    showError(`Failed to refresh repo data: ${err.message}`);
+                } finally {
+                    btn.disabled = false;
+                    btn.innerHTML = originalHtml;
+                    btn.classList.remove('opacity-70', 'cursor-not-allowed');
+                }
+                return;
+            }
+
             // Handle Analyze All button (run readiness analysis for every tracked PR)
             if (e.target.closest('#analyzeAllBtn')) {
                 const ANALYZE_MAX_RETRIES = 3;
diff --git a/src/github_api.py b/src/github_api.py
index ad50987..3d24b65 100644
--- a/src/github_api.py
+++ b/src/github_api.py
@@ -374,7 +374,7 @@ async def fetch_multiple_prs_batch(prs_to_fetch, token=None):
         batch = prs_to_fetch[batch_start:batch_start + MAX_PRS_PER_BATCH]
         
         # Build GraphQL query with aliases for each PR
-        # We'll fetch essential PR data in one query
+        # We'll fetch essential PR data including check runs in one query
         query_parts = []
         for i, (owner, repo, pr_number) in enumerate(batch):
             alias = f"pr{i}"
@@ -389,7 +389,7 @@ async def fetch_multiple_prs_batch(prs_to_fetch, token=None):
                         mergeable
                         mergeStateStatus
                         changedFiles
-                        commits {{
+                        commitsTotal: commits {{
                             totalCount
                         }}
                         author {{
@@ -427,6 +427,27 @@ async def fetch_multiple_prs_batch(prs_to_fetch, token=None):
                                 }}
                             }}
                         }}
+                        headCommit: commits(last: 1) {{
+                            nodes {{
+                                commit {{
+                                    statusCheckRollup {{
+                                        state
+                                        contexts(first: 100) {{
+                                            nodes {{
+                                                __typename
+                                                ... on CheckRun {{
+                                                    conclusion
+                                                    status
+                                                }}
+                                                ... on StatusContext {{
+                                                    state
+                                                }}
+                                            }}
+                                        }}
+                                    }}
+                                }}
+                            }}
+                        }}
                     }}
                 }}
             """)
@@ -480,6 +501,8 @@ async def fetch_multiple_prs_batch(prs_to_fetch, token=None):
             
             # Extract PR data from response
             data = result.get('data', {})
+            # Collect comparison inputs for second-pass query: (alias, owner, repo, head_sha, base_branch)
+            comparison_inputs = []
             for i, (owner, repo, pr_number) in enumerate(batch):
                 alias = f"pr{i}"
                 repo_data = data.get(alias, {})
@@ -490,11 +513,6 @@ async def fetch_multiple_prs_batch(prs_to_fetch, token=None):
                     all_results[(owner, repo, pr_number)] = None
                     continue
                 
-                # Transform GraphQL response to match REST API format used by fetch_pr_data
-                # Note: Some fields (checks_passed, checks_failed, checks_skipped, behind_by) 
-                # are not available in this batch GraphQL query to keep it simple and fast.
-                # These fields are set to 0 and marked with _incomplete_data flag.
-                # For critical updates where these fields matter, use individual fetch_pr_data() instead.
                 author = pr_data.get('author', {})
                 base_repo = pr_data.get('baseRepository', {})
                 
@@ -503,7 +521,6 @@ async def fetch_multiple_prs_batch(prs_to_fetch, token=None):
                 open_conversations_count = sum(1 for thread in review_threads if not thread.get('isResolved', False))
                 
                 # Note: If there are more than 100 review threads, this count will be incomplete
-                # The pageInfo would indicate hasNextPage=true in that case
                 page_info = pr_data.get('reviewThreads', {}).get('pageInfo', {})
                 if page_info.get('hasNextPage'):
                     print(f"Warning: PR {owner}/{repo}#{pr_number} has >100 review threads, count may be incomplete")
@@ -527,6 +544,37 @@ async def fetch_multiple_prs_batch(prs_to_fetch, token=None):
                         }
                 reviewers_list = list(latest_reviews.values())
                 
+                # Process check runs from statusCheckRollup (headCommit field)
+                checks_passed = 0
+                checks_failed = 0
+                checks_skipped = 0
+                head_commit_nodes = pr_data.get('headCommit', {}).get('nodes', [])
+                if head_commit_nodes:
+                    rollup = head_commit_nodes[-1].get('commit', {}).get('statusCheckRollup') or {}
+                    contexts = rollup.get('contexts', {}).get('nodes', [])
+                    for ctx in contexts:
+                        typename = ctx.get('__typename', '')
+                        if typename == 'CheckRun':
+                            conclusion = (ctx.get('conclusion') or '').upper()
+                            if conclusion == 'SUCCESS':
+                                checks_passed += 1
+                            elif conclusion in ('FAILURE', 'TIMED_OUT', 'CANCELLED', 'ACTION_REQUIRED'):
+                                checks_failed += 1
+                            elif conclusion in ('SKIPPED', 'NEUTRAL'):
+                                checks_skipped += 1
+                        elif typename == 'StatusContext':
+                            state = (ctx.get('state') or '').upper()
+                            if state == 'SUCCESS':
+                                checks_passed += 1
+                            elif state in ('FAILURE', 'ERROR'):
+                                checks_failed += 1
+                
+                # Collect head SHA and base branch for comparison second pass
+                head_sha = pr_data.get('headRefOid', '')
+                base_branch = pr_data.get('baseRefName', '')
+                if head_sha and base_branch:
+                    comparison_inputs.append((alias, owner, repo, pr_number, head_sha, base_branch))
+                
                 # Build the pr_data dict matching REST API format
                 transformed_data = {
                     'title': pr_data.get('title', ''),
@@ -537,22 +585,75 @@ async def fetch_multiple_prs_batch(prs_to_fetch, token=None):
                     'author_login': author.get('login', ''),
                     'author_avatar': author.get('avatarUrl', ''),
                     'repo_owner_avatar': base_repo.get('owner', {}).get('avatarUrl', ''),
-                    'checks_passed': 0,  # Not available in batch query
-                    'checks_failed': 0,  # Not available in batch query
-                    'checks_skipped': 0,  # Not available in batch query
-                    'commits_count': pr_data.get('commits', {}).get('totalCount', 0),
-                    'behind_by': 0,  # Not available in batch query
+                    'checks_passed': checks_passed,
+                    'checks_failed': checks_failed,
+                    'checks_skipped': checks_skipped,
+                    'commits_count': pr_data.get('commitsTotal', {}).get('totalCount', 0),
+                    'behind_by': 0,  # Will be updated by comparison second pass below
                     'review_status': review_status,
                     'last_updated_at': pr_data.get('updatedAt', ''),
                     'is_draft': 1 if pr_data.get('isDraft', False) else 0,
                     'open_conversations_count': open_conversations_count,
                     'reviewers_json': json.dumps(reviewers_list),
                     'etag': None,  # GraphQL doesn't provide ETags
-                    '_batch_fetch': True,  # Mark as batch-fetched (incomplete data)
-                    '_incomplete_fields': ['checks_passed', 'checks_failed', 'checks_skipped', 'behind_by']
+                    '_batch_fetch': True,
                 }
                 
                 all_results[(owner, repo, pr_number)] = transformed_data
+            
+            # === PASS 2: Batch-fetch comparison (behind_by) for all PRs in this batch ===
+            # Each PR needs its own comparison since head SHA differs per PR.
+            # We inline head_sha per alias to avoid N individual REST calls.
+            if comparison_inputs:
+                cmp_query_parts = []
+                for alias, owner, repo, pr_number, head_sha, base_branch in comparison_inputs:
+                    # Sanitize values: git SHAs are hex-only; branch names may contain
+                    # slashes and dots but not quotes, backslashes, or control chars.
+                    safe_base = base_branch.replace('"', '').replace('\\', '').replace('\n', '').replace('\r', '')
+                    safe_head = head_sha.replace('"', '').replace('\\', '').replace('\n', '').replace('\r', '')
+                    cmp_query_parts.append(f"""
+                        {alias}: repository(owner: "{owner}", name: "{repo}") {{
+                            ref(qualifiedName: "{safe_base}") {{
+                                compare(headRef: "{safe_head}") {{
+                                    aheadBy
+                                    status
+                                }}
+                            }}
+                        }}
+                    """)
+                cmp_query = "query { " + " ".join(cmp_query_parts) + " }"
+                try:
+                    cmp_options = to_js({
+                        "method": "POST",
+                        "headers": headers,
+                        "body": json.dumps({"query": cmp_query})
+                    }, dict_converter=Object.fromEntries)
+                    cmp_response = await fetch(graphql_url, cmp_options)
+                    cmp_rate_limit = cmp_response.headers.get('x-ratelimit-limit')
+                    cmp_rate_remaining = cmp_response.headers.get('x-ratelimit-remaining')
+                    cmp_rate_reset = cmp_response.headers.get('x-ratelimit-reset')
+                    if cmp_rate_limit and cmp_rate_remaining:
+                        set_rate_limit_data(cmp_rate_limit, cmp_rate_remaining, cmp_rate_reset)
+                    print(f"GitHub GraphQL Comparison Batch: {len(comparison_inputs)} PRs | Status: {cmp_response.status} | Rate Limit: {cmp_rate_remaining}/{cmp_rate_limit} remaining")
+                    if cmp_response.status == 200:
+                        cmp_result = (await cmp_response.json()).to_py()
+                        if 'errors' not in cmp_result:
+                            cmp_data = cmp_result.get('data', {})
+                            for alias, owner, repo, pr_number, head_sha, base_branch in comparison_inputs:
+                                repo_cmp = cmp_data.get(alias, {})
+                                ref_cmp = (repo_cmp or {}).get('ref') or {}
+                                compare = (ref_cmp or {}).get('compare') or {}
+                                # aheadBy on baseRef.compare = commits in base branch that are NOT in head
+                                # i.e., how far behind the PR branch is from its base branch
+                                behind_by = compare.get('aheadBy') or 0
+                                if (owner, repo, pr_number) in all_results and all_results[(owner, repo, pr_number)]:
+                                    all_results[(owner, repo, pr_number)]['behind_by'] = behind_by
+                        else:
+                            print(f"GraphQL Comparison Batch errors: {cmp_result['errors']}")
+                    else:
+                        print(f"Warning: GraphQL Comparison Batch returned status {cmp_response.status}")
+                except Exception as cmp_e:
+                    print(f"Error in GraphQL comparison batch: {str(cmp_e)}")
                 
         except Exception as e:
             print(f"Error in GraphQL batch fetch: {str(e)}")
@@ -563,6 +664,180 @@ async def fetch_multiple_prs_batch(prs_to_fetch, token=None):
     return all_results
 
 
+async def fetch_repo_open_prs(owner, repo, token=None):
+    """
+    Fetch all open PRs for a repository with their head SHA and base branch.
+
+    Uses paginated GraphQL calls (100 per page) to handle repos with many open PRs.
+    This is the first step for the repo-level refresh — getting the current head SHAs
+    is necessary to build the comparison query.
+
+    Args:
+        owner: Repository owner
+        repo: Repository name
+        token: Optional GitHub token for authentication
+
+    Returns:
+        List of dicts with keys: number, head_sha, base_branch
+        Returns empty list on error.
+    """
+    graphql_url = "https://api.github.com/graphql"
+    headers = {
+        'Accept': 'application/vnd.github+json',
+        'Content-Type': 'application/json',
+        'User-Agent': 'PR-Tracker/1.0'
+    }
+    if token:
+        headers['Authorization'] = f'Bearer {token}'
+
+    all_prs = []
+    cursor = None
+    has_next_page = True
+
+    try:
+        while has_next_page:
+            after_arg = f', after: "{cursor}"' if cursor else ''
+            query = f"""
+            query {{
+                repository(owner: "{owner}", name: "{repo}") {{
+                    pullRequests(first: 100, states: OPEN{after_arg}) {{
+                        nodes {{
+                            number
+                            headRefOid
+                            baseRefName
+                        }}
+                        pageInfo {{
+                            hasNextPage
+                            endCursor
+                        }}
+                    }}
+                }}
+            }}
+            """
+            options = to_js({
+                "method": "POST",
+                "headers": headers,
+                "body": json.dumps({"query": query})
+            }, dict_converter=Object.fromEntries)
+            response = await fetch(graphql_url, options)
+            rate_limit = response.headers.get('x-ratelimit-limit')
+            rate_remaining = response.headers.get('x-ratelimit-remaining')
+            rate_reset = response.headers.get('x-ratelimit-reset')
+            if rate_limit and rate_remaining:
+                set_rate_limit_data(rate_limit, rate_remaining, rate_reset)
+            print(f"GitHub GraphQL Repo Open PRs: {owner}/{repo} | Status: {response.status} | Rate Limit: {rate_remaining}/{rate_limit} remaining")
+            if response.status != 200:
+                print(f"Warning: fetch_repo_open_prs returned status {response.status}")
+                break
+            result = (await response.json()).to_py()
+            if 'errors' in result:
+                print(f"GraphQL Repo Open PRs errors: {result['errors']}")
+                break
+            pr_data = (
+                result.get('data', {})
+                .get('repository', {})
+                .get('pullRequests', {})
+            )
+            nodes = pr_data.get('nodes', [])
+            page_info = pr_data.get('pageInfo', {})
+            all_prs.extend([
+                {
+                    'number': pr['number'],
+                    'head_sha': pr.get('headRefOid', ''),
+                    'base_branch': pr.get('baseRefName', ''),
+                }
+                for pr in nodes
+            ])
+            has_next_page = page_info.get('hasNextPage', False)
+            cursor = page_info.get('endCursor')
+    except Exception as e:
+        print(f"Error in fetch_repo_open_prs for {owner}/{repo}: {str(e)}")
+
+    return all_prs
+
+
+async def fetch_repo_comparison_batch(prs_info, token=None):
+    """
+    Efficiently fetch `behind_by` for a list of PRs using a single GraphQL batch call.
+
+    Used by the repo-level refresh endpoint to update `behind_by` for all tracked PRs
+    in a repository after the base branch has moved (e.g. another PR was merged).
+    This avoids N individual REST compare calls — one GraphQL query handles all PRs.
+
+    Args:
+        prs_info: list of dicts with keys: owner, repo, pr_number, head_sha, base_branch
+        token: Optional GitHub token for authentication
+
+    Returns:
+        dict mapping (owner, repo, pr_number) -> behind_by (int), or empty dict on error
+    """
+    if not prs_info:
+        return {}
+
+    MAX_PER_BATCH = 50
+    graphql_url = "https://api.github.com/graphql"
+    results = {}
+
+    headers = {
+        'Accept': 'application/vnd.github+json',
+        'Content-Type': 'application/json',
+        'User-Agent': 'PR-Tracker/1.0'
+    }
+    if token:
+        headers['Authorization'] = f'Bearer {token}'
+
+    for batch_start in range(0, len(prs_info), MAX_PER_BATCH):
+        batch = prs_info[batch_start:batch_start + MAX_PER_BATCH]
+        query_parts = []
+        for i, pr in enumerate(batch):
+            alias = f"cmp{i}"
+            safe_base = pr['base_branch'].replace('"', '').replace('\\', '').replace('\n', '').replace('\r', '')
+            safe_head = pr['head_sha'].replace('"', '').replace('\\', '').replace('\n', '').replace('\r', '')
+            query_parts.append(f"""
+                {alias}: repository(owner: "{pr['owner']}", name: "{pr['repo']}") {{
+                    ref(qualifiedName: "{safe_base}") {{
+                        compare(headRef: "{safe_head}") {{
+                            aheadBy
+                            status
+                        }}
+                    }}
+                }}
+            """)
+        query = "query { " + " ".join(query_parts) + " }"
+        try:
+            options = to_js({
+                "method": "POST",
+                "headers": headers,
+                "body": json.dumps({"query": query})
+            }, dict_converter=Object.fromEntries)
+            response = await fetch(graphql_url, options)
+            rate_limit = response.headers.get('x-ratelimit-limit')
+            rate_remaining = response.headers.get('x-ratelimit-remaining')
+            rate_reset = response.headers.get('x-ratelimit-reset')
+            if rate_limit and rate_remaining:
+                set_rate_limit_data(rate_limit, rate_remaining, rate_reset)
+            print(f"GitHub GraphQL Repo Comparison Batch: {len(batch)} PRs | Status: {response.status} | Rate Limit: {rate_remaining}/{rate_limit} remaining")
+            if response.status != 200:
+                print(f"Warning: Repo comparison batch returned status {response.status}")
+                continue
+            result = (await response.json()).to_py()
+            if 'errors' in result:
+                print(f"GraphQL Repo Comparison errors: {result['errors']}")
+                continue
+            data = result.get('data', {})
+            for i, pr in enumerate(batch):
+                alias = f"cmp{i}"
+                repo_data = data.get(alias, {})
+                ref_data = (repo_data or {}).get('ref') or {}
+                compare = (ref_data or {}).get('compare') or {}
+                behind_by = compare.get('aheadBy') or 0
+                results[(pr['owner'], pr['repo'], pr['pr_number'])] = behind_by
+        except Exception as e:
+            print(f"Error in repo comparison batch: {str(e)}")
+
+    return results
+
+
 async def fetch_org_repos(owner, token=None, max_repos=200):
     """
     Fetch all public repositories for a GitHub organization or user.
diff --git a/src/handlers.py b/src/handlers.py
index 5f72d27..8ec1a85 100644
--- a/src/handlers.py
+++ b/src/handlers.py
@@ -21,7 +21,8 @@
 from database import get_db, upsert_pr
 from github_api import (
     fetch_pr_data, fetch_pr_timeline_data, fetch_paginated_data,
-    verify_github_signature, fetch_multiple_prs_batch, fetch_org_repos
+    verify_github_signature, fetch_multiple_prs_batch, fetch_org_repos,
+    fetch_repo_open_prs, fetch_repo_comparison_batch
 )
 
 # SQL expression for computed field: issues_count
@@ -633,7 +634,110 @@ async def handle_batch_refresh_prs(request, env):
     except Exception as e:
         return Response.new(json.dumps({'error': f"{type(e).__name__}: {str(e)}"}),
                           {'status': 500, 'headers': {'Content-Type': 'application/json'}})
-        
+
+
+async def handle_refresh_repo(request, env):
+    """
+    Refresh repo-level data (behind_by) for all tracked PRs in a specific repository.
+
+    POST /api/refresh-repo
+    Body: { "repo_owner": "OWASP-BLT", "repo_name": "BLT" }
+
+    This endpoint is optimised for the case where the base branch has advanced
+    (e.g. another PR was just merged).  Instead of re-fetching every PR in full,
+    it:
+      1. Loads the tracked PRs for the repo from the DB (no GitHub API call).
+      2. Issues a single GraphQL batch call to fetch comparison data (behind_by)
+         for all those PRs at once.
+      3. Updates only the `behind_by` column for each PR in the DB.
+
+    This separates the expensive repo-wide refresh from the cheaper per-PR refresh
+    (reviews, check runs, conversations) that the batch endpoint handles.
+    """
+    try:
+        data = (await request.json()).to_py()
+        repo_owner = data.get('repo_owner')
+        repo_name = data.get('repo_name')
+        user_token = request.headers.get('x-github-token') or getattr(env, 'GITHUB_TOKEN', None)
+
+        if not repo_owner or not repo_name:
+            return Response.new(
+                json.dumps({'error': 'repo_owner and repo_name are required'}),
+                {'status': 400, 'headers': {'Content-Type': 'application/json'}}
+            )
+
+        db = get_db(env)
+
+        # Step 1: Fetch all open PRs for this repo from GitHub (head_sha + base_branch per PR).
+        github_prs = await fetch_repo_open_prs(repo_owner, repo_name, user_token)
+
+        # Step 2: Cross-reference GitHub PRs with our DB to get only tracked PRs.
+        github_pr_map = {pr['number']: pr for pr in github_prs}
+
+        db_stmt = db.prepare(
+            'SELECT id, pr_number FROM prs WHERE repo_owner = ? AND repo_name = ? AND state = \'open\' AND is_merged = 0'
+        ).bind(repo_owner, repo_name)
+        db_result = await db_stmt.all()
+
+        if not db_result or not db_result.results:
+            return Response.new(
+                json.dumps({'success': True, 'updated': 0, 'message': 'No tracked open PRs found for this repo'}),
+                {'headers': {'Content-Type': 'application/json'}}
+            )
+
+        prs_info = []
+        pr_id_map = {}  # (owner, repo, pr_number) -> pr_id
+        for row in db_result.results:
+            row_dict = row.to_py()
+            pr_number = row_dict['pr_number']
+            pr_id = row_dict['id']
+            gh_pr = github_pr_map.get(pr_number)
+            if not gh_pr:
+                continue  # PR not found in GitHub open PRs (may have been closed)
+            head_sha = gh_pr.get('head_sha', '')
+            base_branch = gh_pr.get('base_branch', '')
+            if head_sha and base_branch:
+                prs_info.append({
+                    'owner': repo_owner,
+                    'repo': repo_name,
+                    'pr_number': pr_number,
+                    'head_sha': head_sha,
+                    'base_branch': base_branch,
+                })
+                pr_id_map[(repo_owner, repo_name, pr_number)] = pr_id
+
+        if not prs_info:
+            return Response.new(
+                json.dumps({'success': True, 'updated': 0, 'message': 'No PRs with valid ref data to compare'}),
+                {'headers': {'Content-Type': 'application/json'}}
+            )
+
+        # Step 3: Batch-fetch comparison data (behind_by) for all tracked PRs.
+        comparison_results = await fetch_repo_comparison_batch(prs_info, user_token)
+
+        # Step 4: Update behind_by in DB for each PR.
+        updated = 0
+        for key, behind_by in comparison_results.items():
+            pr_id = pr_id_map.get(key)
+            if pr_id is None:
+                continue
+            await db.prepare(
+                'UPDATE prs SET behind_by = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?'
+            ).bind(behind_by, pr_id).run()
+            updated += 1
+
+        return Response.new(json.dumps({
+            'success': True,
+            'updated': updated,
+            'repo': f'{repo_owner}/{repo_name}',
+            'rate_limit': get_rate_limit_cache()
+        }), {'headers': {'Content-Type': 'application/json'}})
+
+    except Exception as e:
+        return Response.new(json.dumps({'error': f"{type(e).__name__}: {str(e)}"}),
+                          {'status': 500, 'headers': {'Content-Type': 'application/json'}})
+
+
 async def handle_rate_limit(env):
     """
     GET /api/rate-limit
diff --git a/src/index.py b/src/index.py
index 8a69e8d..83f01be 100644
--- a/src/index.py
+++ b/src/index.py
@@ -9,6 +9,7 @@
     handle_list_repos,
     handle_refresh_pr,
     handle_batch_refresh_prs,
+    handle_refresh_repo,
     handle_rate_limit,
     handle_status,
     handle_pr_updates_check,
@@ -101,6 +102,8 @@ async def on_fetch(request, env):
         response = await handle_refresh_pr(request, env)
     elif path == '/api/refresh-batch' and request.method == 'POST':
         response = await handle_batch_refresh_prs(request, env)
+    elif path == '/api/refresh-repo' and request.method == 'POST':
+        response = await handle_refresh_repo(request, env)
     elif path == '/api/rate-limit' and request.method == 'GET':
         response = await handle_rate_limit(env)
         for key, value in cors_headers.items():