@oss-autopilot/core 0.43.0 → 0.44.0

package/dist/cli.js

@@ -45,7 +45,6 @@ const LOCAL_ONLY_COMMANDS = [
     'version',
     'setup',
     'checkSetup',
-    'dashboard',
     'serve',
     'parse-issue-list',
     'check-integration',
@@ -537,20 +536,6 @@ dashboardCmd
         handleCommandError(err);
     }
 });
-// Keep bare `dashboard` (no subcommand) for backward compat — generates static HTML
-dashboardCmd
-    .option('--open', 'Open in browser')
-    .option('--json', 'Output as JSON')
-    .option('--offline', 'Use cached data only (no GitHub API calls)')
-    .action(async (options) => {
-    try {
-        const { runDashboard } = await import('./commands/dashboard.js');
-        await runDashboard({ open: options.open, json: options.json, offline: options.offline });
-    }
-    catch (err) {
-        handleCommandError(err, options.json);
-    }
-});
 // Parse issue list command (#82)
 program
     .command('parse-issue-list <path>')
@@ -673,8 +658,6 @@ program
             else {
                 console.log(`OSS Autopilot v${data.version}`);
                 console.log(data.daily?.briefSummary ?? '');
-                if (data.dashboardPath)
-                    console.log(`Dashboard: ${data.dashboardPath}`);
             }
         }
     }

package/dist/commands/config.js

@@ -3,6 +3,7 @@
  * Shows or updates configuration
  */
 import { getStateManager } from '../core/index.js';
