@oss-autopilot/core 0.50.0 → 0.51.0

package/dist/commands/daily.d.ts

@@ -41,7 +41,7 @@ export interface DailyCheckResult {
  *   1. fetchPRData        — fetch open PRs, merged/closed counts, issues
  *   2. updateRepoScores   — update signals, star counts, trust in state
  *   3. updateAnalytics    — store monthly chart data
- *   4. partitionPRs       — expire snoozes, shelve/unshelve, generate digest
+ *   4. partitionPRs       — shelve/unshelve, generate digest
  *   5. generateDigestOutput — capacity, dismiss filter, action menu assembly
  */
 export declare function executeDailyCheck(token: string): Promise<DailyOutput>;

package/dist/commands/daily.js

@@ -230,25 +230,12 @@ async function updateRepoScores(prMonitor, prs, mergedCounts, closedCounts) {
     }
 }
 /**
- * Phase 4: Expire snoozes and partition PRs into active vs shelved buckets.
+ * Phase 4: Partition PRs into active vs shelved buckets.
  * Auto-unshelves PRs where maintainers have engaged, generates the digest,
  * and persists state.
  */
 function partitionPRs(prMonitor, prs, recentlyClosedPRs, recentlyMergedPRs) {
     const stateManager = getStateManager();
-    // Expire any snoozes that have passed their expiresAt timestamp.
-    // Non-critical: corrupted snooze entries should not abort the daily check.
-    try {
-        const expiredSnoozes = stateManager.expireSnoozes();
-        if (expiredSnoozes.length > 0) {
-            const urls = expiredSnoozes.map((url) => `  - ${url}`).join('\n');
-            warn(MODULE, `${expiredSnoozes.length} snoozed PR(s) expired and will resurface:\n${urls}`);
-            stateManager.save();
-        }
-    }
-    catch (error) {
-        warn(MODULE, `Failed to expire/persist snoozes: ${errorMessage(error)}`);
-    }
     // Apply dashboard/CLI status overrides before partitioning.
     // This ensures PRs reclassified in the dashboard (e.g., "Need Attention" → "Waiting")
     // are respected by the CLI pipeline.
@@ -328,31 +315,7 @@ function generateDigestOutput(digest, activePRs, shelvedPRs, commentedIssues, fa
     });
     const issueResponses = filteredCommentedIssues.filter((i) => i.status === 'new_response');
     const summary = formatSummary(digest, capacity, issueResponses);
