@oss-scout/core 0.3.0 → 0.4.0

package/dist/commands/config.js

@@ -13,6 +13,7 @@ const FIELD_CONFIGS = {
     minStars: { type: "number" },
     maxIssueAgeDays: { type: "number" },
     minRepoScoreThreshold: { type: "number" },
+    interPhaseDelayMs: { type: "number" },
     includeDocIssues: { type: "boolean" },
     scope: { type: "enum-array", validValues: IssueScopeSchema.options },
     projectCategories: {
@@ -25,6 +26,8 @@ const FIELD_CONFIGS = {
         validValues: SearchStrategySchema.options,
     },
     githubUsername: { type: "string" },
+    broadPhaseDelayMs: { type: "number" },
+    skipBroadWhenSufficientResults: { type: "number" },
 };
 function parseBoolean(value) {
     const lower = value.toLowerCase();
@@ -83,6 +86,7 @@ export function runConfigShow() {
     console.log(`  minStars:             ${prefs.minStars}`);
     console.log(`  maxIssueAgeDays:      ${prefs.maxIssueAgeDays}`);
     console.log(`  minRepoScoreThreshold: ${prefs.minRepoScoreThreshold}`);
+    console.log(`  interPhaseDelayMs:    ${prefs.interPhaseDelayMs}ms (${(prefs.interPhaseDelayMs / 1000).toFixed(0)}s)`);
     console.log(`  includeDocIssues:     ${prefs.includeDocIssues}`);
     console.log(`  projectCategories:    ${formatArray(prefs.projectCategories)}`);
     console.log(`  excludeRepos:         ${formatArray(prefs.excludeRepos)}`);
@@ -90,6 +94,8 @@ export function runConfigShow() {
     console.log(`  aiPolicyBlocklist:    ${formatArray(prefs.aiPolicyBlocklist)}`);
     console.log(`  defaultStrategy:      ${prefs.defaultStrategy ? formatArray(prefs.defaultStrategy) : "(all)"}`);
     console.log(`  persistence:          ${prefs.persistence}`);
+    console.log(`  broadPhaseDelayMs:    ${prefs.broadPhaseDelayMs}ms (${(prefs.broadPhaseDelayMs / 1000).toFixed(0)}s)`);
+    console.log(`  skipBroadWhenSufficientResults: ${prefs.skipBroadWhenSufficientResults}`);
     console.log();
 }
 /**

package/dist/core/issue-discovery.js

@@ -21,10 +21,8 @@ import { debug, info, warn } from "./logger.js";
 import { isDocOnlyIssue, applyPerRepoCap, } from "./issue-filtering.js";
 import { IssueVetter } from "./issue-vetting.js";
 import { getTopicsForCategories } from "./category-mapping.js";
-import { buildEffectiveLabels, interleaveArrays, cachedSearchIssues, filterVetAndScore, searchInRepos, searchWithChunkedLabels, } from "./search-phases.js";
+import { buildEffectiveLabels, interleaveArrays, cachedSearchIssues, fetchIssuesFromMaintainedRepos, filterVetAndScore, fetchIssuesFromKnownRepos, 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. */
@@ -60,27 +58,27 @@ function buildIssueFilter(config) {
     };
 }
 /** Phase 0: Search repos where user has merged PRs (highest merge probability). */
-async function runPhase0(octokit, vetter, repos, baseQualifiers, maxResults, filterIssues) {
+async function runPhase0(octokit, vetter, repos, maxResults, filterIssues) {
     info(MODULE, `Phase 0: Searching issues in ${repos.length} merged-PR repos (no label filter)...`);
-    const { candidates, allBatchesFailed, rateLimitHit } = await searchInRepos(octokit, vetter, repos, baseQualifiers, [], maxResults, "merged_pr", filterIssues);
+    const { candidates, allReposFailed, rateLimitHit } = await fetchIssuesFromKnownRepos(octokit, vetter, repos, [], maxResults, "merged_pr", filterIssues);
     info(MODULE, `Found ${candidates.length} candidates from merged-PR repos`);
     return {
         candidates,
-        error: allBatchesFailed ? "All merged-PR repo batches failed" : null,
+        error: allReposFailed ? "All merged-PR repo fetches failed" : null,
         rateLimitHit,
     };
 }
 /** Phase 1: Search starred repos. */
-async function runPhase1(octokit, vetter, repos, baseQualifiers, labels, maxResults, filterIssues) {
+async function runPhase1(octokit, vetter, repos, labels, maxResults, filterIssues) {
     info(MODULE, `Phase 1: Searching issues in ${repos.length} starred repos...`);
-    // Cap labels to reduce Search API calls: starred repos already signal user
-    // interest, so fewer labels suffice.
+    // Cap labels: starred repos already signal user interest, so fewer labels suffice.
     const phase1Labels = labels.slice(0, 3);
-    const { candidates, allBatchesFailed, rateLimitHit } = await searchInRepos(octokit, vetter, repos.slice(0, 10), baseQualifiers, phase1Labels, maxResults, "starred", filterIssues);
+    const reposToSearch = repos.slice(0, 10);
+    const { candidates, allReposFailed, rateLimitHit } = await fetchIssuesFromKnownRepos(octokit, vetter, reposToSearch, phase1Labels, maxResults, "starred", filterIssues);
     info(MODULE, `Found ${candidates.length} candidates from starred repos`);
     return {
         candidates,
-        error: allBatchesFailed ? "All starred repo batches failed" : null,
+        error: allReposFailed ? "All starred repo fetches failed" : null,
         rateLimitHit,
     };
 }
@@ -150,9 +148,36 @@ async function runPhase2(octokit, vetter, scopes, labels, configLabels, baseQual
         rateLimitHit,
     };
 }
-/** Phase 3: Actively maintained repos. */
-async function runPhase3(octokit, vetter, langQuery, minStars, projectCategories, maxResults, phase0RepoSet, starredRepoSet, existingCandidates, filterIssues) {
+/** Phase 3: Actively maintained repos (REST-first, Search API fallback). */
+async function runPhase3(octokit, vetter, langQuery, minStars, projectCategories, maxResults, phase0RepoSet, starredRepoSet, starredRepos, existingCandidates, filterIssues) {
     info(MODULE, "Phase 3: Searching actively maintained repos...");
+    const seenRepos = new Set(existingCandidates.map((c) => c.issue.repo));
+    // Step 1: Try REST API with starred repos first (no Search API quota used)
+    const eligibleStarred = starredRepos.filter((r) => !phase0RepoSet.has(r) && !seenRepos.has(r));
+    if (eligibleStarred.length > 0) {
+        info(MODULE, `Phase 3: Checking ${eligibleStarred.length} starred repos via REST API...`);
+        const restItems = await fetchIssuesFromMaintainedRepos(octokit, eligibleStarred.slice(0, 15), minStars, maxResults);
+        if (restItems.length > 0) {
+            try {
+                const { candidates, allVetFailed, rateLimitHit: vetRateLimitHit, } = await filterVetAndScore(vetter, restItems, filterIssues, [phase0RepoSet, seenRepos], maxResults, minStars, "Phase 3 (REST)");
+                if (candidates.length > 0) {
+                    info(MODULE, `Found ${candidates.length} candidates from maintained-repo REST search`);
+                    return {
+                        candidates,
+                        error: allVetFailed ? "all vetting failed" : null,
+                        rateLimitHit: vetRateLimitHit,
+                    };
+                }
+            }
+            catch (error) {
+                if (getHttpStatusCode(error) === 401)
+                    throw error;
+                warn(MODULE, `Phase 3 REST vetting failed, falling back to Search API:`, errorMessage(error));
+            }
+        }
+    }
+    // Step 2: Fall back to Search API if REST didn't yield results
+    info(MODULE, "Phase 3: Falling back to Search API...");
     const thirtyDaysAgo = new Date();
     thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
     const pushedSince = thirtyDaysAgo.toISOString().split("T")[0];
@@ -169,7 +194,6 @@ async function runPhase3(octokit, vetter, langQuery, minStars, projectCategories
             per_page: maxResults * 3,
         });
         info(MODULE, `Found ${data.total_count} issues in maintained-repo search, processing top ${data.items.length}...`);
-        const seenRepos = new Set(existingCandidates.map((c) => c.issue.repo));
         const { candidates, allVetFailed, rateLimitHit: vetRateLimitHit, } = await filterVetAndScore(vetter, data.items, filterIssues, [phase0RepoSet, starredRepoSet, seenRepos], maxResults, minStars, "Phase 3");
         info(MODULE, `Found ${candidates.length} candidates from maintained-repo search`);
         return {
@@ -259,6 +283,7 @@ export class IssueDiscovery {
             (scopes ? buildEffectiveLabels(scopes, config.labels) : config.labels);
         const maxResults = options.maxResults || 10;
         const minStars = config.minStars ?? 50;
+        const interPhaseDelay = config.interPhaseDelayMs ?? 30000;
         // Strategy selection
         const ALL_STRATEGIES = CONCRETE_STRATEGIES;
         const rawStrategies = options.strategies ??
@@ -333,7 +358,7 @@ export class IssueDiscovery {
         if (phase0Repos.length > 0 && enabledStrategies.has("merged")) {
             const remaining = maxResults - allCandidates.length;
             if (remaining > 0) {
-                const result = await runPhase0(this.octokit, this.vetter, phase0Repos, baseQualifiers, remaining, filterIssues);
+                const result = await runPhase0(this.octokit, this.vetter, phase0Repos, remaining, filterIssues);
                 allCandidates.push(...result.candidates);
                 phaseErrors["0"] = result.error;
                 if (result.rateLimitHit)
@@ -346,12 +371,15 @@ export class IssueDiscovery {
             starredRepos.length > 0 &&
             searchBudget >= CRITICAL_BUDGET_THRESHOLD &&
             enabledStrategies.has("starred")) {
-            await sleep(INTER_PHASE_DELAY_MS);
+            if (interPhaseDelay > 0) {
+                info(MODULE, `Waiting ${(interPhaseDelay / 1000).toFixed(0)}s between phases for rate limit management...`);
+                await sleep(interPhaseDelay);
+            }
             const reposToSearch = starredRepos.filter((r) => !phase0RepoSet.has(r));
             if (reposToSearch.length > 0) {
                 const remaining = maxResults - allCandidates.length;
                 if (remaining > 0) {
-                    const result = await runPhase1(this.octokit, this.vetter, reposToSearch, baseQualifiers, labels, remaining, filterIssues);
+                    const result = await runPhase1(this.octokit, this.vetter, reposToSearch, labels, remaining, filterIssues);
                     allCandidates.push(...result.candidates);
                     phaseErrors["1"] = result.error;
                     if (result.rateLimitHit)
@@ -360,26 +388,49 @@ export class IssueDiscovery {
             }
             strategiesUsed.push("starred");
         }
-        // Phase 2: General search
+        // Phase 2: General search (with rate limit mitigation)
+        const broadDelay = config.broadPhaseDelayMs ?? 90000;
+        const skipThreshold = config.skipBroadWhenSufficientResults ?? 15;
         if (allCandidates.length < maxResults &&
             searchBudget >= LOW_BUDGET_THRESHOLD &&
             enabledStrategies.has("broad")) {
-            await sleep(INTER_PHASE_DELAY_MS);
-            const remaining = maxResults - allCandidates.length;
-            const result = await runPhase2(this.octokit, this.vetter, scopes, labels, config.labels, baseQualifiers, remaining, minStars, phase0RepoSet, starredRepoSet, allCandidates, filterIssues);
-            allCandidates.push(...result.candidates);
-            phaseErrors["2"] = result.error;
-            if (result.rateLimitHit)
-                rateLimitHitDuringSearch = true;
+            // Skip broad search if we already have enough candidates
+            if (skipThreshold > 0 && allCandidates.length >= skipThreshold) {
+                info(MODULE, `Skipping broad search: already found ${allCandidates.length} candidates (threshold: ${skipThreshold})`);
+            }
+            else {
+                // Always apply baseline inter-phase delay
+                if (interPhaseDelay > 0) {
+                    info(MODULE, `Waiting ${(interPhaseDelay / 1000).toFixed(0)}s between phases for rate limit management...`);
+                    await sleep(interPhaseDelay);
+                }
+                // Apply additional broad-phase cooldown, but skip if previous phases found nothing
+                if (allCandidates.length > 0 && broadDelay > 0) {
+                    info(MODULE, `Waiting ${(broadDelay / 1000).toFixed(0)}s for rate limit cooldown before broad search...`);
+                    await sleep(broadDelay);
+                }
+                else if (allCandidates.length === 0) {
+                    info(MODULE, `Skipping broad phase delay: no results from previous phases, proceeding immediately`);
+                }
+                const remaining = maxResults - allCandidates.length;
+                const result = await runPhase2(this.octokit, this.vetter, scopes, labels, config.labels, baseQualifiers, remaining, minStars, phase0RepoSet, starredRepoSet, allCandidates, filterIssues);
+                allCandidates.push(...result.candidates);
+                phaseErrors["2"] = result.error;
+                if (result.rateLimitHit)
+                    rateLimitHitDuringSearch = true;
+            }
             strategiesUsed.push("broad");
         }
         // Phase 3: Actively maintained repos
         if (allCandidates.length < maxResults &&
             searchBudget >= LOW_BUDGET_THRESHOLD &&
             enabledStrategies.has("maintained")) {
-            await sleep(INTER_PHASE_DELAY_MS);
+            if (interPhaseDelay > 0) {
+                info(MODULE, `Waiting ${(interPhaseDelay / 1000).toFixed(0)}s between phases for rate limit management...`);
+                await sleep(interPhaseDelay);
+            }
             const remaining = maxResults - allCandidates.length;
-            const result = await runPhase3(this.octokit, this.vetter, langQuery, minStars, config.projectCategories ?? [], remaining, phase0RepoSet, starredRepoSet, allCandidates, filterIssues);
+            const result = await runPhase3(this.octokit, this.vetter, langQuery, minStars, config.projectCategories ?? [], remaining, phase0RepoSet, starredRepoSet, starredRepos, allCandidates, filterIssues);
             allCandidates.push(...result.candidates);
             phaseErrors["3"] = result.error;
             if (result.rateLimitHit)

package/dist/core/schemas.d.ts

@@ -203,6 +203,7 @@ export declare const ScoutPreferencesSchema: z.ZodObject<{
     maxIssueAgeDays: z.ZodDefault<z.ZodNumber>;
     includeDocIssues: z.ZodDefault<z.ZodBoolean>;
     minRepoScoreThreshold: z.ZodDefault<z.ZodNumber>;
+    interPhaseDelayMs: z.ZodDefault<z.ZodNumber>;
     persistence: z.ZodDefault<z.ZodEnum<{
         local: "local";
         gist: "gist";
@@ -214,6 +215,8 @@ export declare const ScoutPreferencesSchema: z.ZodObject<{
         broad: "broad";
         maintained: "maintained";
     }>>>;
+    broadPhaseDelayMs: z.ZodDefault<z.ZodNumber>;
+    skipBroadWhenSufficientResults: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
 export declare const ScoutStateSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
@@ -241,6 +244,7 @@ export declare const ScoutStateSchema: z.ZodObject<{
         maxIssueAgeDays: z.ZodDefault<z.ZodNumber>;
         includeDocIssues: z.ZodDefault<z.ZodBoolean>;
         minRepoScoreThreshold: z.ZodDefault<z.ZodNumber>;
+        interPhaseDelayMs: z.ZodDefault<z.ZodNumber>;
         persistence: z.ZodDefault<z.ZodEnum<{
             local: "local";
             gist: "gist";
@@ -252,6 +256,8 @@ export declare const ScoutStateSchema: z.ZodObject<{
             broad: "broad";
             maintained: "maintained";
         }>>>;
+        broadPhaseDelayMs: z.ZodDefault<z.ZodNumber>;
+        skipBroadWhenSufficientResults: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>>;
     repoScores: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
         repo: z.ZodString;

package/dist/core/schemas.js

@@ -146,8 +146,11 @@ export const ScoutPreferencesSchema = z.object({
     maxIssueAgeDays: z.number().default(90),
     includeDocIssues: z.boolean().default(true),
     minRepoScoreThreshold: z.number().default(4),
+    interPhaseDelayMs: z.number().min(0).max(120000).default(30000),
     persistence: PersistenceModeSchema.default("local"),
     defaultStrategy: z.array(SearchStrategySchema).optional(),
+    broadPhaseDelayMs: z.number().min(0).max(300000).default(90000),
+    skipBroadWhenSufficientResults: z.number().int().min(0).max(100).default(15),
 });
 // ── Root state schema ───────────────────────────────────────────────
 export const ScoutStateSchema = z.object({

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

@@ -26,6 +26,27 @@ export declare function cachedSearchIssues(octokit: Octokit, params: {
     total_count: number;
     items: GitHubSearchItem[];
 }>;
+/**
+ * Fetch issues from maintained repos using REST API (no Search API quota).
+ *
+ * Checks each repo for recent push activity and star threshold,
+ * then fetches open issues via `GET /repos/{owner}/{repo}/issues`.
+ * Falls back to the caller to use Search API if this doesn't yield enough.
+ */
+export declare function fetchIssuesFromMaintainedRepos(octokit: Octokit, repos: string[], minStars: number, maxResults: number): Promise<GitHubSearchItem[]>;
+/**
+ * Fetch open issues from known repos using REST API (no Search API quota).
+ * Used by Phase 0 (merged-PR repos) and Phase 1 (starred repos).
+ *
+ * Instead of the Search API (`octokit.search.issuesAndPullRequests`), this
+ * calls `GET /repos/{owner}/{repo}/issues` which counts against the much
+ * larger Core API rate limit and avoids consuming the scarce Search quota.
+ */
+export declare function fetchIssuesFromKnownRepos(octokit: Octokit, vetter: IssueVetter, repos: string[], labels: string[], maxResults: number, priority: SearchPriority, filterFn: (items: GitHubSearchItem[]) => GitHubSearchItem[]): Promise<{
+    candidates: IssueCandidate[];
+    allReposFailed: boolean;
+    rateLimitHit: boolean;
+}>;
 /**
  * Search across chunked labels with deduplication.
  *

package/dist/core/search-phases.js

@@ -5,9 +5,9 @@
  * caching, spam-filtering, and batched repo search logic.
  */
 import { SCOPE_LABELS, } from "./types.js";
-import { errorMessage, isRateLimitError } from "./errors.js";
+import { errorMessage, getHttpStatusCode, isRateLimitError } from "./errors.js";
 import { debug, warn } from "./logger.js";
-import { getHttpCache, cachedTimeBased } from "./http-cache.js";
+import { getHttpCache } from "./http-cache.js";
 import { detectLabelFarmingRepos, } from "./issue-filtering.js";
 import { extractRepoFromUrl, sleep } from "./utils.js";
 import { getSearchBudgetTracker } from "./search-budget.js";
@@ -95,20 +95,166 @@ const SEARCH_CACHE_TTL_MS = 15 * 60 * 1000;
  */
 export async function cachedSearchIssues(octokit, params) {
     const cacheKey = `search:${params.q}:${params.sort}:${params.order}:${params.per_page}`;
-    return cachedTimeBased(getHttpCache(), cacheKey, SEARCH_CACHE_TTL_MS, async () => {
-        const tracker = getSearchBudgetTracker();
-        await tracker.waitForBudget();
+    const cache = getHttpCache();
+    // Check cache first
+    const cached = cache.getIfFresh(cacheKey, SEARCH_CACHE_TTL_MS);
+    if (cached) {
+        debug(MODULE, `Search cache hit for query`);
+        return cached;
+    }
+    // Fetch from API
+    const tracker = getSearchBudgetTracker();
+    await tracker.waitForBudget();
+    let data;
+    try {
+        const response = await octokit.search.issuesAndPullRequests(params);
+        data = response.data;
+    }
+    finally {
+        tracker.recordCall();
+    }
+    // Only cache non-empty results to prevent poisoning from rate-limited responses
+    if (data.items.length > 0) {
+        cache.set(cacheKey, "", data);
+    }
+    else {
+        debug(MODULE, `Skipping cache for empty search result (possible rate limit artifact)`);
+    }
+    return data;
+}
+// ── REST-based search functions ──
+/**
+ * Fetch issues from maintained repos using REST API (no Search API quota).
+ *
+ * Checks each repo for recent push activity and star threshold,
+ * then fetches open issues via `GET /repos/{owner}/{repo}/issues`.
+ * Falls back to the caller to use Search API if this doesn't yield enough.
+ */
+export async function fetchIssuesFromMaintainedRepos(octokit, repos, minStars, maxResults) {
+    const items = [];
+    for (const repoFullName of repos) {
+        if (items.length >= maxResults * 3)
+            break;
+        const [owner, repo] = repoFullName.split("/");
+        if (!owner || !repo)
+            continue;
         try {
-            const { data } = await octokit.search.issuesAndPullRequests(params);
-            return data;
+            const { data: repoData } = await octokit.repos.get({ owner, repo });
+            if (!repoData.pushed_at)
+                continue;
+            const pushedAt = new Date(repoData.pushed_at);
+            const thirtyDaysAgo = new Date();
+            thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
+            if (pushedAt < thirtyDaysAgo)
+                continue;
+            if ((repoData.stargazers_count ?? 0) < minStars)
+                continue;
+            if (repoData.archived)
+                continue;
+            const { data: issues } = await octokit.issues.listForRepo({
+                owner,
+                repo,
+                state: "open",
+                sort: "created",
+                direction: "desc",
+                per_page: 5,
+            });
+            // Filter out pull requests and assigned issues (REST endpoint returns both)
+            const realIssues = issues.filter((i) => !i.pull_request && !i.assignee);
+            for (const issue of realIssues) {
+                items.push({
+                    html_url: issue.html_url,
+                    repository_url: `https://api.github.com/repos/${repoFullName}`,
+                    updated_at: issue.updated_at ?? "",
+                    title: issue.title,
+                    labels: issue.labels,
+                });
+            }
+            await sleep(INTER_QUERY_DELAY_MS);
         }
-        finally {
-            // Always record the call — failed requests still consume GitHub rate limit points
-            tracker.recordCall();
+        catch (error) {
+            if (getHttpStatusCode(error) === 401)
+                throw error;
+            if (isRateLimitError(error)) {
+                warn(MODULE, `Rate limit hit fetching issues from ${repoFullName}:`, errorMessage(error));
+                break;
+            }
+            warn(MODULE, `Error fetching issues from ${repoFullName}:`, errorMessage(error));
         }
-    });
+    }
+    return items;
 }
 // ── Search infrastructure ──
+/**
+ * Fetch open issues from known repos using REST API (no Search API quota).
+ * Used by Phase 0 (merged-PR repos) and Phase 1 (starred repos).
+ *
+ * Instead of the Search API (`octokit.search.issuesAndPullRequests`), this
+ * calls `GET /repos/{owner}/{repo}/issues` which counts against the much
+ * larger Core API rate limit and avoids consuming the scarce Search quota.
+ */
+export async function fetchIssuesFromKnownRepos(octokit, vetter, repos, labels, maxResults, priority, filterFn) {
+    const candidates = [];
+    let failedRepos = 0;
+    let rateLimitFailures = 0;
+    for (let i = 0; i < repos.length; i++) {
+        if (candidates.length >= maxResults)
+            break;
+        // Delay between repos to avoid REST secondary rate limits
+        if (i > 0)
+            await sleep(INTER_QUERY_DELAY_MS);
+        const repoFullName = repos[i];
+        const [owner, repo] = repoFullName.split("/");
+        try {
+            const response = await octokit.issues.listForRepo({
+                owner,
+                repo,
+                state: "open",
+                sort: "created",
+                direction: "desc",
+                per_page: 5,
+                ...(labels.length > 0 ? { labels: labels.join(",") } : {}),
+            });
+            // Filter out pull requests (REST issues endpoint returns both) and assigned issues
+            const issuesOnly = response.data.filter((item) => !("pull_request" in item) && !item.assignee);
+            const mapped = issuesOnly.map((issue) => ({
+                html_url: issue.html_url,
+                repository_url: `https://api.github.com/repos/${repoFullName}`,
+                updated_at: issue.updated_at ?? "",
+                title: issue.title,
+                labels: issue.labels,
+            }));
+            if (mapped.length > 0) {
+                const filtered = filterFn(mapped);
+                if (filtered.length > 0) {
+                    const remainingNeeded = maxResults - candidates.length;
+                    const { candidates: vetted, rateLimitHit: vetRateLimitHit } = await vetter.vetIssuesParallel(filtered
+                        .slice(0, remainingNeeded * 2)
+                        .map((item) => item.html_url), remainingNeeded, priority);
+                    candidates.push(...vetted);
+                    if (vetRateLimitHit)
+                        rateLimitFailures++;
+                }
+            }
+        }
+        catch (error) {
+            if (getHttpStatusCode(error) === 401)
+                throw error;
+            failedRepos++;
+            if (isRateLimitError(error)) {
+                rateLimitFailures++;
+            }
+            warn(MODULE, `Error fetching issues from ${repoFullName}:`, errorMessage(error));
+        }
+    }
+    const allReposFailed = failedRepos === repos.length && repos.length > 0;
+    const rateLimitHit = rateLimitFailures > 0;
+    if (allReposFailed) {
+        warn(MODULE, `All ${repos.length} repo(s) failed for ${priority} phase. ` +
+            `This may indicate a systemic issue (rate limit, auth, network).`);
+    }
+    return { candidates, allReposFailed, rateLimitHit };
+}
 /**
  * Search across chunked labels with deduplication.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oss-scout/core",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Personalized GitHub issue finder with multi-strategy search, deep vetting, and viability scoring — CLI, library, MCP server, and Claude Code plugin",
   "type": "module",
   "bin": {
@@ -21,16 +21,6 @@
     "!dist/**/*.map",
     "!dist/core/test-utils.*"
   ],
-  "scripts": {
-    "build": "tsc",
-    "bundle": "esbuild src/cli.ts --bundle --platform=node --target=node20 --format=cjs --minify --sourcemap --outfile=dist/cli.bundle.cjs",
-    "start": "tsx src/cli.ts",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run",
-    "test:coverage": "vitest run --coverage",
-    "test:watch": "vitest",
-    "prepublishOnly": "pnpm run build && pnpm run bundle"
-  },
   "keywords": [
     "open-source",
     "github",
@@ -70,5 +60,14 @@
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "vitest": "^4.1.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "bundle": "esbuild src/cli.ts --bundle --platform=node --target=node20 --format=cjs --minify --sourcemap --outfile=dist/cli.bundle.cjs",
+    "start": "tsx src/cli.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "test:watch": "vitest"
   }
-}
+}

package/dist/core/concurrency.d.ts

@@ -1,6 +0,0 @@
-/**
- * Runs a worker pool that processes items with bounded concurrency.
- * N workers consume from a shared index. On any worker error, remaining
- * workers are aborted via a shared flag and the error is propagated.
- */
-export declare function runWorkerPool<T>(items: T[], worker: (item: T) => Promise<void>, concurrency: number): Promise<void>;

package/dist/core/concurrency.js

@@ -1,25 +0,0 @@
-/**
- * Runs a worker pool that processes items with bounded concurrency.
- * N workers consume from a shared index. On any worker error, remaining
- * workers are aborted via a shared flag and the error is propagated.
- */
-export async function runWorkerPool(items, worker, concurrency) {
-    let index = 0;
-    let aborted = false;
-    const poolWorker = async () => {
-        while (index < items.length) {
-            if (aborted)
-                break;
-            const item = items[index++];
-            try {
-                await worker(item);
-            }
-            catch (err) {
-                aborted = true;
-                throw err;
-            }
-        }
-    };
-    const workerCount = Math.min(concurrency, items.length);
-    await Promise.all(Array.from({ length: workerCount }, () => poolWorker()));
-}