@oss-autopilot/core 0.49.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 } 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,7 +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']);
+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;
@@ -51,7 +51,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,
@@ -244,10 +245,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 — move is PR-only, dismiss_issue_response is issue-only.
+        const isDismiss = body.action === 'dismiss_issue_response';
         try {
             validateUrl(body.url);
-            validateGitHubUrl(body.url, PR_URL_PATTERN, 'PR');
+            validateGitHubUrl(body.url, isDismiss ? ISSUE_URL_PATTERN : PR_URL_PATTERN, isDismiss ? 'issue' : 'PR');
         }
         catch (err) {
             if (err instanceof ValidationError) {
@@ -259,32 +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;
                 }
+                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/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/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/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

@@ -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) {
@@ -294,10 +292,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