@oss-autopilot/core 0.42.5 → 0.43.0

package/dist/cli.bundle.cjs

@@ -10847,6 +10847,9 @@ var init_display_utils = __esm({
 });
 
 // src/core/github-stats.ts
+function emptyPRCountsResult() {
+  return { repos: /* @__PURE__ */ new Map(), monthlyCounts: {}, monthlyOpenedCounts: {}, dailyActivityCounts: {} };
+}
 function isCachedPRCounts(v) {
   if (typeof v !== "object" || v === null) return false;
   const obj = v;
@@ -10854,7 +10857,7 @@ function isCachedPRCounts(v) {
 }
 async function fetchUserPRCounts(octokit, githubUsername, query, label, accumulateRepo) {
   if (!githubUsername) {
-    return { repos: /* @__PURE__ */ new Map(), monthlyCounts: {}, monthlyOpenedCounts: {}, dailyActivityCounts: {} };
+    return emptyPRCountsResult();
   }
   const cache = getHttpCache();
   const cacheKey = `pr-counts:${label}:${githubUsername}`;
@@ -10875,6 +10878,7 @@ async function fetchUserPRCounts(octokit, githubUsername, query, label, accumula
   const dailyActivityCounts = {};
   let page = 1;
   let fetched = 0;
+  let totalCount;
   while (true) {
     const { data } = await octokit.search.issuesAndPullRequests({
       q: `is:pr ${query} author:${githubUsername}`,
@@ -10883,6 +10887,7 @@ async function fetchUserPRCounts(octokit, githubUsername, query, label, accumula
       per_page: 100,
       page
     });
+    totalCount = data.total_count;
     for (const item of data.items) {
       const parsed = extractOwnerRepo(item.html_url);
       if (!parsed) {
@@ -10907,11 +10912,17 @@ async function fetchUserPRCounts(octokit, githubUsername, query, label, accumula
       }
     }
     fetched += data.items.length;
-    if (fetched >= data.total_count || fetched >= 1e3 || data.items.length === 0) {
+    if (fetched >= data.total_count || fetched >= 1e3 || data.items.length === 0 || page >= MAX_PAGINATION_PAGES) {
       break;
     }
     page++;
   }
+  if (fetched < totalCount && page >= MAX_PAGINATION_PAGES) {
+    warn(
+      MODULE6,
+      `Pagination capped at ${MAX_PAGINATION_PAGES} pages: fetched ${fetched} of ${totalCount} ${label} PRs. Stats may be incomplete for prolific contributors.`
+    );
+  }
   debug(MODULE6, `Found ${fetched} ${label} PRs across ${repos.size} repos`);
   cache.set(cacheKey, "", {
     reposEntries: Array.from(repos.entries()),
@@ -11020,7 +11031,7 @@ async function fetchRecentlyMergedPRs(octokit, config, days = 7) {
     }
   );
 }
-var MODULE6, PR_COUNTS_CACHE_TTL_MS;
+var MODULE6, PR_COUNTS_CACHE_TTL_MS, MAX_PAGINATION_PAGES;
 var init_github_stats = __esm({
   "src/core/github-stats.ts"() {
     "use strict";
@@ -11028,7 +11039,8 @@ var init_github_stats = __esm({
     init_logger();
     init_http_cache();
     MODULE6 = "github-stats";
-    PR_COUNTS_CACHE_TTL_MS = 60 * 60 * 1e3;
+    PR_COUNTS_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+    MAX_PAGINATION_PAGES = 3;
   }
 });
 
@@ -13476,8 +13488,14 @@ async function fetchPRData(prMonitor, token) {
   const issueMonitor = new IssueConversationMonitor(token);
   const [mergedResult, closedResult, recentlyClosedPRs, recentlyMergedPRs, issueConversationResult] = await Promise.all(
     [
-      prMonitor.fetchUserMergedPRCounts(),
-      prMonitor.fetchUserClosedPRCounts(),
+      prMonitor.fetchUserMergedPRCounts().catch((err) => {
+        console.error(`Warning: 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)}`);
+        return emptyPRCountsResult();
+      }),
       prMonitor.fetchRecentlyClosedPRs().catch((err) => {
         console.error(`Warning: Failed to fetch recently closed PRs: ${errorMessage(err)}`);
         return [];
@@ -13626,12 +13644,16 @@ async function updateRepoScores(prMonitor, prs, mergedCounts, closedCounts) {
 function updateAnalytics(prs, monthlyCounts, monthlyClosedCounts, openedFromMerged, openedFromClosed) {
   const stateManager2 = getStateManager();
   try {
-    stateManager2.setMonthlyMergedCounts(monthlyCounts);
+    if (Object.keys(monthlyCounts).length > 0) {
+      stateManager2.setMonthlyMergedCounts(monthlyCounts);
+    }
   } catch (error) {
     console.error("[DAILY] Failed to store monthly merged counts:", errorMessage(error));
   }
   try {
-    stateManager2.setMonthlyClosedCounts(monthlyClosedCounts);
+    if (Object.keys(monthlyClosedCounts).length > 0) {
+      stateManager2.setMonthlyClosedCounts(monthlyClosedCounts);
+    }
   } catch (error) {
     console.error("[DAILY] Failed to store monthly closed counts:", errorMessage(error));
   }
@@ -13646,7 +13668,9 @@ function updateAnalytics(prs, monthlyCounts, monthlyClosedCounts, openedFromMerg
         combinedOpenedCounts[month] = (combinedOpenedCounts[month] || 0) + 1;
       }
     }
-    stateManager2.setMonthlyOpenedCounts(combinedOpenedCounts);
+    if (Object.keys(combinedOpenedCounts).length > 0) {
+      stateManager2.setMonthlyOpenedCounts(combinedOpenedCounts);
+    }
   } catch (error) {
     console.error("[DAILY] Failed to compute/store monthly opened counts:", errorMessage(error));
   }
@@ -13816,6 +13840,7 @@ var init_daily = __esm({
     "use strict";
     init_core();
     init_errors();
+    init_github_stats();
     init_json();
     init_core();
   }
@@ -14542,8 +14567,14 @@ async function fetchDashboardData(token) {
       console.error(`Warning: Failed to fetch recently merged PRs: ${errorMessage(err)}`);
       return [];
     }),
-    prMonitor.fetchUserMergedPRCounts(),
-    prMonitor.fetchUserClosedPRCounts(),
+    prMonitor.fetchUserMergedPRCounts().catch((err) => {
+      console.error(`Warning: 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)}`);
+      return emptyPRCountsResult();
+    }),
     issueMonitor.fetchCommentedIssues().catch((error) => {
       const msg = errorMessage(error);
       if (msg.includes("No GitHub username configured")) {
@@ -14567,12 +14598,16 @@ async function fetchDashboardData(token) {
   const { monthlyCounts, monthlyOpenedCounts: openedFromMerged } = mergedResult;
   const { monthlyCounts: monthlyClosedCounts, monthlyOpenedCounts: openedFromClosed } = closedResult;
   try {
-    stateManager2.setMonthlyMergedCounts(monthlyCounts);
+    if (Object.keys(monthlyCounts).length > 0) {
+      stateManager2.setMonthlyMergedCounts(monthlyCounts);
+    }
   } catch (error) {
     console.error("[DASHBOARD] Failed to store monthly merged counts:", errorMessage(error));
   }
   try {
-    stateManager2.setMonthlyClosedCounts(monthlyClosedCounts);
+    if (Object.keys(monthlyClosedCounts).length > 0) {
+      stateManager2.setMonthlyClosedCounts(monthlyClosedCounts);
+    }
   } catch (error) {
     console.error("[DASHBOARD] Failed to store monthly closed counts:", errorMessage(error));
   }
@@ -14587,7 +14622,9 @@ async function fetchDashboardData(token) {
         combinedOpenedCounts[month] = (combinedOpenedCounts[month] || 0) + 1;
       }
     }
-    stateManager2.setMonthlyOpenedCounts(combinedOpenedCounts);
+    if (Object.keys(combinedOpenedCounts).length > 0) {
+      stateManager2.setMonthlyOpenedCounts(combinedOpenedCounts);
+    }
   } catch (error) {
     console.error("[DASHBOARD] Failed to store monthly opened counts:", errorMessage(error));
   }
@@ -14634,6 +14671,7 @@ var init_dashboard_data = __esm({
     "use strict";
     init_core();
     init_errors();
+    init_github_stats();
     init_daily();
   }
 });
@@ -16263,8 +16301,79 @@ var init_dashboard_templates = __esm({
 // src/commands/dashboard-server.ts
 var dashboard_server_exports = {};
 __export(dashboard_server_exports, {
-  startDashboardServer: () => startDashboardServer
+  findRunningDashboardServer: () => findRunningDashboardServer,
+  getDashboardPidPath: () => getDashboardPidPath,
+  isDashboardServerRunning: () => isDashboardServerRunning,
+  readDashboardServerInfo: () => readDashboardServerInfo,
+  removeDashboardServerInfo: () => removeDashboardServerInfo,
+  startDashboardServer: () => startDashboardServer,
+  writeDashboardServerInfo: () => writeDashboardServerInfo
 });
+function getDashboardPidPath() {
+  return path5.join(getDataDir(), "dashboard-server.pid");
+}
+function writeDashboardServerInfo(info2) {
+  fs5.writeFileSync(getDashboardPidPath(), JSON.stringify(info2), { mode: 384 });
+}
+function readDashboardServerInfo() {
+  try {
+    const content = fs5.readFileSync(getDashboardPidPath(), "utf-8");
+    const parsed = JSON.parse(content);
+    if (typeof parsed !== "object" || parsed === null || typeof parsed.pid !== "number" || typeof parsed.port !== "number" || typeof parsed.startedAt !== "string") {
+      console.error("[DASHBOARD] PID file has invalid structure, ignoring");
+      return null;
+    }
+    return parsed;
+  } catch (err) {
+    const code = err.code;
+    if (code !== "ENOENT") {
+      console.error(`[DASHBOARD] Failed to read PID file: ${err.message}`);
+    }
+    return null;
+  }
+}
+function removeDashboardServerInfo() {
+  try {
+    fs5.unlinkSync(getDashboardPidPath());
+  } catch (err) {
+    const code = err.code;
+    if (code !== "ENOENT") {
+      console.error(`[DASHBOARD] Failed to remove PID file: ${err.message}`);
+    }
+  }
+}
+function isDashboardServerRunning(port) {
+  return new Promise((resolve5) => {
+    const req = http.get(`http://127.0.0.1:${port}/api/data`, { timeout: 2e3 }, (res) => {
+      res.resume();
+      resolve5(res.statusCode === 200);
+    });
+    req.on("error", () => resolve5(false));
+    req.on("timeout", () => {
+      req.destroy();
+      resolve5(false);
+    });
+  });
+}
+async function findRunningDashboardServer() {
+  const info2 = readDashboardServerInfo();
+  if (!info2) return null;
+  try {
+    process.kill(info2.pid, 0);
+  } catch (err) {
+    const code = err.code;
+    if (code !== "ESRCH" && code !== "EPERM") {
+      console.error(`[DASHBOARD] Unexpected error checking PID ${info2.pid}: ${err.message}`);
+    }
+    removeDashboardServerInfo();
+    return null;
+  }
+  if (await isDashboardServerRunning(info2.port)) {
+    return { port: info2.port, url: `http://localhost:${info2.port}` };
+  }
+  removeDashboardServerInfo();
+  return null;
+}
 function buildDashboardJson(digest, state, commentedIssues) {
   const prsByRepo = computePRsByRepo(digest, state);
   const topRepos = computeTopRepos(prsByRepo);
@@ -16545,6 +16654,7 @@ async function startDashboardServer(options) {
       process.exit(1);
     }
   }
+  writeDashboardServerInfo({ pid: process.pid, port: actualPort, startedAt: (/* @__PURE__ */ new Date()).toISOString() });
   const serverUrl = `http://localhost:${actualPort}`;
   console.error(`Dashboard server running at ${serverUrl}`);
   if (open) {
@@ -16574,6 +16684,7 @@ async function startDashboardServer(options) {
   }
   const shutdown = () => {
     console.error("\nShutting down dashboard server...");
+    removeDashboardServerInfo();
     server.close(() => {
       process.exit(0);
     });
@@ -16611,6 +16722,7 @@ var init_dashboard_server = __esm({
 // src/commands/dashboard.ts
 var dashboard_exports = {};
 __export(dashboard_exports, {
+  resolveAssetsDir: () => resolveAssetsDir,
   runDashboard: () => runDashboard,
   serveDashboard: () => serveDashboard,
   writeDashboardFromState: () => writeDashboardFromState
@@ -17138,6 +17250,78 @@ var init_local_repos = __esm({
   }
 });
 
+// src/commands/dashboard-lifecycle.ts
+function sleep(ms) {
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
+}
+async function launchDashboardServer(options) {
+  const assetsDir = resolveAssetsDir();
+  if (!assetsDir) {
+    return null;
+  }
+  const existing = await findRunningDashboardServer();
+  if (existing) {
+    return { url: existing.url, port: existing.port, alreadyRunning: true };
+  }
+  const port = options?.port ?? DEFAULT_PORT;
+  const cliPath = process.argv[1];
+  const child = (0, import_child_process5.spawn)("node", [cliPath, "dashboard", "serve", "--port", String(port), "--no-open"], {
+    detached: true,
+    stdio: "ignore"
+  });
+  let spawnFailed = false;
+  let childExited = false;
+  child.on("error", (err) => {
+    spawnFailed = true;
+    console.error(`[STARTUP] Failed to spawn dashboard server: ${err.message}`);
+  });
+  child.on("exit", (code) => {
+    childExited = true;
+    if (code !== 0 && code !== null) {
+      console.error(`[STARTUP] Dashboard server exited prematurely (code ${code})`);
+    }
+  });
+  child.unref();
+  for (let i = 0; i < MAX_POLL_ATTEMPTS; i++) {
+    await sleep(POLL_INTERVAL_MS);
+    if (spawnFailed || childExited) {
+      return null;
+    }
+    const info2 = readDashboardServerInfo();
+    if (info2) {
+      if (await isDashboardServerRunning(info2.port)) {
+        return { url: `http://localhost:${info2.port}`, port: info2.port, alreadyRunning: false };
+      }
+    }
+  }
+  console.error("[STARTUP] Dashboard server failed to start within 5 seconds");
+  if (child.pid) {
+    try {
+      process.kill(child.pid, "SIGTERM");
+    } catch (err) {
+      const code = err.code;
+      if (code !== "ESRCH") {
+        console.error(
+          `[STARTUP] Failed to kill orphan dashboard process (PID ${child.pid}): ${err.message}`
+        );
+      }
+    }
+  }
+  return null;
+}
+var import_child_process5, DEFAULT_PORT, POLL_INTERVAL_MS, MAX_POLL_ATTEMPTS;
+var init_dashboard_lifecycle = __esm({
+  "src/commands/dashboard-lifecycle.ts"() {
+    "use strict";
+    import_child_process5 = require("child_process");
+    init_dashboard_server();
+    init_dashboard();
+    DEFAULT_PORT = 3e3;
+    POLL_INTERVAL_MS = 200;
+    MAX_POLL_ATTEMPTS = 25;
+  }
+});
+
 // src/commands/startup.ts
 var startup_exports = {};
 __export(startup_exports, {
@@ -17205,10 +17389,23 @@ function detectIssueList() {
   }
 }
 function openInBrowser(filePath) {
-  const isWindows = process.platform === "win32";
-  const openCmd = process.platform === "darwin" ? "open" : isWindows ? "cmd" : "xdg-open";
-  const args = isWindows ? ["/c", "start", "", filePath] : [filePath];
-  (0, import_child_process5.execFile)(openCmd, args, (error) => {
+  let openCmd;
+  let args;
+  switch (process.platform) {
+    case "darwin":
+      openCmd = "open";
+      args = [filePath];
+      break;
+    case "win32":
+      openCmd = "cmd";
+      args = ["/c", "start", "", filePath];
+      break;
+    default:
+      openCmd = "xdg-open";
+      args = [filePath];
+      break;
+  }
+  (0, import_child_process6.execFile)(openCmd, args, (error) => {
     if (error) {
       console.error(`[STARTUP] Failed to open dashboard in browser: ${error.message}`);
     }
@@ -17230,15 +17427,28 @@ async function runStartup() {
   }
   const daily = await executeDailyCheck(token);
   let dashboardPath;
-  let dashboardOpened = false;
   try {
     dashboardPath = writeDashboardFromState();
-    if (daily.digest.summary.totalActivePRs > 0) {
+  } catch (error) {
+    console.error("[STARTUP] Dashboard generation failed:", errorMessage(error));
+  }
+  let dashboardUrl;
+  let dashboardOpened = false;
+  if (daily.digest.summary.totalActivePRs > 0) {
+    let spaResult = null;
+    try {
+      spaResult = await launchDashboardServer();
+    } catch (error) {
+      console.error("[STARTUP] SPA dashboard launch failed:", errorMessage(error));
+    }
+    if (spaResult) {
+      dashboardUrl = spaResult.url;
+      openInBrowser(spaResult.url);
+      dashboardOpened = true;
+    } else if (dashboardPath) {
       openInBrowser(dashboardPath);
       dashboardOpened = true;
     }
-  } catch (error) {
-    console.error("[STARTUP] Dashboard generation failed:", errorMessage(error));
   }
   if (dashboardOpened) {
     daily.briefSummary += " | Dashboard opened in browser";
@@ -17249,19 +17459,21 @@ async function runStartup() {
     setupComplete: true,
     daily,
     dashboardPath,
+    dashboardUrl,
     issueList
   };
 }
-var fs9, import_child_process5;
+var fs9, import_child_process6;
 var init_startup = __esm({
   "src/commands/startup.ts"() {
     "use strict";
     fs9 = __toESM(require("fs"), 1);
-    import_child_process5 = require("child_process");
+    import_child_process6 = require("child_process");
     init_core();
     init_errors();
     init_daily();
     init_dashboard();
+    init_dashboard_lifecycle();
   }
 });
 

package/dist/commands/daily.js

@@ -8,6 +8,7 @@
  */
 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 { emptyPRCountsResult } from '../core/github-stats.js';
 import { deduplicateDigest, compactActionableIssues, compactRepoGroups, } from '../formatters/json.js';
 // Re-export domain functions so existing consumers (tests, dashboard, startup)
 // can continue importing from './daily.js' without changes.
@@ -28,11 +29,17 @@ async function fetchPRData(prMonitor, token) {
         console.error(`Warning: ${failures.length} PR fetch(es) failed`);
     }
     // Fetch merged PR counts, closed PR counts, recently closed PRs, recently merged PRs, and commented issues in parallel
-    // Recently closed/merged are non-critical (cosmetic sections), so isolate their failure
+    // 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(),
-        prMonitor.fetchUserClosedPRCounts(),
+        prMonitor.fetchUserMergedPRCounts().catch((err) => {
+            console.error(`Warning: 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)}`);
+            return emptyPRCountsResult();
+        }),
         prMonitor.fetchRecentlyClosedPRs().catch((err) => {
             console.error(`Warning: Failed to fetch recently closed PRs: ${errorMessage(err)}`);
             return [];
@@ -195,15 +202,21 @@ async function updateRepoScores(prMonitor, prs, mergedCounts, closedCounts) {
  */
 function updateAnalytics(prs, monthlyCounts, monthlyClosedCounts, openedFromMerged, openedFromClosed) {
     const stateManager = getStateManager();
-    // Store monthly chart data (non-critical — each metric isolated so partial failures don't leave inconsistent state)
+    // Store monthly chart data (non-critical — each metric isolated so partial failures don't leave inconsistent state).
+    // Guard: skip overwriting when the data is empty to avoid wiping existing chart data on transient API failures.
+    // An empty object means the fetch failed and fell back to emptyPRCountsResult(), so we preserve previous state.
     try {
-        stateManager.setMonthlyMergedCounts(monthlyCounts);
+        if (Object.keys(monthlyCounts).length > 0) {
+            stateManager.setMonthlyMergedCounts(monthlyCounts);
+        }
     }
     catch (error) {
         console.error('[DAILY] Failed to store monthly merged counts:', errorMessage(error));
     }
     try {
-        stateManager.setMonthlyClosedCounts(monthlyClosedCounts);
+        if (Object.keys(monthlyClosedCounts).length > 0) {
+            stateManager.setMonthlyClosedCounts(monthlyClosedCounts);
+        }
     }
     catch (error) {
         console.error('[DAILY] Failed to store monthly closed counts:', errorMessage(error));
@@ -221,7 +234,9 @@ function updateAnalytics(prs, monthlyCounts, monthlyClosedCounts, openedFromMerg
                 combinedOpenedCounts[month] = (combinedOpenedCounts[month] || 0) + 1;
             }
         }
-        stateManager.setMonthlyOpenedCounts(combinedOpenedCounts);
+        if (Object.keys(combinedOpenedCounts).length > 0) {
+            stateManager.setMonthlyOpenedCounts(combinedOpenedCounts);
+        }
     }
     catch (error) {
         console.error('[DAILY] Failed to compute/store monthly opened counts:', errorMessage(error));

package/dist/commands/dashboard-data.js

@@ -5,6 +5,7 @@
  */
 import { getStateManager, PRMonitor, IssueConversationMonitor } from '../core/index.js';
 import { errorMessage } from '../core/errors.js';
+import { emptyPRCountsResult } from '../core/github-stats.js';
 import { toShelvedPRRef } from './daily.js';
 /**
  * Fetch fresh dashboard data from GitHub.
@@ -25,8 +26,14 @@ export async function fetchDashboardData(token) {
             console.error(`Warning: Failed to fetch recently merged PRs: ${errorMessage(err)}`);
             return [];
         }),
-        prMonitor.fetchUserMergedPRCounts(),
-        prMonitor.fetchUserClosedPRCounts(),
+        prMonitor.fetchUserMergedPRCounts().catch((err) => {
+            console.error(`Warning: 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)}`);
+            return emptyPRCountsResult();
+        }),
         issueMonitor.fetchCommentedIssues().catch((error) => {
             const msg = errorMessage(error);
             if (msg.includes('No GitHub username configured')) {
@@ -51,14 +58,19 @@ export async function fetchDashboardData(token) {
     // Store monthly chart data (opened/merged/closed) so charts have data
     const { monthlyCounts, monthlyOpenedCounts: openedFromMerged } = mergedResult;
     const { monthlyCounts: monthlyClosedCounts, monthlyOpenedCounts: openedFromClosed } = closedResult;
+    // Guard: skip overwriting when data is empty to avoid wiping chart data on transient API failures.
     try {
-        stateManager.setMonthlyMergedCounts(monthlyCounts);
+        if (Object.keys(monthlyCounts).length > 0) {
+            stateManager.setMonthlyMergedCounts(monthlyCounts);
+        }
     }
     catch (error) {
         console.error('[DASHBOARD] Failed to store monthly merged counts:', errorMessage(error));
     }
     try {
-        stateManager.setMonthlyClosedCounts(monthlyClosedCounts);
+        if (Object.keys(monthlyClosedCounts).length > 0) {
+            stateManager.setMonthlyClosedCounts(monthlyClosedCounts);
+        }
     }
     catch (error) {
         console.error('[DASHBOARD] Failed to store monthly closed counts:', errorMessage(error));
@@ -74,7 +86,9 @@ export async function fetchDashboardData(token) {
                 combinedOpenedCounts[month] = (combinedOpenedCounts[month] || 0) + 1;
             }
         }
-        stateManager.setMonthlyOpenedCounts(combinedOpenedCounts);
+        if (Object.keys(combinedOpenedCounts).length > 0) {
+            stateManager.setMonthlyOpenedCounts(combinedOpenedCounts);
+        }
     }
     catch (error) {
         console.error('[DASHBOARD] Failed to store monthly opened counts:', errorMessage(error));

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

@@ -0,0 +1,22 @@
+/**
+ * Dashboard server lifecycle management.
+ * Handles launching the interactive SPA dashboard as a background process
+ * and detecting whether a server is already running.
+ */
+export interface LaunchResult {
+    url: string;
+    port: number;
+    alreadyRunning: boolean;
+}
+/**
+ * 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).
+ *
+ * If a server is already running (detected via PID file + health probe),
+ * returns its URL without launching a new one.
+ */
+export declare function launchDashboardServer(options?: {
+    port?: number;
+}): Promise<LaunchResult | null>;

package/dist/commands/dashboard-lifecycle.js

@@ -0,0 +1,87 @@
+/**
+ * Dashboard server lifecycle management.
+ * Handles launching the interactive SPA dashboard as a background process
+ * and detecting whether a server is already running.
+ */
+import { spawn } from 'child_process';
+import { findRunningDashboardServer, isDashboardServerRunning, readDashboardServerInfo } from './dashboard-server.js';
+import { resolveAssetsDir } from './dashboard.js';
+const DEFAULT_PORT = 3000;
+const POLL_INTERVAL_MS = 200;
+const MAX_POLL_ATTEMPTS = 25; // 5 seconds total
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, 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).
+ *
+ * If a server is already running (detected via PID file + health probe),
+ * returns its URL without launching a new one.
+ */
+export async function launchDashboardServer(options) {
+    // 1. Check if SPA assets exist
+    const assetsDir = resolveAssetsDir();
+    if (!assetsDir) {
+        return null;
+    }
+    // 2. Check if a server is already running
+    const existing = await findRunningDashboardServer();
+    if (existing) {
+        return { url: existing.url, port: existing.port, alreadyRunning: true };
+    }
+    // 3. Launch as detached child process
+    const port = options?.port ?? DEFAULT_PORT;
+    // process.argv[1] is the CLI entry point (cli.bundle.cjs in production, cli.ts in dev)
+    const cliPath = process.argv[1];
+    const child = spawn('node', [cliPath, 'dashboard', 'serve', '--port', String(port), '--no-open'], {
+        detached: true,
+        stdio: 'ignore',
+    });
+    // Track spawn failures and early exits so the polling loop can bail early
+    let spawnFailed = false;
+    let childExited = false;
+    child.on('error', (err) => {
+        spawnFailed = true;
+        console.error(`[STARTUP] Failed to spawn dashboard server: ${err.message}`);
+    });
+    child.on('exit', (code) => {
+        childExited = true;
+        if (code !== 0 && code !== null) {
+            console.error(`[STARTUP] Dashboard server exited prematurely (code ${code})`);
+        }
+    });
+    child.unref();
+    // 4. Poll for PID file to appear (server writes it after binding)
+    for (let i = 0; i < MAX_POLL_ATTEMPTS; i++) {
+        await sleep(POLL_INTERVAL_MS);
+        // Bail early if spawn failed or child crashed before writing PID file
+        if (spawnFailed || childExited) {
+            return null;
+        }
+        const info = readDashboardServerInfo();
+        if (info) {
+            // PID file appeared — verify the server is responding
+            if (await isDashboardServerRunning(info.port)) {
+                return { url: `http://localhost:${info.port}`, port: info.port, alreadyRunning: false };
+            }
+        }
+    }
+    // 5. Timeout — server didn't start in time; kill orphan process
+    console.error('[STARTUP] Dashboard server failed to start within 5 seconds');
+    if (child.pid) {
+        try {
+            process.kill(child.pid, 'SIGTERM');
+        }
+        catch (err) {
+            // ESRCH = process already exited, which is fine
+            const code = err.code;
+            if (code !== 'ESRCH') {
+                console.error(`[STARTUP] Failed to kill orphan dashboard process (PID ${child.pid}): ${err.message}`);
+            }
+        }
+    }
+    return null;
+}

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

@@ -11,4 +11,18 @@ export interface DashboardServerOptions {
     token: string | null;
     open: boolean;
 }
+export interface DashboardServerInfo {
+    pid: number;
+    port: number;
+    startedAt: string;
+}
+export declare function getDashboardPidPath(): string;
+export declare function writeDashboardServerInfo(info: DashboardServerInfo): void;
+export declare function readDashboardServerInfo(): DashboardServerInfo | null;
+export declare function removeDashboardServerInfo(): void;
+export declare function isDashboardServerRunning(port: number): Promise<boolean>;
+export declare function findRunningDashboardServer(): Promise<{
+    port: number;
+    url: string;
+} | null>;
 export declare function startDashboardServer(options: DashboardServerOptions): Promise<void>;

package/dist/commands/dashboard-server.js

@@ -8,7 +8,7 @@
 import * as http from 'http';
 import * as fs from 'fs';
 import * as path from 'path';
-import { getStateManager, getGitHubToken } from '../core/index.js';
+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';
@@ -25,6 +25,87 @@ const MIME_TYPES = {
     '.png': 'image/png',
     '.ico': 'image/x-icon',
 };
+// ── PID File Management ──────────────────────────────────────────────────────
+export function getDashboardPidPath() {
+    return path.join(getDataDir(), 'dashboard-server.pid');
+}
+export function writeDashboardServerInfo(info) {
+    fs.writeFileSync(getDashboardPidPath(), JSON.stringify(info), { mode: 0o600 });
+}
+export function readDashboardServerInfo() {
+    try {
+        const content = fs.readFileSync(getDashboardPidPath(), 'utf-8');
+        const parsed = JSON.parse(content);
+        if (typeof parsed !== 'object' ||
+            parsed === null ||
+            typeof parsed.pid !== 'number' ||
+            typeof parsed.port !== 'number' ||
+            typeof parsed.startedAt !== 'string') {
+            console.error('[DASHBOARD] PID file has invalid structure, ignoring');
+            return null;
+        }
+        return parsed;
+    }
+    catch (err) {
+        const code = err.code;
+        if (code !== 'ENOENT') {
+            console.error(`[DASHBOARD] Failed to read PID file: ${err.message}`);
+        }
+        return null;
+    }
+}
+export function removeDashboardServerInfo() {
+    try {
+        fs.unlinkSync(getDashboardPidPath());
+    }
+    catch (err) {
+        const code = err.code;
+        if (code !== 'ENOENT') {
+            console.error(`[DASHBOARD] Failed to remove PID file: ${err.message}`);
+        }
+    }
+}
+// ── Health Probe ─────────────────────────────────────────────────────────────
+export function isDashboardServerRunning(port) {
+    return new Promise((resolve) => {
+        const req = http.get(`http://127.0.0.1:${port}/api/data`, { timeout: 2000 }, (res) => {
+            // Consume response data to free up memory
+            res.resume();
+            resolve(res.statusCode === 200);
+        });
+        req.on('error', () => resolve(false));
+        req.on('timeout', () => {
+            req.destroy();
+            resolve(false);
+        });
+    });
+}
+export async function findRunningDashboardServer() {
+    const info = readDashboardServerInfo();
+    if (!info)
+        return null;
+    // Check if process is alive (signal 0 = existence check only)
+    try {
+        process.kill(info.pid, 0);
+    }
+    catch (err) {
+        const code = err.code;
+        if (code !== 'ESRCH' && code !== 'EPERM') {
+            console.error(`[DASHBOARD] Unexpected error checking PID ${info.pid}: ${err.message}`);
+        }
+        // ESRCH = no process at that PID; EPERM = PID recycled to another user's process
+        // Either way, our dashboard server is no longer running — clean up stale PID file
+        removeDashboardServerInfo();
+        return null;
+    }
+    // Process exists — verify it's actually our server via HTTP probe
+    if (await isDashboardServerRunning(info.port)) {
+        return { port: info.port, url: `http://localhost:${info.port}` };
+    }
+    // Process exists but not responding on expected port — stale
+    removeDashboardServerInfo();
+    return null;
+}
 // ── Helpers ────────────────────────────────────────────────────────────────────
 /**
  * Build the JSON payload that the SPA expects from GET /api/data.
@@ -359,6 +440,8 @@ export async function startDashboardServer(options) {
             process.exit(1);
         }
     }
+    // Write PID file so other processes can detect this running server
+    writeDashboardServerInfo({ pid: process.pid, port: actualPort, startedAt: new Date().toISOString() });
     const serverUrl = `http://localhost:${actualPort}`;
     console.error(`Dashboard server running at ${serverUrl}`);
     // ── Open browser ─────────────────────────────────────────────────────────
@@ -390,6 +473,7 @@ export async function startDashboardServer(options) {
     // ── Clean shutdown ───────────────────────────────────────────────────────
     const shutdown = () => {
         console.error('\nShutting down dashboard server...');
+        removeDashboardServerInfo();
         server.close(() => {
             process.exit(0);
         });

package/dist/commands/dashboard.d.ts

@@ -19,5 +19,10 @@ interface ServeOptions {
     port: number;
     open: boolean;
 }
+/**
+ * Resolve the SPA assets directory from packages/dashboard/dist/.
+ * Tries multiple strategies to locate it across dev (tsx) and bundled (cjs) modes.
+ */
+export declare function resolveAssetsDir(): string | null;
 export declare function serveDashboard(options: ServeOptions): Promise<void>;
 export {};

package/dist/commands/dashboard.js

@@ -138,7 +138,7 @@ export function writeDashboardFromState() {
  * Resolve the SPA assets directory from packages/dashboard/dist/.
  * Tries multiple strategies to locate it across dev (tsx) and bundled (cjs) modes.
  */
-function resolveAssetsDir() {
+export function resolveAssetsDir() {
     // Strategy 1: relative to this source file (works in dev with tsx)
     const devPath = path.resolve(__dirname, '../../dashboard/dist');
     if (fs.existsSync(path.join(devPath, 'index.html'))) {

package/dist/commands/startup.d.ts

@@ -31,7 +31,7 @@ export declare function detectIssueList(): IssueListInfo | undefined;
  * Returns StartupOutput with one of three shapes:
  * 1. Setup incomplete: { version, setupComplete: false }
  * 2. Auth failure: { version, setupComplete: true, authError: "..." }
- * 3. Success: { version, setupComplete: true, daily, dashboardPath?, issueList? }
+ * 3. Success: { version, setupComplete: true, daily, dashboardPath?, dashboardUrl?, issueList? }
  *
  * Errors from the daily check propagate to the caller.
  */

package/dist/commands/startup.js

@@ -12,6 +12,7 @@ import { getStateManager, getGitHubToken, getCLIVersion } from '../core/index.js
 import { errorMessage } from '../core/errors.js';
 import { executeDailyCheck } from './daily.js';
 import { writeDashboardFromState } from './dashboard.js';
+import { launchDashboardServer } from './dashboard-lifecycle.js';
 /**
  * Parse issueListPath from a config file's YAML frontmatter.
  * Returns the path string or undefined if not found.
@@ -93,9 +94,22 @@ export function detectIssueList() {
     }
 }
 function openInBrowser(filePath) {
-    const isWindows = process.platform === 'win32';
-    const openCmd = process.platform === 'darwin' ? 'open' : isWindows ? 'cmd' : 'xdg-open';
-    const args = isWindows ? ['/c', 'start', '', filePath] : [filePath];
+    let openCmd;
+    let args;
+    switch (process.platform) {
+        case 'darwin':
+            openCmd = 'open';
+            args = [filePath];
+            break;
+        case 'win32':
+            openCmd = 'cmd';
+            args = ['/c', 'start', '', filePath];
+            break;
+        default:
+            openCmd = 'xdg-open';
+            args = [filePath];
+            break;
+    }
     execFile(openCmd, args, (error) => {
         if (error) {
             console.error(`[STARTUP] Failed to open dashboard in browser: ${error.message}`);
@@ -107,7 +121,7 @@ function openInBrowser(filePath) {
  * Returns StartupOutput with one of three shapes:
  * 1. Setup incomplete: { version, setupComplete: false }
  * 2. Auth failure: { version, setupComplete: true, authError: "..." }
- * 3. Success: { version, setupComplete: true, daily, dashboardPath?, issueList? }
+ * 3. Success: { version, setupComplete: true, daily, dashboardPath?, dashboardUrl?, issueList? }
  *
  * Errors from the daily check propagate to the caller.
  */
@@ -129,31 +143,49 @@ export async function runStartup() {
     }
     // 3. Run daily check
     const daily = await executeDailyCheck(token);
-    // 4. Generate dashboard from state (just saved by daily)
-    // Skip opening on first run (0 PRs) — the welcome flow handles onboarding
+    // 4. Generate static HTML dashboard (always — serves as fallback + snapshot)
     let dashboardPath;
-    let dashboardOpened = false;
     try {
         dashboardPath = writeDashboardFromState();
-        if (daily.digest.summary.totalActivePRs > 0) {
-            openInBrowser(dashboardPath);
-            dashboardOpened = true;
-        }
     }
     catch (error) {
         console.error('[STARTUP] Dashboard generation failed:', errorMessage(error));
     }
+    // 5. Launch interactive SPA dashboard (preferred) with static HTML fallback
+    // Skip opening on first run (0 PRs) — the welcome flow handles onboarding
+    let dashboardUrl;
+    let dashboardOpened = false;
+    if (daily.digest.summary.totalActivePRs > 0) {
+        let spaResult = null;
+        try {
+            spaResult = await launchDashboardServer();
+        }
+        catch (error) {
+            console.error('[STARTUP] SPA dashboard launch failed:', errorMessage(error));
+        }
+        if (spaResult) {
+            dashboardUrl = spaResult.url;
+            openInBrowser(spaResult.url);
+            dashboardOpened = true;
+        }
+        else if (dashboardPath) {
+            // SPA unavailable (assets not built) — fall back to static HTML
+            openInBrowser(dashboardPath);
+            dashboardOpened = true;
+        }
+    }
     // Append dashboard status to brief summary (only startup opens the browser, not daily)
     if (dashboardOpened) {
         daily.briefSummary += ' | Dashboard opened in browser';
     }
-    // 5. Detect issue list
+    // 6. Detect issue list
     const issueList = detectIssueList();
     return {
         version,
         setupComplete: true,
         daily,
         dashboardPath,
+        dashboardUrl,
         issueList,
     };
 }

package/dist/core/github-stats.d.ts

@@ -4,7 +4,7 @@
  */
 import { Octokit } from '@octokit/rest';
 import { ClosedPR, MergedPR } from './types.js';
-/** TTL for cached PR count results (1 hour). */
+/** TTL for cached PR count results (24 hours — these stats change slowly). */
 export declare const PR_COUNTS_CACHE_TTL_MS: number;
 /** Return type shared by both merged and closed PR count functions. */
 export interface PRCountsResult<R> {
@@ -13,6 +13,8 @@ export interface PRCountsResult<R> {
     monthlyOpenedCounts: Record<string, number>;
     dailyActivityCounts: Record<string, number>;
 }
+/** Returns an empty PRCountsResult. Used as the fallback when stats fetches fail or username is empty. */
+export declare function emptyPRCountsResult<R>(): PRCountsResult<R>;
 /**
  * Fetch merged PR counts and latest merge dates per repository for the configured user.
  * Also builds a monthly histogram of all merges for the contribution timeline.

package/dist/core/github-stats.js

@@ -6,8 +6,18 @@ import { extractOwnerRepo, parseGitHubUrl, isOwnRepo } from './utils.js';
 import { debug, warn } from './logger.js';
 import { getHttpCache } from './http-cache.js';
 const MODULE = 'github-stats';
-/** TTL for cached PR count results (1 hour). */
-export const PR_COUNTS_CACHE_TTL_MS = 60 * 60 * 1000;
+/** TTL for cached PR count results (24 hours — these stats change slowly). */
+export const PR_COUNTS_CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+/**
+ * Maximum number of pages to fetch during paginated PR count searches.
+ * GitHub's Search API becomes unreliable (500s, ECONNRESET) at deep pages (4-5+).
+ * 3 pages × 100 per_page = 300 results, which covers the vast majority of users.
+ */
+const MAX_PAGINATION_PAGES = 3;
+/** Returns an empty PRCountsResult. Used as the fallback when stats fetches fail or username is empty. */
+export function emptyPRCountsResult() {
+    return { repos: new Map(), monthlyCounts: {}, monthlyOpenedCounts: {}, dailyActivityCounts: {} };
+}
 /** Type guard for deserialized cache data — prevents crashes on corrupt/stale cache. */
 function isCachedPRCounts(v) {
     if (typeof v !== 'object' || v === null)
@@ -31,7 +41,7 @@ function isCachedPRCounts(v) {
  */
 async function fetchUserPRCounts(octokit, githubUsername, query, label, accumulateRepo) {
     if (!githubUsername) {
-        return { repos: new Map(), monthlyCounts: {}, monthlyOpenedCounts: {}, dailyActivityCounts: {} };
+        return emptyPRCountsResult();
     }
     // Check for a fresh cached result (avoids 10-20 paginated API calls)
     const cache = getHttpCache();
@@ -53,6 +63,7 @@ async function fetchUserPRCounts(octokit, githubUsername, query, label, accumula
     const dailyActivityCounts = {};
     let page = 1;
     let fetched = 0;
+    let totalCount;
     while (true) {
         const { data } = await octokit.search.issuesAndPullRequests({
             q: `is:pr ${query} author:${githubUsername}`,
@@ -61,6 +72,7 @@ async function fetchUserPRCounts(octokit, githubUsername, query, label, accumula
             per_page: 100,
             page,
         });
+        totalCount = data.total_count;
         for (const item of data.items) {
             const parsed = extractOwnerRepo(item.html_url);
             if (!parsed) {
@@ -95,14 +107,22 @@ async function fetchUserPRCounts(octokit, githubUsername, query, label, accumula
             }
         }
         fetched += data.items.length;
-        // Stop if we've fetched all results or hit the API limit (1000)
-        if (fetched >= data.total_count || fetched >= 1000 || data.items.length === 0) {
+        // Stop if we've fetched all results, hit the API limit (1000), or reached max pages
+        // GitHub Search API returns 500/ECONNRESET on deep pagination (page 4-5+),
+        // so we cap at MAX_PAGINATION_PAGES to avoid taking down the entire startup flow.
+        if (fetched >= data.total_count || 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} ${label} PRs. Stats may be incomplete for prolific contributors.`);
+    }
     debug(MODULE, `Found ${fetched} ${label} PRs across ${repos.size} repos`);
-    // Cache the aggregated result (Map → entries array for JSON serialization)
+    // Cache the aggregated result (Map → entries array for JSON serialization).
+    // Note: truncated results (from pagination cap) are cached with the same TTL. This is an
+    // accepted tradeoff — prolific contributors (300+ PRs) may see slightly incomplete stats
+    // for up to 24 hours, but these are cosmetic and self-heal on the next cache expiry.
     cache.set(cacheKey, '', {
         reposEntries: Array.from(repos.entries()),
         monthlyCounts,

package/dist/formatters/json.d.ts

@@ -200,7 +200,7 @@ export interface IssueListInfo {
  * Three valid shapes:
  * 1. Setup incomplete: { version, setupComplete: false }
  * 2. Auth failure: { version, setupComplete: true, authError: "..." }
- * 3. Success: { version, setupComplete: true, daily, dashboardPath?, issueList? }
+ * 3. Success: { version, setupComplete: true, daily, dashboardPath?, dashboardUrl?, issueList? }
  */
 export interface StartupOutput {
     version: string;
@@ -208,6 +208,8 @@ export interface StartupOutput {
     authError?: string;
     daily?: DailyOutput;
     dashboardPath?: string;
+    /** URL of the interactive SPA dashboard server, when running (e.g., "http://localhost:3000") */
+    dashboardUrl?: string;
     issueList?: IssueListInfo;
 }
 /** A single parsed issue from a markdown list (#82) */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oss-autopilot/core",
-  "version": "0.42.5",
+  "version": "0.43.0",
   "description": "CLI and core library for managing open source contributions",
   "type": "module",
   "bin": {