@oss-autopilot/core 0.47.2 → 0.49.0

package/dist/commands/daily.d.ts

@@ -8,7 +8,7 @@
  */
 import { type DailyDigest, type CommentedIssue, type PRCheckFailure, type RepoGroup, type AgentState, type StarFilter } from '../core/index.js';
 import { type DailyOutput, type CapacityAssessment, type ActionableIssue, type ActionMenu } from '../formatters/json.js';
-export { computeRepoSignals, groupPRsByRepo, assessCapacity, collectActionableIssues, computeActionMenu, toShelvedPRRef, formatBriefSummary, formatSummary, printDigest, CRITICAL_STATUSES, } from '../core/index.js';
+export { applyStatusOverrides, computeRepoSignals, groupPRsByRepo, assessCapacity, collectActionableIssues, computeActionMenu, toShelvedPRRef, formatBriefSummary, formatSummary, printDigest, CRITICAL_STATUSES, } from '../core/index.js';
 /**
  * Build a star filter from state for use in fetchUserPRCounts.
  * Returns undefined if no star data is available (first run).

package/dist/commands/daily.js

@@ -6,7 +6,7 @@
  * Domain logic lives in src/core/daily-logic.ts; this file is a thin
  * orchestration layer that wires up the phases and handles I/O.
  */
-import { getStateManager, PRMonitor, IssueConversationMonitor, requireGitHubToken, CRITICAL_STATUSES, computeRepoSignals, groupPRsByRepo, assessCapacity, collectActionableIssues, computeActionMenu, toShelvedPRRef, formatBriefSummary, formatSummary, } from '../core/index.js';
+import { getStateManager, PRMonitor, IssueConversationMonitor, requireGitHubToken, CRITICAL_STATUSES, applyStatusOverrides, computeRepoSignals, groupPRsByRepo, assessCapacity, collectActionableIssues, computeActionMenu, toShelvedPRRef, formatBriefSummary, formatSummary, } from '../core/index.js';
 import { errorMessage, isRateLimitOrAuthError } from '../core/errors.js';
 import { warn } from '../core/logger.js';
 import { emptyPRCountsResult } from '../core/github-stats.js';
@@ -15,7 +15,7 @@ import { deduplicateDigest, compactActionableIssues, compactRepoGroups, } from '
 const MODULE = 'daily';
 // Re-export domain functions so existing consumers (tests, dashboard, startup)
 // can continue importing from './daily.js' without changes.
-export { computeRepoSignals, groupPRsByRepo, assessCapacity, collectActionableIssues, computeActionMenu, toShelvedPRRef, formatBriefSummary, formatSummary, printDigest, CRITICAL_STATUSES, } from '../core/index.js';
+export { applyStatusOverrides, computeRepoSignals, groupPRsByRepo, assessCapacity, collectActionableIssues, computeActionMenu, toShelvedPRRef, formatBriefSummary, formatSummary, printDigest, CRITICAL_STATUSES, } from '../core/index.js';
 /**
  * Build a star filter from state for use in fetchUserPRCounts.
  * Returns undefined if no star data is available (first run).
@@ -249,11 +249,15 @@ function partitionPRs(prMonitor, prs, recentlyClosedPRs, recentlyMergedPRs) {
     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.
+    const overriddenPRs = applyStatusOverrides(prs, stateManager.getState());
     // Partition PRs into active vs shelved, auto-unshelving when maintainers engage
     const shelvedPRs = [];
     const autoUnshelvedPRs = [];
     const activePRs = [];
-    for (const pr of prs) {
+    for (const pr of overriddenPRs) {
         if (stateManager.isPRShelved(pr.url)) {
             if (CRITICAL_STATUSES.has(pr.status)) {
                 stateManager.unshelvePR(pr.url);
@@ -273,10 +277,10 @@ function partitionPRs(prMonitor, prs, recentlyClosedPRs, recentlyMergedPRs) {
             activePRs.push(pr);
         }
     }
-    // Generate digest from fresh data.
+    // Generate digest from override-applied PRs so status categories are correct.
     // Note: digest.openPRs contains ALL fetched PRs (including shelved).
     // We override summary fields below to reflect active-only counts.
-    const digest = prMonitor.generateDigest(prs, recentlyClosedPRs, recentlyMergedPRs);
+    const digest = prMonitor.generateDigest(overriddenPRs, recentlyClosedPRs, recentlyMergedPRs);
     // Attach shelve info to digest
     digest.shelvedPRs = shelvedPRs;
     digest.autoUnshelvedPRs = autoUnshelvedPRs;
@@ -292,7 +296,7 @@ function partitionPRs(prMonitor, prs, recentlyClosedPRs, recentlyMergedPRs) {
  * Assesses capacity, filters dismissed issues, computes actionable items,
  * and assembles the action menu.
  */
