@oss-autopilot/core 0.49.0 → 0.51.0

package/dist/core/issue-discovery.js

@@ -18,6 +18,7 @@ import { getHttpCache, cachedTimeBased } from './http-cache.js';
 import { isDocOnlyIssue, detectLabelFarmingRepos, applyPerRepoCap } from './issue-filtering.js';
 import { IssueVetter } from './issue-vetting.js';
 import { calculateViabilityScore as calcViabilityScore } from './issue-scoring.js';
+import { getTopicsForCategories } from './category-mapping.js';
 // Re-export everything from sub-modules for backward compatibility.
 // Existing consumers (tests, CLI commands) import from './issue-discovery.js'.
 export { isDocOnlyIssue, applyPerRepoCap, isLabelFarming, hasTemplatedTitle, detectLabelFarmingRepos, DOC_ONLY_LABELS, BEGINNER_LABELS, } from './issue-filtering.js';
@@ -282,6 +283,51 @@ export class IssueDiscovery {
                 }
             }
         }
+        // Phase 0.5: Search preferred organizations (explicit user preference)
+        let phase0_5Error = null;
+        const preferredOrgs = config.preferredOrgs ?? [];
+        if (allCandidates.length < maxResults && preferredOrgs.length > 0) {
+            // Filter out orgs already covered by Phase 0 repos
+            const phase0Orgs = new Set(phase0Repos.map((r) => r.split('/')[0]?.toLowerCase()));
+            const orgsToSearch = preferredOrgs.filter((org) => !phase0Orgs.has(org.toLowerCase())).slice(0, 5);
+            if (orgsToSearch.length > 0) {
+                info(MODULE, `Phase 0.5: Searching issues in ${orgsToSearch.length} preferred org(s)...`);
+                const remainingNeeded = maxResults - allCandidates.length;
+                const orgRepoFilter = orgsToSearch.map((org) => `org:${org}`).join(' OR ');
+                const orgQuery = `${baseQuery} (${orgRepoFilter})`;
+                try {
+                    const data = await this.cachedSearch({
+                        q: orgQuery,
+                        sort: 'created',
+                        order: 'desc',
+                        per_page: remainingNeeded * 3,
+                    });
+                    if (data.items.length > 0) {
+                        const filtered = filterIssues(data.items).filter((item) => {
+                            const repoFullName = item.repository_url.split('/').slice(-2).join('/');
+                            return !phase0RepoSet.has(repoFullName);
+                        });
+                        const { candidates: orgCandidates, allFailed: allVetFailed, rateLimitHit, } = await this.vetter.vetIssuesParallel(filtered.slice(0, remainingNeeded * 2).map((i) => i.html_url), remainingNeeded, 'preferred_org');
+                        allCandidates.push(...orgCandidates);
+                        if (allVetFailed) {
+                            phase0_5Error = 'All preferred org issue vetting failed';
+                        }
+                        if (rateLimitHit) {
+                            rateLimitHitDuringSearch = true;
+                        }
+                        info(MODULE, `Found ${orgCandidates.length} candidates from preferred orgs`);
+                    }
+                }
+                catch (error) {
+                    const errMsg = errorMessage(error);
+                    phase0_5Error = errMsg;
+                    if (isRateLimitError(error)) {
+                        rateLimitHitDuringSearch = true;
+                    }
+                    warn(MODULE, `Error searching preferred orgs: ${errMsg}`);
+                }
+            }
+        }
         // Phase 1: Search starred repos (filter out already-searched Phase 0 repos)
         if (allCandidates.length < maxResults && starredRepos.length > 0) {
             const reposToSearch = starredRepos.filter((r) => !phase0RepoSet.has(r));
@@ -345,7 +391,12 @@ export class IssueDiscovery {
             const thirtyDaysAgo = new Date();
             thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
             const pushedSince = thirtyDaysAgo.toISOString().split('T')[0];
-            const phase3Query = `is:issue is:open no:assignee ${langQuery} stars:>=${minStars} pushed:>=${pushedSince} archived:false`
+            // When user has category preferences, add a single topic filter to focus on relevant repos.
+            // GitHub Search API AND-joins multiple topic: qualifiers, which is overly restrictive,
+            // so we pick just the first topic to nudge results without eliminating valid matches.
+            const categoryTopics = getTopicsForCategories(config.projectCategories ?? []);
+            const topicQuery = categoryTopics.length > 0 ? `topic:${categoryTopics[0]}` : '';
+            const phase3Query = `is:issue is:open no:assignee ${langQuery} ${topicQuery} stars:>=${minStars} pushed:>=${pushedSince} archived:false`
                 .replace(/  +/g, ' ')
                 .trim();
             try {
@@ -379,6 +430,7 @@ export class IssueDiscovery {
         if (allCandidates.length === 0) {
             const phaseErrors = [
                 phase0Error ? `Phase 0 (merged-PR repos): ${phase0Error}` : null,
+                phase0_5Error ? `Phase 0.5 (preferred orgs): ${phase0_5Error}` : null,
                 phase1Error ? `Phase 1 (starred repos): ${phase1Error}` : null,
                 phase2Error ? `Phase 2 (general): ${phase2Error}` : null,
                 phase3Error ? `Phase 3 (maintained repos): ${phase3Error}` : null,
@@ -406,8 +458,8 @@ export class IssueDiscovery {
         }
         // Sort by priority first, then by recommendation, then by viability score
         allCandidates.sort((a, b) => {
-            // Priority order: merged_pr > starred > normal
-            const priorityOrder = { merged_pr: 0, starred: 1, normal: 2 };
+            // Priority order: merged_pr > preferred_org > starred > normal
+            const priorityOrder = { merged_pr: 0, preferred_org: 1, starred: 2, normal: 3 };
             const priorityDiff = priorityOrder[a.searchPriority] - priorityOrder[b.searchPriority];
             if (priorityDiff !== 0)
                 return priorityDiff;

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

@@ -21,6 +21,8 @@ export interface ViabilityScoreParams {
     mergedPRCount: number;
     orgHasMergedPRs: boolean;
     repoQualityBonus?: number;
+    /** True when the repo matches one of the user's preferred project categories. */
+    matchesPreferredCategory?: boolean;
 }
 /**
  * Calculate viability score for an issue (0-100 scale)
@@ -33,6 +35,7 @@ export interface ViabilityScoreParams {
  * - +15 for freshness (recently updated)
  * - +10 for contribution guidelines
  * - +5 for org affinity (merged PRs in same org)
+ * - +5 for category preference (matches user's project categories)
  * - -30 if existing PR
  * - -20 if claimed
  * - -15 if closed-without-merge history with no merges

package/dist/core/issue-scoring.js

@@ -37,6 +37,7 @@ export function calculateRepoQualityBonus(stargazersCount, forksCount) {
  * - +15 for freshness (recently updated)
  * - +10 for contribution guidelines
  * - +5 for org affinity (merged PRs in same org)
+ * - +5 for category preference (matches user's project categories)
  * - -30 if existing PR
  * - -20 if claimed
  * - -15 if closed-without-merge history with no merges
@@ -75,6 +76,10 @@ export function calculateViabilityScore(params) {
     if (params.orgHasMergedPRs) {
         score += 5;
     }
+    // Category preference bonus (+5) — repo matches user's preferred project categories
+    if (params.matchesPreferredCategory) {
+        score += 5;
+    }
     // Penalty for existing PR (-30)
     if (params.hasExistingPR) {
         score -= 30;

package/dist/core/issue-vetting.js

@@ -10,6 +10,7 @@ import { ValidationError, errorMessage, isRateLimitError } from './errors.js';
 import { warn } from './logger.js';
 import { getHttpCache, cachedRequest, cachedTimeBased } from './http-cache.js';
 import { calculateRepoQualityBonus, calculateViabilityScore } from './issue-scoring.js';
+import { repoBelongsToCategory } from './category-mapping.js';
 const MODULE = 'issue-vetting';
 const MAX_CONCURRENT_REQUESTS = DEFAULT_CONCURRENCY;
 // Cache for contribution guidelines (expires after 1 hour, max 100 entries)
@@ -173,6 +174,12 @@ export class IssueVetter {
         if (orgHasMergedPRs) {
             reasonsToApprove.push(`Org affinity (merged PRs in other ${orgName} repos)`);
         }
+        // Check for category preference match
+        const projectCategories = config.projectCategories ?? [];
+        const matchesCategory = repoBelongsToCategory(repoFullName, projectCategories);
+        if (matchesCategory) {
+            reasonsToApprove.push('Matches preferred project category');
+        }
         let recommendation;
         if (vettingResult.passedAllChecks) {
             recommendation = 'approve';
@@ -207,12 +214,17 @@ export class IssueVetter {
             mergedPRCount: effectiveMergedCount,
             orgHasMergedPRs,
             repoQualityBonus,
+            matchesPreferredCategory: matchesCategory,
         });
         const starredRepos = this.stateManager.getStarredRepos();
+        const preferredOrgs = config.preferredOrgs ?? [];
         let searchPriority = 'normal';
         if (effectiveMergedCount > 0) {
             searchPriority = 'merged_pr';
         }
+        else if (preferredOrgs.some((o) => o.toLowerCase() === orgName?.toLowerCase())) {
+            searchPriority = 'preferred_org';
+        }
         else if (starredRepos.includes(repoFullName)) {
             searchPriority = 'starred';
         }

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

@@ -10,12 +10,14 @@
  * - maintainer-analysis.ts: Maintainer action hint extraction
  * - display-utils.ts: Display label computation
  * - github-stats.ts: Merged/closed PR counts and star fetching
+ * - status-determination.ts: PR status classification logic
  */
 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';
 export { isConditionalChecklistItem } from './checklist-analysis.js';
+export { determineStatus } from './status-determination.js';
 export interface PRCheckFailure {
     prUrl: string;
     error: string;
@@ -42,33 +44,6 @@ export declare class PRMonitor {
      * Centralizes PR construction and display label computation (#79).
      */
     private buildFetchedPR;
-    /**
-     * 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
      */

package/dist/core/pr-monitor.js

@@ -10,10 +10,12 @@
  * - maintainer-analysis.ts: Maintainer action hint extraction
  * - display-utils.ts: Display label computation
  * - github-stats.ts: Merged/closed PR counts and star fetching
+ * - status-determination.ts: PR status classification logic
  */
 import { getOctokit } from './github.js';
 import { getStateManager } from './state.js';
 import { daysBetween, parseGitHubUrl, extractOwnerRepo, isOwnRepo, DEFAULT_CONCURRENCY } from './utils.js';
+import { determineStatus } from './status-determination.js';
 import { runWorkerPool } from './concurrency.js';
 import { ConfigurationError, ValidationError, errorMessage, getHttpStatusCode } from './errors.js';
 import { paginateAll } from './pagination.js';
@@ -30,6 +32,7 @@ import { fetchUserMergedPRCounts as fetchUserMergedPRCountsImpl, fetchUserClosed
 export { computeDisplayLabel } from './display-utils.js';
 export { classifyCICheck, classifyFailingChecks } from './ci-analysis.js';
 export { isConditionalChecklistItem } from './checklist-analysis.js';
+export { determineStatus } from './status-determination.js';
 const MODULE = 'pr-monitor';
 const MAX_CONCURRENT_REQUESTS = DEFAULT_CONCURRENCY;
 export class PRMonitor {
@@ -217,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 } = this.determineStatus({
+        const { status, actionReason, waitReason, stalenessTier } = determineStatus({
             ciStatus,
             hasMergeConflict,
             hasUnrespondedComment,
@@ -275,115 +278,6 @@ export class PRMonitor {
         pr.displayDescription = displayDescription;
         return pr;
     }
-    /**
-     * Determine the overall status of a PR
-     */
-    determineStatus(input) {
-        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.
-            // 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 { status: 'needs_addressing', actionReason: 'needs_response', stalenessTier };
-                }
-                if (ciStatus === 'failing' && hasActionableCIFailure)
-                    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 { status: 'waiting_on_maintainer', waitReason: 'changes_addressed', stalenessTier };
-            }
-            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 { status: 'needs_addressing', actionReason: 'needs_changes', stalenessTier };
-            }
-            // Commit is after review — changes have been addressed
-            if (ciStatus === 'failing' && hasActionableCIFailure)
-                return { status: 'needs_addressing', actionReason: 'failing_ci', stalenessTier };
-            // Non-actionable CI failures don't block changes_addressed (#502)
-            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 (hasMergeConflict) {
-            return { status: 'needs_addressing', actionReason: 'merge_conflict', stalenessTier };
-        }
-        if (hasIncompleteChecklist) {
-            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 { status: 'waiting_on_maintainer', waitReason: 'pending_merge', stalenessTier };
-        }
-        // 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 commitMs - commentMs >= PRMonitor.MIN_RESPONSE_GAP_MS;
-    }
     /**
      * Check if PR has merge conflict
      */

package/dist/core/state.d.ts

@@ -2,7 +2,7 @@
  * State management for the OSS Contribution Agent
  * Persists state to a JSON file in ~/.oss-autopilot/
  */
-import { AgentState, TrackedIssue, RepoScore, RepoScoreUpdate, StateEvent, StateEventType, DailyDigest, LocalRepoCache, SnoozeInfo, StatusOverride, FetchedPRStatus, StoredMergedPR, StoredClosedPR } from './types.js';
+import { AgentState, TrackedIssue, RepoScore, RepoScoreUpdate, StateEvent, StateEventType, DailyDigest, LocalRepoCache, StatusOverride, FetchedPRStatus, StoredMergedPR, StoredClosedPR } from './types.js';
 /**
  * Acquire an advisory file lock using exclusive-create (`wx` flag).
  * If the lock file already exists but is stale (older than LOCK_TIMEOUT_MS or corrupt),
@@ -240,57 +240,25 @@ export declare class StateManager {
      */
     isPRShelved(url: string): boolean;
     /**
-     * Dismiss an issue or PR by URL. Dismissed URLs are excluded from `new_response` notifications
+     * Dismiss an issue by URL. Dismissed issues are excluded from `new_response` notifications
      * until new activity occurs after the dismiss timestamp.
-     * @param url - The full GitHub issue or PR URL.
-     * @param timestamp - ISO timestamp of when the issue/PR was dismissed.
+     * @param url - The full GitHub issue URL.
+     * @param timestamp - ISO timestamp of when the issue was dismissed.
      * @returns true if newly dismissed, false if already dismissed.
      */
     dismissIssue(url: string, timestamp: string): boolean;
     /**
-     * Undismiss an issue or PR by URL.
-     * @param url - The full GitHub issue or PR URL.
+     * Undismiss an issue by URL.
+     * @param url - The full GitHub issue URL.
      * @returns true if found and removed, false if not dismissed.
      */
     undismissIssue(url: string): boolean;
     /**
-     * Get the timestamp when an issue or PR was dismissed.
-     * @param url - The full GitHub issue or PR URL.
+     * Get the timestamp when an issue was dismissed.
+     * @param url - The full GitHub issue URL.
      * @returns The ISO dismiss timestamp, or undefined if not dismissed.
      */
     getIssueDismissedAt(url: string): string | undefined;
-    /**
-     * Snooze a PR's CI failure for a given number of days.
-     * Snoozed PRs are excluded from actionable CI failure lists until the snooze expires.
-     * @param url - The full GitHub PR URL.
-     * @param reason - Why the CI failure is being snoozed (e.g., "upstream infrastructure issue").
-     * @param durationDays - Number of days to snooze. Default 7.
-     * @returns true if newly snoozed, false if already snoozed.
-     */
-    snoozePR(url: string, reason: string, durationDays: number): boolean;
-    /**
-     * Unsnooze a PR by URL.
-     * @param url - The full GitHub PR URL.
-     * @returns true if found and removed, false if not snoozed.
-     */
-    unsnoozePR(url: string): boolean;
-    /**
-     * Check if a PR is currently snoozed (not expired).
-     * @param url - The full GitHub PR URL.
-     * @returns true if the PR is snoozed and the snooze has not expired.
-     */
-    isSnoozed(url: string): boolean;
-    /**
-     * Get snooze metadata for a PR.
-     * @param url - The full GitHub PR URL.
-     * @returns The snooze metadata, or undefined if not snoozed.
-     */
-    getSnoozeInfo(url: string): SnoozeInfo | undefined;
-    /**
-     * Expire all snoozes that are past their `expiresAt` timestamp.
-     * @returns Array of PR URLs whose snoozes were expired.
-     */
-    expireSnoozes(): string[];
     /**
      * Set a manual status override for a PR.
      * @param url - The full GitHub PR URL.

package/dist/core/state.js

@@ -6,7 +6,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { INITIAL_STATE, isBelowMinStars, } from './types.js';
 import { getStatePath, getBackupDir, getDataDir } from './utils.js';
-import { ValidationError, errorMessage } from './errors.js';
+import { errorMessage } from './errors.js';
 import { debug, warn } from './logger.js';
 const MODULE = 'state';
 // Current state version
@@ -196,7 +196,6 @@ export class StateManager {
                 trustedProjects: [],
                 shelvedPRUrls: [],
                 dismissedIssues: {},
-                snoozedPRs: {},
             },
             events: [],
             lastRunAt: new Date().toISOString(),
@@ -342,6 +341,34 @@ export class StateManager {
                     atomicWriteFileSync(statePath, JSON.stringify(state, null, 2), 0o600);
                     debug(MODULE, 'Migrated state saved');
                 }
+                // Strip legacy fields from persisted state (snoozedPRs and PR dismiss
+                // entries were removed in the three-state PR model simplification)
+                try {
+                    let needsCleanupSave = false;
+                    const rawConfig = state.config;
+                    if (rawConfig.snoozedPRs) {
+                        delete rawConfig.snoozedPRs;
+                        needsCleanupSave = true;
+                    }
+                    // Strip PR URLs from dismissedIssues (PR dismiss removed)
+                    if (state.config.dismissedIssues) {
+                        const PR_URL_RE = /\/pull\/\d+$/;
+                        for (const url of Object.keys(state.config.dismissedIssues)) {
+                            if (PR_URL_RE.test(url)) {
+                                delete state.config.dismissedIssues[url];
+                                needsCleanupSave = true;
+                            }
+                        }
+                    }
+                    if (needsCleanupSave) {
+                        atomicWriteFileSync(statePath, JSON.stringify(state, null, 2), 0o600);
+                        warn(MODULE, 'Cleaned up removed features (snoozedPRs, dismissed PR URLs) from persisted state');
+                    }
+                }
+                catch (cleanupError) {
+                    warn(MODULE, `Failed to clean up removed features from state: ${errorMessage(cleanupError)}`);
+                    // Continue with loaded state — cleanup will be retried on next load
+                }
                 // Log appropriate message based on version
                 const repoCount = Object.keys(state.repoScores).length;
                 debug(MODULE, `Loaded state v${state.version}: ${repoCount} repo scores tracked`);
@@ -803,10 +830,10 @@ export class StateManager {
     }
     // === Dismiss / Undismiss Issues ===
     /**
-     * Dismiss an issue or PR by URL. Dismissed URLs are excluded from `new_response` notifications
+     * Dismiss an issue by URL. Dismissed issues are excluded from `new_response` notifications
      * until new activity occurs after the dismiss timestamp.
-     * @param url - The full GitHub issue or PR URL.
-     * @param timestamp - ISO timestamp of when the issue/PR was dismissed.
+     * @param url - The full GitHub issue URL.
+     * @param timestamp - ISO timestamp of when the issue was dismissed.
      * @returns true if newly dismissed, false if already dismissed.
      */
     dismissIssue(url, timestamp) {
@@ -820,8 +847,8 @@ export class StateManager {
         return true;
     }
     /**
-     * Undismiss an issue or PR by URL.
-     * @param url - The full GitHub issue or PR URL.
+     * Undismiss an issue by URL.
+     * @param url - The full GitHub issue URL.
      * @returns true if found and removed, false if not dismissed.
      */
     undismissIssue(url) {
@@ -832,97 +859,13 @@ export class StateManager {
         return true;
     }
     /**
-     * Get the timestamp when an issue or PR was dismissed.
-     * @param url - The full GitHub issue or PR URL.
+     * Get the timestamp when an issue was dismissed.
+     * @param url - The full GitHub issue URL.
      * @returns The ISO dismiss timestamp, or undefined if not dismissed.
      */
     getIssueDismissedAt(url) {
         return this.state.config.dismissedIssues?.[url];
     }
-    // === Snooze / Unsnooze CI Failures ===
-    /**
-     * Snooze a PR's CI failure for a given number of days.
-     * Snoozed PRs are excluded from actionable CI failure lists until the snooze expires.
-     * @param url - The full GitHub PR URL.
-     * @param reason - Why the CI failure is being snoozed (e.g., "upstream infrastructure issue").
-     * @param durationDays - Number of days to snooze. Default 7.
-     * @returns true if newly snoozed, false if already snoozed.
-     */
-    snoozePR(url, reason, durationDays) {
-        if (!Number.isFinite(durationDays) || durationDays <= 0) {
-            throw new ValidationError(`Invalid snooze duration: ${durationDays}. Must be a positive finite number.`);
-        }
-        if (!this.state.config.snoozedPRs) {
-            this.state.config.snoozedPRs = {};
-        }
-        if (url in this.state.config.snoozedPRs) {
-            return false;
-        }
-        const now = new Date();
-        const expiresAt = new Date(now.getTime() + durationDays * 24 * 60 * 60 * 1000);
-        this.state.config.snoozedPRs[url] = {
-            reason,
-            snoozedAt: now.toISOString(),
-            expiresAt: expiresAt.toISOString(),
-        };
-        return true;
-    }
-    /**
-     * Unsnooze a PR by URL.
-     * @param url - The full GitHub PR URL.
-     * @returns true if found and removed, false if not snoozed.
-     */
-    unsnoozePR(url) {
-        if (!this.state.config.snoozedPRs || !(url in this.state.config.snoozedPRs)) {
-            return false;
-        }
-        delete this.state.config.snoozedPRs[url];
-        return true;
-    }
-    /**
-     * Check if a PR is currently snoozed (not expired).
-     * @param url - The full GitHub PR URL.
-     * @returns true if the PR is snoozed and the snooze has not expired.
-     */
-    isSnoozed(url) {
-        const info = this.getSnoozeInfo(url);
-        if (!info)
-            return false;
-        const expiresAtMs = new Date(info.expiresAt).getTime();
-        if (isNaN(expiresAtMs)) {
-            warn(MODULE, `Invalid expiresAt for snoozed PR ${url}: "${info.expiresAt}". Treating as not snoozed.`);
-            return false;
-        }
-        return expiresAtMs > Date.now();
-    }
-    /**
-     * Get snooze metadata for a PR.
-     * @param url - The full GitHub PR URL.
-     * @returns The snooze metadata, or undefined if not snoozed.
-     */
-    getSnoozeInfo(url) {
-        return this.state.config.snoozedPRs?.[url];
-    }
-    /**
-     * Expire all snoozes that are past their `expiresAt` timestamp.
-     * @returns Array of PR URLs whose snoozes were expired.
-     */
-    expireSnoozes() {
-        if (!this.state.config.snoozedPRs)
-            return [];
-        const expired = [];
-        const now = Date.now();
-        for (const [url, info] of Object.entries(this.state.config.snoozedPRs)) {
-            const expiresAtMs = new Date(info.expiresAt).getTime();
-            if (isNaN(expiresAtMs) || expiresAtMs <= now) {
-                expired.push(url);
-            }
-        }
-        for (const url of expired) {
-            delete this.state.config.snoozedPRs[url];
-        }
-        return expired;
-    }
     // === Status Overrides ===
     /**
      * Set a manual status override for a PR.

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

@@ -0,0 +1,35 @@
+/**
+ * Status determination logic for PRs — extracted from PRMonitor (#263).
+ *
+ * Computes the top-level status (needs_addressing vs waiting_on_maintainer),
+ * granular action/wait reasons, and staleness tier for a single PR based on
+ * its CI, review, merge-conflict, and timeline signals.
+ */
+import type { DetermineStatusInput, DetermineStatusResult } from './types.js';
+/**
+ * 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.
+ */
+export declare const CI_FIX_BOTS: ReadonlySet<string>;
+/** 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. */
+export declare const MIN_RESPONSE_GAP_MS: number;
+/**
+ * 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).
+ */
+export declare function isContributorCommit(commitAuthor?: string, contributorUsername?: string): boolean;
+/**
+ * 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).
+ */
+export declare function isCommitAfterComment(commitDate: string, commentDate: string): boolean;
+/**
+ * Determine the overall status of a PR based on its signals.
+ */
+export declare function determineStatus(input: DetermineStatusInput): DetermineStatusResult;