@oss-autopilot/core 0.53.1 → 0.55.0

package/dist/core/repo-health.js

@@ -0,0 +1,193 @@
+/**
+ * Repo Health — project health checks and contribution guidelines fetching.
+ *
+ * Extracted from issue-vetting.ts (#621) to isolate repo-level checks
+ * from issue-level eligibility logic.
+ */
+import { daysBetween } from './utils.js';
+import { errorMessage } from './errors.js';
+import { warn } from './logger.js';
+import { getHttpCache, cachedRequest, cachedTimeBased } from './http-cache.js';
+const MODULE = 'repo-health';
+// ── Cache for contribution guidelines ──
+const guidelinesCache = new Map();
+/** TTL for cached contribution guidelines (1 hour). */
+const CACHE_TTL_MS = 60 * 60 * 1000;
+/** TTL for cached project health results (4 hours). Health data (stars, commits, CI) changes slowly. */
+const HEALTH_CACHE_TTL_MS = 4 * 60 * 60 * 1000;
+/** Max entries in the guidelines cache before pruning. */
+const CACHE_MAX_SIZE = 100;
+/** Remove expired and excess entries from the guidelines cache. */
+function pruneCache() {
+    const now = Date.now();
+    // First, remove expired entries (older than CACHE_TTL_MS)
+    for (const [key, value] of guidelinesCache.entries()) {
+        if (now - value.fetchedAt > CACHE_TTL_MS) {
+            guidelinesCache.delete(key);
+        }
+    }
+    // Then, if still over size limit, remove oldest entries
+    if (guidelinesCache.size > CACHE_MAX_SIZE) {
+        const entries = Array.from(guidelinesCache.entries()).sort((a, b) => a[1].fetchedAt - b[1].fetchedAt);
+        const toRemove = entries.slice(0, guidelinesCache.size - CACHE_MAX_SIZE);
+        for (const [key] of toRemove) {
+            guidelinesCache.delete(key);
+        }
+    }
+}
+// ── Project health ──
+/**
+ * Check the health of a GitHub project: recent commits, CI status, star/fork counts.
+ * Results are cached for HEALTH_CACHE_TTL_MS (4 hours).
+ */
+export async function checkProjectHealth(octokit, owner, repo) {
+    const cache = getHttpCache();
+    const healthCacheKey = `health:${owner}/${repo}`;
+    try {
+        return await cachedTimeBased(cache, healthCacheKey, HEALTH_CACHE_TTL_MS, async () => {
+            // Get repo info (with ETag caching — repo metadata changes infrequently)
+            const url = `/repos/${owner}/${repo}`;
+            const repoData = await cachedRequest(cache, url, (headers) => octokit.repos.get({ owner, repo, headers }));
+            // Get recent commits
+            const { data: commits } = await octokit.repos.listCommits({
+                owner,
+                repo,
+                per_page: 1,
+            });
+            const lastCommit = commits[0];
+            const lastCommitAt = lastCommit?.commit?.author?.date || repoData.pushed_at;
+            const daysSinceLastCommit = daysBetween(new Date(lastCommitAt));
+            // Check CI status (simplified - just check if workflows exist)
+            let ciStatus = 'unknown';
+            try {
+                const { data: workflows } = await octokit.actions.listRepoWorkflows({
+                    owner,
+                    repo,
+                    per_page: 1,
+                });
+                if (workflows.total_count > 0) {
+                    ciStatus = 'passing'; // Assume passing if workflows exist
+                }
+            }
+            catch (error) {
+                const errMsg = errorMessage(error);
+                warn(MODULE, `Failed to check CI status for ${owner}/${repo}: ${errMsg}. Defaulting to unknown.`);
+            }
+            return {
+                repo: `${owner}/${repo}`,
+                lastCommitAt,
+                daysSinceLastCommit,
+                openIssuesCount: repoData.open_issues_count,
+                avgIssueResponseDays: 0, // Would need more API calls to calculate
+                ciStatus,
+                isActive: daysSinceLastCommit < 30,
+                stargazersCount: repoData.stargazers_count,
+                forksCount: repoData.forks_count,
+            };
+        });
+    }
+    catch (error) {
+        const errMsg = errorMessage(error);
+        warn(MODULE, `Error checking project health for ${owner}/${repo}: ${errMsg}`);
+        return {
+            repo: `${owner}/${repo}`,
+            lastCommitAt: '',
+            daysSinceLastCommit: 999,
+            openIssuesCount: 0,
+            avgIssueResponseDays: 0,
+            ciStatus: 'unknown',
+            isActive: false,
+            checkFailed: true,
+            failureReason: errMsg,
+        };
+    }
+}
+// ── Contribution guidelines ──
+/**
+ * Fetch and parse CONTRIBUTING.md (or variants) from a GitHub repo.
+ * Probes multiple paths in parallel: CONTRIBUTING.md, .github/CONTRIBUTING.md,
+ * docs/CONTRIBUTING.md, contributing.md. Results are cached for CACHE_TTL_MS.
+ */
+export async function fetchContributionGuidelines(octokit, owner, repo) {
+    const cacheKey = `${owner}/${repo}`;
+    // Check cache first
+    const cached = guidelinesCache.get(cacheKey);
+    if (cached && Date.now() - cached.fetchedAt < CACHE_TTL_MS) {
+        return cached.guidelines;
+    }
+    const filesToCheck = ['CONTRIBUTING.md', '.github/CONTRIBUTING.md', 'docs/CONTRIBUTING.md', 'contributing.md'];
+    // Probe all paths in parallel — take the first success in priority order
+    const results = await Promise.allSettled(filesToCheck.map((file) => octokit.repos.getContent({ owner, repo, path: file }).then(({ data }) => {
+        if ('content' in data) {
+            return Buffer.from(data.content, 'base64').toString('utf-8');
+        }
+        return null;
+    })));
+    for (let i = 0; i < results.length; i++) {
+        const result = results[i];
+        if (result.status === 'fulfilled' && result.value) {
+            const guidelines = parseContributionGuidelines(result.value);
+            guidelinesCache.set(cacheKey, { guidelines, fetchedAt: Date.now() });
+            pruneCache();
+            return guidelines;
+        }
+        if (result.status === 'rejected') {
+            const msg = result.reason instanceof Error ? result.reason.message : String(result.reason);
+            if (!msg.includes('404') && !msg.includes('Not Found')) {
+                warn(MODULE, `Unexpected error fetching ${filesToCheck[i]} from ${owner}/${repo}: ${msg}`);
+            }
+        }
+    }
+    // Cache the negative result too and prune if needed
+    guidelinesCache.set(cacheKey, { guidelines: undefined, fetchedAt: Date.now() });
+    pruneCache();
+    return undefined;
+}
+/**
+ * Parse the raw content of a CONTRIBUTING.md file to extract structured guidelines:
+ * branch naming, commit format, test framework, linter, formatter, CLA requirement.
+ */
+export function parseContributionGuidelines(content) {
+    const guidelines = {
+        rawContent: content,
+    };
+    const lowerContent = content.toLowerCase();
+    // Detect branch naming conventions
+    if (lowerContent.includes('branch')) {
+        const branchMatch = content.match(/branch[^\n]*(?:named?|format|convention)[^\n]*[`"]([^`"]+)[`"]/i);
+        if (branchMatch) {
+            guidelines.branchNamingConvention = branchMatch[1];
+        }
+    }
+    // Detect commit message format
+    if (lowerContent.includes('conventional commit')) {
+        guidelines.commitMessageFormat = 'conventional commits';
+    }
+    else if (lowerContent.includes('commit message')) {
+        const commitMatch = content.match(/commit message[^\n]*[`"]([^`"]+)[`"]/i);
+        if (commitMatch) {
+            guidelines.commitMessageFormat = commitMatch[1];
+        }
+    }
+    // Detect test framework
+    if (lowerContent.includes('jest'))
+        guidelines.testFramework = 'Jest';
+    else if (lowerContent.includes('rspec'))
+        guidelines.testFramework = 'RSpec';
+    else if (lowerContent.includes('pytest'))
+        guidelines.testFramework = 'pytest';
+    else if (lowerContent.includes('mocha'))
+        guidelines.testFramework = 'Mocha';
+    // Detect linter
+    if (lowerContent.includes('eslint'))
+        guidelines.linter = 'ESLint';
+    else if (lowerContent.includes('rubocop'))
+        guidelines.linter = 'RuboCop';
+    else if (lowerContent.includes('prettier'))
+        guidelines.formatter = 'Prettier';
+    // Detect CLA requirement
+    if (lowerContent.includes('cla') || lowerContent.includes('contributor license agreement')) {
+        guidelines.claRequired = true;
+    }
+    return guidelines;
+}

