@oss-autopilot/core 1.2.0 → 1.4.0

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

@@ -0,0 +1,24 @@
+/**
+ * Vet-list command (#764)
+ * Re-vets all available issues in a curated issue list file.
+ */
+import { type VetListOutput, type VetOutput, type VetListItemStatus } from '../formatters/json.js';
+interface VetListOptions {
+    issueListPath?: string;
+    concurrency?: number;
+}
+/**
+ * Determine the list status from vetting results.
+ * Maps vetting recommendation + reasons to a list-level status.
+ */
+export declare function classifyListStatus(vetResult: VetOutput): VetListItemStatus;
+/**
+ * Re-vet all available issues in a curated issue list.
+ * Reads the list file, extracts available (non-done) issues,
+ * and vets each in parallel with concurrency control.
+ *
+ * @param options - Vet-list options
+ * @returns Consolidated vetting results with list status for each issue
+ */
+export declare function runVetList(options?: VetListOptions): Promise<VetListOutput>;
+export {};

package/dist/commands/vet-list.js

@@ -0,0 +1,112 @@
+/**
+ * Vet-list command (#764)
+ * Re-vets all available issues in a curated issue list file.
+ */
+import { IssueDiscovery, requireGitHubToken } from '../core/index.js';
+import { detectIssueList } from './startup.js';
+/**
+ * Determine the list status from vetting results.
+ * Maps vetting recommendation + reasons to a list-level status.
+ */
+export function classifyListStatus(vetResult) {
+    const skipReasons = vetResult.reasonsToSkip.map((r) => r.toLowerCase());
+    if (skipReasons.some((r) => r.includes('closed')))
+        return 'closed';
+    if (skipReasons.some((r) => r.includes('claimed') || r.includes('assigned')))
+        return 'claimed';
+    if (skipReasons.some((r) => r.includes('existing pr') || r.includes('linked pr') || r.includes('pull request')))
+        return 'has_pr';
+    if (vetResult.recommendation === 'approve' || vetResult.recommendation === 'needs_review') {
+        return 'still_available';
+    }
+    // Default: if skipped for other reasons, still mark as available
+    // (the vetting result will show why it's not recommended)
+    return 'still_available';
+}
+/**
+ * Re-vet all available issues in a curated issue list.
+ * Reads the list file, extracts available (non-done) issues,
+ * and vets each in parallel with concurrency control.
+ *
+ * @param options - Vet-list options
+ * @returns Consolidated vetting results with list status for each issue
+ */
+export async function runVetList(options = {}) {
+    const token = requireGitHubToken();
+    const concurrency = options.concurrency ?? 5;
+    // 1. Find and parse the issue list
+    let issueListPath = options.issueListPath;
+    if (!issueListPath) {
+        const detected = detectIssueList();
+        if (!detected) {
+            throw new Error('No issue list found. Provide a path with --path or configure issueListPath in settings.');
+        }
+        issueListPath = detected.path;
+    }
+    const { runParseList } = await import('./parse-list.js');
+    const parsed = await runParseList({ filePath: issueListPath });
+    if (parsed.available.length === 0) {
+        return {
+            results: [],
+            summary: { total: 0, stillAvailable: 0, claimed: 0, closed: 0, hasPR: 0, errors: 0 },
+        };
+    }
+    // 2. Vet each available issue in parallel with concurrency limit
+    const discovery = new IssueDiscovery(token);
+    const results = [];
+    // Simple concurrency limiter
+    const items = parsed.available;
+    let index = 0;
+    async function processNext() {
+        while (index < items.length) {
+            const item = items[index++];
+            try {
+                const candidate = await discovery.vetIssue(item.url);
+                const vetResult = {
+                    issue: {
+                        repo: candidate.issue.repo,
+                        number: candidate.issue.number,
+                        title: candidate.issue.title,
+                        url: candidate.issue.url,
+                        labels: candidate.issue.labels,
+                    },
+                    recommendation: candidate.recommendation,
+                    reasonsToApprove: candidate.reasonsToApprove,
+                    reasonsToSkip: candidate.reasonsToSkip,
+                    projectHealth: candidate.projectHealth,
+                    vettingResult: candidate.vettingResult,
+                };
+                results.push({
+                    ...vetResult,
+                    listStatus: classifyListStatus(vetResult),
+                });
+            }
+            catch (error) {
+                // Per-issue errors don't fail the batch
+                results.push({
+                    issue: { repo: item.repo, number: item.number, title: item.title, url: item.url, labels: [] },
+                    recommendation: 'skip',
+                    reasonsToApprove: [],
+                    reasonsToSkip: [`Error: ${error instanceof Error ? error.message : String(error)}`],
+                    projectHealth: {},
+                    vettingResult: {},
+                    listStatus: 'error',
+                    errorMessage: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+    }
+    // Start `concurrency` workers
+    const workers = Array.from({ length: Math.min(concurrency, items.length) }, () => processNext());
+    await Promise.all(workers);
+    // 3. Compute summary
+    const summary = {
+        total: results.length,
+        stillAvailable: results.filter((r) => r.listStatus === 'still_available').length,
+        claimed: results.filter((r) => r.listStatus === 'claimed').length,
+        closed: results.filter((r) => r.listStatus === 'closed').length,
+        hasPR: results.filter((r) => r.listStatus === 'has_pr').length,
+        errors: results.filter((r) => r.listStatus === 'error').length,
+    };
+    return { results, summary };
+}

package/dist/core/daily-logic.js

@@ -333,11 +333,25 @@ export function computeActionMenu(actionableIssues, capacity, commentedIssues =
     }
     // The orchestration layer (commands/oss.md Action Menu section) may insert issue-list
     // options before the search item when a curated list is available.
-    items.push({
+    const searchItem = {
         key: 'search',
         label: 'Search for new issues',
         description: 'Look for new contribution opportunities',
-    });
+    };
+    if (!capacity.hasCapacity) {
+        const atLimit = capacity.activePRCount >= capacity.maxActivePRs;
+        const hasCritical = capacity.criticalIssueCount > 0;
+        if (atLimit && hasCritical) {
+            searchItem.capacityWarning = `You're at ${capacity.activePRCount}/${capacity.maxActivePRs} active PRs and have ${capacity.criticalIssueCount} critical issue(s). Resolve existing work before claiming new issues.`;
+        }
+        else if (atLimit) {
+            searchItem.capacityWarning = `You're at ${capacity.activePRCount}/${capacity.maxActivePRs} active PRs. Claiming a new issue will exceed your limit.`;
+        }
+        else {
+            searchItem.capacityWarning = `You have ${capacity.criticalIssueCount} critical issue(s) needing attention. Resolve them before claiming new issues.`;
+        }
+    }
+    items.push(searchItem);
     items.push({
         key: 'done',
         label: 'Done for now',

package/dist/core/github.d.ts

@@ -24,7 +24,7 @@ export declare function getRateLimitCallbacks(): {
  * Returns a cached instance if the token matches, otherwise creates a new one.
  *
  * The client retries on primary rate limits (up to 2 retries) and
- * secondary rate limits (1 retry).
+ * secondary rate limits (up to 3 retries).
  *
  * @param token - GitHub personal access token
  * @returns Authenticated Octokit instance with rate limit throttling

package/dist/core/github.js

@@ -31,8 +31,8 @@ export function getRateLimitCallbacks() {
         onSecondaryRateLimit: (retryAfter, options, _octokit, retryCount) => {
             const opts = options;
             const resetAt = new Date(Date.now() + retryAfter * 1000);
-            if (retryCount < 1) {
-                warn(MODULE, `Secondary rate limit hit (retry ${retryCount + 1}/1, waiting ${retryAfter}s, resets at ${formatResetTime(resetAt)}) — ${opts.method} ${opts.url}`);
+            if (retryCount < 3) {
+                warn(MODULE, `Secondary rate limit hit (retry ${retryCount + 1}/3, waiting ${retryAfter}s, resets at ${formatResetTime(resetAt)}) — ${opts.method} ${opts.url}`);
                 return true;
             }
             warn(MODULE, `Secondary rate limit exceeded, not retrying — ${opts.method} ${opts.url} (resets at ${formatResetTime(resetAt)})`);
@@ -45,7 +45,7 @@ export function getRateLimitCallbacks() {
  * Returns a cached instance if the token matches, otherwise creates a new one.
  *
  * The client retries on primary rate limits (up to 2 retries) and
- * secondary rate limits (1 retry).
+ * secondary rate limits (up to 3 retries).
  *
  * @param token - GitHub personal access token
  * @returns Authenticated Octokit instance with rate limit throttling

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

@@ -14,11 +14,11 @@ import { type IssueCandidate } from './types.js';
  * Multi-phase issue discovery engine that searches GitHub for contributable issues.
  *
  * Search phases (in priority order):
- * 1. Repos where user has merged PRs (highest merge probability)
- * 2. Preferred organizations
- * 3. Starred repos
- * 4. General label-filtered search
- * 5. Actively maintained repos
+ * 0. Repos where user has merged PRs (highest merge probability)
+ * 0.5. Preferred organizations
+ * 1. Starred repos
+ * 2. General label-filtered search
+ * 3. Actively maintained repos
  *
  * Each candidate is vetted for claimability and scored 0-100 for viability.
  */
@@ -44,8 +44,8 @@ export declare class IssueDiscovery {
     getStarredReposWithRefresh(): Promise<string[]>;
     /**
      * Search for issues matching our criteria.
-     * Searches in priority order: merged-PR repos first (no label filter), then starred repos,
-     * then general search, then actively maintained repos.
+     * Searches in priority order: merged-PR repos first (no label filter), then preferred
+     * organizations, then starred repos, then general search, then actively maintained repos.
      * Filters out issues from low-scoring and excluded repos.
      *
      * @param options - Search configuration

package/dist/core/issue-discovery.js

@@ -13,7 +13,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { getOctokit, checkRateLimit } from './github.js';
 import { getStateManager } from './state.js';
-import { daysBetween, getDataDir } from './utils.js';
+import { daysBetween, getDataDir, sleep } from './utils.js';
 import { DEFAULT_CONFIG, SCOPE_LABELS } from './types.js';
 import { ValidationError, errorMessage, getHttpStatusCode, isRateLimitError } from './errors.js';
 import { debug, info, warn } from './logger.js';
@@ -22,15 +22,21 @@ import { IssueVetter } from './issue-vetting.js';
 import { getTopicsForCategories } from './category-mapping.js';
 import { buildEffectiveLabels, interleaveArrays, cachedSearchIssues, filterVetAndScore, searchInRepos, searchWithChunkedLabels, } from './search-phases.js';
 const MODULE = 'issue-discovery';
+/** Delay between major search phases to let GitHub's rate limit window cool down. */
+const INTER_PHASE_DELAY_MS = 2000;
+/** If remaining search quota is below this, skip heavy phases (2, 3). */
+const LOW_BUDGET_THRESHOLD = 20;
+/** If remaining search quota is below this, only run Phase 0. */
+const CRITICAL_BUDGET_THRESHOLD = 10;
 /**
  * Multi-phase issue discovery engine that searches GitHub for contributable issues.
  *
  * Search phases (in priority order):
- * 1. Repos where user has merged PRs (highest merge probability)
- * 2. Preferred organizations
- * 3. Starred repos
- * 4. General label-filtered search
- * 5. Actively maintained repos
+ * 0. Repos where user has merged PRs (highest merge probability)
+ * 0.5. Preferred organizations
+ * 1. Starred repos
+ * 2. General label-filtered search
+ * 3. Actively maintained repos
  *
  * Each candidate is vetted for claimability and scored 0-100 for viability.
  */
@@ -118,8 +124,8 @@ export class IssueDiscovery {
     }
     /**
      * Search for issues matching our criteria.
-     * Searches in priority order: merged-PR repos first (no label filter), then starred repos,
-     * then general search, then actively maintained repos.
+     * Searches in priority order: merged-PR repos first (no label filter), then preferred
+     * organizations, then starred repos, then general search, then actively maintained repos.
      * Filters out issues from low-scoring and excluded repos.
      *
      * @param options - Search configuration
@@ -151,23 +157,31 @@ export class IssueDiscovery {
         let phase0Error = null;
         let phase1Error = null;
         let rateLimitHitDuringSearch = false;
-        // Pre-flight rate limit check (#100)
+        // Pre-flight rate limit check (#100) — also determines adaptive phase budget
         this.rateLimitWarning = null;
+        let searchBudget = LOW_BUDGET_THRESHOLD - 1; // conservative: below threshold to skip heavy phases
         try {
             const rateLimit = await checkRateLimit(this.githubToken);
+            searchBudget = rateLimit.remaining;
             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.`;
                 warn(MODULE, this.rateLimitWarning);
             }
+            if (searchBudget < CRITICAL_BUDGET_THRESHOLD) {
+                info(MODULE, `Search budget critical (${searchBudget} remaining) — running only Phase 0`);
+            }
+            else if (searchBudget < LOW_BUDGET_THRESHOLD) {
+                info(MODULE, `Search budget low (${searchBudget} remaining) — skipping heavy phases (2, 3)`);
+            }
         }
         catch (error) {
             // Fail fast on auth errors — no point searching with a bad token
             if (getHttpStatusCode(error) === 401) {
                 throw error;
             }
-            // Non-fatal: proceed with search for transient/network errors
-            warn(MODULE, 'Could not check rate limit:', errorMessage(error));
+            // Non-fatal: proceed with conservative budget for transient/network errors
+            warn(MODULE, 'Could not check rate limit — using conservative budget, skipping heavy phases:', errorMessage(error));
         }
         // Get merged-PR repos (highest merge probability)
         const mergedPRRepos = this.stateManager.getReposWithMergedPRs();
@@ -263,9 +277,13 @@ export class IssueDiscovery {
             }
         }
         // Phase 0.5: Search preferred organizations (explicit user preference)
+        // Skip if budget is critical — Phase 0 results are sufficient
         let phase0_5Error = null;
         const preferredOrgs = config.preferredOrgs ?? [];
-        if (allCandidates.length < maxResults && preferredOrgs.length > 0) {
+        if (allCandidates.length < maxResults && preferredOrgs.length > 0 && searchBudget >= CRITICAL_BUDGET_THRESHOLD) {
+            // Inter-phase delay to let GitHub's rate limit window cool down
+            if (phase0Repos.length > 0)
+                await sleep(INTER_PHASE_DELAY_MS);
             // Filter out orgs already covered by Phase 0 repos
             const phase0Orgs = new Set(phase0Repos.map((r) => r.split('/')[0]?.toLowerCase()));
             const orgsToSearch = preferredOrgs.filter((org) => !phase0Orgs.has(org.toLowerCase())).slice(0, 5);
@@ -303,7 +321,9 @@ export class IssueDiscovery {
             }
         }
         // Phase 1: Search starred repos (filter out already-searched Phase 0 repos)
-        if (allCandidates.length < maxResults && starredRepos.length > 0) {
+        // Skip if budget is critical
+        if (allCandidates.length < maxResults && starredRepos.length > 0 && searchBudget >= CRITICAL_BUDGET_THRESHOLD) {
+            await sleep(INTER_PHASE_DELAY_MS);
             const reposToSearch = starredRepos.filter((r) => !phase0RepoSet.has(r));
             if (reposToSearch.length > 0) {
                 info(MODULE, `Phase 1: Searching issues in ${reposToSearch.length} starred repos...`);
@@ -322,11 +342,13 @@ export class IssueDiscovery {
             }
         }
         // Phase 2: General search (if still need more)
+        // Skip if budget is low — Phases 0, 0.5, 1 are cheaper and higher-value
         // When multiple scope tiers are active, fire one query per tier and interleave
         // results to prevent high-volume tiers (e.g., "enhancement") from drowning out
         // beginner results.
         let phase2Error = null;
-        if (allCandidates.length < maxResults) {
+        if (allCandidates.length < maxResults && searchBudget >= LOW_BUDGET_THRESHOLD) {
+            await sleep(INTER_PHASE_DELAY_MS);
             info(MODULE, 'Phase 2: General issue search...');
             const remainingNeeded = maxResults - allCandidates.length;
             const seenRepos = new Set(allCandidates.map((c) => c.issue.repo));
@@ -390,8 +412,10 @@ export class IssueDiscovery {
             allCandidates.push(...interleaved.slice(0, remainingNeeded));
         }
         // Phase 3: Actively maintained repos (#349)
+        // Skip if budget is low — this phase is API-heavy with broad queries
         let phase3Error = null;
-        if (allCandidates.length < maxResults) {
+        if (allCandidates.length < maxResults && searchBudget >= LOW_BUDGET_THRESHOLD) {
+            await sleep(INTER_PHASE_DELAY_MS);
             info(MODULE, 'Phase 3: Searching actively maintained repos...');
             const remainingNeeded = maxResults - allCandidates.length;
             const thirtyDaysAgo = new Date();
@@ -430,6 +454,15 @@ export class IssueDiscovery {
                 warn(MODULE, `Error in maintained-repo search: ${errMsg}`);
             }
         }
+        // Determine if phases were skipped due to budget constraints
+        const phasesSkippedForBudget = searchBudget < LOW_BUDGET_THRESHOLD;
+        let budgetNote = '';
+        if (searchBudget < CRITICAL_BUDGET_THRESHOLD) {
+            budgetNote = ` Most search phases were skipped due to critically low API quota (${searchBudget} remaining).`;
+        }
+        else if (phasesSkippedForBudget) {
+            budgetNote = ` Some search phases were skipped due to low API quota (${searchBudget} remaining).`;
+        }
         if (allCandidates.length === 0) {
             const phaseErrors = [
                 phase0Error ? `Phase 0 (merged-PR repos): ${phase0Error}` : null,
@@ -439,9 +472,9 @@ export class IssueDiscovery {
                 phase3Error ? `Phase 3 (maintained repos): ${phase3Error}` : null,
             ].filter(Boolean);
             const details = phaseErrors.length > 0 ? ` ${phaseErrors.join('. ')}.` : '';
-            if (rateLimitHitDuringSearch) {
+            if (rateLimitHitDuringSearch || phasesSkippedForBudget) {
                 this.rateLimitWarning =
-                    `Search returned no results due to GitHub API rate limits.${details} ` +
+                    `Search returned no results due to GitHub API rate limits.${details}${budgetNote} ` +
                         `Try again after the rate limit resets.`;
                 return [];
             }
@@ -449,10 +482,10 @@ export class IssueDiscovery {
                 'Try adjusting your search criteria (languages, labels) or check your network connection.');
         }
         // Surface rate limit warning even with partial results (#100)
-        if (rateLimitHitDuringSearch) {
+        if (rateLimitHitDuringSearch || phasesSkippedForBudget) {
             this.rateLimitWarning =
-                `Search results may be incomplete: GitHub API rate limits were hit during search. ` +
-                    `Found ${allCandidates.length} candidate${allCandidates.length === 1 ? '' : 's'} but some search phases failed. ` +
+                `Search results may be incomplete: GitHub API rate limits were hit during search.${budgetNote} ` +
+                    `Found ${allCandidates.length} candidate${allCandidates.length === 1 ? '' : 's'} but some search phases were limited. ` +
                     `Try again after the rate limit resets for complete results.`;
         }
         // Sort by priority first, then by recommendation, then by viability score

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

@@ -15,6 +15,7 @@ export declare class IssueVetter {
     constructor(octokit: Octokit, stateManager: ReturnType<typeof getStateManager>);
     /**
      * Vet a specific issue — runs all checks and computes recommendation + viability score.
+     * Results are cached for 15 minutes to avoid redundant API calls on repeated searches.
      */
     vetIssue(issueUrl: string): Promise<IssueCandidate>;
     /**

package/dist/core/issue-vetting.js

@@ -6,15 +6,19 @@
  * - issue-eligibility.ts — PR existence, claim detection, requirements analysis
  * - repo-health.ts       — project health, contribution guidelines
  */
-import { parseGitHubUrl, DEFAULT_CONCURRENCY } from './utils.js';
+import { parseGitHubUrl } from './utils.js';
 import { ValidationError, errorMessage, isRateLimitError } from './errors.js';
-import { warn } from './logger.js';
+import { debug, warn } from './logger.js';
 import { calculateRepoQualityBonus, calculateViabilityScore } from './issue-scoring.js';
 import { repoBelongsToCategory } from './category-mapping.js';
 import { checkNoExistingPR, checkNotClaimed, checkUserMergedPRsInRepo, analyzeRequirements, } from './issue-eligibility.js';
 import { checkProjectHealth, fetchContributionGuidelines } from './repo-health.js';
+import { getHttpCache } from './http-cache.js';
 const MODULE = 'issue-vetting';
-const MAX_CONCURRENT_REQUESTS = DEFAULT_CONCURRENCY;
+/** Vetting concurrency: kept low to reduce burst pressure on GitHub's secondary rate limit. */
+const MAX_CONCURRENT_VETTING = 3;
+/** TTL for cached vetting results (15 minutes). Kept short so config changes take effect quickly. */
+const VETTING_CACHE_TTL_MS = 15 * 60 * 1000;
 export class IssueVetter {
     octokit;
     stateManager;
@@ -24,8 +28,17 @@ export class IssueVetter {
     }
     /**
      * Vet a specific issue — runs all checks and computes recommendation + viability score.
+     * Results are cached for 15 minutes to avoid redundant API calls on repeated searches.
      */
     async vetIssue(issueUrl) {
+        // Check vetting cache first — avoids ~6+ API calls per issue
+        const cache = getHttpCache();
+        const cacheKey = `vet:${issueUrl}`;
+        const cached = cache.getIfFresh(cacheKey, VETTING_CACHE_TTL_MS);
+        if (cached && typeof cached === 'object' && 'issue' in cached && 'viabilityScore' in cached) {
+            debug(MODULE, `Vetting cache hit for ${issueUrl}`);
+            return cached;
+        }
         // Parse URL
         const parsed = parseGitHubUrl(issueUrl);
         if (!parsed || parsed.type !== 'issues') {
@@ -207,7 +220,7 @@ export class IssueVetter {
         else if (starredRepos.includes(repoFullName)) {
             searchPriority = 'starred';
         }
-        return {
+        const result = {
             issue: trackedIssue,
             vettingResult,
             projectHealth,
@@ -217,6 +230,9 @@ export class IssueVetter {
             viabilityScore,
             searchPriority,
         };
+        // Cache the vetting result to avoid redundant API calls on repeated searches
+        cache.set(cacheKey, '', result);
+        return result;
     }
     /**
      * Vet multiple issues in parallel with concurrency limit
@@ -251,7 +267,7 @@ export class IssueVetter {
                 .finally(() => pending.delete(url));
             pending.set(url, task);
             // Limit concurrency — wait for at least one to complete before launching more
-            if (pending.size >= MAX_CONCURRENT_REQUESTS) {
+            if (pending.size >= MAX_CONCURRENT_VETTING) {
                 await Promise.race(pending.values());
             }
         }

package/dist/core/search-phases.js

@@ -9,16 +9,14 @@ import { errorMessage, isRateLimitError } from './errors.js';
 import { debug, warn } from './logger.js';
 import { getHttpCache, cachedTimeBased } from './http-cache.js';
 import { detectLabelFarmingRepos } from './issue-filtering.js';
+import { sleep } from './utils.js';
 const MODULE = 'search-phases';
 /** GitHub Search API enforces a max of 5 AND/OR/NOT operators per query. */
 export const GITHUB_MAX_BOOLEAN_OPS = 5;
-/** Small delay between search API calls to avoid secondary rate limits. */
-const INTER_QUERY_DELAY_MS = 500;
+/** Delay between search API calls to avoid GitHub's secondary rate limit (~30 req/min). */
+const INTER_QUERY_DELAY_MS = 1500;
 /** Batch size for repo queries. 3 repos = 2 OR operators, leaving room for labels. */
 const BATCH_SIZE = 3;
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
 /**
  * Chunk labels into groups that fit within the operator budget.
  * N labels require N-1 OR operators, so maxPerChunk = budget + 1.
@@ -189,9 +187,13 @@ export async function searchInRepos(octokit, vetter, repos, baseQualifiers, labe
     const batches = batchRepos(repos, BATCH_SIZE);
     let failedBatches = 0;
     let rateLimitFailures = 0;
-    for (const batch of batches) {
+    for (let batchIdx = 0; batchIdx < batches.length; batchIdx++) {
+        const batch = batches[batchIdx];
         if (candidates.length >= maxResults)
             break;
+        // Delay between batches to avoid secondary rate limits
+        if (batchIdx > 0)
+            await sleep(INTER_QUERY_DELAY_MS);
         try {
             const repoFilter = batch.map((r) => `repo:${r}`).join(' OR ');
             const repoOps = batch.length - 1;
@@ -200,8 +202,10 @@ export async function searchInRepos(octokit, vetter, repos, baseQualifiers, labe
             if (allItems.length > 0) {
                 const filtered = filterFn(allItems);
                 const remainingNeeded = maxResults - candidates.length;
-                const { candidates: vetted } = await vetter.vetIssuesParallel(filtered.slice(0, remainingNeeded * 2).map((i) => i.html_url), remainingNeeded, priority);
+                const { candidates: vetted, rateLimitHit: vetRateLimitHit } = await vetter.vetIssuesParallel(filtered.slice(0, remainingNeeded * 2).map((i) => i.html_url), remainingNeeded, priority);
                 candidates.push(...vetted);
+                if (vetRateLimitHit)
+                    rateLimitFailures++;
             }
         }
         catch (error) {

package/dist/core/utils.d.ts

@@ -3,6 +3,8 @@
  */
 /** Default concurrency limit for parallel GitHub API requests. */
 export declare const DEFAULT_CONCURRENCY = 5;
+/** Async sleep — exported for mockability in tests. */
+export declare function sleep(ms: number): Promise<void>;
 /**
  * Returns the oss-autopilot data directory path, creating it if it does not exist.
  *

package/dist/core/utils.js

@@ -1,14 +1,18 @@
 /**
  * Shared utility functions
  */
-/** Default concurrency limit for parallel GitHub API requests. */
-export const DEFAULT_CONCURRENCY = 5;
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 import { execFileSync, execFile } from 'child_process';
 import { ConfigurationError } from './errors.js';
 import { debug } from './logger.js';
+/** Default concurrency limit for parallel GitHub API requests. */
+export const DEFAULT_CONCURRENCY = 5;
+/** Async sleep — exported for mockability in tests. */
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
 const MODULE = 'utils';
 // Cached GitHub token (fetched once per session)
 let cachedGitHubToken = null;

package/dist/formatters/json.d.ts

@@ -53,6 +53,8 @@ export interface ActionMenuItem {
     label: string;
     /** Explanation shown below the label. */
     description: string;
+    /** Present when the action would exceed the user's PR capacity limit (#765). */
+    capacityWarning?: string;
 }
 /**
  * Pre-computed action menu for the orchestration layer.
@@ -111,6 +113,31 @@ export interface DailyOutput {
     repoGroups: CompactRepoGroup[];
     failures: PRCheckFailure[];
 }
+/**
+ * Compact version of DailyOutput for reduced JSON payload size (#763).
+ * Omits `summary` (pre-rendered markdown ~8KB that duplicates structured fields),
+ * `repoGroups` (derivable from digest.openPRs), and full `failures` array.
+ * Retains `commentedIssues` because downstream workflows (review-issue-replies.md,
+ * action-menu.md) consume it directly.
+ * Includes `failureCount` so consumers can detect partial fetch failures without
+ * carrying the full error payload.
+ */
+export interface CompactDailyOutput {
+    digest: DailyDigestCompact;
+    capacity: CapacityAssessment;
+    briefSummary: string;
+    actionableIssues: CompactActionableIssue[];
+    actionMenu: ActionMenu;
+    commentedIssues: CommentedIssue[];
+    /** Number of PRs that failed to fetch. Non-zero indicates partial results. */
+    failureCount: number;
+}
+/**
+ * Strip a full DailyOutput down to the compact subset (#763).
+ * Omits summary, repoGroups, and full failures array. Retains a failureCount
+ * so consumers can detect partial fetch failures.
+ */
+export declare function toCompactDailyOutput(output: DailyOutput): CompactDailyOutput;
 /**
  * Convert a full DailyDigest to the compact format for JSON output (#287).
  * Category arrays become PR URL arrays; full objects stay only in openPRs.
@@ -207,6 +234,19 @@ export interface StartupOutput {
     dashboardUrl?: string;
     issueList?: IssueListInfo;
 }
+/**
+ * Compact version of StartupOutput for reduced JSON payload (#763).
+ * Derived from StartupOutput with CompactDailyOutput substituted for DailyOutput.
+ * Using Omit ensures new fields added to StartupOutput are automatically included.
+ */
+export type CompactStartupOutput = Omit<StartupOutput, 'daily'> & {
+    daily?: CompactDailyOutput;
+};
+/**
+ * Convert a full StartupOutput to the compact format (#763).
+ * Uses destructuring to auto-forward any new fields added to StartupOutput.
+ */
+export declare function toCompactStartupOutput(output: StartupOutput): CompactStartupOutput;
 /** A single parsed issue from a markdown list (#82) */
 export interface ParsedIssueItem {
     repo: string;
@@ -234,6 +274,23 @@ export interface CheckIntegrationOutput {
     newFiles: NewFileInfo[];
     unreferencedCount: number;
 }
+/** Status of a re-vetted issue from the curated list (#764). */
+export type VetListItemStatus = 'still_available' | 'claimed' | 'closed' | 'has_pr' | 'error';
+/** Output of the vet-list command (#764). */
+export interface VetListOutput {
+    results: Array<VetOutput & {
+        listStatus: VetListItemStatus;
+        errorMessage?: string;
+    }>;
+    summary: {
+        total: number;
+        stillAvailable: number;
+        claimed: number;
+        closed: number;
+        hasPR: number;
+        errors: number;
+    };
+}
 /** Output of the vet command */
 export interface VetOutput {
     issue: {