-function generateDigestOutput(digest, activePRs, shelvedPRs, commentedIssues, failures) {
+function generateDigestOutput(digest, activePRs, shelvedPRs, commentedIssues, failures, previousLastDigestAt) {
     const stateManager = getStateManager();
     // Assess capacity from active PRs only (shelved PRs excluded)
     const capacity = assessCapacity(activePRs, stateManager.getState().config.maxActivePRs, shelvedPRs.length);
@@ -357,7 +361,7 @@ function generateDigestOutput(digest, activePRs, shelvedPRs, commentedIssues, fa
             warn(MODULE, `Failed to persist auto-undismissed state: ${errorMessage(error)}`);
         }
     }
-    const actionableIssues = collectActionableIssues(nonDismissedPRs, snoozedUrls);
+    const actionableIssues = collectActionableIssues(nonDismissedPRs, snoozedUrls, previousLastDigestAt);
     digest.summary.totalNeedingAttention = actionableIssues.length;
     const briefSummary = formatBriefSummary(digest, actionableIssues.length, issueResponses.length);
     const actionMenu = computeActionMenu(actionableIssues, capacity, filteredCommentedIssues);
@@ -425,10 +429,13 @@ async function executeDailyCheckInternal(token) {
     await updateRepoScores(prMonitor, prs, mergedCounts, closedCounts);
     // Phase 3: Persist monthly analytics
     updateMonthlyAnalytics(prs, monthlyCounts, monthlyClosedCounts, openedFromMerged, openedFromClosed);
+    // 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
     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);
+    return generateDigestOutput(digest, activePRs, shelvedPRs, commentedIssues, failures, previousLastDigestAt);
 }
 /**
  * Run the daily check and return deduplicated DailyOutput.

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

@@ -3,7 +3,7 @@
  * Handles GitHub API calls, PR grouping, stats computation, and monthly chart data.
  * Consumed by the dashboard HTTP server (dashboard-server.ts) for the SPA API.
  */
