@oss-scout/core 0.2.1 → 0.4.0

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. */
@@ -47,6 +45,8 @@ function buildIssueFilter(config) {
                 return false;
             if (config.lowScoringRepos.has(repoFullName))
                 return false;
+            if (config.skippedUrls.has(item.html_url))
+                return false;
             const updatedAt = new Date(item.updated_at);
             const ageDays = daysBetween(updatedAt, config.now);
             if (ageDays > config.maxAgeDays)
@@ -58,63 +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 0.5: Search preferred organizations. */
-async function runPhase05(octokit, vetter, orgsToSearch, baseQualifiers, labels, maxResults, phase0RepoSet, filterIssues) {
-    info(MODULE, `Phase 0.5: Searching issues in ${orgsToSearch.length} preferred org(s)...`);
-    const orgRepoFilter = orgsToSearch.map((org) => `org:${org}`).join(" OR ");
-    const orgOps = orgsToSearch.length - 1;
-    try {
-        const allItems = await searchWithChunkedLabels(octokit, labels, orgOps, (labelQ) => `${baseQualifiers} ${labelQ} (${orgRepoFilter})`
-            .replace(/  +/g, " ")
-            .trim(), maxResults * 3);
-        if (allItems.length === 0) {
-            return { candidates: [], error: null, rateLimitHit: false };
-        }
-        const filtered = filterIssues(allItems).filter((item) => {
-            const repoFullName = extractRepoFromUrl(item.repository_url);
-            if (!repoFullName)
-                return false;
-            return !phase0RepoSet.has(repoFullName);
-        });
-        const { candidates, allFailed: allVetFailed, rateLimitHit, } = await vetter.vetIssuesParallel(filtered.slice(0, maxResults * 2).map((i) => i.html_url), maxResults, "preferred_org");
-        info(MODULE, `Found ${candidates.length} candidates from preferred orgs`);
-        return {
-            candidates,
-            error: allVetFailed ? "All preferred org issue vetting failed" : null,
-            rateLimitHit,
-        };
-    }
-    catch (error) {
-        const errMsg = errorMessage(error);
-        warn(MODULE, `Error searching preferred orgs: ${errMsg}`);
-        return {
-            candidates: [],
-            error: errMsg,
-            rateLimitHit: isRateLimitError(error),
-        };
-    }
-}
 /** 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,
     };
 }
@@ -184,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];
@@ -203,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 {
@@ -228,7 +218,6 @@ async function runPhase3(octokit, vetter, langQuery, minStars, projectCategories
  *
  * Search phases (in priority order):
  * 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
@@ -264,8 +253,8 @@ export class IssueDiscovery {
     }
     /**
      * Search for issues matching our criteria.
-     * Searches in priority order: merged-PR repos first (no label filter), then preferred
-     * organizations, then starred repos, then general search, then actively maintained repos.
+     * Searches in priority order: merged-PR repos first (no label filter), then starred
+     * repos, then general search, then actively maintained repos.
      * Filters out issues from low-scoring and excluded repos.
      *
      * @param options - Search configuration
@@ -294,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 ??
@@ -329,6 +319,11 @@ export class IssueDiscovery {
             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));
         }
+        if (searchBudget <= 0) {
+            this.rateLimitWarning =
+                "GitHub search API quota exhausted. Try again after the rate limit resets.";
+            return { candidates: [], strategiesUsed: [] };
+        }
         // Derive search context
         const mergedPRRepos = this.stateReader.getReposWithMergedPRs();
         const starredRepos = this.getStarredRepos();
@@ -352,6 +347,7 @@ export class IssueDiscovery {
             excludeOrgs: new Set((config.excludeOrgs ?? []).map((o) => o.toLowerCase())),
             aiBlocklisted,
             lowScoringRepos,
+            skippedUrls: options.skippedUrls ?? new Set(),
             maxAgeDays: config.maxIssueAgeDays || 90,
             now: new Date(),
             includeDocIssues: config.includeDocIssues ?? true,
@@ -362,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)
@@ -370,39 +366,20 @@ export class IssueDiscovery {
             }
             strategiesUsed.push("merged");
         }
-        // Phase 0.5: Preferred organizations
-        const preferredOrgs = config.preferredOrgs ?? [];
-        if (allCandidates.length < maxResults &&
-            preferredOrgs.length > 0 &&
-            searchBudget >= CRITICAL_BUDGET_THRESHOLD &&
-            enabledStrategies.has("orgs")) {
-            if (phase0Repos.length > 0)
-                await sleep(INTER_PHASE_DELAY_MS);
-            const phase0Orgs = new Set(phase0Repos.map((r) => r.split("/")[0]?.toLowerCase()));
-            const orgsToSearch = preferredOrgs
-                .filter((org) => !phase0Orgs.has(org.toLowerCase()))
-                .slice(0, 5);
-            if (orgsToSearch.length > 0) {
-                const remaining = maxResults - allCandidates.length;
-                const result = await runPhase05(this.octokit, this.vetter, orgsToSearch, baseQualifiers, labels, remaining, phase0RepoSet, filterIssues);
-                allCandidates.push(...result.candidates);
-                phaseErrors["0.5"] = result.error;
-                if (result.rateLimitHit)
-                    rateLimitHitDuringSearch = true;
-            }
-            strategiesUsed.push("orgs");
-        }
         // Phase 1: Starred repos
         if (allCandidates.length < maxResults &&
             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)
@@ -411,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)
@@ -451,9 +451,6 @@ export class IssueDiscovery {
                 phaseErrors["0"]
                     ? `Phase 0 (merged-PR repos): ${phaseErrors["0"]}`
                     : null,
-                phaseErrors["0.5"]
-                    ? `Phase 0.5 (preferred orgs): ${phaseErrors["0.5"]}`
-                    : null,
                 phaseErrors["1"]
                     ? `Phase 1 (starred repos): ${phaseErrors["1"]}`
                     : null,
@@ -482,9 +479,8 @@ export class IssueDiscovery {
         allCandidates.sort((a, b) => {
             const priorityOrder = {
                 merged_pr: 0,
-                preferred_org: 1,
-                starred: 2,
-                normal: 3,
+                starred: 1,
+                normal: 2,
             };
             const priorityDiff = priorityOrder[a.searchPriority] - priorityOrder[b.searchPriority];
             if (priorityDiff !== 0)

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

@@ -17,8 +17,6 @@ export interface ScoutStateReader {
     getReposWithMergedPRs(): string[];
     /** User's starred repos (from GitHub). */
     getStarredRepos(): string[];
-    /** Preferred GitHub orgs from user preferences. */
-    getPreferredOrgs(): string[];
     /** Preferred project categories from user preferences. */
     getProjectCategories(): ProjectCategory[];
     /** Numeric quality score for a repo, or null if not evaluated. */

package/dist/core/issue-vetting.js

@@ -205,14 +205,10 @@ export class IssueVetter {
             matchesPreferredCategory: matchesCategory,
         });
         const starredRepos = this.stateReader.getStarredRepos();