+import { validateGitHubUsername } from './validation.js';
 export async function runConfig(options) {
     const stateManager = getStateManager();
     const currentConfig = stateManager.getState().config;
@@ -17,7 +18,7 @@ export async function runConfig(options) {
     // Handle specific config keys
     switch (options.key) {
         case 'username':
-            stateManager.updateConfig({ githubUsername: value });
+            stateManager.updateConfig({ githubUsername: validateGitHubUsername(value) });
             break;
         case 'add-language':
             if (!currentConfig.languages.includes(value)) {

package/dist/commands/daily.js

@@ -7,9 +7,22 @@
  * 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 { errorMessage } from '../core/errors.js';
+import { errorMessage, getHttpStatusCode } from '../core/errors.js';
+import { warn } from '../core/logger.js';
 import { emptyPRCountsResult } from '../core/github-stats.js';
 import { deduplicateDigest, compactActionableIssues, compactRepoGroups, } from '../formatters/json.js';
+const MODULE = 'daily';
+/** Return true for errors that should propagate (not degrade gracefully). */
+function isRateLimitOrAuthError(err) {
+    const status = getHttpStatusCode(err);
+    if (status === 401 || status === 429)
+        return true;
+    if (status === 403) {
+        const msg = errorMessage(err).toLowerCase();
+        return msg.includes('rate limit') || msg.includes('abuse detection');
+    }
+    return false;
+}
 // 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';
@@ -26,35 +39,45 @@ async function fetchPRData(prMonitor, token) {
     const { prs, failures } = await prMonitor.fetchUserOpenPRs();
     // Log any failures (but continue with successful checks)
     if (failures.length > 0) {
-        console.error(`Warning: ${failures.length} PR fetch(es) failed`);
+        warn(MODULE, `${failures.length} PR fetch(es) failed`);
     }
     // Fetch merged PR counts, closed PR counts, recently closed PRs, recently merged PRs, and commented issues in parallel
     // 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().catch((err) => {
-            console.error(`Warning: Failed to fetch merged PR counts: ${errorMessage(err)}`);
+            if (isRateLimitOrAuthError(err))
+                throw err;
+            warn(MODULE, `Failed to fetch merged PR counts: ${errorMessage(err)}`);
             return emptyPRCountsResult();
         }),
         prMonitor.fetchUserClosedPRCounts().catch((err) => {
-            console.error(`Warning: Failed to fetch closed PR counts: ${errorMessage(err)}`);
+            if (isRateLimitOrAuthError(err))
+                throw err;
+            warn(MODULE, `Failed to fetch closed PR counts: ${errorMessage(err)}`);
             return emptyPRCountsResult();
         }),
         prMonitor.fetchRecentlyClosedPRs().catch((err) => {
-            console.error(`Warning: Failed to fetch recently closed PRs: ${errorMessage(err)}`);
+            if (isRateLimitOrAuthError(err))
+                throw err;
+            warn(MODULE, `Failed to fetch recently closed PRs: ${errorMessage(err)}`);
             return [];
         }),
         prMonitor.fetchRecentlyMergedPRs().catch((err) => {
-            console.error(`Warning: Failed to fetch recently merged PRs: ${errorMessage(err)}`);
+            if (isRateLimitOrAuthError(err))
+                throw err;
+            warn(MODULE, `Failed to fetch recently merged PRs: ${errorMessage(err)}`);
             return [];
         }),
         issueMonitor.fetchCommentedIssues().catch((error) => {
+            if (isRateLimitOrAuthError(error))
+                throw error;
             const msg = errorMessage(error);
             if (msg.includes('No GitHub username configured')) {
-                console.error(`[DAILY] Issue conversation tracking requires setup: ${msg}`);
+                warn(MODULE, `Issue conversation tracking requires setup: ${msg}`);
             }
             else {
-                console.error(`[DAILY] Issue conversation fetch failed: ${msg}`);
+                warn(MODULE, `Issue conversation fetch failed: ${msg}`);
             }
             return {
                 issues: [],
@@ -64,7 +87,7 @@ async function fetchPRData(prMonitor, token) {
     ]);
     const commentedIssues = issueConversationResult.issues;
     if (issueConversationResult.failures.length > 0) {
-        console.error(`[DAILY] ${issueConversationResult.failures.length} issue conversation check(s) failed`);
+        warn(MODULE, `${issueConversationResult.failures.length} issue conversation check(s) failed`);
     }
     const { repos: mergedCounts, monthlyCounts, monthlyOpenedCounts: openedFromMerged } = mergedResult;
     const { repos: closedCounts, monthlyCounts: monthlyClosedCounts, monthlyOpenedCounts: openedFromClosed, } = closedResult;
@@ -94,7 +117,7 @@ async function updateRepoScores(prMonitor, prs, mergedCounts, closedCounts) {
     // skip the reset to avoid wiping scores due to transient API failures.
     const existingReposWithMerges = Object.values(stateManager.getState().repoScores).filter((s) => s.mergedPRCount > 0);
     if (mergedCounts.size === 0 && existingReposWithMerges.length > 0) {
-        console.error(`[DAILY] Skipping stale repo reset: API returned 0 merged PR results but state has ${existingReposWithMerges.length} repo(s) with merges. Possible API issue.`);
+        warn(MODULE, `Skipping stale repo reset: API returned 0 merged PR results but state has ${existingReposWithMerges.length} repo(s) with merges. Possible API issue.`);
     }
     else {
         for (const score of Object.values(stateManager.getState().repoScores)) {
@@ -111,18 +134,18 @@ async function updateRepoScores(prMonitor, prs, mergedCounts, closedCounts) {
         }
         catch (error) {
             mergedCountFailures++;
-            console.error(`[DAILY] Failed to update merged count for ${repo}:`, errorMessage(error));
+            warn(MODULE, `Failed to update merged count for ${repo}: ${errorMessage(error)}`);
         }
     }
     if (mergedCountFailures === mergedCounts.size && mergedCounts.size > 0) {
-        console.error(`[DAILY_ALL_MERGED_COUNT_UPDATES_FAILED] All ${mergedCounts.size} merged count update(s) failed.`);
+        warn(MODULE, `[ALL_MERGED_COUNT_UPDATES_FAILED] All ${mergedCounts.size} merged count update(s) failed.`);
     }
     // Populate closedWithoutMergeCount in repo scores.
     // Diagnostic: warn if API returned empty but we have known closed PRs (possible transient API failure).
     // Unlike merged counts above, there is no stale-reset loop for closed counts, so no skip is needed.
     const existingReposWithClosed = Object.values(stateManager.getState().repoScores).filter((s) => (s.closedWithoutMergeCount || 0) > 0);
     if (closedCounts.size === 0 && existingReposWithClosed.length > 0) {
-        console.error(`[DAILY] Warning: API returned 0 closed PR results but state has ${existingReposWithClosed.length} repo(s) with closed PRs. Possible transient API issue.`);
+        warn(MODULE, `API returned 0 closed PR results but state has ${existingReposWithClosed.length} repo(s) with closed PRs. Possible transient API issue.`);
     }
     let closedCountFailures = 0;
     for (const [repo, count] of closedCounts) {
@@ -131,11 +154,11 @@ async function updateRepoScores(prMonitor, prs, mergedCounts, closedCounts) {
         }
         catch (error) {
             closedCountFailures++;
-            console.error(`[DAILY] Failed to update closed count for ${repo}:`, errorMessage(error));
+            warn(MODULE, `Failed to update closed count for ${repo}: ${errorMessage(error)}`);
         }
     }
     if (closedCountFailures === closedCounts.size && closedCounts.size > 0) {
-        console.error(`[DAILY_ALL_CLOSED_COUNT_UPDATES_FAILED] All ${closedCounts.size} closed count update(s) failed.`);
+        warn(MODULE, `[ALL_CLOSED_COUNT_UPDATES_FAILED] All ${closedCounts.size} closed count update(s) failed.`);
     }
     // Update repo signals from observed open PR data (responsiveness, active maintainers).
     // Only repos with current open PRs get signal updates — repos with no open PRs
@@ -150,11 +173,11 @@ async function updateRepoScores(prMonitor, prs, mergedCounts, closedCounts) {
         }
         catch (error) {
             signalUpdateFailures++;
-            console.error(`[DAILY] Failed to update signals for ${repo}:`, errorMessage(error));
+            warn(MODULE, `Failed to update signals for ${repo}: ${errorMessage(error)}`);
         }
     }
     if (signalUpdateFailures === repoSignals.size && repoSignals.size > 0) {
-        console.error(`[DAILY_ALL_SIGNAL_UPDATES_FAILED] All ${repoSignals.size} signal update(s) failed. This may indicate corrupted state.`);
+        warn(MODULE, `[ALL_SIGNAL_UPDATES_FAILED] All ${repoSignals.size} signal update(s) failed. This may indicate corrupted state.`);
     }
     // Fetch star counts for all scored repos (used by dashboard minStars filter, #216)
     const allRepos = Object.keys(stateManager.getState().repoScores);
@@ -163,8 +186,8 @@ async function updateRepoScores(prMonitor, prs, mergedCounts, closedCounts) {
         starCounts = await prMonitor.fetchRepoStarCounts(allRepos);
     }
     catch (error) {
-        console.error('[DAILY] Failed to fetch repo star counts:', errorMessage(error));
-        console.error('[DAILY] Dashboard minStars filter will use cached star counts (or be skipped for repos without cached data).');
+        warn(MODULE, `Failed to fetch repo star counts: ${errorMessage(error)}`);
+        warn(MODULE, 'Dashboard minStars filter will use cached star counts (or be skipped for repos without cached data).');
         starCounts = new Map();
     }
     let starUpdateFailures = 0;
@@ -174,11 +197,11 @@ async function updateRepoScores(prMonitor, prs, mergedCounts, closedCounts) {
         }
         catch (error) {
             starUpdateFailures++;
-            console.error(`[DAILY] Failed to update star count for ${repo}:`, errorMessage(error));
+            warn(MODULE, `Failed to update star count for ${repo}: ${errorMessage(error)}`);
         }
     }
     if (starUpdateFailures === starCounts.size && starCounts.size > 0) {
-        console.error(`[DAILY_ALL_STAR_COUNT_UPDATES_FAILED] All ${starCounts.size} star count update(s) failed.`);
+        warn(MODULE, `[ALL_STAR_COUNT_UPDATES_FAILED] All ${starCounts.size} star count update(s) failed.`);
     }
     // Auto-sync trustedProjects from repos with merged PRs
     let trustSyncFailures = 0;
@@ -188,11 +211,11 @@ async function updateRepoScores(prMonitor, prs, mergedCounts, closedCounts) {
         }
         catch (error) {
             trustSyncFailures++;
-            console.error(`[DAILY] Failed to sync trusted project ${repo}:`, errorMessage(error));
+            warn(MODULE, `Failed to sync trusted project ${repo}: ${errorMessage(error)}`);
         }
     }
     if (trustSyncFailures === mergedCounts.size && mergedCounts.size > 0) {
-        console.error(`[DAILY_ALL_TRUST_SYNCS_FAILED] All ${mergedCounts.size} trusted project sync(s) failed. This may indicate corrupted state.`);
+        warn(MODULE, `[ALL_TRUST_SYNCS_FAILED] All ${mergedCounts.size} trusted project sync(s) failed. This may indicate corrupted state.`);
     }
 }
 /**
@@ -211,7 +234,7 @@ function updateAnalytics(prs, monthlyCounts, monthlyClosedCounts, openedFromMerg
         }
     }
     catch (error) {
-        console.error('[DAILY] Failed to store monthly merged counts:', errorMessage(error));
+        warn(MODULE, `Failed to store monthly merged counts: ${errorMessage(error)}`);
     }
     try {
         if (Object.keys(monthlyClosedCounts).length > 0) {
@@ -219,7 +242,7 @@ function updateAnalytics(prs, monthlyCounts, monthlyClosedCounts, openedFromMerg
         }
     }
     catch (error) {
-        console.error('[DAILY] Failed to store monthly closed counts:', errorMessage(error));
+        warn(MODULE, `Failed to store monthly closed counts: ${errorMessage(error)}`);
     }
     try {
         // Build combined monthly opened counts from merged + closed + currently-open PRs
@@ -239,7 +262,7 @@ function updateAnalytics(prs, monthlyCounts, monthlyClosedCounts, openedFromMerg
         }
     }
     catch (error) {
-        console.error('[DAILY] Failed to compute/store monthly opened counts:', errorMessage(error));
+        warn(MODULE, `Failed to compute/store monthly opened counts: ${errorMessage(error)}`);
     }
 }
 /**
@@ -254,15 +277,13 @@ function partitionPRs(prMonitor, prs, recentlyClosedPRs, recentlyMergedPRs) {
     try {
         const expiredSnoozes = stateManager.expireSnoozes();
         if (expiredSnoozes.length > 0) {
-            console.error(`[DAILY] ${expiredSnoozes.length} snoozed PR(s) expired and will resurface:`);
-            for (const url of expiredSnoozes) {
-                console.error(`  - ${url}`);
-            }
+            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) {
-        console.error('[DAILY] Failed to expire/persist snoozes:', errorMessage(error));
+        warn(MODULE, `Failed to expire/persist snoozes: ${errorMessage(error)}`);
     }
     // Partition PRs into active vs shelved, auto-unshelving when maintainers engage
     const shelvedPRs = [];
@@ -322,12 +343,12 @@ function generateDigestOutput(digest, activePRs, shelvedPRs, commentedIssues, fa
             if (isNaN(responseTime) || isNaN(dismissTime)) {
                 // Invalid timestamp — fail open (include issue to be safe) without
                 // permanently removing dismiss record (may be a transient data issue)
-                console.error(`[DAILY] Invalid timestamp in dismiss check for ${issue.url}, including issue`);
+                warn(MODULE, `Invalid timestamp in dismiss check for ${issue.url}, including issue`);
                 return true;
             }
             if (responseTime > dismissTime) {
                 // New activity after dismiss — auto-undismiss and resurface
-                console.error(`[DAILY] Auto-undismissing issue ${issue.url}: new response at ${issue.lastResponseAt} after dismiss at ${dismissedAt}`);
+                warn(MODULE, `Auto-undismissing issue ${issue.url}: new response at ${issue.lastResponseAt} after dismiss at ${dismissedAt}`);
                 stateManager.undismissIssue(issue.url);
                 hasAutoUndismissed = true;
                 return true;
@@ -349,12 +370,12 @@ function generateDigestOutput(digest, activePRs, shelvedPRs, commentedIssues, fa
         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)
-            console.error(`[DAILY] Invalid timestamp in PR dismiss check for ${pr.url}, including PR`);
+            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
-            console.error(`[DAILY] Auto-undismissing PR ${pr.url}: new activity at ${pr.updatedAt} after dismiss at ${dismissedAt}`);
+            warn(MODULE, `Auto-undismissing PR ${pr.url}: new activity at ${pr.updatedAt} after dismiss at ${dismissedAt}`);
             stateManager.undismissIssue(pr.url);
             hasAutoUndismissed = true;
             return true;
@@ -368,7 +389,7 @@ function generateDigestOutput(digest, activePRs, shelvedPRs, commentedIssues, fa
             stateManager.save();
         }
         catch (error) {
-            console.error('[DAILY] Failed to persist auto-undismissed state:', errorMessage(error));
+            warn(MODULE, `Failed to persist auto-undismissed state: ${errorMessage(error)}`);
         }
     }
     const actionableIssues = collectActionableIssues(nonDismissedPRs, snoozedUrls);

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

@@ -1,22 +1,25 @@
 /**
  * Dashboard data fetching and aggregation.
  * Handles GitHub API calls, PR grouping, stats computation, and monthly chart data.
- * Separates data concerns from template generation and command orchestration.
+ * Consumed by the dashboard HTTP server (dashboard-server.ts) for the SPA API.
  */
 import type { DailyDigest, AgentState, CommentedIssue } from '../core/types.js';
+export interface DashboardStats {
+    activePRs: number;
+    shelvedPRs: number;
+    mergedPRs: number;
+    closedPRs: number;
+    mergeRate: string;
+}
+export declare function buildDashboardStats(digest: DailyDigest, state: Readonly<AgentState>): DashboardStats;
 export interface DashboardFetchResult {
     digest: DailyDigest;
     commentedIssues: CommentedIssue[];
 }
-/**
- * Fetch fresh dashboard data from GitHub.
- * Returns the digest and commented issues, updating state as a side effect.
- * Throws if the fetch fails entirely (caller should fall back to cached data).
- */
 export declare function fetchDashboardData(token: string): Promise<DashboardFetchResult>;
 /**
  * Compute PRs grouped by repository from a digest and state.
- * Used for chart data in both JSON and HTML output.
+ * Used for chart data in the dashboard API.
  */
 export declare function computePRsByRepo(digest: DailyDigest, state: Readonly<AgentState>): Record<string, {
     active: number;

package/dist/commands/dashboard-data.js

@@ -1,17 +1,42 @@
 /**
  * Dashboard data fetching and aggregation.
  * Handles GitHub API calls, PR grouping, stats computation, and monthly chart data.
- * Separates data concerns from template generation and command orchestration.
+ * Consumed by the dashboard HTTP server (dashboard-server.ts) for the SPA API.
  */
 import { getStateManager, PRMonitor, IssueConversationMonitor } from '../core/index.js';
-import { errorMessage } from '../core/errors.js';
+import { errorMessage, getHttpStatusCode } from '../core/errors.js';
 import { emptyPRCountsResult } from '../core/github-stats.js';
 import { toShelvedPRRef } from './daily.js';
+export function buildDashboardStats(digest, state) {
+    const summary = digest.summary || {
+        totalActivePRs: 0,
+        totalMergedAllTime: 0,
+        mergeRate: 0,
+        totalNeedingAttention: 0,
+    };
+    return {
+        activePRs: summary.totalActivePRs,
+        shelvedPRs: (digest.shelvedPRs || []).length,
+        mergedPRs: summary.totalMergedAllTime,
+        closedPRs: Object.values(state.repoScores || {}).reduce((sum, s) => sum + (s.closedWithoutMergeCount || 0), 0),
+        mergeRate: `${(summary.mergeRate ?? 0).toFixed(1)}%`,
+    };
+}
 /**
  * Fetch fresh dashboard data from GitHub.
  * Returns the digest and commented issues, updating state as a side effect.
  * Throws if the fetch fails entirely (caller should fall back to cached data).
  */
+function isRateLimitOrAuthError(err) {
+    const status = getHttpStatusCode(err);
+    if (status === 401 || status === 429)
+        return true;
+    if (status === 403) {
+        const msg = errorMessage(err).toLowerCase();
+        return msg.includes('rate limit') || msg.includes('abuse detection');
+    }
+    return false;
+}
 export async function fetchDashboardData(token) {
     const stateManager = getStateManager();
     const prMonitor = new PRMonitor(token);
@@ -19,18 +44,26 @@ export async function fetchDashboardData(token) {
     const [{ prs, failures }, recentlyClosedPRs, recentlyMergedPRs, mergedResult, closedResult, fetchedIssues] = await Promise.all([
         prMonitor.fetchUserOpenPRs(),
         prMonitor.fetchRecentlyClosedPRs().catch((err) => {
+            if (isRateLimitOrAuthError(err))
+                throw err;
             console.error(`Warning: Failed to fetch recently closed PRs: ${errorMessage(err)}`);
             return [];
         }),
         prMonitor.fetchRecentlyMergedPRs().catch((err) => {
+            if (isRateLimitOrAuthError(err))
+                throw err;
             console.error(`Warning: Failed to fetch recently merged PRs: ${errorMessage(err)}`);
             return [];
         }),
         prMonitor.fetchUserMergedPRCounts().catch((err) => {
+            if (isRateLimitOrAuthError(err))
+                throw err;
             console.error(`Warning: Failed to fetch merged PR counts: ${errorMessage(err)}`);
             return emptyPRCountsResult();
         }),
         prMonitor.fetchUserClosedPRCounts().catch((err) => {
+            if (isRateLimitOrAuthError(err))
+                throw err;
             console.error(`Warning: Failed to fetch closed PR counts: ${errorMessage(err)}`);
             return emptyPRCountsResult();
         }),
@@ -113,7 +146,7 @@ export async function fetchDashboardData(token) {
 }
 /**
  * Compute PRs grouped by repository from a digest and state.
- * Used for chart data in both JSON and HTML output.
+ * Used for chart data in the dashboard API.
  */
 export function computePRsByRepo(digest, state) {
     const prsByRepo = {};

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

@@ -1,14 +1,7 @@
 /**
- * Dashboard data formatting helpers: escapeHtml, DashboardStats, and stats builder.
+ * Dashboard HTML formatting helpers.
+ * Used by dashboard-templates.ts and dashboard-components.ts for static HTML generation.
  */
-import type { DailyDigest, AgentState } from '../core/types.js';
-export interface DashboardStats {
-    activePRs: number;
-    shelvedPRs: number;
-    mergedPRs: number;
-    closedPRs: number;
-    mergeRate: string;
-}
 /**
  * Escape HTML special characters to prevent XSS when interpolating
  * user-controlled content (e.g. PR titles, comment bodies, author names) into HTML.
@@ -17,4 +10,3 @@ export interface DashboardStats {
  * the URL scheme if the source is untrusted. GitHub API URLs are trusted.
  */
 export declare function escapeHtml(text: string): string;
-export declare function buildDashboardStats(digest: DailyDigest, state: Readonly<AgentState>): DashboardStats;

package/dist/commands/dashboard-formatters.js

@@ -1,5 +1,6 @@
 /**
- * Dashboard data formatting helpers: escapeHtml, DashboardStats, and stats builder.
+ * Dashboard HTML formatting helpers.
+ * Used by dashboard-templates.ts and dashboard-components.ts for static HTML generation.
  */
 /**
  * Escape HTML special characters to prevent XSS when interpolating
@@ -16,18 +17,3 @@ export function escapeHtml(text) {
         .replace(/"/g, '"')
         .replace(/'/g, ''');
 }
-export function buildDashboardStats(digest, state) {
-    const summary = digest.summary || {
-        totalActivePRs: 0,
-        totalMergedAllTime: 0,
-        mergeRate: 0,
-        totalNeedingAttention: 0,
-    };
-    return {
-        activePRs: summary.totalActivePRs,
-        shelvedPRs: (digest.shelvedPRs || []).length,
-        mergedPRs: summary.totalMergedAllTime,
-        closedPRs: Object.values(state.repoScores || {}).reduce((sum, s) => sum + (s.closedWithoutMergeCount || 0), 0),
-        mergeRate: `${(summary.mergeRate ?? 0).toFixed(1)}%`,
-    };
-}

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

@@ -12,7 +12,7 @@ export interface LaunchResult {
  * Launch the interactive dashboard SPA server as a detached background process.
  *
  * Returns the server URL if launched successfully, or null if the SPA assets
- * are not available (caller should fall back to static HTML).
+ * are not available (dashboard is skipped).
  *
  * If a server is already running (detected via PID file + health probe),
  * returns its URL without launching a new one.

package/dist/commands/dashboard-lifecycle.js

@@ -16,7 +16,7 @@ function sleep(ms) {
  * Launch the interactive dashboard SPA server as a detached background process.
  *
  * Returns the server URL if launched successfully, or null if the SPA assets
- * are not available (caller should fall back to static HTML).
+ * are not available (dashboard is skipped).
  *
  * If a server is already running (detected via PID file + health probe),
  * returns its URL without launching a new one.

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

@@ -2,6 +2,6 @@
  * Client-side JavaScript for the dashboard: theme toggle, filtering, Chart.js charts.
  */
 import type { DailyDigest, AgentState } from '../core/types.js';
-import type { DashboardStats } from './dashboard-formatters.js';
+import type { DashboardStats } from './dashboard-data.js';
 /** Generate the Chart.js JavaScript for the dashboard. */
 export declare function generateDashboardScripts(stats: DashboardStats, monthlyMerged: Record<string, number>, monthlyClosed: Record<string, number>, monthlyOpened: Record<string, number>, digest: DailyDigest, state: Readonly<AgentState>): string;

package/dist/commands/dashboard-server.js

@@ -11,8 +11,8 @@ import * as path from 'path';
 import { getStateManager, getGitHubToken, getDataDir } from '../core/index.js';
 import { errorMessage, ValidationError } from '../core/errors.js';
 import { validateUrl, validateGitHubUrl, validateMessage, PR_URL_PATTERN } from './validation.js';
-import { fetchDashboardData, computePRsByRepo, computeTopRepos, getMonthlyData } from './dashboard-data.js';
-import { buildDashboardStats } from './dashboard-templates.js';
+import { fetchDashboardData, computePRsByRepo, computeTopRepos, getMonthlyData, buildDashboardStats, } from './dashboard-data.js';
+import { openInBrowser } from './startup.js';
 // ── Constants ────────────────────────────────────────────────────────────────
 const VALID_ACTIONS = new Set(['shelve', 'unshelve', 'snooze', 'unsnooze']);
 const MAX_BODY_BYTES = 10_240;
@@ -109,12 +109,11 @@ export async function findRunningDashboardServer() {
 // ── Helpers ────────────────────────────────────────────────────────────────────
 /**
  * Build the JSON payload that the SPA expects from GET /api/data.
- * Same shape as the existing `dashboard --json` output.
  */
 function buildDashboardJson(digest, state, commentedIssues) {
     const prsByRepo = computePRsByRepo(digest, state);
     const topRepos = computeTopRepos(prsByRepo);
-    const { monthlyMerged } = getMonthlyData(state);
+    const { monthlyMerged, monthlyOpened, monthlyClosed } = getMonthlyData(state);
     const stats = buildDashboardStats(digest, state);
     const issueResponses = commentedIssues.filter((i) => i.status === 'new_response');
     return {
@@ -122,8 +121,13 @@ function buildDashboardJson(digest, state, commentedIssues) {
         prsByRepo,
         topRepos: topRepos.map(([repo, data]) => ({ repo, ...data })),
         monthlyMerged,
+        monthlyOpened,
+        monthlyClosed,
         activePRs: digest.openPRs || [],
         shelvedPRUrls: state.config.shelvedPRUrls || [],
+        recentlyMergedPRs: digest.recentlyMergedPRs || [],
+        recentlyClosedPRs: digest.recentlyClosedPRs || [],
+        autoUnshelvedPRs: digest.autoUnshelvedPRs || [],
         commentedIssues,
         issueResponses,
     };
@@ -181,25 +185,11 @@ export async function startDashboardServer(options) {
     const stateManager = getStateManager();
     const resolvedAssetsDir = path.resolve(assetsDir);
     // ── Cached data ──────────────────────────────────────────────────────────
-    let cachedDigest;
+    // Start immediately with state.json data (written by the daily check that
+    // precedes this server launch). A background GitHub fetch refreshes the
+    // cache after the port is bound, so the startup poller sees us in time.
+    let cachedDigest = stateManager.getState().lastDigest;
     let cachedCommentedIssues = [];
-    // Fetch initial data
-    if (token) {
-        try {
-            console.error('Fetching dashboard data from GitHub...');
-            const result = await fetchDashboardData(token);
-            cachedDigest = result.digest;
-            cachedCommentedIssues = result.commentedIssues;
-        }
-        catch (error) {
-            console.error('Failed to fetch data from GitHub:', error);
-            console.error('Falling back to cached data...');
-            cachedDigest = stateManager.getState().lastDigest;
-        }
-    }
-    else {
-        cachedDigest = stateManager.getState().lastDigest;
-    }
     if (!cachedDigest) {
         console.error('No dashboard data available. Run the daily check first:');
         console.error('  GITHUB_TOKEN=$(gh auth token) npm start -- daily');
@@ -328,9 +318,7 @@ export async function startDashboardServer(options) {
             return;
         }
         // Rebuild dashboard data from cached digest + updated state
-        if (cachedDigest) {
-            cachedJsonData = buildDashboardJson(cachedDigest, stateManager.getState(), cachedCommentedIssues);
-        }
+        cachedJsonData = buildDashboardJson(cachedDigest, stateManager.getState(), cachedCommentedIssues);
         sendJson(res, 200, cachedJsonData);
     }
     // ── POST /api/refresh handler ────────────────────────────────────────────
@@ -444,31 +432,24 @@ export async function startDashboardServer(options) {
     writeDashboardServerInfo({ pid: process.pid, port: actualPort, startedAt: new Date().toISOString() });
     const serverUrl = `http://localhost:${actualPort}`;
     console.error(`Dashboard server running at ${serverUrl}`);
+    // ── Background refresh ─────────────────────────────────────────────────
+    // Port is bound and PID file written — now fetch fresh data from GitHub
+    // so subsequent /api/data requests get live data instead of cached state.
+    if (token) {
+        fetchDashboardData(token)
+            .then((result) => {
+            cachedDigest = result.digest;
+            cachedCommentedIssues = result.commentedIssues;
+            cachedJsonData = buildDashboardJson(cachedDigest, stateManager.getState(), cachedCommentedIssues);
+            console.error('Background data refresh complete');
+        })
+            .catch((error) => {
+            console.error('Background data refresh failed (serving cached data):', errorMessage(error));
+        });
+    }
     // ── Open browser ─────────────────────────────────────────────────────────
     if (open) {
-        const { execFile } = await import('child_process');
-        let openCmd;
-        let args;
-        switch (process.platform) {
-            case 'darwin':
-                openCmd = 'open';
-                args = [serverUrl];
-                break;
-            case 'win32':
-                openCmd = 'cmd';
-                args = ['/c', 'start', '', serverUrl];
-                break;
-            default:
-                openCmd = 'xdg-open';
-                args = [serverUrl];
-                break;
-        }
-        execFile(openCmd, args, (error) => {
-            if (error) {
-                console.error('Failed to open browser:', error.message);
-                console.error(`Open manually: ${serverUrl}`);
-            }
-        });
+        openInBrowser(serverUrl);
     }
     // ── Clean shutdown ───────────────────────────────────────────────────────
     const shutdown = () => {