@oss-autopilot/core 1.6.3 → 1.7.1

package/dist/commands/dashboard-data.d.ts

@@ -10,6 +10,7 @@ export interface DashboardStats {
     mergedPRs: number;
     closedPRs: number;
     mergeRate: string;
+    availableIssues?: number;
 }
 export declare function buildDashboardStats(digest: DailyDigest, state: Readonly<AgentState>, storedMergedCount?: number, storedClosedCount?: number): DashboardStats;
 /**

package/dist/commands/dashboard-server.js

@@ -13,7 +13,8 @@ import { errorMessage, ValidationError } from '../core/errors.js';
 import { warn } from '../core/logger.js';
 import { validateUrl, validateGitHubUrl, PR_URL_PATTERN, ISSUE_URL_PATTERN } from './validation.js';
 import { fetchDashboardData, computePRsByRepo, computeTopRepos, getMonthlyData, buildDashboardStats, storedToMergedPRs, storedToClosedPRs, } from './dashboard-data.js';
-import { openInBrowser } from './startup.js';
+import { openInBrowser, detectIssueList } from './startup.js';
+import { parseIssueList } from './parse-list.js';
 import { writeDashboardServerInfo, removeDashboardServerInfo } from './dashboard-process.js';
 import { RateLimiter } from './rate-limiter.js';
 import { isBelowMinStars, } from '../core/types.js';
@@ -34,6 +35,22 @@ const MIME_TYPES = {
     '.ico': 'image/x-icon',
 };
 // ── Helpers ────────────────────────────────────────────────────────────────────
+/**
+ * Read and parse the vetted issue list file (non-fatal on failure).
+ */
+function readVettedIssues() {
+    try {
+        const info = detectIssueList();
+        if (!info)
+            return null;
+        const content = fs.readFileSync(info.path, 'utf-8');
+        return parseIssueList(content);
+    }
+    catch (error) {
+        warn(MODULE, `Failed to read vetted issue list: ${errorMessage(error)}`);
+        return null;
+    }
+}
 /**
  * Build the JSON payload that the SPA expects from GET /api/data.
  */
@@ -60,6 +77,10 @@ function buildDashboardJson(digest, state, commentedIssues, allMergedPRs, allClo
             repoMetadata[repo] = { stars: score.stargazersCount, language: score.language };
         }
     }
+    const vettedIssues = readVettedIssues();
+    if (vettedIssues) {
+        stats.availableIssues = vettedIssues.availableCount;
+    }
     return {
         stats,
         prsByRepo,
@@ -77,6 +98,7 @@ function buildDashboardJson(digest, state, commentedIssues, allMergedPRs, allClo
         allMergedPRs: filteredMergedPRs,
         allClosedPRs: filteredClosedPRs,
         repoMetadata,
+        vettedIssues,
     };
 }
 /**

package/dist/commands/index.d.ts

@@ -56,7 +56,7 @@ export { runSetup } from './setup.js';
 /** Check whether setup has been completed. */
 export { runCheckSetup } from './setup.js';
 /** Parse a curated markdown issue list file into structured issue items. */
-export { runParseList } from './parse-list.js';
+export { runParseList, pruneIssueList } from './parse-list.js';
 /** Check if new files are properly referenced/integrated. */
 export { runCheckIntegration } from './check-integration.js';
 /** Detect formatters/linters configured in a local repository (#703). */
@@ -65,7 +65,7 @@ export { runDetectFormatters } from './detect-formatters.js';
 export { runLocalRepos } from './local-repos.js';
 export type { DailyOutput, SearchOutput, StartupOutput, StatusOutput, TrackOutput } from '../formatters/json.js';
 export type { VetOutput, CommentsOutput, PostOutput, ClaimOutput } from '../formatters/json.js';
-export type { ConfigOutput, DetectFormattersOutput, ParseIssueListOutput, CheckIntegrationOutput, LocalReposOutput, } from '../formatters/json.js';
+export type { ConfigOutput, DetectFormattersOutput, ParseIssueListOutput, ParsedIssueItem, CheckIntegrationOutput, LocalReposOutput, } from '../formatters/json.js';
 export type { ReadOutput } from './read.js';
 export type { ShelveOutput, UnshelveOutput } from './shelve.js';
 export type { MoveOutput, MoveTarget } from './move.js';

