@oss-scout/core 0.3.0 → 0.5.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/bootstrap.d.ts

@@ -7,6 +7,7 @@ export interface BootstrapResult {
     starredRepoCount: number;
     mergedPRCount: number;
     closedPRCount: number;
+    openPRCount: number;
     reposScoredCount: number;
     skippedDueToRateLimit: boolean;
     errors: string[];

package/dist/core/bootstrap.js

@@ -4,7 +4,7 @@
  */
 import { getOctokit, checkRateLimit } from "./github.js";
 import { debug, warn } from "./logger.js";
-import { ConfigurationError, errorMessage } from "./errors.js";
+import { ConfigurationError, errorMessage, getHttpStatusCode, isRateLimitError, } from "./errors.js";
 import { extractRepoFromUrl } from "./utils.js";
 const MODULE = "bootstrap";
 const STARRED_MAX_PAGES = 5;
@@ -23,6 +23,7 @@ export async function bootstrapScout(scout, token) {
             starredRepoCount: 0,
             mergedPRCount: 0,
             closedPRCount: 0,
+            openPRCount: 0,
             reposScoredCount: 0,
             skippedDueToRateLimit: true,
             errors: [],
@@ -80,6 +81,8 @@ export async function bootstrapScout(scout, token) {
         debug(MODULE, `Imported ${mergedPRCount} merged PRs`);
     }
     catch (err) {
+        if (getHttpStatusCode(err) === 401 || isRateLimitError(err))
+            throw err;
         warn(MODULE, `Failed to fetch merged PRs: ${errorMessage(err)}`);
         errors.push("merged PR fetch failed");
     }
@@ -110,15 +113,50 @@ export async function bootstrapScout(scout, token) {
         debug(MODULE, `Imported ${closedPRCount} closed PRs`);
     }
     catch (err) {
+        if (getHttpStatusCode(err) === 401 || isRateLimitError(err))
+            throw err;
         warn(MODULE, `Failed to fetch closed PRs: ${errorMessage(err)}`);
         errors.push("closed PR fetch failed");
     }
+    // 4. Fetch currently-open PRs via Search API
+    let openPRCount = 0;
+    try {
+        for (let page = 1; page <= SEARCH_MAX_PAGES; page++) {
+            const { data } = await octokit.search.issuesAndPullRequests({
+                q: `is:pr is:open author:${username}`,
+                per_page: PER_PAGE,
+                page,
+            });
+            for (const item of data.items) {
+                const repo = extractRepoFromUrl(item.html_url);
+                if (!repo)
+                    continue;
+                scout.recordOpenPR({
+                    url: item.html_url,
+                    title: item.title,
+                    openedAt: item.created_at ?? new Date().toISOString(),
+                    repo,
+                });
+                openPRCount++;
+            }
+            if (data.items.length < PER_PAGE)
+                break;
+        }
+        debug(MODULE, `Imported ${openPRCount} open PRs`);
+    }
+    catch (err) {
+        if (getHttpStatusCode(err) === 401 || isRateLimitError(err))
+            throw err;
+        warn(MODULE, `Failed to fetch open PRs: ${errorMessage(err)}`);
+        errors.push("open PR fetch failed");
+    }
     const state = scout.getState();
     const reposScoredCount = Object.keys(state.repoScores).length;
     return {
         starredRepoCount: starredRepos.length,
         mergedPRCount,
         closedPRCount,
+        openPRCount,
         reposScoredCount,
         skippedDueToRateLimit: false,
         errors,

package/dist/core/gist-state-store.d.ts

@@ -88,7 +88,7 @@ export declare class GistStateStore {
 /**
  * Merge two ScoutState objects with conflict resolution:
  * - repoScores: per-repo, keep the one with more total PR activity
- * - mergedPRs/closedPRs: union by URL
+ * - mergedPRs/closedPRs/openPRs: union by URL
  * - preferences: remote wins
  * - starredRepos: keep the list with the fresher timestamp
  * - savedResults: union by issueUrl, keep newer lastSeenAt

package/dist/core/gist-state-store.js

@@ -238,7 +238,7 @@ export class GistStateStore {
 /**
  * Merge two ScoutState objects with conflict resolution:
  * - repoScores: per-repo, keep the one with more total PR activity
- * - mergedPRs/closedPRs: union by URL
+ * - mergedPRs/closedPRs/openPRs: union by URL
  * - preferences: remote wins
  * - starredRepos: keep the list with the fresher timestamp
  * - savedResults: union by issueUrl, keep newer lastSeenAt
@@ -252,6 +252,7 @@ export function mergeStates(local, remote) {
         starredReposLastFetched: pickFresherTimestamp(local.starredReposLastFetched, remote.starredReposLastFetched),
         mergedPRs: unionByUrl(local.mergedPRs, remote.mergedPRs),
         closedPRs: unionByUrl(local.closedPRs, remote.closedPRs),
+        openPRs: unionByUrl(local.openPRs ?? [], remote.openPRs ?? []),
         savedResults: mergeSavedResults(local.savedResults ?? [], remote.savedResults ?? []),
         skippedIssues: mergeSkippedIssues(local.skippedIssues ?? [], remote.skippedIssues ?? []),
         lastSearchAt: pickFresherTimestamp(local.lastSearchAt, remote.lastSearchAt),

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 ??
@@ -301,6 +326,7 @@ export class IssueDiscovery {
         }
         // Derive search context
         const mergedPRRepos = this.stateReader.getReposWithMergedPRs();
+        const openPRRepos = this.stateReader.getReposWithOpenPRs();
         const starredRepos = this.getStarredRepos();
         const starredRepoSet = new Set(starredRepos);
         const lowScoringRepos = new Set(this.deriveLowScoringRepos(config.minRepoScoreThreshold));
@@ -327,13 +353,24 @@ export class IssueDiscovery {
             now: new Date(),
             includeDocIssues: config.includeDocIssues ?? true,
         });
-        // Phase 0: Merged-PR repos
-        const phase0Repos = mergedPRRepos.slice(0, 10);
+        // Phase 0: Repos the user has engaged with — merged PRs first (strongest
+        // signal), then open PRs (active engagement even without a merge yet).
+        // Deduped and capped so REST cost stays bounded.
+        const seenPhase0 = new Set();
+        const phase0Repos = [];
+        for (const repo of [...mergedPRRepos, ...openPRRepos]) {
+            if (seenPhase0.has(repo))
+                continue;
+            seenPhase0.add(repo);
+            phase0Repos.push(repo);
+            if (phase0Repos.length >= 10)
+                break;
+        }
         const phase0RepoSet = new Set(phase0Repos);
         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 +383,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 +400,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/issue-vetting.d.ts

@@ -15,6 +15,8 @@ import { type SearchPriority, type IssueCandidate, type ProjectCategory } from "
 export interface ScoutStateReader {
     /** Repos where the user has at least one merged PR. */
     getReposWithMergedPRs(): string[];
+    /** Repos where the user has at least one open PR. */
+    getReposWithOpenPRs(): string[];
     /** User's starred repos (from GitHub). */
     getStarredRepos(): string[];
     /** Preferred project categories from user preferences. */

package/dist/core/schemas.d.ts

@@ -64,6 +64,11 @@ export declare const StoredClosedPRSchema: z.ZodObject<{
     title: z.ZodString;
     closedAt: z.ZodString;
 }, z.core.$strip>;
+export declare const StoredOpenPRSchema: z.ZodObject<{
+    url: z.ZodString;
+    title: z.ZodString;
+    openedAt: z.ZodString;
+}, z.core.$strip>;
 export declare const ContributionGuidelinesSchema: z.ZodObject<{
     branchNamingConvention: z.ZodOptional<z.ZodString>;
     commitMessageFormat: z.ZodOptional<z.ZodString>;
@@ -203,6 +208,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 +220,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 +249,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 +261,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;
@@ -281,6 +292,11 @@ export declare const ScoutStateSchema: z.ZodObject<{
         title: z.ZodString;
         closedAt: z.ZodString;
     }, z.core.$strip>>>;
+    openPRs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        url: z.ZodString;
+        title: z.ZodString;
+        openedAt: z.ZodString;
+    }, z.core.$strip>>>;
     savedResults: z.ZodDefault<z.ZodArray<z.ZodObject<{
         issueUrl: z.ZodString;
         repo: z.ZodString;
@@ -316,6 +332,7 @@ export type RepoSignals = z.infer<typeof RepoSignalsSchema>;
 export type RepoScore = z.infer<typeof RepoScoreSchema>;
 export type StoredMergedPR = z.infer<typeof StoredMergedPRSchema>;
 export type StoredClosedPR = z.infer<typeof StoredClosedPRSchema>;
+export type StoredOpenPR = z.infer<typeof StoredOpenPRSchema>;
 export type ContributionGuidelines = z.infer<typeof ContributionGuidelinesSchema>;
 export type IssueVettingResult = z.infer<typeof IssueVettingResultSchema>;
 export type TrackedIssue = z.infer<typeof TrackedIssueSchema>;

package/dist/core/schemas.js

@@ -67,6 +67,11 @@ export const StoredClosedPRSchema = z.object({
     title: z.string(),
     closedAt: z.string(),
 });
+export const StoredOpenPRSchema = z.object({
+    url: z.string(),
+    title: z.string(),
+    openedAt: z.string(),
+});
 // ── Contribution schemas ────────────────────────────────────────────
 export const ContributionGuidelinesSchema = z.object({
     branchNamingConvention: z.string().optional(),
@@ -146,8 +151,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({
@@ -158,6 +166,7 @@ export const ScoutStateSchema = z.object({
     starredReposLastFetched: z.string().optional(),
     mergedPRs: z.array(StoredMergedPRSchema).default([]),
     closedPRs: z.array(StoredClosedPRSchema).default([]),
+    openPRs: z.array(StoredOpenPRSchema).default([]),
     savedResults: z.array(SavedCandidateSchema).default([]),
     skippedIssues: z.array(SkippedIssueSchema).default([]),
     lastSearchAt: 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.
  *