-    const snoozedUrls = new Set(Object.keys(stateManager.getState().config.snoozedPRs ?? {}).filter((url) => stateManager.isSnoozed(url)));
-    // Filter dismissed PRs: suppress if dismissed after last activity, auto-undismiss if new activity (#416, #468)
-    const nonDismissedPRs = activePRs.filter((pr) => {
-        const dismissedAt = stateManager.getIssueDismissedAt(pr.url);
-        if (!dismissedAt)
-            return true; // Not dismissed — include
-        const activityTime = new Date(pr.updatedAt).getTime();
-        const dismissTime = new Date(dismissedAt).getTime();
-        if (isNaN(activityTime) || isNaN(dismissTime)) {
-            // Invalid timestamp — fail open (include PR to be safe) without
-            // permanently removing dismiss record (may be a transient data issue)
-            warn(MODULE, `Invalid timestamp in PR dismiss check for ${pr.url}, including PR`);
-            return true;
-        }
-        if (activityTime > dismissTime) {
-            // New activity after dismiss — auto-undismiss and resurface
-            warn(MODULE, `Auto-undismissing PR ${pr.url}: new activity at ${pr.updatedAt} after dismiss at ${dismissedAt}`);
-            stateManager.undismissIssue(pr.url);
-            hasAutoUndismissed = true;
-            return true;
-        }
-        // Still dismissed (last activity is at or before dismiss timestamp)
-        return false;
-    });
-    // Persist auto-undismiss state changes (issue + PR combined into one save)
+    // Persist auto-undismiss state changes for issues
     if (hasAutoUndismissed) {
         try {
             stateManager.save();
@@ -361,7 +324,7 @@ function generateDigestOutput(digest, activePRs, shelvedPRs, commentedIssues, fa
             warn(MODULE, `Failed to persist auto-undismissed state: ${errorMessage(error)}`);
         }
     }
-    const actionableIssues = collectActionableIssues(nonDismissedPRs, snoozedUrls, previousLastDigestAt);
+    const actionableIssues = collectActionableIssues(activePRs, previousLastDigestAt);
     digest.summary.totalNeedingAttention = actionableIssues.length;
     const briefSummary = formatBriefSummary(digest, actionableIssues.length, issueResponses.length);
     const actionMenu = computeActionMenu(actionableIssues, capacity, filteredCommentedIssues);
@@ -410,7 +373,7 @@ function toDailyOutput(result) {
  *   1. fetchPRData        — fetch open PRs, merged/closed counts, issues
  *   2. updateRepoScores   — update signals, star counts, trust in state
  *   3. updateAnalytics    — store monthly chart data
- *   4. partitionPRs       — expire snoozes, shelve/unshelve, generate digest
+ *   4. partitionPRs       — shelve/unshelve, generate digest
  *   5. generateDigestOutput — capacity, dismiss filter, action menu assembly
  */
 export async function executeDailyCheck(token) {
@@ -432,7 +395,7 @@ async function executeDailyCheckInternal(token) {
     // Capture lastDigestAt BEFORE Phase 4 overwrites it with the current run's timestamp.
     // Used by collectActionableIssues to determine which PRs are "new" (created since last digest).
     const previousLastDigestAt = getStateManager().getState().lastDigestAt;
-    // Phase 4: Expire snoozes, partition PRs, generate and save digest
+    // Phase 4: Partition PRs, generate and save digest
     const { activePRs, shelvedPRs, digest } = partitionPRs(prMonitor, prs, recentlyClosedPRs, recentlyMergedPRs);
     // Phase 5: Build structured output (capacity, dismiss filter, action menu)
     return generateDigestOutput(digest, activePRs, shelvedPRs, commentedIssues, failures, previousLastDigestAt);

package/dist/commands/dashboard-server.d.ts

@@ -1,7 +1,7 @@
 /**
  * Dashboard HTTP server.
  * Serves the Preact SPA from packages/dashboard/dist/ and provides API endpoints
- * for live data fetching and state mutations (shelve, unshelve, override, etc.).
+ * for live data fetching and state mutations (PR state transitions, issue dismiss).
  *
  * Uses Node's built-in http module — no Express/Fastify.
  */

package/dist/commands/dashboard-server.js

@@ -1,7 +1,7 @@
 /**
  * Dashboard HTTP server.
  * Serves the Preact SPA from packages/dashboard/dist/ and provides API endpoints
- * for live data fetching and state mutations (shelve, unshelve, override, etc.).
+ * for live data fetching and state mutations (PR state transitions, issue dismiss).
  *
  * Uses Node's built-in http module — no Express/Fastify.
  */
@@ -11,7 +11,7 @@ import * as path from 'path';
 import { getStateManager, getGitHubToken, getCLIVersion, applyStatusOverrides } from '../core/index.js';
 import { errorMessage, ValidationError } from '../core/errors.js';
 import { warn } from '../core/logger.js';
-import { validateUrl, validateGitHubUrl, PR_URL_PATTERN, ISSUE_OR_PR_URL_PATTERN } from './validation.js';
+import { validateUrl, validateGitHubUrl, PR_URL_PATTERN, ISSUE_URL_PATTERN } from './validation.js';
 import { fetchDashboardData, computePRsByRepo, computeTopRepos, getMonthlyData, buildDashboardStats, storedToMergedPRs, storedToClosedPRs, } from './dashboard-data.js';
 import { openInBrowser } from './startup.js';
 import { writeDashboardServerInfo, removeDashboardServerInfo } from './dashboard-process.js';
@@ -20,12 +20,7 @@ import { isBelowMinStars, } from '../core/types.js';
 // Re-export process management functions for backward compatibility
 export { getDashboardPidPath, writeDashboardServerInfo, readDashboardServerInfo, removeDashboardServerInfo, isDashboardServerRunning, findRunningDashboardServer, } from './dashboard-process.js';
 // ── Constants ────────────────────────────────────────────────────────────────
-const VALID_ACTIONS = new Set([
-    'shelve',
-    'unshelve',
-    'override_status',
-    'dismiss_issue_response',
-]);
+const VALID_ACTIONS = new Set(['move', 'dismiss_issue_response']);
 const MODULE = 'dashboard-server';
 const MAX_BODY_BYTES = 10_240;
 const REQUEST_TIMEOUT_MS = 30_000;
@@ -250,11 +245,11 @@ export async function startDashboardServer(options) {
             sendError(res, 400, 'Missing or invalid "url" field');
             return;
         }
-        // Validate URL format — dismiss_issue_response accepts issue or PR URLs, others are PR-only.
+        // Validate URL format — move is PR-only, dismiss_issue_response is issue-only.
         const isDismiss = body.action === 'dismiss_issue_response';
         try {
             validateUrl(body.url);
-            validateGitHubUrl(body.url, isDismiss ? ISSUE_OR_PR_URL_PATTERN : PR_URL_PATTERN, isDismiss ? 'issue or PR' : 'PR');
+            validateGitHubUrl(body.url, isDismiss ? ISSUE_URL_PATTERN : PR_URL_PATTERN, isDismiss ? 'issue' : 'PR');
         }
         catch (err) {
             if (err instanceof ValidationError) {
@@ -266,35 +261,20 @@ export async function startDashboardServer(options) {
             }
             return;
         }
-        // Validate override_status-specific fields
-        if (body.action === 'override_status') {
-            if (!body.status || (body.status !== 'needs_addressing' && body.status !== 'waiting_on_maintainer')) {
-                sendError(res, 400, 'override_status requires a valid "status" field (needs_addressing or waiting_on_maintainer)');
-                return;
-            }
-        }
         try {
-            switch (body.action) {
-                case 'shelve':
-                    stateManager.shelvePR(body.url);
-                    break;
-                case 'unshelve':
-                    stateManager.unshelvePR(body.url);
-                    break;
-                case 'override_status': {
-                    // body.status is validated above — the early return ensures it's defined here
-                    const overrideStatus = body.status;
-                    // Find the PR to get its current updatedAt for auto-clear tracking
-                    const targetPR = (cachedDigest?.openPRs || []).find((pr) => pr.url === body.url);
-                    const lastActivityAt = targetPR?.updatedAt || new Date().toISOString();
-                    stateManager.setStatusOverride(body.url, overrideStatus, lastActivityAt);
-                    break;
+            if (body.action === 'move') {
+                const { VALID_TARGETS, runMove } = await import('./move.js');
+                if (!body.target || !VALID_TARGETS.includes(body.target)) {
+                    sendError(res, 400, `move requires a valid "target" field (${VALID_TARGETS.join(', ')})`);
+                    return;
                 }
-                case 'dismiss_issue_response':
-                    stateManager.dismissIssue(body.url, new Date().toISOString());
-                    break;
+                await runMove({ prUrl: body.url, target: body.target });
+            }
+            else {
+                // dismiss_issue_response
+                stateManager.dismissIssue(body.url, new Date().toISOString());
+                stateManager.save();
             }
-            stateManager.save();
         }
         catch (error) {
             warn(MODULE, `Action failed: ${body.action} ${body.url} ${errorMessage(error)}`);

package/dist/commands/dismiss.d.ts

@@ -1,6 +1,6 @@
 /**
  * Dismiss/Undismiss commands
- * Manages dismissing issue and PR notifications without posting a comment.
+ * Manages dismissing issue notifications without posting a comment.
  * Dismissed URLs resurface automatically when new responses arrive after the dismiss timestamp.
  */
 export interface DismissOutput {

package/dist/commands/dismiss.js

@@ -1,13 +1,13 @@
 /**
  * Dismiss/Undismiss commands
- * Manages dismissing issue and PR notifications without posting a comment.
+ * Manages dismissing issue notifications without posting a comment.
  * Dismissed URLs resurface automatically when new responses arrive after the dismiss timestamp.
  */
 import { getStateManager } from '../core/index.js';
-import { ISSUE_OR_PR_URL_PATTERN, validateGitHubUrl, validateUrl } from './validation.js';
+import { ISSUE_URL_PATTERN, validateGitHubUrl, validateUrl } from './validation.js';
 export async function runDismiss(options) {
     validateUrl(options.url);
-    validateGitHubUrl(options.url, ISSUE_OR_PR_URL_PATTERN, 'issue or PR');
+    validateGitHubUrl(options.url, ISSUE_URL_PATTERN, 'issue');
     const stateManager = getStateManager();
     const added = stateManager.dismissIssue(options.url, new Date().toISOString());
     if (added) {
@@ -17,7 +17,7 @@ export async function runDismiss(options) {
 }
 export async function runUndismiss(options) {
     validateUrl(options.url);
-    validateGitHubUrl(options.url, ISSUE_OR_PR_URL_PATTERN, 'issue or PR');
+    validateGitHubUrl(options.url, ISSUE_URL_PATTERN, 'issue');
     const stateManager = getStateManager();
     const removed = stateManager.undismissIssue(options.url);
     if (removed) {

package/dist/commands/index.d.ts

@@ -35,14 +35,12 @@ export { runRead } from './read.js';
 export { runShelve } from './shelve.js';
 /** Restore a shelved PR to the daily digest. */
 export { runUnshelve } from './shelve.js';
+/** Move a PR between states: attention, waiting, shelved, auto. */
+export { runMove } from './move.js';
 /** Dismiss issue reply notifications (auto-resurfaces on new activity). */
 export { runDismiss } from './dismiss.js';
 /** Restore a dismissed issue to notifications. */
 export { runUndismiss } from './dismiss.js';
-/** Temporarily suppress CI failure notifications for a PR. */
-export { runSnooze } from './snooze.js';
-/** Restore CI failure notifications for a snoozed PR. */
-export { runUnsnooze } from './snooze.js';
 /** Fetch comments for tracked issues/PRs. */
 export { runComments } from './comments.js';
 /** Post a comment to a GitHub issue or PR. */
@@ -68,8 +66,8 @@ export type { VetOutput, CommentsOutput, PostOutput, ClaimOutput } from '../form
 export type { ConfigOutput, ParseIssueListOutput, CheckIntegrationOutput, LocalReposOutput, } from '../formatters/json.js';
 export type { ReadOutput } from './read.js';
 export type { ShelveOutput, UnshelveOutput } from './shelve.js';
+export type { MoveOutput, MoveTarget } from './move.js';
 export type { DismissOutput, UndismissOutput } from './dismiss.js';
-export type { SnoozeOutput, UnsnoozeOutput } from './snooze.js';
 export type { UntrackOutput } from './track.js';
 export type { InitOutput } from './init.js';
 export type { ConfigSetOutput, ConfigCommandOutput } from './config.js';

package/dist/commands/index.js

@@ -37,14 +37,12 @@ export { runRead } from './read.js';
 export { runShelve } from './shelve.js';
 /** Restore a shelved PR to the daily digest. */
 export { runUnshelve } from './shelve.js';
+/** Move a PR between states: attention, waiting, shelved, auto. */
+export { runMove } from './move.js';
 /** Dismiss issue reply notifications (auto-resurfaces on new activity). */
 export { runDismiss } from './dismiss.js';
 /** Restore a dismissed issue to notifications. */
 export { runUndismiss } from './dismiss.js';
-/** Temporarily suppress CI failure notifications for a PR. */
-export { runSnooze } from './snooze.js';
-/** Restore CI failure notifications for a snoozed PR. */
-export { runUnsnooze } from './snooze.js';
 // ── Issue & Comment Management ──────────────────────────────────────────────
 /** Fetch comments for tracked issues/PRs. */
 export { runComments } from './comments.js';

package/dist/commands/move.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Move command — transition a PR between states:
+ * attention, waiting, shelved, or auto (reset to computed status).
+ */
+export declare const VALID_TARGETS: readonly ["attention", "waiting", "shelved", "auto"];
+export type MoveTarget = (typeof VALID_TARGETS)[number];
+export interface MoveOutput {
+    url: string;
+    target: MoveTarget;
+    /** Human-readable description of what happened. */
+    description: string;
+}
+export declare function runMove(options: {
+    prUrl: string;
+    target: string;
+}): Promise<MoveOutput>;

package/dist/commands/move.js

@@ -0,0 +1,56 @@
+/**
+ * Move command — transition a PR between states:
+ * attention, waiting, shelved, or auto (reset to computed status).
+ */
+import { getStateManager } from '../core/index.js';
+import { PR_URL_PATTERN, validateGitHubUrl, validateUrl } from './validation.js';
+export const VALID_TARGETS = ['attention', 'waiting', 'shelved', 'auto'];
+export async function runMove(options) {
+    validateUrl(options.prUrl);
+    validateGitHubUrl(options.prUrl, PR_URL_PATTERN, 'PR');
+    const target = options.target;
+    if (!VALID_TARGETS.includes(target)) {
+        throw new Error(`Invalid target "${options.target}". Must be one of: ${VALID_TARGETS.join(', ')}`);
+    }
+    const stateManager = getStateManager();
+    switch (target) {
+        case 'attention':
+        case 'waiting': {
+            const status = target === 'attention' ? 'needs_addressing' : 'waiting_on_maintainer';
+            const label = target === 'attention' ? 'Need Attention' : 'Waiting on Maintainer';
+            // Use current time — the CLI doesn't have cached PR data. The override
+            // will auto-clear on the next daily run if the PR has new activity after this.
+            const lastActivityAt = new Date().toISOString();
+            stateManager.setStatusOverride(options.prUrl, status, lastActivityAt);
+            stateManager.unshelvePR(options.prUrl);
+            stateManager.save();
+            return { url: options.prUrl, target, description: `Moved to ${label}` };
+        }
+        case 'shelved': {
+            stateManager.shelvePR(options.prUrl);
+            stateManager.clearStatusOverride(options.prUrl);
+            stateManager.save();
+            return {
+                url: options.prUrl,
+                target,
+                description: 'Shelved — excluded from capacity and actionable items',
+            };
+        }
+        case 'auto': {
+            const clearedOverride = stateManager.clearStatusOverride(options.prUrl);
+            const unshelved = stateManager.unshelvePR(options.prUrl);
+            if (clearedOverride || unshelved) {
+                stateManager.save();
+            }
+            return {
+                url: options.prUrl,
+                target,
+                description: 'Reset to computed status',
+            };
+        }
+        default: {
+            const _exhaustive = target;
+            throw new Error(`Unhandled move target: ${_exhaustive}`);
+        }
+    }
+}

package/dist/commands/shelve.d.ts

@@ -2,6 +2,10 @@
  * Shelve/Unshelve commands
  * Manages shelving PRs to exclude them from capacity and actionable issues.
  * Shelved PRs are auto-unshelved when a maintainer engages.
+ *
+ * Note: The CLI and MCP shelve/unshelve commands delegate to runMove(),
+ * which also clears status overrides. These functions match that behavior
+ * to keep the library API consistent.
  */
 import { PR_URL_PATTERN } from './validation.js';
 export interface ShelveOutput {

package/dist/commands/shelve.js

@@ -2,6 +2,10 @@
  * Shelve/Unshelve commands
  * Manages shelving PRs to exclude them from capacity and actionable issues.
  * Shelved PRs are auto-unshelved when a maintainer engages.
+ *
+ * Note: The CLI and MCP shelve/unshelve commands delegate to runMove(),
+ * which also clears status overrides. These functions match that behavior
+ * to keep the library API consistent.
  */
 import { getStateManager } from '../core/index.js';
 import { PR_URL_PATTERN, validateGitHubUrl, validateUrl } from './validation.js';
@@ -12,7 +16,8 @@ export async function runShelve(options) {
     validateGitHubUrl(options.prUrl, PR_URL_PATTERN, 'PR');
     const stateManager = getStateManager();
     const added = stateManager.shelvePR(options.prUrl);
-    if (added) {
+    const clearedOverride = stateManager.clearStatusOverride(options.prUrl);
+    if (added || clearedOverride) {
         stateManager.save();
     }
     return { shelved: added, url: options.prUrl };
@@ -22,7 +27,8 @@ export async function runUnshelve(options) {
     validateGitHubUrl(options.prUrl, PR_URL_PATTERN, 'PR');
     const stateManager = getStateManager();
     const removed = stateManager.unshelvePR(options.prUrl);
-    if (removed) {
+    const clearedOverride = stateManager.clearStatusOverride(options.prUrl);
+    if (removed || clearedOverride) {
         stateManager.save();
     }
     return { unshelved: removed, url: options.prUrl };

package/dist/core/daily-logic.d.ts

@@ -54,7 +54,7 @@ export declare function assessCapacity(activePRs: FetchedPR[], maxActivePRs: num
  * Note: Recently closed PRs are informational only and excluded from this list.
  * They are available separately in digest.recentlyClosedPRs (#156).
  */
-export declare function collectActionableIssues(prs: FetchedPR[], snoozedUrls?: Set<string>, lastDigestAt?: string): ActionableIssue[];
+export declare function collectActionableIssues(prs: FetchedPR[], lastDigestAt?: string): ActionableIssue[];
 /**
  * Format a maintainer action hint as a human-readable label
  */

package/dist/core/daily-logic.js

@@ -198,7 +198,7 @@ export function assessCapacity(activePRs, maxActivePRs, shelvedPRCount) {
  * Note: Recently closed PRs are informational only and excluded from this list.
  * They are available separately in digest.recentlyClosedPRs (#156).
  */
-export function collectActionableIssues(prs, snoozedUrls = new Set(), lastDigestAt) {
+export function collectActionableIssues(prs, lastDigestAt) {
     const issues = [];
     const actionPRs = prs.filter((pr) => pr.status === 'needs_addressing');
     const lastDigestTime = lastDigestAt ? new Date(lastDigestAt).getTime() : NaN;
@@ -213,8 +213,6 @@ export function collectActionableIssues(prs, snoozedUrls = new Set(), lastDigest
         for (const pr of actionPRs) {
             if (pr.actionReason !== reason)
                 continue;
-            if (reason === 'failing_ci' && snoozedUrls.has(pr.url))
-                continue;
             let label;
             let type;
             switch (reason) {

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