package/dist/commands/index.js

@@ -61,7 +61,7 @@ export { runSetup } from './setup.js';
 export { runCheckSetup } from './setup.js';
 // ── Utilities ───────────────────────────────────────────────────────────────
 /** Parse a curated markdown issue list file into structured issue items. */
-export { runParseList } from './parse-list.js';
+export { runParseList, pruneIssueList } from './parse-list.js';
 /** Check if new files are properly referenced/integrated. */
 export { runCheckIntegration } from './check-integration.js';
 /** Detect formatters/linters configured in a local repository (#703). */

package/dist/commands/parse-list.d.ts

@@ -9,4 +9,18 @@ interface ParseListOptions {
 export type { ParseIssueListOutput, ParsedIssueItem };
 /** Parse a markdown string into structured issue items */
 export declare function parseIssueList(content: string): ParseIssueListOutput;
+/**
+ * Prune a markdown issue list: remove completed, skipped, and low-score items.
+ * Rewrites the file in place, removing:
+ * - Items with strikethrough, [x], Done, Skip, or Dropped status
+ * - Items with score < minScore
+ * - Empty section headings left after removal
+ * - Sub-bullets belonging to removed items
+ *
+ * @returns Count of items removed
+ */
+export declare function pruneIssueList(content: string, minScore?: number): {
+    pruned: string;
+    removedCount: number;
+};
 export declare function runParseList(options: ParseListOptions): Promise<ParseIssueListOutput>;

package/dist/commands/parse-list.js

@@ -48,17 +48,34 @@ function isCompleted(line) {
         return true;
     return false;
 }
+/** Extract a score from a sub-bullet line (e.g., "Score 8/10" or "Score 7.5/10") */
+function extractScore(line) {
+    const match = line.match(/Score\s+(\d+(?:\.\d+)?)\/10/i);
+    return match ? parseFloat(match[1]) : undefined;
+}
+/** Check if a sub-bullet indicates the item is terminal (completed/abandoned — safe to prune) */
+function isSubBulletTerminal(line) {
+    return /\*\*(Skip|Done|Dropped|Merged|Closed)\*\*/i.test(line);
+}
+/** Check if a sub-bullet indicates the item is in-progress (not available, but NOT safe to prune) */
+function isSubBulletInProgress(line) {
+    return /\*\*(In Progress|Wait|Waiting)\*\*/i.test(line);
+}
 /** Parse a markdown string into structured issue items */
 export function parseIssueList(content) {
     const lines = content.split('\n');
     const available = [];
     const completed = [];
     let currentTier = 'Uncategorized';
+    let lastItem = null;
+    // Track which array the last item was placed in so sub-bullets can move it
+    let lastItemInAvailable = false;
     for (const line of lines) {
         // Check for section headings (# or ##)
         const headingMatch = line.match(/^#{1,3}\s+(.+)/);
         if (headingMatch) {
             currentTier = headingMatch[1].trim();
+            lastItem = null;
             continue;
         }
         // Skip empty lines and non-list items
@@ -67,8 +84,26 @@ export function parseIssueList(content) {
         }
         // Extract GitHub URL -- skip lines without one
         const ghUrl = extractGitHubUrl(line);
-        if (!ghUrl)
+        if (!ghUrl) {
+            // No URL — check if this is a sub-bullet for the previous item
+            if (lastItem && /^\s{2,}/.test(line)) {
+                const score = extractScore(line);
+                if (score !== undefined) {
+                    lastItem.score = score;
+                }
+                // Check if sub-bullet marks item as terminal or in-progress
+                if (lastItemInAvailable && (isSubBulletTerminal(line) || isSubBulletInProgress(line))) {
+                    // Move from available to completed
+                    const idx = available.indexOf(lastItem);
+                    if (idx !== -1) {
+                        available.splice(idx, 1);
+                        completed.push(lastItem);
+                        lastItemInAvailable = false;
+                    }
+                }
+            }
             continue;
+        }
         const title = extractTitle(line);
         const item = {
             repo: ghUrl.repo,
@@ -79,10 +114,13 @@ export function parseIssueList(content) {
         };
         if (isCompleted(line)) {
             completed.push(item);
+            lastItemInAvailable = false;
         }
         else {
             available.push(item);
+            lastItemInAvailable = true;
         }
+        lastItem = item;
     }
     return {
         available,
@@ -91,6 +129,112 @@ export function parseIssueList(content) {
         completedCount: completed.length,
     };
 }
+/**
+ * Prune a markdown issue list: remove completed, skipped, and low-score items.
+ * Rewrites the file in place, removing:
+ * - Items with strikethrough, [x], Done, Skip, or Dropped status
+ * - Items with score < minScore
+ * - Empty section headings left after removal
+ * - Sub-bullets belonging to removed items
+ *
+ * @returns Count of items removed
+ */
+export function pruneIssueList(content, minScore = 6) {
+    const lines = content.split('\n');
+    const output = [];
+    let removedCount = 0;
+    let skipSubBullets = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Always keep headings (we'll clean empty ones in a second pass)
+        if (/^#{1,3}\s+/.test(line)) {
+            skipSubBullets = false;
+            output.push(line);
+            continue;
+        }
+        // Sub-bullet of a removed item — skip it
+        if (skipSubBullets && /^\s{2,}/.test(line)) {
+            continue;
+        }
+        skipSubBullets = false;
+        // Check if this is a list item
+        const isList = /^\s*[-*+]\s/.test(line);
+        // Remove any completed list item (even without a GitHub URL)
+        if (isList && isCompleted(line)) {
+            removedCount++;
+            skipSubBullets = true;
+            continue;
+        }
+        const ghUrl = extractGitHubUrl(line);
+        if (ghUrl) {
+            // Look ahead at sub-bullets for terminal status or low score
+            let shouldRemove = false;
+            let j = i + 1;
+            while (j < lines.length && /^\s{2,}/.test(lines[j])) {
+                if (isSubBulletTerminal(lines[j])) {
+                    shouldRemove = true;
+                }
+                const score = extractScore(lines[j]);
+                if (score !== undefined && score < minScore) {
+                    shouldRemove = true;
+                }
+                j++;
+            }
+            if (shouldRemove) {
+                removedCount++;
+                skipSubBullets = true;
+                continue;
+            }
+        }
+        // Skip cruft lines: "Skip (N issues)", standalone "---", old "Removed" labels
+        if (/^\s*skip\s*\(\d+\s*issues?\)/i.test(line.replace(/[#*]/g, '').trim())) {
+            continue;
+        }
+        if (/^---\s*$/.test(line)) {
+            continue;
+        }
+        if (/^\s*(###?\s*)?(Removed|Previously dropped)/i.test(line)) {
+            continue;
+        }
+        // Skip blockquote metadata lines ("> Sources: ...", "> Prioritized ...")
+        if (/^>\s/.test(line)) {
+            continue;
+        }
+        // Non-list lines, metadata, and surviving items — keep
+        output.push(line);
+    }
+    // Second pass: remove empty section headings (heading followed by another heading or end of file)
+    const cleaned = [];
+    for (let i = 0; i < output.length; i++) {
+        const isHeading = /^#{1,3}\s+/.test(output[i]);
+        if (isHeading) {
+            // Check if next non-empty line is another heading or end of content
+            let nextContentIdx = i + 1;
+            while (nextContentIdx < output.length && output[nextContentIdx].trim() === '') {
+                nextContentIdx++;
+            }
+            const nextIsHeadingOrEnd = nextContentIdx >= output.length || /^#{1,3}\s+/.test(output[nextContentIdx]);
+            if (nextIsHeadingOrEnd) {
+                // Skip this empty heading and any blank lines after it
+                continue;
+            }
+        }
+        cleaned.push(output[i]);
+    }
+    // Collapse consecutive blank lines into at most one
+    const collapsed = [];
+    for (const line of cleaned) {
+        if (line.trim() === '' && collapsed.length > 0 && collapsed[collapsed.length - 1].trim() === '') {
+            continue;
+        }
+        collapsed.push(line);
+    }
+    // Remove trailing blank lines
+    while (collapsed.length > 0 && collapsed[collapsed.length - 1].trim() === '') {
+        collapsed.pop();
+    }
+    return { pruned: collapsed.join('\n') + '\n', removedCount };
+}
 export async function runParseList(options) {
     const filePath = path.resolve(options.filePath);
     if (!fs.existsSync(filePath)) {

package/dist/commands/vet-list.d.ts

@@ -6,6 +6,7 @@ import { type VetListOutput, type VetOutput, type VetListItemStatus } from '../f
 interface VetListOptions {
     issueListPath?: string;
     concurrency?: number;
+    prune?: boolean;
 }
 /**
  * Determine the list status from vetting results.

package/dist/commands/vet-list.js

@@ -2,7 +2,9 @@
  * Vet-list command (#764)
  * Re-vets all available issues in a curated issue list file.
  */
+import * as fs from 'fs';
 import { IssueDiscovery, requireGitHubToken } from '../core/index.js';
+import { runParseList, pruneIssueList } from './parse-list.js';
 import { detectIssueList } from './startup.js';
 /**
  * Determine the list status from vetting results.
@@ -43,7 +45,6 @@ export async function runVetList(options = {}) {
         }
         issueListPath = detected.path;
     }
-    const { runParseList } = await import('./parse-list.js');
     const parsed = await runParseList({ filePath: issueListPath });
     if (parsed.available.length === 0) {
         return {
@@ -108,5 +109,21 @@ export async function runVetList(options = {}) {
         hasPR: results.filter((r) => r.listStatus === 'has_pr').length,
         errors: results.filter((r) => r.listStatus === 'error').length,
     };
-    return { results, summary };
+    // 4. Prune the file if requested — remove completed/skipped/low-score items
+    let pruneResult;
+    if (options.prune && issueListPath) {
+        try {
+            const content = fs.readFileSync(issueListPath, 'utf-8');
+            const { pruned, removedCount } = pruneIssueList(content);
+            if (pruned !== content) {
+                fs.writeFileSync(issueListPath, pruned, 'utf-8');
+            }
+            pruneResult = { removedCount };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            console.error(`Warning: Failed to prune ${issueListPath}: ${msg}`);
+        }
+    }
+    return { results, summary, pruneResult };
 }

package/dist/core/issue-discovery.js

@@ -13,6 +13,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { getOctokit, checkRateLimit } from './github.js';
 import { getStateManager } from './state.js';
+import { getSearchBudgetTracker } from './search-budget.js';
 import { daysBetween, getDataDir, sleep } from './utils.js';
 import { DEFAULT_CONFIG, SCOPE_LABELS } from './types.js';
 import { ValidationError, errorMessage, getHttpStatusCode, isRateLimitError } from './errors.js';
@@ -159,10 +160,12 @@ export class IssueDiscovery {
         let rateLimitHitDuringSearch = false;
         // Pre-flight rate limit check (#100) — also determines adaptive phase budget
         this.rateLimitWarning = null;
+        const tracker = getSearchBudgetTracker();
         let searchBudget = LOW_BUDGET_THRESHOLD - 1; // conservative: below threshold to skip heavy phases
         try {
             const rateLimit = await checkRateLimit(this.githubToken);
             searchBudget = rateLimit.remaining;
+            tracker.init(rateLimit.remaining, rateLimit.resetAt);
             if (rateLimit.remaining < 5) {
                 const resetTime = new Date(rateLimit.resetAt).toLocaleTimeString('en-US', { hour12: false });
                 this.rateLimitWarning = `GitHub search API quota low (${rateLimit.remaining}/${rateLimit.limit} remaining, resets at ${resetTime}). Search may be slow.`;
@@ -180,7 +183,9 @@ export class IssueDiscovery {
             if (getHttpStatusCode(error) === 401) {
                 throw error;
             }
-            // Non-fatal: proceed with conservative budget for transient/network errors
+            // Non-fatal: proceed with conservative budget for transient/network errors.
+            // Initialize tracker with conservative defaults so it doesn't fly blind.
+            tracker.init(CRITICAL_BUDGET_THRESHOLD, new Date(Date.now() + 60000).toISOString());
             warn(MODULE, 'Could not check rate limit — using conservative budget, skipping heavy phases:', errorMessage(error));
         }
         // Get merged-PR repos (highest merge probability)
@@ -329,7 +334,12 @@ export class IssueDiscovery {
                 info(MODULE, `Phase 1: Searching issues in ${reposToSearch.length} starred repos...`);
                 const remainingNeeded = maxResults - allCandidates.length;
                 if (remainingNeeded > 0) {
-                    const { candidates: starredCandidates, allBatchesFailed, rateLimitHit, } = await searchInRepos(this.octokit, this.vetter, reposToSearch.slice(0, 10), baseQualifiers, labels, remainingNeeded, 'starred', filterIssues);
+                    // Cap labels to reduce Search API calls: starred repos already signal user
+                    // interest, so fewer labels suffice. With 3 labels and batch size 3 (2 repo ORs),
+                    // each batch fits in a single label chunk instead of 3+, cutting Phase 1 calls
+                    // from ~12 to ~4.
+                    const phase1Labels = labels.slice(0, 3);
+                    const { candidates: starredCandidates, allBatchesFailed, rateLimitHit, } = await searchInRepos(this.octokit, this.vetter, reposToSearch.slice(0, 10), baseQualifiers, phase1Labels, remainingNeeded, 'starred', filterIssues);
                     allCandidates.push(...starredCandidates);
                     if (allBatchesFailed) {
                         phase1Error = 'All starred repo batches failed';
@@ -502,6 +512,7 @@ export class IssueDiscovery {
         });
         // Apply per-repo cap: max 2 issues from any single repo (#105)
         const capped = applyPerRepoCap(allCandidates, 2);
+        info(MODULE, `Search complete: ${tracker.getTotalCalls()} Search API calls used, ${capped.length} candidates returned`);
         return capped.slice(0, maxResults);
     }
     /**

package/dist/core/issue-eligibility.d.ts

@@ -14,12 +14,15 @@ export interface CheckResult {
 }
 /**
  * Check whether an open PR already exists for the given issue.
- * Searches both the PR search index and the issue timeline for linked PRs.
+ * Uses the timeline API (REST) to detect cross-referenced PRs, avoiding
+ * the Search API's strict 30 req/min rate limit.
  */
 export declare function checkNoExistingPR(octokit: Octokit, owner: string, repo: string, issueNumber: number): Promise<CheckResult>;
 /**
  * Check how many merged PRs the authenticated user has in a repo.
  * Uses GitHub Search API. Returns 0 on error (non-fatal).
+ * Results are cached per-repo for 15 minutes to avoid redundant Search API
+ * calls when multiple issues from the same repo are vetted.
  */
 export declare function checkUserMergedPRsInRepo(octokit: Octokit, owner: string, repo: string): Promise<number>;
 /**

package/dist/core/issue-eligibility.js

@@ -8,6 +8,8 @@
 import { paginateAll } from './pagination.js';
 import { errorMessage } from './errors.js';
 import { warn } from './logger.js';
+import { getHttpCache } from './http-cache.js';
+import { getSearchBudgetTracker } from './search-budget.js';
 const MODULE = 'issue-eligibility';
 /** Phrases that indicate someone has already claimed an issue. */
 const CLAIM_PHRASES = [
@@ -29,16 +31,16 @@ const CLAIM_PHRASES = [
 ];
 /**
  * Check whether an open PR already exists for the given issue.
- * Searches both the PR search index and the issue timeline for linked PRs.
+ * Uses the timeline API (REST) to detect cross-referenced PRs, avoiding
+ * the Search API's strict 30 req/min rate limit.
  */
 export async function checkNoExistingPR(octokit, owner, repo, issueNumber) {
     try {
-        // Search for PRs that mention this issue
-        const { data } = await octokit.search.issuesAndPullRequests({
-            q: `repo:${owner}/${repo} is:pr ${issueNumber}`,
-            per_page: 5,
-        });
-        // Also check timeline for linked PRs
+        // Use the timeline API (REST, not Search) to detect linked PRs.
+        // This avoids consuming GitHub Search API quota (30 req/min limit).
+        // Timeline captures formally linked PRs via cross-referenced events
+        // but may miss PRs that only mention the issue number without a formal
+        // link — an acceptable trade-off since most PRs use "Fixes #N" syntax.
         const timeline = await paginateAll((page) => octokit.issues.listEventsForTimeline({
             owner,
             repo,
@@ -50,7 +52,7 @@ export async function checkNoExistingPR(octokit, owner, repo, issueNumber) {
             const e = event;
             return e.event === 'cross-referenced' && e.source?.issue?.pull_request;
         });
-        return { passed: data.total_count === 0 && linkedPRs.length === 0 };
+        return { passed: linkedPRs.length === 0 };
     }
     catch (error) {
         const errMsg = errorMessage(error);
@@ -58,23 +60,46 @@ export async function checkNoExistingPR(octokit, owner, repo, issueNumber) {
         return { passed: true, inconclusive: true, reason: errMsg };
     }
 }
+/** TTL for cached merged-PR counts per repo (15 minutes). */
+const MERGED_PR_CACHE_TTL_MS = 15 * 60 * 1000;
 /**
  * Check how many merged PRs the authenticated user has in a repo.
  * Uses GitHub Search API. Returns 0 on error (non-fatal).
+ * Results are cached per-repo for 15 minutes to avoid redundant Search API
+ * calls when multiple issues from the same repo are vetted.
  */
 export async function checkUserMergedPRsInRepo(octokit, owner, repo) {
+    const cache = getHttpCache();
+    const cacheKey = `merged-prs:${owner}/${repo}`;
+    // Manual cache check — do not use cachedTimeBased because we must NOT cache
+    // error-path fallback values (a transient failure returning 0 would poison the
+    // cache for 15 minutes, hiding that the user has merged PRs in the repo).
+    const cached = cache.getIfFresh(cacheKey, MERGED_PR_CACHE_TTL_MS);
+    if (cached != null && typeof cached === 'number') {
+        return cached;
+    }
     try {
-        // Use @me to search as the authenticated user
-        const { data } = await octokit.search.issuesAndPullRequests({
-            q: `repo:${owner}/${repo} is:pr is:merged author:@me`,
-            per_page: 1, // We only need total_count
-        });
-        return data.total_count;
+        const tracker = getSearchBudgetTracker();
+        await tracker.waitForBudget();
+        try {
+            // Use @me to search as the authenticated user
+            const { data } = await octokit.search.issuesAndPullRequests({
+                q: `repo:${owner}/${repo} is:pr is:merged author:@me`,
+                per_page: 1, // We only need total_count
+            });
+            // Only cache successful results
+            cache.set(cacheKey, '', data.total_count);
+            return data.total_count;
+        }
+        finally {
+            // Always record the call — failed requests still consume GitHub rate limit points
+            tracker.recordCall();
+        }
     }
     catch (error) {
         const errMsg = errorMessage(error);
         warn(MODULE, `Could not check merged PRs in ${owner}/${repo}: ${errMsg}. Defaulting to 0.`);
-        return 0;
+        return 0; // Not cached — next call will retry
     }
 }
 /**

package/dist/core/issue-vetting.js

@@ -52,13 +52,17 @@ export class IssueVetter {
             repo,
             issue_number: number,
         });
+        // Check local state first to skip the merged-PR Search API call when
+        // the repo already has authoritative data (saves 1 Search call per issue).
+        const repoScoreRecord = this.stateManager.getRepoScore(repoFullName);
+        const skipMergedPRCheck = repoScoreRecord != null && repoScoreRecord.mergedPRCount > 0;
         // Run all vetting checks in parallel — delegates to standalone functions
         const [existingPRCheck, claimCheck, projectHealth, contributionGuidelines, userMergedPRCount] = await Promise.all([
             checkNoExistingPR(this.octokit, owner, repo, number),
             checkNotClaimed(this.octokit, owner, repo, number, ghIssue.comments),
             checkProjectHealth(this.octokit, owner, repo),
             fetchContributionGuidelines(this.octokit, owner, repo),
-            checkUserMergedPRsInRepo(this.octokit, owner, repo),
+            skipMergedPRCheck ? Promise.resolve(0) : checkUserMergedPRsInRepo(this.octokit, owner, repo),
         ]);
         const noExistingPR = existingPRCheck.passed;
         const notClaimed = claimCheck.passed;
@@ -138,7 +142,6 @@ export class IssueVetter {
         // Determine effective merged PR count: prefer local state (authoritative if present),
         // fall back to live GitHub API count to detect contributions made before using oss-autopilot (#373)
         const config = this.stateManager.getState().config;
-        const repoScoreRecord = this.stateManager.getRepoScore(repoFullName);
         const effectiveMergedCount = repoScoreRecord && repoScoreRecord.mergedPRCount > 0 ? repoScoreRecord.mergedPRCount : userMergedPRCount;
         if (effectiveMergedCount > 0) {
             reasonsToApprove.push(`Trusted project (${effectiveMergedCount} PR${effectiveMergedCount > 1 ? 's' : ''} merged)`);
@@ -230,6 +233,18 @@ export class IssueVetter {
             viabilityScore,
             searchPriority,
         };
+        // Persist repo metadata (stars, language) so the dashboard can display it (#839)
+        if (!projectHealth.checkFailed) {
+            try {
+                this.stateManager.updateRepoScore(repoFullName, {
+                    stargazersCount: projectHealth.stargazersCount,
+                    language: projectHealth.language,
+                });
+            }
+            catch (error) {
+                warn(MODULE, `Failed to persist repo metadata for ${repoFullName}: ${errorMessage(error)}`);
+            }
+        }
         // Cache the vetting result to avoid redundant API calls on repeated searches
         cache.set(cacheKey, '', result);
         return result;

package/dist/core/repo-health.js

@@ -83,6 +83,7 @@ export async function checkProjectHealth(octokit, owner, repo) {
                 isActive: daysSinceLastCommit < 30,
                 stargazersCount: repoData.stargazers_count,
                 forksCount: repoData.forks_count,
+                language: repoData.language,
             };
         });
     }

package/dist/core/search-budget.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Search Budget Tracker — centralized rate limit management for GitHub Search API.
+ *
+ * The GitHub Search API enforces a strict 30 requests/minute limit for
+ * authenticated users. This module tracks actual consumption via a sliding
+ * window and provides adaptive delays to stay within budget.
+ *
+ * Usage:
+ * - Initialize once per search run with pre-flight rate limit data
+ * - Call recordCall() after every Search API call
+ * - Call waitForBudget() before making a Search API call to pace requests
+ * - Call canAfford(n) to check if n more calls fit in the remaining budget
+ */
+export declare class SearchBudgetTracker {
+    /** Timestamps of recent Search API calls within the sliding window. */
+    private callTimestamps;
+    /** Last known remaining quota from GitHub's rate limit endpoint. */
+    private knownRemaining;
+    /** Epoch ms when the rate limit window resets (from GitHub API). */
+    private resetAt;
+    /** Total calls recorded since init (for diagnostics). */
+    private totalCalls;
+    /**
+     * Initialize with pre-flight rate limit data from GitHub.
+     */
+    init(remaining: number, resetAt: string): void;
+    /**
+     * Record that a Search API call was just made.
+     */
+    recordCall(): void;
+    /**
+     * Remove timestamps older than the sliding window.
+     */
+    private pruneOldTimestamps;
+    /**
+     * Get the number of calls made in the current sliding window.
+     */
+    getCallsInWindow(): number;
+    /**
+     * Get the effective budget, accounting for both the sliding window limit
+     * and the pre-flight remaining quota from GitHub.
+     */
+    private getEffectiveBudget;
+    /**
+     * Check if we can afford N more Search API calls without exceeding the budget.
+     */
+    canAfford(n: number): boolean;
+    /**
+     * Wait if necessary to stay within the Search API rate limit.
+     * If the sliding window is at capacity, sleeps until the oldest
+     * call ages out of the window.
+     */
+    waitForBudget(): Promise<void>;
+    /**
+     * Get total calls recorded since init (for diagnostics).
+     */
+    getTotalCalls(): number;
+}
+/**
+ * Get (or create) the shared SearchBudgetTracker singleton.
+ */
+export declare function getSearchBudgetTracker(): SearchBudgetTracker;