package/dist/core/repo-score-manager.js

@@ -94,6 +94,8 @@ export function updateRepoScore(state, repo, updates) {
         repoScore.lastMergedAt = updates.lastMergedAt;
     if (updates.stargazersCount !== undefined)
         repoScore.stargazersCount = updates.stargazersCount;
+    if (updates.language !== undefined)
+        repoScore.language = updates.language;
     if (updates.signals) {
         repoScore.signals = { ...repoScore.signals, ...updates.signals };
     }

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

@@ -0,0 +1,55 @@
+/**
+ * Search Phases — utilities and infrastructure for multi-phase issue search.
+ *
+ * Extracted from issue-discovery.ts (#621) to isolate search helpers,
+ * caching, spam-filtering, and batched repo search logic.
+ */
+import { Octokit } from '@octokit/rest';
+import { type SearchPriority, type IssueCandidate, type IssueScope } from './types.js';
+import { type GitHubSearchItem } from './issue-filtering.js';
+import { IssueVetter } from './issue-vetting.js';
+/** Build a GitHub Search API label filter from a list of labels. */
+export declare function buildLabelQuery(labels: string[]): string;
+/** Resolve scope tiers into a flat label list, merged with custom labels. */
+export declare function buildEffectiveLabels(scopes: IssueScope[], customLabels: string[]): string[];
+/** Round-robin interleave multiple arrays. */
+export declare function interleaveArrays<T>(arrays: T[][]): T[];
+/** Split repos into batches of the specified size. */
+export declare function batchRepos(repos: string[], batchSize: number): string[][];
+/**
+ * Wrap octokit.search.issuesAndPullRequests with time-based caching.
+ * Repeated identical queries within SEARCH_CACHE_TTL_MS return cached results
+ * without consuming GitHub API rate limit points.
+ */
+export declare function cachedSearchIssues(octokit: Octokit, params: {
+    q: string;
+    sort: 'created' | 'updated' | 'comments' | 'reactions' | 'interactions';
+    order: 'asc' | 'desc';
+    per_page: number;
+}): Promise<{
+    total_count: number;
+    items: GitHubSearchItem[];
+}>;
+/**
+ * Shared pipeline: spam-filter, repo-exclusion, vetting, and star-count filter.
+ * Used by Phases 2 and 3 to convert raw search results into vetted candidates.
+ */
+export declare function filterVetAndScore(vetter: IssueVetter, items: GitHubSearchItem[], filterIssues: (items: GitHubSearchItem[]) => GitHubSearchItem[], excludedRepoSets: Set<string>[], remainingNeeded: number, minStars: number, phaseLabel: string): Promise<{
+    candidates: IssueCandidate[];
+    allVetFailed: boolean;
+    rateLimitHit: boolean;
+}>;
+/**
+ * Search for issues within specific repos using batched queries.
+ *
+ * To avoid GitHub's secondary rate limit (30 requests/minute), we batch
+ * multiple repos into a single search query using OR syntax:
+ *   repo:owner1/repo1 OR repo:owner2/repo2 OR repo:owner3/repo3
+ *
+ * This reduces API calls from N (one per repo) to ceil(N/BATCH_SIZE).
+ */
+export declare function searchInRepos(octokit: Octokit, vetter: IssueVetter, repos: string[], baseQuery: string, maxResults: number, priority: SearchPriority, filterFn: (items: GitHubSearchItem[]) => GitHubSearchItem[]): Promise<{
+    candidates: IssueCandidate[];
+    allBatchesFailed: boolean;
+    rateLimitHit: boolean;
+}>;

package/dist/core/search-phases.js

@@ -0,0 +1,155 @@
+/**
+ * Search Phases — utilities and infrastructure for multi-phase issue search.
+ *
+ * Extracted from issue-discovery.ts (#621) to isolate search helpers,
+ * caching, spam-filtering, and batched repo search logic.
+ */
+import { SCOPE_LABELS } from './types.js';
+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';
+const MODULE = 'search-phases';
+// ── Pure utilities ──
+/** Build a GitHub Search API label filter from a list of labels. */
+export function buildLabelQuery(labels) {
+    if (labels.length === 0)
+        return '';
+    if (labels.length === 1)
+        return `label:"${labels[0]}"`;
+    return `(${labels.map((l) => `label:"${l}"`).join(' OR ')})`;
+}
+/** Resolve scope tiers into a flat label list, merged with custom labels. */
+export function buildEffectiveLabels(scopes, customLabels) {
+    const labels = new Set();
+    for (const scope of scopes) {
+        for (const label of SCOPE_LABELS[scope] ?? [])
+            labels.add(label);
+    }
+    for (const label of customLabels)
+        labels.add(label);
+    return [...labels];
+}
+/** Round-robin interleave multiple arrays. */
+export function interleaveArrays(arrays) {
+    const result = [];
+    const maxLen = Math.max(...arrays.map((a) => a.length), 0);
+    for (let i = 0; i < maxLen; i++) {
+        for (const arr of arrays) {
+            if (i < arr.length)
+                result.push(arr[i]);
+        }
+    }
+    return result;
+}
+/** Split repos into batches of the specified size. */
+export function batchRepos(repos, batchSize) {
+    const batches = [];
+    for (let i = 0; i < repos.length; i += batchSize) {
+        batches.push(repos.slice(i, i + batchSize));
+    }
+    return batches;
+}
+// ── Search caching ──
+/** TTL for cached search API results (15 minutes). */
+const SEARCH_CACHE_TTL_MS = 15 * 60 * 1000;
+/**
+ * Wrap octokit.search.issuesAndPullRequests with time-based caching.
+ * Repeated identical queries within SEARCH_CACHE_TTL_MS return cached results
+ * without consuming GitHub API rate limit points.
+ */
+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 { data } = await octokit.search.issuesAndPullRequests(params);
+        return data;
+    });
+}
+// ── Search infrastructure ──
+/**
+ * Shared pipeline: spam-filter, repo-exclusion, vetting, and star-count filter.
+ * Used by Phases 2 and 3 to convert raw search results into vetted candidates.
+ */
+export async function filterVetAndScore(vetter, items, filterIssues, excludedRepoSets, remainingNeeded, minStars, phaseLabel) {
+    const spamRepos = detectLabelFarmingRepos(items);
+    if (spamRepos.size > 0) {
+        const spamCount = items.filter((i) => spamRepos.has(i.repository_url.split('/').slice(-2).join('/'))).length;
+        debug(MODULE, `[SPAM_FILTER] Filtered ${spamCount} issues from ${spamRepos.size} label-farming repos: ${[...spamRepos].join(', ')}`);
+    }
+    const itemsToVet = filterIssues(items)
+        .filter((item) => {
+        const repoFullName = item.repository_url.split('/').slice(-2).join('/');
+        if (spamRepos.has(repoFullName))
+            return false;
+        return excludedRepoSets.every((s) => !s.has(repoFullName));
+    })
+        .slice(0, remainingNeeded * 2);
+    if (itemsToVet.length === 0) {
+        debug(MODULE, `[${phaseLabel}] All ${items.length} items filtered before vetting`);
+        return { candidates: [], allVetFailed: false, rateLimitHit: false };
+    }
+    const { candidates: results, allFailed: allVetFailed, rateLimitHit, } = await vetter.vetIssuesParallel(itemsToVet.map((i) => i.html_url), remainingNeeded, 'normal');
+    const starFiltered = results.filter((c) => {
+        if (c.projectHealth.checkFailed)
+            return true;
+        const stars = c.projectHealth.stargazersCount ?? 0;
+        return stars >= minStars;
+    });
+    const starFilteredCount = results.length - starFiltered.length;
+    if (starFilteredCount > 0) {
+        debug(MODULE, `[STAR_FILTER] Filtered ${starFilteredCount} ${phaseLabel} candidates below ${minStars} stars`);
+    }
+    return { candidates: starFiltered, allVetFailed, rateLimitHit };
+}
+/**
+ * Search for issues within specific repos using batched queries.
+ *
+ * To avoid GitHub's secondary rate limit (30 requests/minute), we batch
+ * multiple repos into a single search query using OR syntax:
+ *   repo:owner1/repo1 OR repo:owner2/repo2 OR repo:owner3/repo3
+ *
+ * This reduces API calls from N (one per repo) to ceil(N/BATCH_SIZE).
+ */
+export async function searchInRepos(octokit, vetter, repos, baseQuery, maxResults, priority, filterFn) {
+    const candidates = [];
+    const BATCH_SIZE = 5;
+    const batches = batchRepos(repos, BATCH_SIZE);
+    let failedBatches = 0;
+    let rateLimitFailures = 0;
+    for (const batch of batches) {
+        if (candidates.length >= maxResults)
+            break;
+        try {
+            // Build repo filter: (repo:a OR repo:b OR repo:c)
+            const repoFilter = batch.map((r) => `repo:${r}`).join(' OR ');
+            const batchQuery = `${baseQuery} (${repoFilter})`;
+            const data = await cachedSearchIssues(octokit, {
+                q: batchQuery,
+                sort: 'created',
+                order: 'desc',
+                per_page: Math.min(30, (maxResults - candidates.length) * 3),
+            });
+            if (data.items.length > 0) {
+                const filtered = filterFn(data.items);
+                const remainingNeeded = maxResults - candidates.length;
+                const { candidates: vetted } = await vetter.vetIssuesParallel(filtered.slice(0, remainingNeeded * 2).map((i) => i.html_url), remainingNeeded, priority);
+                candidates.push(...vetted);
+            }
+        }
+        catch (error) {
+            failedBatches++;
+            if (isRateLimitError(error)) {
+                rateLimitFailures++;
+            }
+            const batchReposStr = batch.join(', ');
+            warn(MODULE, `Error searching issues in batch [${batchReposStr}]:`, errorMessage(error));
+        }
+    }
+    const allBatchesFailed = failedBatches === batches.length && batches.length > 0;
+    const rateLimitHit = rateLimitFailures > 0;
+    if (allBatchesFailed) {
+        warn(MODULE, `All ${batches.length} batch(es) failed for ${priority} phase. ` +
+            `This may indicate a systemic issue (rate limit, auth, network).`);
+    }
+    return { candidates, allBatchesFailed, rateLimitHit };
+}

