@oss-autopilot/core 0.44.3 → 0.44.15

package/dist/core/display-utils.js

@@ -1,14 +1,13 @@
 /**
  * Display Utils - Human-readable display label computation for PR statuses.
  * Extracted from PRMonitor to isolate presentation logic (#263).
+ *
+ * Uses two reason-keyed maps (ACTION_DISPLAY / WAIT_DISPLAY) instead of a
+ * single status-keyed map, reflecting the 2-status taxonomy where the
+ * granular reason lives in `actionReason` / `waitReason`.
  */
 import { warn } from './logger.js';
-const MODULE = 'display-utils';
-/**
- * Deterministic mapping from FetchedPRStatus -> human-readable display label (#79).
- * Ensures consistent label text across sessions — agents no longer derive these.
- */
-const STATUS_DISPLAY = {
+const ACTION_DISPLAY = {
     needs_response: {
         label: '[Needs Response]',
         description: (pr) => pr.lastMaintainerComment ? `@${pr.lastMaintainerComment.author} commented` : 'Maintainer awaiting response',
@@ -33,25 +32,20 @@ const STATUS_DISPLAY = {
             return 'One or more CI checks are failing';
         },
     },
-    ci_blocked: {
-        label: '[CI Blocked]',
-        description: (pr) => {
-            const checks = pr.classifiedChecks || [];
-            if (checks.length > 0 && checks.every((c) => c.category !== 'actionable')) {
-                const categories = [...new Set(checks.map((c) => c.category))];
-                return `All failing checks are non-actionable (${categories.join(', ')})`;
-            }
-            return 'CI checks are failing but no action is needed from you';
-        },
+    merge_conflict: {
+        label: '[Merge Conflict]',
+        description: () => 'PR has merge conflicts with the base branch',
+    },
+    incomplete_checklist: {
+        label: '[Incomplete Checklist]',
+        description: (pr) => pr.checklistStats
+            ? `${pr.checklistStats.checked}/${pr.checklistStats.total} items checked`
+            : 'PR body has unchecked required checkboxes',
     },
     ci_not_running: {
         label: '[CI Not Running]',
         description: () => 'No CI checks have been triggered',
     },
-    merge_conflict: {
-        label: '[Merge Conflict]',
-        description: () => 'PR has merge conflicts with the base branch',
-    },
     needs_rebase: {
         label: '[Needs Rebase]',
         description: () => 'PR branch is significantly behind upstream',
@@ -60,48 +54,53 @@ const STATUS_DISPLAY = {
         label: '[Missing Files]',
         description: (pr) => pr.missingRequiredFiles ? `Missing: ${pr.missingRequiredFiles.join(', ')}` : 'Required files are missing',
     },
-    incomplete_checklist: {
-        label: '[Incomplete Checklist]',
-        description: (pr) => pr.checklistStats
-            ? `${pr.checklistStats.checked}/${pr.checklistStats.total} items checked`
-            : 'PR body has unchecked required checkboxes',
-    },
-    changes_addressed: {
-        label: '[Changes Addressed]',
-        description: (pr) => pr.lastMaintainerComment
-            ? `Waiting for @${pr.lastMaintainerComment.author} to re-review`
-            : 'Waiting for maintainer re-review',
-    },
-    waiting: {
-        label: '[Waiting]',
-        description: () => 'CI pending or awaiting review',
+};
+const WAIT_DISPLAY = {
+    pending_review: {
+        label: '[Waiting on Maintainer]',
+        description: () => 'Awaiting review',
     },
-    waiting_on_maintainer: {
+    pending_merge: {
         label: '[Waiting on Maintainer]',
         description: () => 'Approved and CI passes — waiting for merge',
     },
-    healthy: {
-        label: '[Healthy]',
-        description: () => 'Everything looks good — normal review cycle',
-    },
-    approaching_dormant: {
-        label: '[Approaching Dormant]',
-        description: (pr) => `No activity for ${pr.daysSinceActivity} days`,
+    changes_addressed: {
+        label: '[Waiting on Maintainer]',
+        description: (pr) => {
+            if (pr.hasUnrespondedComment && pr.lastMaintainerComment) {
+                return `Changes addressed — waiting for @${pr.lastMaintainerComment.author} to re-review`;
+            }
+            return 'Changes addressed — awaiting re-review';
+        },
     },
-    dormant: {
-        label: '[Dormant]',
-        description: (pr) => `No activity for ${pr.daysSinceActivity} days`,
+    ci_blocked: {
+        label: '[CI Blocked]',
+        description: (pr) => {
+            const checks = pr.classifiedChecks || [];
+            if (checks.length > 0 && checks.every((c) => c.category !== 'actionable')) {
+                const categories = [...new Set(checks.map((c) => c.category))];
+                return `All failing checks are non-actionable (${categories.join(', ')})`;
+            }
+            return 'CI checks are failing but no action is needed from you';
+        },
     },
 };
 /** Compute display label and description for a FetchedPR (#79). */
 export function computeDisplayLabel(pr) {
-    const entry = STATUS_DISPLAY[pr.status];
-    if (!entry) {
-        warn(MODULE, `Unknown status "${pr.status}" for PR #${pr.number} (${pr.url})`);
-        return { displayLabel: `[${pr.status}]`, displayDescription: 'Unknown status' };
+    if (pr.status === 'needs_addressing' && pr.actionReason) {
+        const entry = ACTION_DISPLAY[pr.actionReason];
+        if (entry)
+            return { displayLabel: entry.label, displayDescription: entry.description(pr) };
+    }
+    if (pr.status === 'waiting_on_maintainer' && pr.waitReason) {
+        const entry = WAIT_DISPLAY[pr.waitReason];
+        if (entry)
+            return { displayLabel: entry.label, displayDescription: entry.description(pr) };
+    }
+    // Fallback for missing reason — log so we can identify data issues
+    warn('display-utils', `PR ${pr.url} has status "${pr.status}" but no matching reason (actionReason=${pr.actionReason}, waitReason=${pr.waitReason})`);
+    if (pr.status === 'needs_addressing') {
+        return { displayLabel: '[Needs Addressing]', displayDescription: 'Action required' };
     }
-    return {
-        displayLabel: entry.label,
-        displayDescription: entry.description(pr),
-    };
+    return { displayLabel: '[Waiting on Maintainer]', displayDescription: 'Awaiting maintainer action' };
 }

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

@@ -3,7 +3,7 @@
  * Extracted from PRMonitor to isolate statistics-gathering API calls (#263).
  */
 import { Octokit } from '@octokit/rest';
-import { ClosedPR, MergedPR } from './types.js';
+import { ClosedPR, MergedPR, type StarFilter } from './types.js';
 /** TTL for cached PR count results (24 hours — these stats change slowly). */
 export declare const PR_COUNTS_CACHE_TTL_MS: number;
 /** Return type shared by both merged and closed PR count functions. */
@@ -19,7 +19,7 @@ export declare function emptyPRCountsResult<R>(): PRCountsResult<R>;
  * Fetch merged PR counts and latest merge dates per repository for the configured user.
  * Also builds a monthly histogram of all merges for the contribution timeline.
  */
-export declare function fetchUserMergedPRCounts(octokit: Octokit, githubUsername: string): Promise<PRCountsResult<{
+export declare function fetchUserMergedPRCounts(octokit: Octokit, githubUsername: string, starFilter?: StarFilter): Promise<PRCountsResult<{
     count: number;
     lastMergedAt: string;
 }>>;
@@ -27,7 +27,7 @@ export declare function fetchUserMergedPRCounts(octokit: Octokit, githubUsername
  * Fetch closed-without-merge PR counts per repository for the configured user.
  * Used to populate closedWithoutMergeCount in repo scores for accurate merge rate.
  */
-export declare function fetchUserClosedPRCounts(octokit: Octokit, githubUsername: string): Promise<PRCountsResult<number>>;
+export declare function fetchUserClosedPRCounts(octokit: Octokit, githubUsername: string, starFilter?: StarFilter): Promise<PRCountsResult<number>>;
 /**
  * Fetch PRs closed without merge in the last N days.
  * Returns lightweight ClosedPR objects for surfacing in the daily digest.

package/dist/core/github-stats.js

@@ -3,6 +3,7 @@
  * Extracted from PRMonitor to isolate statistics-gathering API calls (#263).
  */
 import { extractOwnerRepo, parseGitHubUrl, isOwnRepo } from './utils.js';
+import { isBelowMinStars } from './types.js';
 import { debug, warn } from './logger.js';
 import { getHttpCache } from './http-cache.js';
 const MODULE = 'github-stats';
@@ -39,13 +40,14 @@ function isCachedPRCounts(v) {
  * string (e.g. mergedAt or closedAt) used for monthly counts and daily activity.
  * Return an empty string to skip histogram tracking for that item.
  */
-async function fetchUserPRCounts(octokit, githubUsername, query, label, accumulateRepo) {
+async function fetchUserPRCounts(octokit, githubUsername, query, label, accumulateRepo, starFilter) {
     if (!githubUsername) {
         return emptyPRCountsResult();
     }
     // Check for a fresh cached result (avoids 10-20 paginated API calls)
     const cache = getHttpCache();
-    const cacheKey = `pr-counts:${label}:${githubUsername}`;
+    const minStarsSuffix = starFilter ? `:stars${starFilter.minStars}` : '';
+    const cacheKey = `pr-counts:v3:${label}:${githubUsername}${minStarsSuffix}`;
     const cached = cache.getIfFresh(cacheKey, PR_COUNTS_CACHE_TTL_MS);
     if (cached && isCachedPRCounts(cached)) {
         debug(MODULE, `Using cached ${label} PR counts for @${githubUsername}`);
@@ -66,7 +68,7 @@ async function fetchUserPRCounts(octokit, githubUsername, query, label, accumula
     let totalCount;
     while (true) {
         const { data } = await octokit.search.issuesAndPullRequests({
-            q: `is:pr ${query} author:${githubUsername}`,
+            q: `is:pr ${query} author:${githubUsername} -user:${githubUsername}`,
             sort: 'updated',
             order: 'desc',
             per_page: 100,
@@ -86,6 +88,12 @@ async function fetchUserPRCounts(octokit, githubUsername, query, label, accumula
                 continue;
             // Note: excludeRepos/excludeOrgs are intentionally NOT filtered here.
             // Those filters control issue discovery/search, not historical statistics.
+            // Skip repos below the minimum star threshold (#576).
+            // Repos with unknown star counts (not yet fetched) are included — they'll be
+            // filtered on the next run once star data is cached in repoScores.
+            if (starFilter && isBelowMinStars(starFilter.knownStarCounts.get(repo), starFilter.minStars)) {
+                continue;
+            }
             // Per-repo accumulation + get primary date for histograms
             const primaryDate = accumulateRepo(repos, repo, item);
             // Monthly histogram for primary date (merged/closed)
@@ -135,7 +143,7 @@ async function fetchUserPRCounts(octokit, githubUsername, query, label, accumula
  * Fetch merged PR counts and latest merge dates per repository for the configured user.
  * Also builds a monthly histogram of all merges for the contribution timeline.
  */
-export function fetchUserMergedPRCounts(octokit, githubUsername) {
+export function fetchUserMergedPRCounts(octokit, githubUsername, starFilter) {
     return fetchUserPRCounts(octokit, githubUsername, 'is:merged', 'merged', (repos, repo, item) => {
         if (!item.pull_request?.merged_at) {
             warn(MODULE, `merged_at missing for merged PR ${item.html_url}${item.closed_at ? ', falling back to closed_at' : ', no date available'}`);
@@ -152,17 +160,17 @@ export function fetchUserMergedPRCounts(octokit, githubUsername) {
             repos.set(repo, { count: 1, lastMergedAt: mergedAt });
         }
         return mergedAt;
-    });
+    }, starFilter);
 }
 /**
  * Fetch closed-without-merge PR counts per repository for the configured user.
  * Used to populate closedWithoutMergeCount in repo scores for accurate merge rate.
  */
-export function fetchUserClosedPRCounts(octokit, githubUsername) {
+export function fetchUserClosedPRCounts(octokit, githubUsername, starFilter) {
     return fetchUserPRCounts(octokit, githubUsername, 'is:closed is:unmerged', 'closed', (repos, repo, item) => {
         repos.set(repo, (repos.get(repo) || 0) + 1);
         return item.closed_at || '';
-    });
+    }, starFilter);
 }
 /**
  * Shared helper: search for recent PRs and filter out own repos, excluded repos/orgs.

package/dist/core/issue-vetting.js

@@ -509,7 +509,7 @@ export class IssueVetter {
         if (!body || body.length < 50)
             return false;
         // Check for clear structure
-        const hasSteps = /\d+\.|[-*]\s/.test(body);
+        const hasSteps = /\d\.|[-*]\s/.test(body);
         const hasCodeBlock = /```/.test(body);
         const hasExpectedBehavior = /expect|should|must|want/i.test(body);
         // Must have at least two indicators of clarity

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

@@ -11,7 +11,7 @@
  * - display-utils.ts: Display label computation
  * - github-stats.ts: Merged/closed PR counts and star fetching
  */
-import { FetchedPR, DailyDigest, ClosedPR, MergedPR } from './types.js';
+import { FetchedPR, DailyDigest, ClosedPR, MergedPR, StarFilter } from './types.js';
 import { type PRCountsResult } from './github-stats.js';
 export { computeDisplayLabel } from './display-utils.js';
 export { classifyCICheck, classifyFailingChecks } from './ci-analysis.js';
@@ -46,6 +46,29 @@ export declare class PRMonitor {
      * Determine the overall status of a PR
      */
     private determineStatus;
+    /**
+     * 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.
+     * This is intentionally an allowlist — not all `[bot]` accounts are CI-fix bots
+     * (e.g. dependabot[bot] and renovate[bot] open their own PRs).
+     * Values must be lowercase — lookup uses .toLowerCase() for case-insensitive matching.
+     */
+    private static readonly CI_FIX_BOTS;
+    /**
+     * Check whether the HEAD commit was authored by the contributor (#547).
+     * Returns true when the author matches, when the author is a known CI-fix
+     * bot (#568), or when author info is unavailable (graceful degradation).
+     */
+    private isContributorCommit;
+    /** Minimum gap (ms) between maintainer comment and contributor commit for
+     *  the commit to count as "addressing" the feedback (#547). Prevents false
+     *  positives from race conditions, clock skew, and in-flight pushes. */
+    private static readonly MIN_RESPONSE_GAP_MS;
+    /**
+     * Check whether the contributor's commit is meaningfully after the maintainer's
+     * comment — i.e. the commit timestamp is at least MIN_RESPONSE_GAP_MS later (#547).
+     */
+    private isCommitAfterComment;
     /**
      * Check if PR has merge conflict
      */
@@ -60,7 +83,7 @@ export declare class PRMonitor {
      * Fetch merged PR counts and latest merge dates per repository for the configured user.
      * Delegates to github-stats module.
      */
-    fetchUserMergedPRCounts(): Promise<PRCountsResult<{
+    fetchUserMergedPRCounts(starFilter?: StarFilter): Promise<PRCountsResult<{
         count: number;
         lastMergedAt: string;
     }>>;
@@ -68,7 +91,7 @@ export declare class PRMonitor {
      * Fetch closed-without-merge PR counts per repository for the configured user.
      * Delegates to github-stats module.
      */
-    fetchUserClosedPRCounts(): Promise<PRCountsResult<number>>;
+    fetchUserClosedPRCounts(starFilter?: StarFilter): Promise<PRCountsResult<number>>;
     /**
      * Fetch GitHub star counts for a list of repositories.
      * Delegates to github-stats module.

package/dist/core/pr-monitor.js

@@ -119,27 +119,11 @@ export class PRMonitor {
                 }
             }, MAX_CONCURRENT_REQUESTS);
         });
-        // Sort by days since activity (most urgent first)
+        // Sort by status (needs_addressing first, then waiting_on_maintainer)
         prs.sort((a, b) => {
-            // Priority: needs_response > failing_ci > merge_conflict > approaching_dormant > dormant > waiting > healthy
-            const statusPriority = {
-                needs_response: 0,
-                needs_changes: 1,
-                failing_ci: 2,
-                ci_blocked: 3,
-                ci_not_running: 4,
-                merge_conflict: 5,
-                needs_rebase: 6,
-                missing_required_files: 7,
-                incomplete_checklist: 8,
-                changes_addressed: 9,
-                approaching_dormant: 10,
-                dormant: 11,
-                waiting: 12,
-                waiting_on_maintainer: 13,
-                healthy: 14,
-            };
-            return statusPriority[a.status] - statusPriority[b.status];
+            if (a.status === b.status)
+                return 0;
+            return a.status === 'needs_addressing' ? -1 : 1;
         });
         return { prs, failures };
     }
@@ -195,14 +179,18 @@ export class PRMonitor {
         const { hasUnrespondedComment, lastMaintainerComment } = checkUnrespondedComments(comments, reviews, reviewComments, config.githubUsername);
         // Fetch CI status and (conditionally) latest commit date in parallel
         // We need the commit date when hasUnrespondedComment is true (to distinguish
-        // "needs_response" from "changes_addressed") OR when reviewDecision is "changes_requested"
+        // "needs_response" from "waiting_on_maintainer") OR when reviewDecision is "changes_requested"
         // (to detect needs_changes: review requested changes but no new commits pushed)
         const ciPromise = this.getCIStatus(owner, repo, ghPR.head.sha);
         const needCommitDate = hasUnrespondedComment || reviewDecision === 'changes_requested';
-        const commitDatePromise = needCommitDate
+        const commitInfoPromise = needCommitDate
             ? this.octokit.repos
                 .getCommit({ owner, repo, ref: ghPR.head.sha })
-                .then((res) => res.data.commit.author?.date)
+                .then((res) => ({
+                date: res.data.commit.author?.date,
+                // GitHub user login of the commit author (may differ from git author)
+                author: res.data.author?.login,
+            }))
                 .catch((err) => {
                 // Rate limit errors must propagate — silently swallowing them produces
                 // misleading status (e.g. needs_changes when changes were addressed) (#469).
@@ -221,10 +209,12 @@ export class PRMonitor {
                 return undefined;
             })
             : Promise.resolve(undefined);
-        const [{ status: ciStatus, failingCheckNames, failingCheckConclusions }, latestCommitDate] = await Promise.all([
+        const [{ status: ciStatus, failingCheckNames, failingCheckConclusions }, commitInfo] = await Promise.all([
             ciPromise,
-            commitDatePromise,
+            commitInfoPromise,
         ]);
+        const latestCommitDate = commitInfo?.date;
+        const latestCommitAuthor = commitInfo?.author;
         // Analyze PR body for incomplete checklists (delegated to checklist-analysis module)
         const { hasIncompleteChecklist, checklistStats } = analyzeChecklist(ghPR.body || '');
         // Extract maintainer action hints from comments (delegated to maintainer-analysis module)
@@ -237,7 +227,7 @@ export class PRMonitor {
         const classifiedChecks = classifyFailingChecks(failingCheckNames, failingCheckConclusions);
         // Determine status
         const hasActionableCIFailure = ciStatus === 'failing' && classifiedChecks.some((c) => c.category === 'actionable');
-        const status = this.determineStatus({
+        const { status, actionReason, waitReason, stalenessTier } = this.determineStatus({
             ciStatus,
             hasMergeConflict,
             hasUnrespondedComment,
@@ -247,6 +237,8 @@ export class PRMonitor {
             dormantThreshold: config.dormantThresholdDays,
             approachingThreshold: config.approachingDormantDays,
             latestCommitDate,
+            latestCommitAuthor,
+            contributorUsername: config.githubUsername,
             lastMaintainerCommentDate: lastMaintainerComment?.createdAt,
             latestChangesRequestedDate,
             hasActionableCIFailure,
@@ -258,6 +250,9 @@ export class PRMonitor {
             number,
             title: ghPR.title,
             status,
+            actionReason,
+            waitReason,
+            stalenessTier,
             createdAt: ghPR.created_at,
             updatedAt: ghPR.updated_at,
             daysSinceActivity,
@@ -294,61 +289,110 @@ export class PRMonitor {
      * Determine the overall status of a PR
      */
     determineStatus(input) {
-        const { ciStatus, hasMergeConflict, hasUnrespondedComment, hasIncompleteChecklist, reviewDecision, daysSinceActivity, dormantThreshold, approachingThreshold, latestCommitDate, lastMaintainerCommentDate, latestChangesRequestedDate, hasActionableCIFailure = true, } = input;
-        // Priority order: needs_response/needs_changes/changes_addressed > failing_ci > merge_conflict > incomplete_checklist > dormant > approaching_dormant > waiting_on_maintainer > waiting/healthy
+        const { ciStatus, hasMergeConflict, hasUnrespondedComment, hasIncompleteChecklist, reviewDecision, daysSinceActivity, dormantThreshold, approachingThreshold, latestCommitDate: rawCommitDate, latestCommitAuthor, contributorUsername, 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 && this.isContributorCommit(latestCommitAuthor, contributorUsername) ? rawCommitDate : undefined;
+        // 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
-            if (latestCommitDate && lastMaintainerCommentDate && latestCommitDate > lastMaintainerCommentDate) {
+            // 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 &&
+                this.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 'needs_response';
+                    return { status: 'needs_addressing', actionReason: 'needs_response', stalenessTier };
                 }
                 if (ciStatus === 'failing' && hasActionableCIFailure)
-                    return 'failing_ci';
+                    return { status: 'needs_addressing', actionReason: 'failing_ci', stalenessTier };
                 // Non-actionable CI failures (infrastructure, fork, auth) don't block changes_addressed —
                 // the contributor can't fix them, so the relevant status is "waiting for re-review" (#502)
-                return 'changes_addressed';
+                return { status: 'waiting_on_maintainer', waitReason: 'changes_addressed', stalenessTier };
             }
-            return 'needs_response';
+            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) {
-                return 'needs_changes';
+                return { status: 'needs_addressing', actionReason: 'needs_changes', stalenessTier };
             }
             // Commit is after review — changes have been addressed
             if (ciStatus === 'failing' && hasActionableCIFailure)
-                return 'failing_ci';
+                return { status: 'needs_addressing', actionReason: 'failing_ci', stalenessTier };
             // Non-actionable CI failures don't block changes_addressed (#502)
-            return 'changes_addressed';
+            return { status: 'waiting_on_maintainer', waitReason: 'changes_addressed', stalenessTier };
         }
         if (ciStatus === 'failing') {
-            return hasActionableCIFailure ? 'failing_ci' : 'ci_blocked';
+            return hasActionableCIFailure
+                ? { status: 'needs_addressing', actionReason: 'failing_ci', stalenessTier }
+                : { status: 'waiting_on_maintainer', waitReason: 'ci_blocked', stalenessTier };
         }
         if (hasMergeConflict) {
-            return 'merge_conflict';
+            return { status: 'needs_addressing', actionReason: 'merge_conflict', stalenessTier };
         }
         if (hasIncompleteChecklist) {
-            return 'incomplete_checklist';
-        }
-        if (daysSinceActivity >= dormantThreshold) {
-            return 'dormant';
-        }
-        if (daysSinceActivity >= approachingThreshold) {
-            return 'approaching_dormant';
+            return { status: 'needs_addressing', actionReason: 'incomplete_checklist', stalenessTier };
         }
         // Approved and CI passing/unknown = waiting on maintainer to merge
         if (reviewDecision === 'approved' && (ciStatus === 'passing' || ciStatus === 'unknown')) {
-            return 'waiting_on_maintainer';
+            return { status: 'waiting_on_maintainer', waitReason: 'pending_merge', stalenessTier };
         }
-        // CI pending means we're waiting
-        if (ciStatus === 'pending') {
-            return 'waiting';
+        // Default: no actionable issues found. Covers pending CI, no reviews yet, etc.
+        return { status: 'waiting_on_maintainer', waitReason: 'pending_review', stalenessTier };
+    }
+    /**
+     * 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.
+     * This is intentionally an allowlist — not all `[bot]` accounts are CI-fix bots
+     * (e.g. dependabot[bot] and renovate[bot] open their own PRs).
+     * Values must be lowercase — lookup uses .toLowerCase() for case-insensitive matching.
+     */
+    static CI_FIX_BOTS = new Set([
+        'autofix-ci[bot]',
+        'prettier-ci[bot]',
+        'pre-commit-ci[bot]',
+    ]);
+    /**
+     * Check whether the HEAD commit was authored by the contributor (#547).
+     * Returns true when the author matches, when the author is a known CI-fix
+     * bot (#568), or when author info is unavailable (graceful degradation).
+     */
+    isContributorCommit(commitAuthor, contributorUsername) {
+        if (!commitAuthor || !contributorUsername)
+            return true; // degrade gracefully
+        const author = commitAuthor.toLowerCase();
+        if (PRMonitor.CI_FIX_BOTS.has(author))
+            return true; // CI-fix bots act on behalf of the contributor (#568)
+        return author === contributorUsername.toLowerCase();
+    }
+    /** Minimum gap (ms) between maintainer comment and contributor commit for
+     *  the commit to count as "addressing" the feedback (#547). Prevents false
+     *  positives from race conditions, clock skew, and in-flight pushes. */
+    static MIN_RESPONSE_GAP_MS = 2 * 60 * 1000; // 2 minutes
+    /**
+     * Check whether the contributor's commit is meaningfully after the maintainer's
+     * comment — i.e. the commit timestamp is at least MIN_RESPONSE_GAP_MS later (#547).
+     */
+    isCommitAfterComment(commitDate, commentDate) {
+        const commitMs = new Date(commitDate).getTime();
+        const commentMs = new Date(commentDate).getTime();
+        if (Number.isNaN(commitMs) || Number.isNaN(commentMs)) {
+            // Fall back to simple string comparison (pre-#547 behavior)
+            return commitDate > commentDate;
         }
-        return 'healthy';
+        return commitMs - commentMs >= PRMonitor.MIN_RESPONSE_GAP_MS;
     }
     /**
      * Check if PR has merge conflict
@@ -426,17 +470,17 @@ export class PRMonitor {
      * Fetch merged PR counts and latest merge dates per repository for the configured user.
      * Delegates to github-stats module.
      */
-    async fetchUserMergedPRCounts() {
+    async fetchUserMergedPRCounts(starFilter) {
         const config = this.stateManager.getState().config;
-        return fetchUserMergedPRCountsImpl(this.octokit, config.githubUsername);
+        return fetchUserMergedPRCountsImpl(this.octokit, config.githubUsername, starFilter);
     }
     /**
      * Fetch closed-without-merge PR counts per repository for the configured user.
      * Delegates to github-stats module.
      */
-    async fetchUserClosedPRCounts() {
+    async fetchUserClosedPRCounts(starFilter) {
         const config = this.stateManager.getState().config;
-        return fetchUserClosedPRCountsImpl(this.octokit, config.githubUsername);
+        return fetchUserClosedPRCountsImpl(this.octokit, config.githubUsername, starFilter);
     }
     /**
      * Fetch GitHub star counts for a list of repositories.
@@ -513,52 +557,22 @@ export class PRMonitor {
     generateDigest(prs, recentlyClosedPRs = [], recentlyMergedPRs = []) {
         const now = new Date().toISOString();
         // Categorize PRs
-        const prsNeedingResponse = prs.filter((pr) => pr.status === 'needs_response');
-        const ciFailingPRs = prs.filter((pr) => pr.status === 'failing_ci');
-        const mergeConflictPRs = prs.filter((pr) => pr.status === 'merge_conflict');
-        const approachingDormant = prs.filter((pr) => pr.status === 'approaching_dormant');
-        const dormantPRs = prs.filter((pr) => pr.status === 'dormant');
-        const healthyPRs = prs.filter((pr) => pr.status === 'healthy' || pr.status === 'waiting');
+        const needsAddressingPRs = prs.filter((pr) => pr.status === 'needs_addressing');
+        const waitingOnMaintainerPRs = prs.filter((pr) => pr.status === 'waiting_on_maintainer');
         // Get stats from state manager (historical data from repo scores)
         const stats = this.stateManager.getStats();
-        const ciBlockedPRs = prs.filter((pr) => pr.status === 'ci_blocked');
-        const ciNotRunningPRs = prs.filter((pr) => pr.status === 'ci_not_running');
-        const needsRebasePRs = prs.filter((pr) => pr.status === 'needs_rebase');
-        const missingRequiredFilesPRs = prs.filter((pr) => pr.status === 'missing_required_files');
-        const incompleteChecklistPRs = prs.filter((pr) => pr.status === 'incomplete_checklist');
-        const needsChangesPRs = prs.filter((pr) => pr.status === 'needs_changes');
-        const changesAddressedPRs = prs.filter((pr) => pr.status === 'changes_addressed');
-        const waitingOnMaintainerPRs = prs.filter((pr) => pr.status === 'waiting_on_maintainer');
         return {
             generatedAt: now,
             openPRs: prs,
-            prsNeedingResponse,
-            ciFailingPRs,
-            ciBlockedPRs,
-            ciNotRunningPRs,
-            mergeConflictPRs,
-            needsRebasePRs,
-            missingRequiredFilesPRs,
-            incompleteChecklistPRs,
-            needsChangesPRs,
-            changesAddressedPRs,
+            needsAddressingPRs,
             waitingOnMaintainerPRs,
-            approachingDormant,
-            dormantPRs,
-            healthyPRs,
             recentlyClosedPRs,
             recentlyMergedPRs,
             shelvedPRs: [],
             autoUnshelvedPRs: [],
             summary: {
                 totalActivePRs: prs.length,
-                totalNeedingAttention: prsNeedingResponse.length +
-                    needsChangesPRs.length +
-                    ciFailingPRs.length +
-                    mergeConflictPRs.length +
-                    needsRebasePRs.length +
-                    missingRequiredFilesPRs.length +
-                    incompleteChecklistPRs.length,
+                totalNeedingAttention: needsAddressingPRs.length,
                 totalMergedAllTime: stats.mergedPRs,
                 mergeRate: parseFloat(stats.mergeRate),
             },