@oss-autopilot/core 1.14.0 → 1.15.0

package/dist/commands/daily.js

@@ -7,7 +7,7 @@
  * orchestration layer that wires up the phases and handles I/O.
  */
 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 { errorMessage, isRateLimitOrAuthError, nonFatalCatch } from '../core/errors.js';
 import { warn } from '../core/logger.js';
 import { emptyPRCountsResult } from '../core/github-stats.js';
 import { createAutopilotScout } from './scout-bridge.js';
@@ -60,30 +60,21 @@ async function fetchPRData(prMonitor, token) {
     // All stats fetches are non-critical (cosmetic/scoring), so isolate their failure
     const issueMonitor = new IssueConversationMonitor(token);
     const [mergedResult, closedResult, recentlyClosedPRs, recentlyMergedPRs, issueConversationResult] = await Promise.all([
-        prMonitor.fetchUserMergedPRCounts(starFilter).catch((err) => {
-            if (isRateLimitOrAuthError(err))
-                throw err;
-            warn(MODULE, `Failed to fetch merged PR counts: ${errorMessage(err)}`);
-            return emptyPRCountsResult();
-        }),
-        prMonitor.fetchUserClosedPRCounts(starFilter).catch((err) => {
-            if (isRateLimitOrAuthError(err))
-                throw err;
-            warn(MODULE, `Failed to fetch closed PR counts: ${errorMessage(err)}`);
-            return emptyPRCountsResult();
-        }),
-        prMonitor.fetchRecentlyClosedPRs().catch((err) => {
-            if (isRateLimitOrAuthError(err))
-                throw err;
-            warn(MODULE, `Failed to fetch recently closed PRs: ${errorMessage(err)}`);
-            return [];
-        }),
-        prMonitor.fetchRecentlyMergedPRs().catch((err) => {
-            if (isRateLimitOrAuthError(err))
-                throw err;
-            warn(MODULE, `Failed to fetch recently merged PRs: ${errorMessage(err)}`);
-            return [];
-        }),
+        prMonitor.fetchUserMergedPRCounts(starFilter).catch(nonFatalCatch({
+            module: MODULE,
+            label: 'fetch merged PR counts',
+            fallback: emptyPRCountsResult(),
+        })),
+        prMonitor
+            .fetchUserClosedPRCounts(starFilter)
+            .catch(nonFatalCatch({ module: MODULE, label: 'fetch closed PR counts', fallback: emptyPRCountsResult() })),
+        prMonitor
+            .fetchRecentlyClosedPRs()
+            .catch(nonFatalCatch({ module: MODULE, label: 'fetch recently closed PRs', fallback: [] })),
+        prMonitor
+            .fetchRecentlyMergedPRs()
+            .catch(nonFatalCatch({ module: MODULE, label: 'fetch recently merged PRs', fallback: [] })),
+        // Issue conversation fetch has custom messaging based on the error content, so it keeps its bespoke catch.
         issueMonitor.fetchCommentedIssues().catch((error) => {
             if (isRateLimitOrAuthError(error))
                 throw error;

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

@@ -3,7 +3,8 @@
  * 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 ClosedPR, type MergedPR, type StoredMergedPR, type StoredClosedPR, type CommentedIssue } from '../core/types.js';
+import { type DailyDigest, type AgentState, type ClosedPR, type MergedPR, type StoredMergedPR, type StoredClosedPR, type CommentedIssue, type CommentedIssueWithResponse, type FetchedPR, type ShelvedPRRef, type RepoMetadataEntry } from '../core/types.js';
+import type { ParseIssueListOutput } from '../formatters/json.js';
 export interface DashboardStats {
     activePRs: number;
     shelvedPRs: number;
@@ -12,6 +13,42 @@ export interface DashboardStats {
     mergeRate: string;
     availableIssues?: number;
 }
+/**
+ * Shape of the JSON payload served by `GET /api/data` from the dashboard
+ * HTTP server. Single source of truth (#965) — imported by
+ * dashboard-server.ts, which previously redeclared this interface inline
+ * and so silently drifted whenever this module changed shape.
+ */
+export interface DashboardJsonData {
+    stats: DashboardStats;
+    prsByRepo: Record<string, {
+        active: number;
+        merged: number;
+        closed: number;
+    }>;
+    topRepos: Array<{
+        repo: string;
+        active: number;
+        merged: number;
+        closed: number;
+    }>;
+    monthlyMerged: Record<string, number>;
+    monthlyOpened: Record<string, number>;
+    monthlyClosed: Record<string, number>;
+    activePRs: FetchedPR[];
+    shelvedPRUrls: string[];
+    recentlyMergedPRs: MergedPR[];
+    recentlyClosedPRs: ClosedPR[];
+    autoUnshelvedPRs: ShelvedPRRef[];
+    commentedIssues: CommentedIssue[];
+    issueResponses: CommentedIssueWithResponse[];
+    allMergedPRs: MergedPR[];
+    allClosedPRs: ClosedPR[];
+    repoMetadata: Record<string, RepoMetadataEntry>;
+    vettedIssues?: ParseIssueListOutput | null;
+    offline?: boolean;
+    lastUpdated?: string;
+}
 export declare function buildDashboardStats(digest: DailyDigest, state: Readonly<AgentState>, storedMergedCount?: number, storedClosedCount?: number): DashboardStats;
 /**
  * Merge fresh API counts into existing stored counts.

package/dist/commands/dashboard-data.js

@@ -4,7 +4,7 @@
  * Consumed by the dashboard HTTP server (dashboard-server.ts) for the SPA API.
  */
 import { getStateManager, PRMonitor, IssueConversationMonitor, getOctokit } from '../core/index.js';
-import { errorMessage, isRateLimitOrAuthError } from '../core/errors.js';
+import { errorMessage, isRateLimitOrAuthError, nonFatalCatch } from '../core/errors.js';
 import { warn } from '../core/logger.js';
 import { emptyPRCountsResult, fetchMergedPRsSince, fetchClosedPRsSince } from '../core/github-stats.js';
 import { parseGitHubUrl } from '../core/utils.js';
@@ -110,30 +110,21 @@ export async function fetchDashboardData(token) {
     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))
-                throw err;
-            warn(MODULE, `Failed to fetch recently closed PRs: ${errorMessage(err)}`);
-            return [];
-        }),
-        prMonitor.fetchRecentlyMergedPRs().catch((err) => {
-            if (isRateLimitOrAuthError(err))
-                throw err;
-            warn(MODULE, `Failed to fetch recently merged PRs: ${errorMessage(err)}`);
-            return [];
-        }),
-        prMonitor.fetchUserMergedPRCounts(starFilter).catch((err) => {
-            if (isRateLimitOrAuthError(err))
-                throw err;
-            warn(MODULE, `Failed to fetch merged PR counts: ${errorMessage(err)}`);
-            return emptyPRCountsResult();
-        }),
-        prMonitor.fetchUserClosedPRCounts(starFilter).catch((err) => {
-            if (isRateLimitOrAuthError(err))
-                throw err;
-            warn(MODULE, `Failed to fetch closed PR counts: ${errorMessage(err)}`);
-            return emptyPRCountsResult();
-        }),
+        prMonitor
+            .fetchRecentlyClosedPRs()
+            .catch(nonFatalCatch({ module: MODULE, label: 'fetch recently closed PRs', fallback: [] })),
+        prMonitor
+            .fetchRecentlyMergedPRs()
+            .catch(nonFatalCatch({ module: MODULE, label: 'fetch recently merged PRs', fallback: [] })),
+        prMonitor.fetchUserMergedPRCounts(starFilter).catch(nonFatalCatch({
+            module: MODULE,
+            label: 'fetch merged PR counts',
+            fallback: emptyPRCountsResult(),
+        })),
+        prMonitor
+            .fetchUserClosedPRCounts(starFilter)
+            .catch(nonFatalCatch({ module: MODULE, label: 'fetch closed PR counts', fallback: emptyPRCountsResult() })),
+        // Issue conversation fetch has custom messaging based on the error content, so it keeps its bespoke catch.
         issueMonitor.fetchCommentedIssues().catch((error) => {
             if (isRateLimitOrAuthError(error))
                 throw error;
@@ -149,18 +140,8 @@ export async function fetchDashboardData(token) {
                 failures: [{ issueUrl: 'N/A', error: `Issue conversation fetch failed: ${msg}` }],
             };
         }),
-        fetchMergedPRsSince(octokit, config, watermark).catch((err) => {
-            if (isRateLimitOrAuthError(err))
-                throw err;
-            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 [];
-        }),
+        fetchMergedPRsSince(octokit, config, watermark).catch(nonFatalCatch({ module: MODULE, label: 'fetch merged PRs for storage', fallback: [] })),
+        fetchClosedPRsSince(octokit, config, closedWatermark).catch(nonFatalCatch({ module: MODULE, label: 'fetch closed PRs for storage', fallback: [] })),
     ]);
     const commentedIssues = fetchedIssues.issues;
     if (fetchedIssues.failures.length > 0) {
@@ -216,10 +197,12 @@ export async function fetchDashboardData(token) {
     return { digest, commentedIssues, allMergedPRs, allClosedPRs };
 }
 /**
- * Convert StoredMergedPR[] to MergedPR[] by deriving repo and number from URL.
- * Skips entries with unparseable URLs.
+ * Convert a stored-shape PR array (StoredMergedPR[] or StoredClosedPR[]) to
+ * its display-shape equivalent (MergedPR[] / ClosedPR[]) by deriving `repo`
+ * and `number` from the URL. Skips entries whose URL cannot be parsed.
+ * Shared by storedToMergedPRs and storedToClosedPRs (#959).
  */
-export function storedToMergedPRs(stored) {
+function storedToPRs(stored, dateField, label) {
     const results = [];
     let skipped = 0;
     for (const pr of stored) {
@@ -233,39 +216,27 @@ export function storedToMergedPRs(stored) {
             repo: `${parsed.owner}/${parsed.repo}`,
             number: parsed.number,
             title: pr.title,
-            mergedAt: pr.mergedAt,
+            [dateField]: pr[dateField],
         });
     }
     if (skipped > 0) {
-        warn(MODULE, `Skipped ${skipped} stored merged PR(s) with unparseable URLs`);
+        warn(MODULE, `Skipped ${skipped} stored ${label} PR(s) with unparseable URLs`);
     }
     return results;
 }
+/**
+ * Convert StoredMergedPR[] to MergedPR[] by deriving repo and number from URL.
+ * Skips entries with unparseable URLs.
+ */
+export function storedToMergedPRs(stored) {
+    return storedToPRs(stored, 'mergedAt', 'merged');
+}
 /**
  * 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;
+    return storedToPRs(stored, 'closedAt', 'closed');
 }
 /**
  * Compute PRs grouped by repository from a digest and state.

package/dist/commands/scout-bridge.js

@@ -44,6 +44,13 @@ export function buildScoutState() {
             title: pr.title,
             closedAt: pr.closedAt,
         })),
+        // Map ephemeral openPRs (regenerated each daily run) from the last digest
+        // so oss-scout's Phase 0 also searches repos with active-but-unmerged PRs.
+        openPRs: (state.lastDigest?.openPRs ?? []).map((pr) => ({
+            url: pr.url,
+            title: pr.title,
+            openedAt: pr.createdAt,
+        })),
         savedResults: [],
         skippedIssues: [],
         lastRunAt: state.lastRunAt,

package/dist/core/errors.d.ts

@@ -45,6 +45,30 @@ export declare function getHttpStatusCode(error: unknown): number | undefined;
 export declare function isRateLimitError(error: unknown): boolean;
 /** Return true for errors that should propagate (not degrade gracefully): rate limits, auth failures, abuse detection. */
 export declare function isRateLimitOrAuthError(err: unknown): boolean;
+/**
+ * Build a `.catch()` handler for the "non-fatal parallel fetch" pattern used
+ * by daily.ts and dashboard-data.ts (#960). When a sibling fetch fails during
+ * a bulk-parallel orchestration, we want:
+ *
+ * - rate-limit / auth errors to propagate (those abort the whole run — the
+ *   user needs to see them), and
+ * - every other error to log a warning and fall back to a safe default so
+ *   the other siblings can still succeed.
+ *
+ * Inline at each call site, this is ~4 lines of boilerplate repeated 10+
+ * times. Consolidated here so the rate-limit-rethrow rule lives in exactly
+ * one place.
+ *
+ * @example
+ *   prMonitor.fetchRecentlyClosedPRs().catch(
+ *     nonFatalCatch({ module: MODULE, label: 'fetch recently closed PRs', fallback: [] as ClosedPR[] })
+ *   );
+ */
+export declare function nonFatalCatch<T>(params: {
+    module: string;
+    label: string;
+    fallback: T;
+}): (err: unknown) => T;
 /**
  * Map an unknown error to a structured ErrorCode for JSON output.
  * Checks custom error classes, HTTP status codes (Octokit errors),

package/dist/core/errors.js

@@ -7,6 +7,7 @@
  * propagate to the caller via isRateLimitError/isRateLimitOrAuthError.
  * Other errors degrade gracefully — modules return partial results and log warnings.
  */
+import { warn } from './logger.js';
 /**
  * Base error for all oss-autopilot errors.
  */
@@ -87,6 +88,33 @@ export function isRateLimitOrAuthError(err) {
     }
     return false;
 }