package/dist/core/state.d.ts

@@ -18,6 +18,8 @@ export declare class StateManager {
     private state;
     private readonly inMemoryOnly;
     private lastLoadedMtimeMs;
+    private _batching;
+    private _batchDirty;
     /**
      * Create a new StateManager instance.
      * @param inMemoryOnly - When true, state is held only in memory and never read from or
@@ -25,6 +27,15 @@ export declare class StateManager {
      *   Defaults to false (normal persistent mode).
      */
     constructor(inMemoryOnly?: boolean);
+    /**
+     * Execute multiple mutations as a single batch, deferring disk I/O until the
+     * batch completes. Nested `batch()` calls are flattened — only the outermost saves.
+     */
+    batch(fn: () => void): void;
+    /**
+     * Auto-persist after a mutation. Inside a `batch()`, defers to the batch boundary.
+     */
+    private autoSave;
     /**
      * Check if initial setup has been completed.
      */

package/dist/core/state.js

@@ -21,6 +21,8 @@ export class StateManager {
     state;
     inMemoryOnly;
     lastLoadedMtimeMs = 0;
+    _batching = false;
+    _batchDirty = false;
     /**
      * Create a new StateManager instance.
      * @param inMemoryOnly - When true, state is held only in memory and never read from or
@@ -38,6 +40,37 @@ export class StateManager {
             this.lastLoadedMtimeMs = result.mtimeMs;
         }
     }
+    /**
+     * Execute multiple mutations as a single batch, deferring disk I/O until the
+     * batch completes. Nested `batch()` calls are flattened — only the outermost saves.
+     */
+    batch(fn) {
+        if (this._batching) {
+            fn();
+            return;
+        }
+        this._batching = true;
+        this._batchDirty = false;
+        try {
+            fn();
+            if (this._batchDirty)
+                this.save();
+        }
+        finally {
+            this._batching = false;
+            this._batchDirty = false;
+        }
+    }
+    /**
+     * Auto-persist after a mutation. Inside a `batch()`, defers to the batch boundary.
+     */
+    autoSave() {
+        if (this._batching) {
+            this._batchDirty = true;
+            return;
+        }
+        this.save();
+    }
     /**
      * Check if initial setup has been completed.
      */
@@ -50,6 +83,7 @@ export class StateManager {
     markSetupComplete() {
         this.state.config.setupComplete = true;
         this.state.config.setupCompletedAt = new Date().toISOString();
+        this.autoSave();
     }
     /**
      * Initialize state with sensible defaults for zero-config onboarding.
@@ -60,10 +94,11 @@ export class StateManager {
             debug(MODULE, `Setup already complete, skipping initializeWithDefaults for "${username}"`);
             return;
         }
-        this.state.config.githubUsername = username;
-        this.markSetupComplete();
-        debug(MODULE, `Initialized with defaults for user "${username}"`);
-        this.save();
+        this.batch(() => {
+            this.updateConfig({ githubUsername: username });
+            this.markSetupComplete();
+            debug(MODULE, `Initialized with defaults for user "${username}"`);
+        });
     }
     /**
      * Persist the current state to disk, creating a timestamped backup of the previous
@@ -100,21 +135,27 @@ export class StateManager {
     setLastDigest(digest) {
         this.state.lastDigest = digest;
         this.state.lastDigestAt = digest.generatedAt;
+        this.autoSave();
     }
     setMonthlyMergedCounts(counts) {
         this.state.monthlyMergedCounts = counts;
+        this.autoSave();
     }
     setMonthlyClosedCounts(counts) {
         this.state.monthlyClosedCounts = counts;
+        this.autoSave();
     }
     setMonthlyOpenedCounts(counts) {
         this.state.monthlyOpenedCounts = counts;
+        this.autoSave();
     }
     setDailyActivityCounts(counts) {
         this.state.dailyActivityCounts = counts;
+        this.autoSave();
     }
     setLocalRepoCache(cache) {
         this.state.localRepoCache = cache;
+        this.autoSave();
     }
     // === Merged PR Storage ===
     getMergedPRs() {
@@ -132,6 +173,7 @@ export class StateManager {
         this.state.mergedPRs.push(...newPRs);
         this.state.mergedPRs.sort((a, b) => b.mergedAt.localeCompare(a.mergedAt));
         debug(MODULE, `Added ${newPRs.length} merged PRs (total: ${this.state.mergedPRs.length})`);
+        this.autoSave();
     }
     getMergedPRWatermark() {
         return this.state.mergedPRs?.[0]?.mergedAt || undefined;
@@ -152,6 +194,7 @@ export class StateManager {
         this.state.closedPRs.push(...newPRs);
         this.state.closedPRs.sort((a, b) => b.closedAt.localeCompare(a.closedAt));
         debug(MODULE, `Added ${newPRs.length} closed PRs (total: ${this.state.closedPRs.length})`);
+        this.autoSave();
     }
     getClosedPRWatermark() {
         return this.state.closedPRs?.[0]?.closedAt || undefined;
@@ -159,6 +202,7 @@ export class StateManager {
     // === Configuration ===
     updateConfig(config) {
         this.state.config = { ...this.state.config, ...config };
+        this.autoSave();
     }
     // === Event Logging ===
     appendEvent(type, data) {
@@ -173,6 +217,7 @@ export class StateManager {
         if (this.state.events.length > MAX_EVENTS) {
             this.state.events = this.state.events.slice(-MAX_EVENTS);
         }
+        this.autoSave();
     }
     getEventsByType(type) {
         return this.state.events.filter((e) => e.type === type);
@@ -192,12 +237,14 @@ export class StateManager {
         }
         this.state.activeIssues.push(issue);
         debug(MODULE, `Added issue: ${issue.repo}#${issue.number}`);
+        this.autoSave();
     }
     // === Trusted Projects ===
     addTrustedProject(repo) {
         if (!this.state.config.trustedProjects.includes(repo)) {
             this.state.config.trustedProjects.push(repo);
             debug(MODULE, `Added trusted project: ${repo}`);
+            this.autoSave();
         }
     }
     static matchesExclusion(repo, repos, orgs) {
@@ -215,6 +262,7 @@ export class StateManager {
         const removedTrusted = beforeTrusted - this.state.config.trustedProjects.length;
         if (removedTrusted > 0) {
             debug(MODULE, `Removed ${removedTrusted} trusted project(s) for excluded repos/orgs`);
+            this.autoSave();
         }
     }
     // === Starred Repos Management ===
@@ -225,6 +273,7 @@ export class StateManager {
         this.state.config.starredRepos = repos;
         this.state.config.starredReposLastFetched = new Date().toISOString();
         debug(MODULE, `Updated starred repos: ${repos.length} repositories`);
+        this.autoSave();
     }
     isStarredReposStale() {
         const lastFetched = this.state.config.starredReposLastFetched;
@@ -245,6 +294,7 @@ export class StateManager {
             return false;
         }
         this.state.config.shelvedPRUrls.push(url);
+        this.autoSave();
         return true;
     }
     unshelvePR(url) {
@@ -256,6 +306,7 @@ export class StateManager {
             return false;
         }
         this.state.config.shelvedPRUrls.splice(index, 1);
+        this.autoSave();
         return true;
     }
     isPRShelved(url) {
@@ -270,6 +321,7 @@ export class StateManager {
             return false;
         }
         this.state.config.dismissedIssues[url] = timestamp;
+        this.autoSave();
         return true;
     }
     undismissIssue(url) {
@@ -277,6 +329,7 @@ export class StateManager {
             return false;
         }
         delete this.state.config.dismissedIssues[url];
+        this.autoSave();
         return true;
     }
     getIssueDismissedAt(url) {
@@ -292,12 +345,14 @@ export class StateManager {
             setAt: new Date().toISOString(),
             lastActivityAt,
         };
+        this.autoSave();
     }
     clearStatusOverride(url) {
         if (!this.state.config.statusOverrides || !(url in this.state.config.statusOverrides)) {
             return false;
         }
         delete this.state.config.statusOverrides[url];
+        this.autoSave();
         return true;
     }
     getStatusOverride(url, currentUpdatedAt) {
@@ -317,15 +372,19 @@ export class StateManager {
     }
     updateRepoScore(repo, updates) {
         repoScoring.updateRepoScore(this.state, repo, updates);
+        this.autoSave();
     }
     incrementMergedCount(repo) {
         repoScoring.incrementMergedCount(this.state, repo);
+        this.autoSave();
     }
     incrementClosedCount(repo) {
         repoScoring.incrementClosedCount(this.state, repo);
+        this.autoSave();
     }
     markRepoHostile(repo) {
         repoScoring.markRepoHostile(this.state, repo);
+        this.autoSave();
     }
     getReposWithMergedPRs() {
         return repoScoring.getReposWithMergedPRs(this.state);

package/dist/core/status-determination.d.ts

@@ -6,6 +6,8 @@
  * its CI, review, merge-conflict, and timeline signals.
  */
 import type { DetermineStatusInput, DetermineStatusResult } from './types.js';
+/** Days of inactivity after which an actionable CI failure is demoted to stale_ci_failure (#675). */
+export declare const STALE_CI_DEMOTION_DAYS = 5;
 /**
  * CI-fix bots that push commits as a direct result of the contributor's push (#568).
  * Their commits represent contributor work and should count as addressing feedback.