-import { type DailyDigest, type AgentState, type MergedPR, type StoredMergedPR, type CommentedIssue } from '../core/types.js';
+import { type DailyDigest, type AgentState, type ClosedPR, type MergedPR, type StoredMergedPR, type StoredClosedPR, type CommentedIssue } from '../core/types.js';
 export interface DashboardStats {
     activePRs: number;
     shelvedPRs: number;
@@ -11,7 +11,7 @@ export interface DashboardStats {
     closedPRs: number;
     mergeRate: string;
 }
-export declare function buildDashboardStats(digest: DailyDigest, state: Readonly<AgentState>, storedMergedCount?: number): DashboardStats;
+export declare function buildDashboardStats(digest: DailyDigest, state: Readonly<AgentState>, storedMergedCount?: number, storedClosedCount?: number): DashboardStats;
 /**
  * Merge fresh API counts into existing stored counts.
  * Months present in the fresh data are updated; months only in the existing data are preserved.
@@ -32,6 +32,7 @@ export interface DashboardFetchResult {
     digest: DailyDigest;
     commentedIssues: CommentedIssue[];
     allMergedPRs: MergedPR[];
+    allClosedPRs: ClosedPR[];
 }
 /**
  * Fetch fresh dashboard data from GitHub.
@@ -44,6 +45,11 @@ export declare function fetchDashboardData(token: string): Promise<DashboardFetc
  * Skips entries with unparseable URLs.
  */
 export declare function storedToMergedPRs(stored: StoredMergedPR[]): MergedPR[];
+/**
+ * Convert StoredClosedPR[] to ClosedPR[] by deriving repo and number from URL.
+ * Skips entries with unparseable URLs.
+ */
+export declare function storedToClosedPRs(stored: StoredClosedPR[]): ClosedPR[];
 /**
  * Compute PRs grouped by repository from a digest and state.
  * Used for chart data in the dashboard API.

package/dist/commands/dashboard-data.js

@@ -6,12 +6,12 @@
 import { getStateManager, PRMonitor, IssueConversationMonitor, getOctokit } from '../core/index.js';
 import { errorMessage, isRateLimitOrAuthError } from '../core/errors.js';
 import { warn } from '../core/logger.js';
-import { emptyPRCountsResult, fetchMergedPRsSince } from '../core/github-stats.js';
+import { emptyPRCountsResult, fetchMergedPRsSince, fetchClosedPRsSince } from '../core/github-stats.js';
 import { parseGitHubUrl } from '../core/utils.js';
 import { isBelowMinStars, } from '../core/types.js';
 import { toShelvedPRRef, buildStarFilter } from './daily.js';
 const MODULE = 'dashboard-data';
-export function buildDashboardStats(digest, state, storedMergedCount) {
+export function buildDashboardStats(digest, state, storedMergedCount, storedClosedCount) {
     const summary = digest.summary || {
         totalActivePRs: 0,
         totalMergedAllTime: 0,
@@ -19,16 +19,19 @@ export function buildDashboardStats(digest, state, storedMergedCount) {
         totalNeedingAttention: 0,
     };
     const minStars = state.config.minStars ?? 50;
-    // Use the higher of stored merged PR count and repoScores-derived count to avoid regressions
-    // when stored list hasn't caught up yet (first fetch caps at 300)
+    // Merged: use the higher of stored count vs repoScores aggregate to avoid regressions
+    // when the stored list hasn't caught up yet (initial fetch caps at 300 PRs)
     const mergedPRs = storedMergedCount !== undefined
         ? Math.max(storedMergedCount, summary.totalMergedAllTime)
         : summary.totalMergedAllTime;
+    // Closed: same anti-regression strategy — use the higher of stored count vs repoScores aggregate
+    const aggregateClosedCount = Object.values(state.repoScores || {}).reduce((sum, s) => sum + (isBelowMinStars(s.stargazersCount, minStars) ? 0 : s.closedWithoutMergeCount || 0), 0);
+    const closedPRs = storedClosedCount !== undefined ? Math.max(storedClosedCount, aggregateClosedCount) : aggregateClosedCount;
     return {
         activePRs: summary.totalActivePRs,
         shelvedPRs: (digest.shelvedPRs || []).length,
         mergedPRs,
-        closedPRs: Object.values(state.repoScores || {}).reduce((sum, s) => sum + (isBelowMinStars(s.stargazersCount, minStars) ? 0 : s.closedWithoutMergeCount || 0), 0),
+        closedPRs,
         mergeRate: `${(summary.mergeRate ?? 0).toFixed(1)}%`,
     };
 }
@@ -102,9 +105,10 @@ export async function fetchDashboardData(token) {
     const config = stateManager.getState().config;
     // Build star filter from cached repoScores (#576)
     const starFilter = buildStarFilter(stateManager.getState());
-    // Get watermark for incremental merged PR fetch
+    // Get watermarks for incremental PR fetch
     const watermark = stateManager.getMergedPRWatermark();
-    const [{ prs, failures }, recentlyClosedPRs, recentlyMergedPRs, mergedResult, closedResult, fetchedIssues, newMergedPRs,] = await Promise.all([
+    const closedWatermark = stateManager.getClosedPRWatermark();
+    const [{ prs, failures }, recentlyClosedPRs, recentlyMergedPRs, mergedResult, closedResult, fetchedIssues, newMergedPRs, newClosedPRs,] = await Promise.all([
         prMonitor.fetchUserOpenPRs(),
         prMonitor.fetchRecentlyClosedPRs().catch((err) => {
             if (isRateLimitOrAuthError(err))
@@ -151,6 +155,12 @@ export async function fetchDashboardData(token) {
             warn(MODULE, `Failed to fetch merged PRs for storage: ${errorMessage(err)}`);
             return [];
         }),
+        fetchClosedPRsSince(octokit, config, closedWatermark).catch((err) => {
+            if (isRateLimitOrAuthError(err))
+                throw err;
+            warn(MODULE, `Failed to fetch closed PRs for storage: ${errorMessage(err)}`);
+            return [];
+        }),
     ]);
     const commentedIssues = fetchedIssues.issues;
     if (fetchedIssues.failures.length > 0) {
@@ -166,8 +176,16 @@ export async function fetchDashboardData(token) {
     catch (error) {
         warn(MODULE, `Failed to store merged PRs: ${errorMessage(error)}`);
     }
-    // Convert stored merged PRs to full MergedPR type (derive repo/number from URL)
+    // Store new closed PRs incrementally (dedupes by URL)
+    try {
+        stateManager.addClosedPRs(newClosedPRs);
+    }
+    catch (error) {
+        warn(MODULE, `Failed to store closed PRs: ${errorMessage(error)}`);
+    }
+    // Convert stored PRs to full types (derive repo/number from URL)
     const allMergedPRs = storedToMergedPRs(stateManager.getMergedPRs());
+    const allClosedPRs = storedToClosedPRs(stateManager.getClosedPRs());
     // Store monthly chart data (opened/merged/closed) so charts have data
     const { monthlyCounts, monthlyOpenedCounts: openedFromMerged } = mergedResult;
     const { monthlyCounts: monthlyClosedCounts, monthlyOpenedCounts: openedFromClosed } = closedResult;
@@ -188,7 +206,7 @@ export async function fetchDashboardData(token) {
         warn(MODULE, `Failed to save dashboard digest to state: ${errorMessage(error)}`);
     }
     warn(MODULE, `Refreshed: ${prs.length} PRs fetched`);
-    return { digest, commentedIssues, allMergedPRs };
+    return { digest, commentedIssues, allMergedPRs, allClosedPRs };
 }
 /**
  * Convert StoredMergedPR[] to MergedPR[] by deriving repo and number from URL.
@@ -216,6 +234,32 @@ export function storedToMergedPRs(stored) {
     }
     return results;
 }
+/**
+ * Convert StoredClosedPR[] to ClosedPR[] by deriving repo and number from URL.
+ * Skips entries with unparseable URLs.
+ */
+export function storedToClosedPRs(stored) {
+    const results = [];
+    let skipped = 0;
+    for (const pr of stored) {
+        const parsed = parseGitHubUrl(pr.url);
+        if (!parsed) {
+            skipped++;
+            continue;
+        }
+        results.push({
+            url: pr.url,
+            repo: `${parsed.owner}/${parsed.repo}`,
+            number: parsed.number,
+            title: pr.title,
+            closedAt: pr.closedAt,
+        });
+    }
+    if (skipped > 0) {
+        warn(MODULE, `Skipped ${skipped} stored closed PR(s) with unparseable URLs`);
+    }
+    return results;
+}
 /**
  * Compute PRs grouped by repository from a digest and state.
  * Used for chart data in the dashboard API.

package/dist/commands/dashboard-lifecycle.js

@@ -102,7 +102,7 @@ export async function launchDashboardServer(options) {
         if (info) {
             // PID file appeared — verify the server is responding
             if (await isDashboardServerRunning(info.port)) {
-                return { url: `http://localhost:${info.port}`, port: info.port, alreadyRunning: false };
+                return { url: `http://oss.localhost:${info.port}`, port: info.port, alreadyRunning: false };
             }
         }
     }

package/dist/commands/dashboard-process.js

@@ -85,7 +85,7 @@ export async function findRunningDashboardServer() {
     }
     // Process exists — verify it's actually our server via HTTP probe
     if (await isDashboardServerRunning(info.port)) {
-        return { port: info.port, url: `http://localhost:${info.port}` };
+        return { port: info.port, url: `http://oss.localhost:${info.port}` };
     }
     // Process exists but not responding on expected port — stale
     removeDashboardServerInfo();

package/dist/commands/dashboard-server.js

@@ -8,11 +8,11 @@
 import * as http from 'http';
 import * as fs from 'fs';
 import * as path from 'path';
-import { getStateManager, getGitHubToken, getCLIVersion } from '../core/index.js';
+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 } from './validation.js';
-import { fetchDashboardData, computePRsByRepo, computeTopRepos, getMonthlyData, buildDashboardStats, storedToMergedPRs, } from './dashboard-data.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';
 import { RateLimiter } from './rate-limiter.js';
@@ -33,57 +33,24 @@ const MIME_TYPES = {
     '.png': 'image/png',
     '.ico': 'image/x-icon',
 };
-/**
- * Apply status overrides from state to the PR list.
- * Overrides are auto-cleared if the PR has new activity since the override was set.
- */
-function applyStatusOverrides(prs, state) {
-    const overrides = state.config.statusOverrides;
-    if (!overrides || Object.keys(overrides).length === 0)
-        return prs;
-    const stateManager = getStateManager();
-    // Snapshot keys before iteration — clearStatusOverride mutates the same object
-    const overrideUrls = new Set(Object.keys(overrides));
-    let didAutoClear = false;
-    const result = prs.map((pr) => {
-        const override = stateManager.getStatusOverride(pr.url, pr.updatedAt);
-        if (!override) {
-            if (overrideUrls.has(pr.url))
-                didAutoClear = true;
-            return pr;
-        }
-        if (override.status === pr.status)
-            return pr;
-        return { ...pr, status: override.status };
-    });
-    // Persist any auto-cleared overrides so they don't resurrect on restart
-    if (didAutoClear) {
-        try {
-            stateManager.save();
-        }
-        catch (err) {
-            warn(MODULE, `Failed to persist auto-cleared overrides — they may reappear on restart: ${errorMessage(err)}`);
-        }
-    }
-    return result;
-}
 // ── Helpers ────────────────────────────────────────────────────────────────────
 /**
  * Build the JSON payload that the SPA expects from GET /api/data.
  */
-function buildDashboardJson(digest, state, commentedIssues, allMergedPRs) {
+function buildDashboardJson(digest, state, commentedIssues, allMergedPRs, allClosedPRs) {
     const prsByRepo = computePRsByRepo(digest, state);
     const topRepos = computeTopRepos(prsByRepo);
     const { monthlyMerged, monthlyOpened, monthlyClosed } = getMonthlyData(state);
-    // Derive allMergedPRs from state if not provided (e.g. initial load from cached state)
+    // Derive from state if not provided (e.g. initial load from cached state)
     const mergedPRs = allMergedPRs ?? storedToMergedPRs(getStateManager().getMergedPRs());
-    // Filter out merged PRs from repos below the minStars threshold
+    const closedPRs = allClosedPRs ?? storedToClosedPRs(getStateManager().getClosedPRs());
+    // Filter out PRs from repos below the minStars threshold
     const minStars = state.config.minStars ?? 50;
-    const filteredMergedPRs = mergedPRs.filter((pr) => {
-        const repoScore = (state.repoScores || {})[pr.repo];
-        return !isBelowMinStars(repoScore?.stargazersCount, minStars);
-    });
-    const stats = buildDashboardStats(digest, state, filteredMergedPRs.length);
+    const repoScores = state.repoScores || {};
+    const isAboveMinStars = (pr) => !isBelowMinStars(repoScores[pr.repo]?.stargazersCount, minStars);
+    const filteredMergedPRs = mergedPRs.filter(isAboveMinStars);
+    const filteredClosedPRs = closedPRs.filter(isAboveMinStars);
+    const stats = buildDashboardStats(digest, state, filteredMergedPRs.length, filteredClosedPRs.length);
     const issueResponses = commentedIssues.filter((i) => i.status === 'new_response');
     return {
         stats,
@@ -100,6 +67,7 @@ function buildDashboardJson(digest, state, commentedIssues, allMergedPRs) {
         commentedIssues,
         issueResponses,
         allMergedPRs: filteredMergedPRs,
+        allClosedPRs: filteredClosedPRs,
     };
 }
 /**
@@ -339,7 +307,7 @@ export async function startDashboardServer(options) {
             const result = await fetchDashboardData(currentToken);
             cachedDigest = result.digest;
             cachedCommentedIssues = result.commentedIssues;
-            cachedJsonData = buildDashboardJson(cachedDigest, stateManager.getState(), cachedCommentedIssues, result.allMergedPRs);
+            cachedJsonData = buildDashboardJson(cachedDigest, stateManager.getState(), cachedCommentedIssues, result.allMergedPRs, result.allClosedPRs);
             sendJson(res, 200, cachedJsonData);
         }
         catch (error) {
@@ -442,8 +410,8 @@ export async function startDashboardServer(options) {
         startedAt: new Date().toISOString(),
         version: getCLIVersion(),
     });
-    const serverUrl = `http://localhost:${actualPort}`;
-    warn(MODULE, `Dashboard server running at ${serverUrl} (also: http://oss.localhost:${actualPort})`);
+    const serverUrl = `http://oss.localhost:${actualPort}`;
+    warn(MODULE, `Dashboard server running at ${serverUrl} (also: http://localhost:${actualPort})`);
     // ── Background refresh ─────────────────────────────────────────────────
     // Port is bound and PID file written — now fetch fresh data from GitHub
     // so subsequent /api/data requests get live data instead of cached state.
@@ -452,7 +420,7 @@ export async function startDashboardServer(options) {
             .then((result) => {
             cachedDigest = result.digest;
             cachedCommentedIssues = result.commentedIssues;
-            cachedJsonData = buildDashboardJson(cachedDigest, stateManager.getState(), cachedCommentedIssues, result.allMergedPRs);
+            cachedJsonData = buildDashboardJson(cachedDigest, stateManager.getState(), cachedCommentedIssues, result.allMergedPRs, result.allClosedPRs);
             warn(MODULE, 'Background data refresh complete');
         })
             .catch((error) => {

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

@@ -10,7 +10,7 @@
  *   - formatActionHint — human-readable maintainer action hint label
  *   - formatBriefSummary / formatSummary / printDigest — rendering
  */
-import type { FetchedPR, FetchedPRStatus, StalenessTier, ActionReason, DailyDigest, ShelvedPRRef, MaintainerActionHint, ComputedRepoSignals, RepoGroup, CommentedIssue, CommentedIssueWithResponse } from './types.js';
+import type { FetchedPR, FetchedPRStatus, StalenessTier, ActionReason, DailyDigest, AgentState, ShelvedPRRef, MaintainerActionHint, ComputedRepoSignals, RepoGroup, CommentedIssue, CommentedIssueWithResponse } from './types.js';
 import type { CapacityAssessment, ActionableIssue, ActionMenu } from '../formatters/json.js';
 /**
  * Statuses indicating action needed from the contributor.
@@ -25,6 +25,7 @@ export declare const CRITICAL_STATUSES: ReadonlySet<FetchedPRStatus>;
 export declare const CRITICAL_ACTION_REASONS: ReadonlySet<ActionReason>;
 /** Staleness tiers indicating staleness — maintainer comments during these tiers don't count as responsive. */
 export declare const STALE_STATUSES: ReadonlySet<StalenessTier>;
+export declare function applyStatusOverrides(prs: FetchedPR[], state: Readonly<AgentState>): FetchedPR[];
 /**
  * Map a full FetchedPR to a lightweight ShelvedPRRef for digest output.
  * Only the fields needed for display are retained, reducing JSON payload size.
@@ -53,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>): ActionableIssue[];
+export declare function collectActionableIssues(prs: FetchedPR[], snoozedUrls?: Set<string>, lastDigestAt?: string): ActionableIssue[];
 /**
  * Format a maintainer action hint as a human-readable label
  */

package/dist/core/daily-logic.js

@@ -12,6 +12,8 @@
  */
 import { formatRelativeTime } from './utils.js';
 import { warn } from './logger.js';
+import { errorMessage } from './errors.js';
+import { getStateManager } from './state.js';
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
@@ -34,6 +36,62 @@ export const CRITICAL_ACTION_REASONS = new Set([
 /** Staleness tiers indicating staleness — maintainer comments during these tiers don't count as responsive. */
 export const STALE_STATUSES = new Set(['dormant', 'approaching_dormant']);
 // ---------------------------------------------------------------------------
+// Status overrides
+// ---------------------------------------------------------------------------
+/**
+ * Apply status overrides from state to the PR list.
+ * Overrides are auto-cleared if the PR has new activity since the override was set.
+ *
+ * When an override changes the status, the contradictory reason field is cleared
+ * and an appropriate default is set so downstream logic (assessCapacity, collectActionableIssues)
+ * works correctly.
+ */
+const VALID_OVERRIDE_STATUSES = new Set(['needs_addressing', 'waiting_on_maintainer']);
+export function applyStatusOverrides(prs, state) {
+    const overrides = state.config.statusOverrides;
+    if (!overrides || Object.keys(overrides).length === 0)
+        return prs;
+    const stateManager = getStateManager();
+    // Snapshot keys before iteration — clearStatusOverride mutates the same object
+    const overrideUrls = new Set(Object.keys(overrides));
+    let didAutoClear = false;
+    const result = prs.map((pr) => {
+        try {
+            const override = stateManager.getStatusOverride(pr.url, pr.updatedAt);
+            if (!override) {
+                if (overrideUrls.has(pr.url))
+                    didAutoClear = true;
+                return pr;
+            }
+            if (!VALID_OVERRIDE_STATUSES.has(override.status)) {
+                warn('daily-logic', `Invalid override status "${override.status}" for ${pr.url} — ignoring`);
+                return pr;
+            }
+            if (override.status === pr.status)
+                return pr;
+            // Clear the contradictory reason field and set an appropriate default
+            if (override.status === 'waiting_on_maintainer') {
+                return { ...pr, status: override.status, actionReason: undefined, waitReason: 'pending_review' };
+            }
+            return { ...pr, status: override.status, waitReason: undefined, actionReason: 'needs_response' };
+        }
+        catch (err) {
+            warn('daily-logic', `Failed to apply status override for ${pr.url}: ${errorMessage(err)}`);
+            return pr;
+        }
+    });
+    // Persist any auto-cleared overrides so they don't resurrect on restart
+    if (didAutoClear) {
+        try {
+            stateManager.save();
+        }
+        catch (err) {
+            warn('daily-logic', `Failed to persist auto-cleared overrides — they may reappear on restart: ${errorMessage(err)}`);
+        }
+    }
+    return result;
+}
+// ---------------------------------------------------------------------------
 // Internal helpers
 // ---------------------------------------------------------------------------
 /**
@@ -140,9 +198,10 @@ 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()) {
+export function collectActionableIssues(prs, snoozedUrls = new Set(), lastDigestAt) {
     const issues = [];
     const actionPRs = prs.filter((pr) => pr.status === 'needs_addressing');
+    const lastDigestTime = lastDigestAt ? new Date(lastDigestAt).getTime() : NaN;
     const reasonOrder = [
         'needs_response',
         'needs_changes',
@@ -191,7 +250,18 @@ export function collectActionableIssues(prs, snoozedUrls = new Set()) {
                     label = `[${reason}]`;
                     type = 'needs_response';
             }
-            issues.push({ type, pr, label });
+            // A PR is "new" if it was created after the last daily digest (first time seen).
+            // If there's no previous digest (first run) or createdAt is invalid, assume new.
+            const createdTime = new Date(pr.createdAt).getTime();
+            let isNewContribution;
+            if (isNaN(createdTime)) {
+                warn('daily-logic', `Invalid createdAt "${pr.createdAt}" for PR ${pr.url}, assuming new contribution`);
+                isNewContribution = true;
+            }
+            else {
+                isNewContribution = isNaN(lastDigestTime) || createdTime > lastDigestTime;
+            }
+            issues.push({ type, pr, label, isNewContribution });
         }
     }
     return issues;

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, StoredMergedPR, type StarFilter } from './types.js';
+import { ClosedPR, MergedPR, StoredMergedPR, StoredClosedPR, 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. */
@@ -50,3 +50,12 @@ export declare function fetchRecentlyMergedPRs(octokit: Octokit, config: {
 export declare function fetchMergedPRsSince(octokit: Octokit, config: {
     githubUsername: string;
 }, since?: string): Promise<StoredMergedPR[]>;
+/**
+ * Fetch closed-without-merge PRs since a watermark date for incremental storage.
+ * If no watermark is provided (first-ever fetch), fetches all closed PRs (up to pagination cap).
+ * Returns StoredClosedPR[] (minimal: url, title, closedAt) for state persistence.
+ * Uses `is:unmerged` to exclude merged PRs (which are also "closed" in GitHub's model).
+ */
+export declare function fetchClosedPRsSince(octokit: Octokit, config: {
+    githubUsername: string;
+}, since?: string): Promise<StoredClosedPR[]>;

package/dist/core/github-stats.js

@@ -287,3 +287,61 @@ export async function fetchMergedPRsSince(octokit, config, since) {
     debug(MODULE, `Fetched ${results.length} merged PRs${since ? ' (incremental)' : ' (initial)'}`);
     return results;
 }
+/**
+ * Fetch closed-without-merge PRs since a watermark date for incremental storage.
+ * If no watermark is provided (first-ever fetch), fetches all closed PRs (up to pagination cap).
+ * Returns StoredClosedPR[] (minimal: url, title, closedAt) for state persistence.
+ * Uses `is:unmerged` to exclude merged PRs (which are also "closed" in GitHub's model).
+ */
+export async function fetchClosedPRsSince(octokit, config, since) {
+    if (!config.githubUsername) {
+        warn(MODULE, 'Skipping closed PRs fetch: no githubUsername configured.');
+        return [];
+    }
+    const dateFilter = since ? ` closed:>${since}` : '';
+    const q = `is:pr is:closed is:unmerged author:${config.githubUsername} -user:${config.githubUsername}${dateFilter}`;
+    debug(MODULE, `Fetching closed PRs${since ? ` since ${since}` : ' (all time)'}...`);
+    const results = [];
+    let page = 1;
+    let fetched = 0;
+    let totalCount;
+    while (true) {
+        const { data } = await octokit.search.issuesAndPullRequests({
+            q,
+            sort: 'updated',
+            order: 'desc',
+            per_page: 100,
+            page,
+        });
+        totalCount = data.total_count;
+        for (const item of data.items) {
+            const parsed = parseGitHubUrl(item.html_url);
+            if (!parsed) {
+                warn(MODULE, `Skipping closed PR with unparseable URL: ${item.html_url}`);
+                continue;
+            }
+            if (isOwnRepo(parsed.owner, config.githubUsername))
+                continue;
+            const closedAt = item.closed_at || '';
+            if (!closedAt) {
+                warn(MODULE, `Skipping closed PR with no close date: ${item.html_url}`);
+                continue;
+            }
+            results.push({
+                url: item.html_url,
+                title: item.title,
+                closedAt,
+            });
+        }
+        fetched += data.items.length;
+        if (fetched >= totalCount || fetched >= 1000 || data.items.length === 0 || page >= MAX_PAGINATION_PAGES) {
+            break;
+        }
+        page++;
+    }
+    if (fetched < totalCount && page >= MAX_PAGINATION_PAGES) {
+        warn(MODULE, `Pagination capped at ${MAX_PAGINATION_PAGES} pages: fetched ${fetched} of ${totalCount} closed PRs. Oldest PRs may be missing.`);
+    }
+    debug(MODULE, `Fetched ${results.length} closed PRs${since ? ' (incremental)' : ' (initial)'}`);
+    return results;
+}

package/dist/core/index.d.ts

@@ -12,7 +12,7 @@ export { parseGitHubUrl, daysBetween, splitRepo, isOwnRepo, getCLIVersion, getDa
 export { OssAutopilotError, ConfigurationError, ValidationError, errorMessage, getHttpStatusCode, isRateLimitError, isRateLimitOrAuthError, } from './errors.js';
 export { enableDebug, isDebugEnabled, debug, info, warn, timed } from './logger.js';
 export { HttpCache, getHttpCache, cachedRequest, type CacheEntry } from './http-cache.js';
-export { CRITICAL_STATUSES, computeRepoSignals, groupPRsByRepo, assessCapacity, collectActionableIssues, computeActionMenu, toShelvedPRRef, formatActionHint, formatBriefSummary, formatSummary, printDigest, } from './daily-logic.js';
+export { CRITICAL_STATUSES, applyStatusOverrides, computeRepoSignals, groupPRsByRepo, assessCapacity, collectActionableIssues, computeActionMenu, toShelvedPRRef, formatActionHint, formatBriefSummary, formatSummary, printDigest, } from './daily-logic.js';
 export { computeContributionStats, type ContributionStats, type ComputeStatsInput } from './stats.js';
 export { fetchPRTemplate, type PRTemplateResult } from './pr-template.js';
 export * from './types.js';

package/dist/core/index.js

@@ -12,7 +12,7 @@ export { parseGitHubUrl, daysBetween, splitRepo, isOwnRepo, getCLIVersion, getDa
 export { OssAutopilotError, ConfigurationError, ValidationError, errorMessage, getHttpStatusCode, isRateLimitError, isRateLimitOrAuthError, } from './errors.js';
 export { enableDebug, isDebugEnabled, debug, info, warn, timed } from './logger.js';
 export { HttpCache, getHttpCache, cachedRequest } from './http-cache.js';
-export { CRITICAL_STATUSES, computeRepoSignals, groupPRsByRepo, assessCapacity, collectActionableIssues, computeActionMenu, toShelvedPRRef, formatActionHint, formatBriefSummary, formatSummary, printDigest, } from './daily-logic.js';
+export { CRITICAL_STATUSES, applyStatusOverrides, computeRepoSignals, groupPRsByRepo, assessCapacity, collectActionableIssues, computeActionMenu, toShelvedPRRef, formatActionHint, formatBriefSummary, formatSummary, printDigest, } from './daily-logic.js';
 export { computeContributionStats } from './stats.js';
 export { fetchPRTemplate } from './pr-template.js';
 export * from './types.js';