-        const preferredOrgs = this.stateReader.getPreferredOrgs();
         let searchPriority = "normal";
         if (effectiveMergedCount > 0) {
             searchPriority = "merged_pr";
         }
-        else if (preferredOrgs.some((o) => o.toLowerCase() === orgName?.toLowerCase())) {
-            searchPriority = "preferred_org";
-        }
         else if (starredRepos.includes(repoFullName)) {
             searchPriority = "starred";
         }

package/dist/core/local-state.js

@@ -39,8 +39,8 @@ export function loadLocalState() {
             fs.copyFileSync(statePath, backupPath);
             warn(MODULE, `Corrupt state backed up to ${backupPath}`);
         }
-        catch {
-            /* best effort backup */
+        catch (backupErr) {
+            warn(MODULE, `Failed to back up corrupt state: ${errorMessage(backupErr)}`);
         }
         return ScoutStateSchema.parse({ version: 1 });
     }

package/dist/core/schemas.d.ts

@@ -27,13 +27,12 @@ export declare const IssueScopeSchema: z.ZodEnum<{
 export declare const SearchStrategySchema: z.ZodEnum<{
     all: "all";
     merged: "merged";
-    orgs: "orgs";
     starred: "starred";
     broad: "broad";
     maintained: "maintained";
 }>;
 /** All concrete strategies (excludes 'all' meta-strategy). */
-export declare const CONCRETE_STRATEGIES: readonly ["merged", "orgs", "starred", "broad", "maintained"];
+export declare const CONCRETE_STRATEGIES: readonly ["merged", "starred", "broad", "maintained"];
 export declare const RepoSignalsSchema: z.ZodObject<{
     hasActiveMaintainers: z.ZodBoolean;
     isResponsive: z.ZodBoolean;
@@ -152,6 +151,13 @@ export declare const TrackedIssueSchema: z.ZodObject<{
         notes: z.ZodArray<z.ZodString>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
+export declare const SkippedIssueSchema: z.ZodObject<{
+    url: z.ZodString;
+    repo: z.ZodString;
+    number: z.ZodNumber;
+    title: z.ZodString;
+    skippedAt: z.ZodString;
+}, z.core.$strip>;
 export declare const SavedCandidateSchema: z.ZodObject<{
     issueUrl: z.ZodString;
     repo: z.ZodString;
@@ -185,7 +191,6 @@ export declare const ScoutPreferencesSchema: z.ZodObject<{
     excludeRepos: z.ZodDefault<z.ZodArray<z.ZodString>>;
     excludeOrgs: z.ZodDefault<z.ZodArray<z.ZodString>>;
     aiPolicyBlocklist: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    preferredOrgs: z.ZodDefault<z.ZodArray<z.ZodString>>;
     projectCategories: z.ZodDefault<z.ZodArray<z.ZodEnum<{
         nonprofit: "nonprofit";
         devtools: "devtools";
@@ -198,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";
@@ -205,11 +211,12 @@ export declare const ScoutPreferencesSchema: z.ZodObject<{
     defaultStrategy: z.ZodOptional<z.ZodArray<z.ZodEnum<{
         all: "all";
         merged: "merged";
-        orgs: "orgs";
         starred: "starred";
         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>;
@@ -225,7 +232,6 @@ export declare const ScoutStateSchema: z.ZodObject<{
         excludeRepos: z.ZodDefault<z.ZodArray<z.ZodString>>;
         excludeOrgs: z.ZodDefault<z.ZodArray<z.ZodString>>;
         aiPolicyBlocklist: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        preferredOrgs: z.ZodDefault<z.ZodArray<z.ZodString>>;
         projectCategories: z.ZodDefault<z.ZodArray<z.ZodEnum<{
             nonprofit: "nonprofit";
             devtools: "devtools";
@@ -238,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";
@@ -245,11 +252,12 @@ export declare const ScoutStateSchema: z.ZodObject<{
         defaultStrategy: z.ZodOptional<z.ZodArray<z.ZodEnum<{
             all: "all";
             merged: "merged";
-            orgs: "orgs";
             starred: "starred";
             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;
@@ -296,11 +304,17 @@ export declare const ScoutStateSchema: z.ZodObject<{
         lastSeenAt: z.ZodString;
         lastScore: z.ZodNumber;
     }, z.core.$strip>>>;
+    skippedIssues: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        url: z.ZodString;
+        repo: z.ZodString;
+        number: z.ZodNumber;
+        title: z.ZodString;
+        skippedAt: z.ZodString;
+    }, z.core.$strip>>>;
     lastSearchAt: z.ZodOptional<z.ZodString>;
     lastRunAt: z.ZodDefault<z.ZodString>;
     gistId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-export type IssueStatus = z.infer<typeof IssueStatusSchema>;
 export type ProjectCategory = z.infer<typeof ProjectCategorySchema>;
 export type IssueScope = z.infer<typeof IssueScopeSchema>;
 export type SearchStrategy = z.infer<typeof SearchStrategySchema>;
@@ -311,7 +325,7 @@ export type StoredClosedPR = z.infer<typeof StoredClosedPRSchema>;
 export type ContributionGuidelines = z.infer<typeof ContributionGuidelinesSchema>;
 export type IssueVettingResult = z.infer<typeof IssueVettingResultSchema>;
 export type TrackedIssue = z.infer<typeof TrackedIssueSchema>;
-export type PersistenceMode = z.infer<typeof PersistenceModeSchema>;
 export type ScoutPreferences = z.infer<typeof ScoutPreferencesSchema>;
 export type SavedCandidate = z.infer<typeof SavedCandidateSchema>;
+export type SkippedIssue = z.infer<typeof SkippedIssueSchema>;
 export type ScoutState = z.infer<typeof ScoutStateSchema>;

package/dist/core/schemas.js

@@ -27,7 +27,6 @@ export const IssueScopeSchema = z.enum([
 ]);
 export const SearchStrategySchema = z.enum([
     "merged",
-    "orgs",
     "starred",
     "broad",
     "maintained",
@@ -36,7 +35,6 @@ export const SearchStrategySchema = z.enum([
 /** All concrete strategies (excludes 'all' meta-strategy). */
 export const CONCRETE_STRATEGIES = [
     "merged",
-    "orgs",
     "starred",
     "broad",
     "maintained",
@@ -111,6 +109,14 @@ export const TrackedIssueSchema = z.object({
     vetted: z.boolean(),
     vettingResult: IssueVettingResultSchema.optional(),
 });
+// ── Skipped issue schema ──────────────────────────────────────────
+export const SkippedIssueSchema = z.object({
+    url: z.string(),
+    repo: z.string(),
+    number: z.number(),
+    title: z.string(),
+    skippedAt: z.string(),
+});
 // ── Saved candidate schema ─────────────────────────────────────────
 export const SavedCandidateSchema = z.object({
     issueUrl: z.string(),
@@ -129,20 +135,22 @@ export const SavedCandidateSchema = z.object({
 export const PersistenceModeSchema = z.enum(["local", "gist"]);
 export const ScoutPreferencesSchema = z.object({
     githubUsername: z.string().default(""),
-    languages: z.array(z.string()).default(["typescript", "javascript"]),
+    languages: z.array(z.string()).default(["any"]),
     labels: z.array(z.string()).default(["good first issue", "help wanted"]),
     scope: z.array(IssueScopeSchema).optional(),
     excludeRepos: z.array(z.string()).default([]),
     excludeOrgs: z.array(z.string()).default([]),
     aiPolicyBlocklist: z.array(z.string()).default(["matplotlib/matplotlib"]),
-    preferredOrgs: z.array(z.string()).default([]),
     projectCategories: z.array(ProjectCategorySchema).default([]),
     minStars: z.number().default(50),
     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({
@@ -154,6 +162,7 @@ export const ScoutStateSchema = z.object({
     mergedPRs: z.array(StoredMergedPRSchema).default([]),
     closedPRs: z.array(StoredClosedPRSchema).default([]),
     savedResults: z.array(SavedCandidateSchema).default([]),
+    skippedIssues: z.array(SkippedIssueSchema).default([]),
     lastSearchAt: z.string().optional(),
     lastRunAt: z.string().default(() => new Date().toISOString()),
     gistId: z.string().optional(),

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.
  *