@oss-autopilot/core 0.53.1 → 0.54.0

package/dist/commands/daily.js

@@ -190,29 +190,31 @@ async function updateRepoScores(prMonitor, prs, mergedCounts, closedCounts) {
     if (signalUpdateFailures === repoSignals.size && repoSignals.size > 0) {
         warn(MODULE, `[ALL_SIGNAL_UPDATES_FAILED] All ${repoSignals.size} signal update(s) failed. This may indicate corrupted state.`);
     }
-    // Fetch star counts for all scored repos (used by dashboard minStars filter, #216)
+    // Fetch metadata (stars + language) for all scored repos (used by dashboard minStars filter and merged PR view, #216, #677)
     const allRepos = Object.keys(stateManager.getState().repoScores);
-    let starCounts;
+    let repoMetadata;
     try {
-        starCounts = await prMonitor.fetchRepoStarCounts(allRepos);
+        repoMetadata = await prMonitor.fetchRepoMetadata(allRepos);
     }
     catch (error) {
-        warn(MODULE, `Failed to fetch repo star counts: ${errorMessage(error)}`);
-        warn(MODULE, 'Repos without cached star data will be excluded from stats until star counts are fetched on the next successful run.');
-        starCounts = new Map();
+        if (isRateLimitOrAuthError(error))
+            throw error;
+        warn(MODULE, `Failed to fetch repo metadata: ${errorMessage(error)}`);
+        warn(MODULE, 'Repos without cached metadata will be excluded from dashboard stats and metadata badges until fetched on the next successful run.');
+        repoMetadata = new Map();
     }
-    let starUpdateFailures = 0;
-    for (const [repo, stars] of starCounts) {
+    let metadataUpdateFailures = 0;
+    for (const [repo, { stars, language }] of repoMetadata) {
         try {
-            stateManager.updateRepoScore(repo, { stargazersCount: stars });
+            stateManager.updateRepoScore(repo, { stargazersCount: stars, language });
         }
         catch (error) {
-            starUpdateFailures++;
-            warn(MODULE, `Failed to update star count for ${repo}: ${errorMessage(error)}`);
+            metadataUpdateFailures++;
+            warn(MODULE, `Failed to update metadata for ${repo}: ${errorMessage(error)}`);
         }
     }
-    if (starUpdateFailures === starCounts.size && starCounts.size > 0) {
-        warn(MODULE, `[ALL_STAR_COUNT_UPDATES_FAILED] All ${starCounts.size} star count update(s) failed.`);
+    if (metadataUpdateFailures === repoMetadata.size && repoMetadata.size > 0) {
+        warn(MODULE, `[ALL_METADATA_UPDATES_FAILED] All ${repoMetadata.size} metadata update(s) failed.`);
     }
     // Auto-sync trustedProjects from repos with merged PRs
     let trustSyncFailures = 0;

package/dist/commands/dashboard-server.js

@@ -53,6 +53,13 @@ function buildDashboardJson(digest, state, commentedIssues, allMergedPRs, allClo
     const stats = buildDashboardStats(digest, state, filteredMergedPRs.length, filteredClosedPRs.length);
     const dismissedIssues = state.config.dismissedIssues || {};
     const issueResponses = commentedIssues.filter((i) => i.status === 'new_response' && !(i.url in dismissedIssues));
+    // Build repo metadata map from repoScores — omit repos without stars or language to avoid empty entries
+    const repoMetadata = {};
+    for (const [repo, score] of Object.entries(repoScores)) {
+        if (score.stargazersCount !== undefined || score.language !== undefined) {
+            repoMetadata[repo] = { stars: score.stargazersCount, language: score.language };
+        }
+    }
     return {
         stats,
         prsByRepo,
@@ -69,6 +76,7 @@ function buildDashboardJson(digest, state, commentedIssues, allMergedPRs, allClo
         issueResponses,
         allMergedPRs: filteredMergedPRs,
         allClosedPRs: filteredClosedPRs,
+        repoMetadata,
     };
 }
 /**

package/dist/core/ci-analysis.js

@@ -15,6 +15,7 @@ const FORK_LIMITATION_PATTERNS = [
     /chromatic/i,
     /percy/i,
     /cloudflare pages/i,
+    /\binternal\b/i,
 ];
 /**
  * Known CI check name patterns that indicate authorization gates (#81).
@@ -30,6 +31,7 @@ const INFRASTRUCTURE_PATTERNS = [
     /\bsetup\s+fail(ed|ure)?\b/i,
     /\bservice\s*unavailable/i,
     /\binfrastructure/i,
+    /\bblacksmith\b/i,
 ];
 /**
  * Classify a failing CI check as actionable, fork_limitation, auth_gate, or infrastructure (#81, #145).

package/dist/core/display-utils.js

@@ -84,13 +84,33 @@ const WAIT_DISPLAY = {
             return 'CI checks are failing but no action is needed from you';
         },
     },
+    stale_ci_failure: {
+        label: '[Stale CI Failure]',
+        description: (pr) => `CI failing for ${pr.daysSinceActivity}+ days — likely pre-existing or non-actionable`,
+    },
 };
+/** Convert a bracketed display label like "[CI Failing]" to a plain lowercase string like "ci failing". */
+function labelToPlainText(reason) {
+    const label = ACTION_DISPLAY[reason]?.label;
+    if (!label)
+        return reason;
+    return label.replace(/[[\]]/g, '').toLowerCase();
+}
 /** Compute display label and description for a FetchedPR (#79). */
 export function computeDisplayLabel(pr) {
     if (pr.status === 'needs_addressing' && pr.actionReason) {
         const entry = ACTION_DISPLAY[pr.actionReason];
-        if (entry)
-            return { displayLabel: entry.label, displayDescription: entry.description(pr) };
+        if (entry) {
+            let displayDescription = entry.description(pr);
+            // Append secondary action reasons when multiple issues exist (#675)
+            if (pr.actionReasons && pr.actionReasons.length > 1) {
+                const secondary = pr.actionReasons.filter((r) => r !== pr.actionReason).map(labelToPlainText);
+                if (secondary.length > 0) {
+                    displayDescription += ` (also: ${secondary.join(', ')})`;
+                }
+            }
+            return { displayLabel: entry.label, displayDescription };
+        }
     }
     if (pr.status === 'waiting_on_maintainer' && pr.waitReason) {
         const entry = WAIT_DISPLAY[pr.waitReason];

package/dist/core/github-stats.d.ts

@@ -1,5 +1,5 @@
 /**
- * GitHub Stats - Fetching merged/closed PR counts and repository star counts.
+ * GitHub Stats - Fetching merged/closed PR counts with star-based filtering.
  * Extracted from PRMonitor to isolate statistics-gathering API calls (#263).
  */
 import { Octokit } from '@octokit/rest';

package/dist/core/github-stats.js

@@ -1,5 +1,5 @@
 /**
- * GitHub Stats - Fetching merged/closed PR counts and repository star counts.
+ * GitHub Stats - Fetching merged/closed PR counts with star-based filtering.
  * Extracted from PRMonitor to isolate statistics-gathering API calls (#263).
  */
 import { extractOwnerRepo, parseGitHubUrl, isOwnRepo } from './utils.js';

package/dist/core/pr-monitor.d.ts

@@ -9,7 +9,7 @@
  * - checklist-analysis.ts: PR body checklist analysis
  * - maintainer-analysis.ts: Maintainer action hint extraction
  * - display-utils.ts: Display label computation
- * - github-stats.ts: Merged/closed PR counts and star fetching
+ * - github-stats.ts: Merged/closed PR counts and star-based filtering
  * - status-determination.ts: PR status classification logic
  */
 import { FetchedPR, DailyDigest, ClosedPR, MergedPR, StarFilter } from './types.js';
@@ -68,10 +68,13 @@ export declare class PRMonitor {
      */
     fetchUserClosedPRCounts(starFilter?: StarFilter): Promise<PRCountsResult<number>>;
     /**
-     * Fetch GitHub star counts for a list of repositories.
-     * Delegates to github-stats module.
+     * Fetch metadata (star count and primary language) for a list of repositories.
+     * Both fields come from the same `repos.get()` call — zero additional API cost.
      */
-    fetchRepoStarCounts(repos: string[]): Promise<Map<string, number>>;
+    fetchRepoMetadata(repos: string[]): Promise<Map<string, {
+        stars: number;
+        language: string | null;
+    }>>;
     /**
      * Fetch PRs closed without merge in the last N days.
      * Delegates to github-stats module.

package/dist/core/pr-monitor.js

@@ -9,7 +9,7 @@
  * - checklist-analysis.ts: PR body checklist analysis
  * - maintainer-analysis.ts: Maintainer action hint extraction
  * - display-utils.ts: Display label computation
- * - github-stats.ts: Merged/closed PR counts and star fetching
+ * - github-stats.ts: Merged/closed PR counts and star-based filtering
  * - status-determination.ts: PR status classification logic
  */
 import { getOctokit } from './github.js';
@@ -220,7 +220,7 @@ export class PRMonitor {
         const classifiedChecks = classifyFailingChecks(failingCheckNames, failingCheckConclusions);
         // Determine status
         const hasActionableCIFailure = ciStatus === 'failing' && classifiedChecks.some((c) => c.category === 'actionable');
-        const { status, actionReason, waitReason, stalenessTier } = determineStatus({
+        const { status, actionReason, waitReason, stalenessTier, actionReasons } = determineStatus({
             ciStatus,
             hasMergeConflict,
             hasUnrespondedComment,
@@ -246,6 +246,7 @@ export class PRMonitor {
             actionReason,
             waitReason,
             stalenessTier,
+            actionReasons,
             createdAt: ghPR.created_at,
             updatedAt: ghPR.updated_at,
             daysSinceActivity,
@@ -367,13 +368,13 @@ export class PRMonitor {
         return fetchUserClosedPRCountsImpl(this.octokit, config.githubUsername, starFilter);
     }
     /**
-     * Fetch GitHub star counts for a list of repositories.
-     * Delegates to github-stats module.
+     * Fetch metadata (star count and primary language) for a list of repositories.
+     * Both fields come from the same `repos.get()` call — zero additional API cost.
      */
-    async fetchRepoStarCounts(repos) {
+    async fetchRepoMetadata(repos) {
         if (repos.length === 0)
             return new Map();
-        debug(MODULE, `Fetching star counts for ${repos.length} repos...`);
+        debug(MODULE, `Fetching repo metadata for ${repos.length} repos...`);
         const results = new Map();
         const cache = getHttpCache();
         // Deduplicate repos to avoid fetching the same repo twice
@@ -394,17 +395,18 @@ export class PRMonitor {
                     repo: name,
                     headers,
                 }));
-                return { repo, stars: data.stargazers_count };
+                const metadata = { stars: data.stargazers_count, language: data.language ?? null };
+                return { repo, metadata };
             }));
             let chunkFailures = 0;
             for (let j = 0; j < settled.length; j++) {
                 const result = settled[j];
                 if (result.status === 'fulfilled') {
-                    results.set(result.value.repo, result.value.stars);
+                    results.set(result.value.repo, result.value.metadata);
                 }
                 else {
                     chunkFailures++;
-                    warn(MODULE, `Failed to fetch stars for ${chunk[j]}: ${errorMessage(result.reason)}`);
+                    warn(MODULE, `Failed to fetch metadata for ${chunk[j]}: ${errorMessage(result.reason)}`);
                 }
             }
             // If entire chunk failed, likely a systemic issue (rate limit, auth, outage) — abort remaining
@@ -416,7 +418,7 @@ export class PRMonitor {
                 break;
             }
         }
-        debug(MODULE, `Fetched star counts for ${results.size}/${repos.length} repos`);
+        debug(MODULE, `Fetched repo metadata for ${results.size}/${repos.length} repos`);
         return results;
     }
     /**

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

package/dist/core/status-determination.js

@@ -5,6 +5,8 @@
  * granular action/wait reasons, and staleness tier for a single PR based on
  * its CI, review, merge-conflict, and timeline signals.
  */
+/** Days of inactivity after which an actionable CI failure is demoted to stale_ci_failure (#675). */
+export 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.
@@ -43,35 +45,89 @@ export function isCommitAfterComment(commitDate, commentDate) {
     }
     return commitMs - commentMs >= MIN_RESPONSE_GAP_MS;
 }
+/**
+ * Resolve the latest commit date, filtering out non-contributor commits (#547, #568).
+ * Returns undefined when the commit was by a non-contributor or when no date is available.
+ */
+function resolveContributorCommitDate(input) {
+    const { latestCommitDate, latestCommitAuthor, contributorUsername } = input;
+    if (!latestCommitDate)
+        return undefined;
+    return isContributorCommit(latestCommitAuthor, contributorUsername) ? latestCommitDate : undefined;
+}
+/** Check whether an unresponded comment has been addressed by a subsequent contributor commit. */
+function isCommentAddressedByCommit(commitDate, commentDate, changesRequestedDate) {
+    if (!commitDate || !commentDate)
+        return false;
+    if (!isCommitAfterComment(commitDate, commentDate))
+        return false;
+    // Safety net (#431): if a CHANGES_REQUESTED review came after the commit, it's not addressed
+    if (changesRequestedDate && commitDate < changesRequestedDate)
+        return false;
+    return true;
+}
+/** Check whether a changes_requested review has been addressed by a subsequent contributor commit. */
+function isChangesAddressedByCommit(commitDate, changesRequestedDate) {
+    if (!commitDate || !changesRequestedDate)
+        return false;
+    return commitDate >= changesRequestedDate;
+}
+/**
+ * Collect all applicable action reasons independently, without short-circuiting (#675).
+ * Used alongside the priority-based decision tree to surface secondary issues.
+ */
+function collectAllActionReasons(input) {
+    const { ciStatus, hasMergeConflict, hasUnrespondedComment, hasIncompleteChecklist, reviewDecision, lastMaintainerCommentDate, latestChangesRequestedDate, hasActionableCIFailure = true, } = input;
+    const commitDate = resolveContributorCommitDate(input);
+    const reasons = [];
+    if (hasUnrespondedComment &&
+        !isCommentAddressedByCommit(commitDate, lastMaintainerCommentDate, latestChangesRequestedDate)) {
+        reasons.push('needs_response');
+    }
+    if (reviewDecision === 'changes_requested' &&
+        latestChangesRequestedDate &&
+        !isChangesAddressedByCommit(commitDate, latestChangesRequestedDate)) {
+        reasons.push('needs_changes');
+    }
+    if (ciStatus === 'failing' && hasActionableCIFailure) {
+        reasons.push('failing_ci');
+    }
+    if (hasMergeConflict) {
+        reasons.push('merge_conflict');
+    }
+    if (hasIncompleteChecklist) {
+        reasons.push('incomplete_checklist');
+    }
+    return reasons.length > 0 ? reasons : undefined;
+}
 /**
  * Determine the overall status of a PR based on its signals.
  */
 export function determineStatus(input) {
-    const { ciStatus, hasMergeConflict, hasUnrespondedComment, hasIncompleteChecklist, reviewDecision, daysSinceActivity, dormantThreshold, approachingThreshold, latestCommitDate: rawCommitDate, latestCommitAuthor, contributorUsername, lastMaintainerCommentDate, latestChangesRequestedDate, hasActionableCIFailure = true, } = input;
+    const primary = determinePrimaryStatus(input);
+    const actionReasons = collectAllActionReasons(input);
+    if (actionReasons) {
+        return { ...primary, actionReasons };
+    }
+    return primary;
+}
+/**
+ * Priority-based decision tree for the primary status classification.
+ * Returns the single highest-priority status; `determineStatus` augments
+ * this with the full `actionReasons` array.
+ */
+function determinePrimaryStatus(input) {
+    const { ciStatus, hasMergeConflict, hasUnrespondedComment, hasIncompleteChecklist, reviewDecision, daysSinceActivity, dormantThreshold, approachingThreshold, lastMaintainerCommentDate, latestChangesRequestedDate, hasActionableCIFailure = true, } = input;
     // Compute staleness tier (independent of status)
     let stalenessTier = 'active';
     if (daysSinceActivity >= dormantThreshold)
         stalenessTier = 'dormant';
     else if (daysSinceActivity >= approachingThreshold)
         stalenessTier = 'approaching_dormant';
-    // Only count the latest commit if it was authored by the contributor or a
-    // CI bot (#547, #568). Non-contributor commits (maintainer merge commits,
-    // GitHub suggestion commits) should not mask unaddressed feedback.
-    const latestCommitDate = rawCommitDate && isContributorCommit(latestCommitAuthor, contributorUsername) ? rawCommitDate : undefined;
+    const commitDate = resolveContributorCommitDate(input);
     // Priority order: needs_addressing (response/changes/ci/conflict/checklist) > waiting_on_maintainer (review/merge/addressed/ci_blocked)
     if (hasUnrespondedComment) {
-        // If the contributor pushed a commit after the maintainer's comment,
-        // the changes have been addressed — waiting for maintainer re-review.
-        // Require a minimum 2-minute gap to avoid false positives from race
-        // conditions (pushing while review is being submitted) (#547).
-        if (latestCommitDate &&
-            lastMaintainerCommentDate &&
-            isCommitAfterComment(latestCommitDate, lastMaintainerCommentDate)) {
-            // Safety net (#431): if a CHANGES_REQUESTED review was submitted after
-            // the commit, the maintainer still expects changes — don't mask it
-            if (latestChangesRequestedDate && latestCommitDate < latestChangesRequestedDate) {
-                return { status: 'needs_addressing', actionReason: 'needs_response', stalenessTier };
-            }
+        if (isCommentAddressedByCommit(commitDate, lastMaintainerCommentDate, latestChangesRequestedDate)) {
             if (ciStatus === 'failing' && hasActionableCIFailure)
                 return { status: 'needs_addressing', actionReason: 'failing_ci', stalenessTier };
             // Non-actionable CI failures (infrastructure, fork, auth) don't block changes_addressed —
@@ -81,9 +137,8 @@ export function determineStatus(input) {
         return { status: 'needs_addressing', actionReason: 'needs_response', stalenessTier };
     }
     // Review requested changes but no unresponded comment.
-    // If the latest commit is before the review, the contributor hasn't addressed it yet.
     if (reviewDecision === 'changes_requested' && latestChangesRequestedDate) {
-        if (!latestCommitDate || latestCommitDate < latestChangesRequestedDate) {
+        if (!isChangesAddressedByCommit(commitDate, latestChangesRequestedDate)) {
             return { status: 'needs_addressing', actionReason: 'needs_changes', stalenessTier };
         }
         // Commit is after review — changes have been addressed
@@ -93,9 +148,14 @@ export function determineStatus(input) {
         return { status: 'waiting_on_maintainer', waitReason: 'changes_addressed', stalenessTier };
     }
     if (ciStatus === 'failing') {
-        return hasActionableCIFailure
-            ? { status: 'needs_addressing', actionReason: 'failing_ci', stalenessTier }
-            : { status: 'waiting_on_maintainer', waitReason: 'ci_blocked', stalenessTier };
+        if (hasActionableCIFailure) {
+            // Demote stale CI failures: if failing for 5+ days with no activity, likely pre-existing (#675)
+            if (daysSinceActivity >= STALE_CI_DEMOTION_DAYS) {
+                return { status: 'waiting_on_maintainer', waitReason: 'stale_ci_failure', stalenessTier };
+            }
+            return { status: 'needs_addressing', actionReason: 'failing_ci', stalenessTier };
+        }
+        return { status: 'waiting_on_maintainer', waitReason: 'ci_blocked', stalenessTier };
     }
     if (hasMergeConflict) {
         return { status: 'needs_addressing', actionReason: 'merge_conflict', stalenessTier };

package/dist/core/types.d.ts

@@ -67,6 +67,8 @@ export interface DetermineStatusResult {
     actionReason?: ActionReason;
     waitReason?: WaitReason;
     stalenessTier: StalenessTier;
+    /** All applicable action reasons, ordered by priority. */
+    actionReasons?: ActionReason[];
 }
 /**
  * Granular reason why a PR needs addressing (contributor's turn).
@@ -77,7 +79,7 @@ export interface DetermineStatusResult {
  */
 export type ActionReason = 'needs_response' | 'needs_changes' | 'failing_ci' | 'merge_conflict' | 'incomplete_checklist' | 'ci_not_running' | 'needs_rebase' | 'missing_required_files';
 /** Granular reason why a PR is waiting on the maintainer. */
-export type WaitReason = 'pending_review' | 'pending_merge' | 'changes_addressed' | 'ci_blocked';
+export type WaitReason = 'pending_review' | 'pending_merge' | 'changes_addressed' | 'ci_blocked' | 'stale_ci_failure';
 /** How stale is the PR based on days since activity. Orthogonal to status. */
 export type StalenessTier = 'active' | 'approaching_dormant' | 'dormant';
 /**
@@ -110,6 +112,8 @@ export interface FetchedPR {
     actionReason?: ActionReason;
     /** Granular reason for waiting_on_maintainer status. Undefined when needs_addressing. */
     waitReason?: WaitReason;
+    /** All applicable action reasons, ordered by priority. Primary reason is first. */
+    actionReasons?: ActionReason[];
     /** How stale the PR is based on activity age. Independent of status — a PR can be both needs_addressing and dormant. */
     stalenessTier: StalenessTier;
     /** Human-readable status label for consistent display (#79). E.g., "[CI Failing]", "[Needs Response]". */
@@ -264,6 +268,8 @@ export interface RepoScore {
     signals: RepoSignals;
     /** GitHub star count, fetched during daily check for dashboard filtering. */
     stargazersCount?: number;
+    /** Primary programming language of the repo, fetched during daily check. */
+    language?: string | null;
 }
 /** Full set of qualitative signals about a repo's maintainer culture. */
 export interface RepoSignals {
@@ -285,6 +291,14 @@ export interface RepoScoreUpdate {
     lastMergedAt?: string;
     signals?: Partial<RepoSignals>;
     stargazersCount?: number;
+    /** Primary programming language of the repo. */
+    language?: string | null;
+}
+/** Repo metadata entry used in dashboard API responses. Shared between server and SPA. */
+export interface RepoMetadataEntry {
+    /** Star count, derived from RepoScore.stargazersCount. */
+    stars?: number;
+    language?: string | null;
 }
 /**
  * Event types recorded in the {@link AgentState} audit log.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oss-autopilot/core",
-  "version": "0.53.1",
+  "version": "0.54.0",
   "description": "CLI and core library for managing open source contributions",
   "type": "module",
   "bin": {