+/**
+ * Build a `.catch()` handler for the "non-fatal parallel fetch" pattern used
+ * by daily.ts and dashboard-data.ts (#960). When a sibling fetch fails during
+ * a bulk-parallel orchestration, we want:
+ *
+ * - rate-limit / auth errors to propagate (those abort the whole run — the
+ *   user needs to see them), and
+ * - every other error to log a warning and fall back to a safe default so
+ *   the other siblings can still succeed.
+ *
+ * Inline at each call site, this is ~4 lines of boilerplate repeated 10+
+ * times. Consolidated here so the rate-limit-rethrow rule lives in exactly
+ * one place.
+ *
+ * @example
+ *   prMonitor.fetchRecentlyClosedPRs().catch(
+ *     nonFatalCatch({ module: MODULE, label: 'fetch recently closed PRs', fallback: [] as ClosedPR[] })
+ *   );
+ */
+export function nonFatalCatch(params) {
+    return (err) => {
+        if (isRateLimitOrAuthError(err))
+            throw err;
+        warn(params.module, `Failed to ${params.label}: ${errorMessage(err)}`);
+        return params.fallback;
+    };
+}
 /**
  * Map an unknown error to a structured ErrorCode for JSON output.
  * Checks custom error classes, HTTP status codes (Octokit errors),

package/dist/core/github-stats.js

@@ -235,22 +235,18 @@ export async function fetchRecentlyMergedPRs(octokit, config, days = 7) {
         };
     });
 }
-/**
- * Fetch merged PRs since a watermark date for incremental storage.
- * If no watermark is provided (first-ever fetch), fetches all merged PRs (up to pagination cap).
- * Returns StoredMergedPR[] (minimal: url, title, mergedAt) for state persistence.
- */
-export async function fetchMergedPRsSince(octokit, config, since) {
+async function fetchPRsSince(octokit, config, adapter, since) {
     if (!config.githubUsername) {
-        warn(MODULE, 'Skipping merged PRs fetch: no githubUsername configured.');
+        warn(MODULE, `Skipping ${adapter.kind} PRs fetch: no githubUsername configured.`);
         return [];
     }
-    const dateFilter = since ? ` merged:>${since}` : '';
-    const q = `is:pr is:merged author:${config.githubUsername} -user:${config.githubUsername}${dateFilter}`;
-    debug(MODULE, `Fetching merged PRs${since ? ` since ${since}` : ' (all time)'}...`);
+    const q = adapter.buildQuery(config.githubUsername, since);
+    debug(MODULE, `Fetching ${adapter.kind} PRs${since ? ` since ${since}` : ' (all time)'}...`);
     const results = [];
     let page = 1;
     let fetched = 0;
+    // Populated from the first Search API response; always set before we exit the loop.
+    let totalCount;
     while (true) {
         const { data } = await octokit.search.issuesAndPullRequests({
             q,
@@ -259,34 +255,48 @@ export async function fetchMergedPRsSince(octokit, config, since) {
             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 merged PR with unparseable URL: ${item.html_url}`);
+                warn(MODULE, `Skipping ${adapter.kind} PR with unparseable URL: ${item.html_url}`);
                 continue;
             }
             if (isOwnRepo(parsed.owner, config.githubUsername))
                 continue;
-            const mergedAt = item.pull_request?.merged_at || item.closed_at || '';
-            if (!mergedAt) {
-                warn(MODULE, `Skipping merged PR with no merge date: ${item.html_url}`);
+            const date = adapter.extractDate(item);
+            if (!date) {
+                warn(MODULE, `Skipping ${adapter.kind} PR with no ${adapter.dateNoun} date: ${item.html_url}`);
                 continue;
             }
-            results.push({
-                url: item.html_url,
-                title: item.title,
-                mergedAt,
-            });
+            results.push(adapter.buildRecord(item, date));
         }
         fetched += data.items.length;
-        if (fetched >= data.total_count || fetched >= 1000 || data.items.length === 0 || page >= MAX_PAGINATION_PAGES) {
+        if (fetched >= totalCount || fetched >= 1000 || data.items.length === 0 || page >= MAX_PAGINATION_PAGES) {
             break;
         }
         page++;
     }
-    debug(MODULE, `Fetched ${results.length} merged PRs${since ? ' (incremental)' : ' (initial)'}`);
+    if (fetched < totalCount && page >= MAX_PAGINATION_PAGES) {
+        warn(MODULE, `Pagination capped at ${MAX_PAGINATION_PAGES} pages: fetched ${fetched} of ${totalCount} ${adapter.kind} PRs. Oldest PRs may be missing.`);
+    }
+    debug(MODULE, `Fetched ${results.length} ${adapter.kind} PRs${since ? ' (incremental)' : ' (initial)'}`);
     return results;
 }
+/**
+ * Fetch merged PRs since a watermark date for incremental storage.
+ * If no watermark is provided (first-ever fetch), fetches all merged PRs (up to pagination cap).
+ * Returns StoredMergedPR[] (minimal: url, title, mergedAt) for state persistence.
+ */
+export async function fetchMergedPRsSince(octokit, config, since) {
+    return fetchPRsSince(octokit, config, {
+        kind: 'merged',
+        dateNoun: 'merge',
+        buildQuery: (u, s) => `is:pr is:merged author:${u} -user:${u}${s ? ` merged:>${s}` : ''}`,
+        extractDate: (item) => item.pull_request?.merged_at || item.closed_at || '',
+        buildRecord: (item, date) => ({ url: item.html_url, title: item.title, mergedAt: date }),
+    }, since);
+}
 /**
  * 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).
@@ -294,54 +304,11 @@ export async function fetchMergedPRsSince(octokit, config, since) {
  * 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;
+    return fetchPRsSince(octokit, config, {
+        kind: 'closed',
+        dateNoun: 'close',
+        buildQuery: (u, s) => `is:pr is:closed is:unmerged author:${u} -user:${u}${s ? ` closed:>${s}` : ''}`,
+        extractDate: (item) => item.closed_at || '',
+        buildRecord: (item, date) => ({ url: item.html_url, title: item.title, closedAt: date }),
+    }, since);
 }

package/dist/core/index.d.ts

@@ -9,7 +9,7 @@ export { IssueConversationMonitor } from './issue-conversation.js';
 export { isBotAuthor, isAcknowledgmentComment } from './comment-utils.js';
 export { getOctokit, checkRateLimit, type RateLimitInfo } from './github.js';
 export { parseGitHubUrl, daysBetween, splitRepo, isOwnRepo, getCLIVersion, getDataDir, getStatePath, getBackupDir, getCacheDir, formatRelativeTime, byDateDescending, getGitHubToken, getGitHubTokenAsync, requireGitHubToken, resetGitHubTokenCache, detectGitHubUsername, stateFileExists, DEFAULT_CONCURRENCY, } from './utils.js';
-export { OssAutopilotError, ConfigurationError, ValidationError, GistPermissionError, errorMessage, getHttpStatusCode, isRateLimitError, isRateLimitOrAuthError, resolveErrorCode, } from './errors.js';
+export { OssAutopilotError, ConfigurationError, ValidationError, GistPermissionError, errorMessage, getHttpStatusCode, isRateLimitError, isRateLimitOrAuthError, nonFatalCatch, resolveErrorCode, } 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, applyStatusOverrides, computeRepoSignals, groupPRsByRepo, assessCapacity, collectActionableIssues, computeActionMenu, toShelvedPRRef, formatActionHint, formatBriefSummary, formatSummary, printDigest, } from './daily-logic.js';

package/dist/core/index.js

@@ -10,7 +10,7 @@ export { IssueConversationMonitor } from './issue-conversation.js';
 export { isBotAuthor, isAcknowledgmentComment } from './comment-utils.js';
 export { getOctokit, checkRateLimit } from './github.js';
 export { parseGitHubUrl, daysBetween, splitRepo, isOwnRepo, getCLIVersion, getDataDir, getStatePath, getBackupDir, getCacheDir, formatRelativeTime, byDateDescending, getGitHubToken, getGitHubTokenAsync, requireGitHubToken, resetGitHubTokenCache, detectGitHubUsername, stateFileExists, DEFAULT_CONCURRENCY, } from './utils.js';
-export { OssAutopilotError, ConfigurationError, ValidationError, GistPermissionError, errorMessage, getHttpStatusCode, isRateLimitError, isRateLimitOrAuthError, resolveErrorCode, } from './errors.js';
+export { OssAutopilotError, ConfigurationError, ValidationError, GistPermissionError, errorMessage, getHttpStatusCode, isRateLimitError, isRateLimitOrAuthError, nonFatalCatch, resolveErrorCode, } from './errors.js';
 export { enableDebug, isDebugEnabled, debug, info, warn, timed } from './logger.js';
 export { HttpCache, getHttpCache, cachedRequest } from './http-cache.js';
 export { CRITICAL_STATUSES, applyStatusOverrides, computeRepoSignals, groupPRsByRepo, assessCapacity, collectActionableIssues, computeActionMenu, toShelvedPRRef, formatActionHint, formatBriefSummary, formatSummary, printDigest, } from './daily-logic.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oss-autopilot/core",
-  "version": "1.14.0",
+  "version": "1.15.0",
   "description": "CLI and core library for managing open source contributions",
   "type": "module",
   "bin": {
@@ -50,7 +50,7 @@
   "dependencies": {
     "@octokit/plugin-throttling": "^11.0.3",
     "@octokit/rest": "^22.0.1",
-    "@oss-scout/core": "^0.4.0",
+    "@oss-scout/core": "^0.5.0",
     "commander": "^14.0.3",
     "zod": "^4.3.6"
   },