@oss-autopilot/core 0.48.0 → 0.50.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-server.js

@@ -8,10 +8,10 @@
 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 { validateUrl, validateGitHubUrl, PR_URL_PATTERN, ISSUE_OR_PR_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,7 +20,12 @@ 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']);
+const VALID_ACTIONS = new Set([
+    'shelve',
+    'unshelve',
+    'override_status',
+    'dismiss_issue_response',
+]);
 const MODULE = 'dashboard-server';
 const MAX_BODY_BYTES = 10_240;
 const REQUEST_TIMEOUT_MS = 30_000;
@@ -33,40 +38,6 @@ 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.
@@ -85,7 +56,8 @@ function buildDashboardJson(digest, state, commentedIssues, allMergedPRs, allClo
     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');
+    const dismissedIssues = state.config.dismissedIssues || {};
+    const issueResponses = commentedIssues.filter((i) => i.status === 'new_response' && !(i.url in dismissedIssues));
     return {
         stats,
         prsByRepo,
@@ -278,10 +250,11 @@ export async function startDashboardServer(options) {
             sendError(res, 400, 'Missing or invalid "url" field');
             return;
         }
-        // Validate URL format — all actions are PR-only now.
+        // Validate URL format — dismiss_issue_response accepts issue or PR URLs, others are PR-only.
+        const isDismiss = body.action === 'dismiss_issue_response';
         try {
             validateUrl(body.url);
-            validateGitHubUrl(body.url, PR_URL_PATTERN, 'PR');
+            validateGitHubUrl(body.url, isDismiss ? ISSUE_OR_PR_URL_PATTERN : PR_URL_PATTERN, isDismiss ? 'issue or PR' : 'PR');
         }
         catch (err) {
             if (err instanceof ValidationError) {
@@ -317,6 +290,9 @@ export async function startDashboardServer(options) {
                     stateManager.setStatusOverride(body.url, overrideStatus, lastActivityAt);
                     break;
                 }
+                case 'dismiss_issue_response':
+                    stateManager.dismissIssue(body.url, new Date().toISOString());
+                    break;
             }
             stateManager.save();
         }

package/dist/commands/setup.d.ts

@@ -2,6 +2,7 @@
  * Setup command
  * Interactive setup / configuration
  */
+import { type ProjectCategory } from '../core/types.js';
 interface SetupOptions {
     reset?: boolean;
     set?: string[];
@@ -20,6 +21,8 @@ export interface SetupCompleteOutput {
         approachingDormantDays: number;
         languages: string[];
         labels: string[];
+        projectCategories: ProjectCategory[];
+        preferredOrgs: string[];
     };
 }
 export interface SetupPrompt {

package/dist/commands/setup.js

@@ -5,6 +5,7 @@
 import { getStateManager, DEFAULT_CONFIG } from '../core/index.js';
 import { ValidationError } from '../core/errors.js';
 import { validateGitHubUsername } from './validation.js';
+import { PROJECT_CATEGORIES } from '../core/types.js';
 /** Parse and validate a positive integer setting value. */
 function parsePositiveInt(value, settingName) {
     const parsed = Number(value);
@@ -111,6 +112,51 @@ export async function runSetup(options) {
                     results[key] = valid.length > 0 ? valid.join(', ') : '(empty)';
                     break;
                 }
+                case 'projectCategories': {
+                    const categories = value
+                        .split(',')
+                        .map((c) => c.trim())
+                        .filter(Boolean);
+                    const validCategories = [];
+                    const invalidCategories = [];
+                    for (const cat of categories) {
+                        if (PROJECT_CATEGORIES.includes(cat)) {
+                            validCategories.push(cat);
+                        }
+                        else {
+                            invalidCategories.push(cat);
+                        }
+                    }
+                    if (invalidCategories.length > 0) {
+                        warnings.push(`Unknown project categories: ${invalidCategories.join(', ')}. Valid: ${PROJECT_CATEGORIES.join(', ')}`);
+                    }
+                    const dedupedCategories = [...new Set(validCategories)];
+                    stateManager.updateConfig({ projectCategories: dedupedCategories });
+                    results[key] = dedupedCategories.length > 0 ? dedupedCategories.join(', ') : '(empty)';
+                    break;
+                }
+                case 'preferredOrgs': {
+                    const orgs = value
+                        .split(',')
+                        .map((o) => o.trim())
+                        .filter(Boolean);
+                    const validOrgs = [];
+                    for (const org of orgs) {
+                        if (org.includes('/')) {
+                            warnings.push(`"${org}" looks like a repo path. Use org name only (e.g., "vercel" not "vercel/next.js").`);
+                        }
+                        else if (!/^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?$/.test(org)) {
+                            warnings.push(`"${org}" is not a valid GitHub organization name. Skipping.`);
+                        }
+                        else {
+                            validOrgs.push(org.toLowerCase());
+                        }
+                    }
+                    const dedupedOrgs = [...new Set(validOrgs)];
+                    stateManager.updateConfig({ preferredOrgs: dedupedOrgs });
+                    results[key] = dedupedOrgs.length > 0 ? dedupedOrgs.join(', ') : '(empty)';
+                    break;
+                }
                 case 'complete':
                     if (value === 'true') {
                         stateManager.markSetupComplete();
@@ -135,6 +181,8 @@ export async function runSetup(options) {
                 approachingDormantDays: config.approachingDormantDays,
                 languages: config.languages,
                 labels: config.labels,
+                projectCategories: config.projectCategories ?? [],
+                preferredOrgs: config.preferredOrgs ?? [],
             },
         };
     }
@@ -191,6 +239,20 @@ export async function runSetup(options) {
                 default: ['matplotlib/matplotlib'],
                 type: 'list',
             },
+            {
+                setting: 'projectCategories',
+                prompt: 'What types of projects interest you? (nonprofit, devtools, infrastructure, web-frameworks, data-ml, education)',
+                current: config.projectCategories ?? [],
+                default: [],
+                type: 'list',
+            },
+            {
+                setting: 'preferredOrgs',
+                prompt: 'Any GitHub organizations to prioritize? (org names, comma-separated)',
+                current: config.preferredOrgs ?? [],
+                default: [],
+                type: 'list',
+            },
         ],
     };
 }

package/dist/core/category-mapping.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Category Mapping — static mappings from project categories to GitHub topics and organizations.
+ *
+ * Used by issue discovery to prioritize repos matching user's category preferences.
+ */
+import type { ProjectCategory } from './types.js';
+/** GitHub topics associated with each project category, used for `topic:` search queries. */
+export declare const CATEGORY_TOPICS: Record<ProjectCategory, string[]>;
+/** Well-known GitHub organizations associated with each project category. */
+export declare const CATEGORY_ORGS: Record<ProjectCategory, string[]>;
+/**
+ * Check if a repo belongs to any of the given categories based on its owner matching a category org.
+ * Comparison is case-insensitive.
+ */
+export declare function repoBelongsToCategory(repoFullName: string, categories: ProjectCategory[]): boolean;
+/**
+ * Get deduplicated GitHub topics for the given categories, for use in `topic:` search queries.
+ */
+export declare function getTopicsForCategories(categories: ProjectCategory[]): string[];

package/dist/core/category-mapping.js

@@ -0,0 +1,58 @@
+/**
+ * Category Mapping — static mappings from project categories to GitHub topics and organizations.
+ *
+ * Used by issue discovery to prioritize repos matching user's category preferences.
+ */
+/** GitHub topics associated with each project category, used for `topic:` search queries. */
+export const CATEGORY_TOPICS = {
+    nonprofit: ['nonprofit', 'social-good', 'humanitarian', 'charity', 'social-impact', 'civic-tech'],
+    devtools: ['developer-tools', 'devtools', 'cli', 'sdk', 'linter', 'formatter', 'build-tool'],
+    infrastructure: ['infrastructure', 'cloud', 'kubernetes', 'docker', 'devops', 'monitoring', 'observability'],
+    'web-frameworks': ['web-framework', 'frontend', 'backend', 'fullstack', 'nextjs', 'react', 'vue'],
+    'data-ml': ['machine-learning', 'data-science', 'deep-learning', 'nlp', 'data-pipeline', 'analytics'],
+    education: ['education', 'learning', 'tutorial', 'courseware', 'edtech', 'teaching'],
+};
+/** Well-known GitHub organizations associated with each project category. */
+export const CATEGORY_ORGS = {
+    nonprofit: ['code-for-america', 'opengovfoundation', 'ushahidi', 'hotosm', 'openfn', 'democracyearth'],
+    devtools: ['eslint', 'prettier', 'vitejs', 'biomejs', 'oxc-project', 'ast-grep', 'turbot'],
+    infrastructure: ['kubernetes', 'hashicorp', 'grafana', 'prometheus', 'open-telemetry', 'envoyproxy', 'cncf'],
+    'web-frameworks': ['vercel', 'remix-run', 'sveltejs', 'nuxt', 'astro', 'redwoodjs', 'blitz-js'],
+    'data-ml': ['huggingface', 'mlflow', 'apache', 'dbt-labs', 'dagster-io', 'prefecthq', 'langchain-ai'],
+    education: ['freeCodeCamp', 'TheOdinProject', 'exercism', 'codecademy', 'oppia', 'Khan'],
+};
+/**
+ * Check if a repo belongs to any of the given categories based on its owner matching a category org.
+ * Comparison is case-insensitive.
+ */
+export function repoBelongsToCategory(repoFullName, categories) {
+    if (categories.length === 0)
+        return false;
+    const owner = repoFullName.split('/')[0]?.toLowerCase();
+    if (!owner)
+        return false;
+    for (const category of categories) {
+        const orgs = CATEGORY_ORGS[category];
+        if (!orgs)
+            continue; // Guard against invalid categories from hand-edited state.json
+        if (orgs.some((org) => org.toLowerCase() === owner)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Get deduplicated GitHub topics for the given categories, for use in `topic:` search queries.
+ */
+export function getTopicsForCategories(categories) {
+    const topics = new Set();
+    for (const category of categories) {
+        const categoryTopics = CATEGORY_TOPICS[category];
+        if (!categoryTopics)
+            continue; // Guard against invalid categories from hand-edited state.json
+        for (const topic of categoryTopics) {
+            topics.add(topic);
+        }
+    }
+    return [...topics];
+}

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;
@@ -224,10 +294,15 @@ export function computeActionMenu(actionableIssues, capacity, commentedIssues =
     const hasActionableIssues = actionableIssues.length > 0;
     const hasIssueResponses = issueResponses.length > 0;
     if (hasActionableIssues) {
+        const isSingle = actionableIssues.length === 1;
         items.push({
             key: 'address_all',
-            label: `Work through all ${actionableIssues.length} issue${actionableIssues.length === 1 ? '' : 's'} (Recommended)`,
-            description: 'Run maintenance in parallel, then address code changes one at a time',
+            label: isSingle
+                ? 'Address this issue (Recommended)'
+                : `Work through all ${actionableIssues.length} issues (Recommended)`,
+            description: isSingle
+                ? 'Fix the issue blocking your PR'
+                : 'Run maintenance in parallel, then address code changes one at a time',
         });
     }
     // Issue replies — positioned after address_all but before search

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';

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;