@oss-autopilot/core 0.44.2 → 0.44.15

package/dist/commands/daily.d.ts

@@ -6,9 +6,14 @@
  * Domain logic lives in src/core/daily-logic.ts; this file is a thin
  * orchestration layer that wires up the phases and handles I/O.
  */
-import { type DailyDigest, type CommentedIssue, type PRCheckFailure, type RepoGroup } from '../core/index.js';
+import { type DailyDigest, type CommentedIssue, type PRCheckFailure, type RepoGroup, type AgentState, type StarFilter } from '../core/index.js';
 import { type DailyOutput, type CapacityAssessment, type ActionableIssue, type ActionMenu } from '../formatters/json.js';
 export { computeRepoSignals, groupPRsByRepo, assessCapacity, collectActionableIssues, computeActionMenu, toShelvedPRRef, formatBriefSummary, formatSummary, printDigest, CRITICAL_STATUSES, } from '../core/index.js';
+/**
+ * Build a star filter from state for use in fetchUserPRCounts.
+ * Returns undefined if no star data is available (first run).
+ */
+export declare function buildStarFilter(state: Readonly<AgentState>): StarFilter | undefined;
 /**
  * Internal result of the daily check, using full (non-deduplicated) types.
  * Consumed by printDigest() (text mode) and converted to DailyOutput (JSON mode)

package/dist/commands/daily.js

@@ -7,25 +7,32 @@
  * 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, getHttpStatusCode } from '../core/errors.js';
+import { errorMessage, isRateLimitOrAuthError } from '../core/errors.js';
 import { warn } from '../core/logger.js';
 import { emptyPRCountsResult } from '../core/github-stats.js';
+import { updateMonthlyAnalytics } from './dashboard-data.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';
+/**
+ * Build a star filter from state for use in fetchUserPRCounts.
+ * Returns undefined if no star data is available (first run).
+ */
+export function buildStarFilter(state) {
+    const minStars = state.config.minStars ?? 50;
+    const knownStarCounts = new Map();
+    for (const [repo, score] of Object.entries(state.repoScores)) {
+        if (score.stargazersCount !== undefined) {
+            knownStarCounts.set(repo, score.stargazersCount);
+        }
+    }
+    // Only filter if we have some star data to work with
+    if (knownStarCounts.size === 0)
+        return undefined;
+    return { minStars, knownStarCounts };
+}
 // ---------------------------------------------------------------------------
 // Phase functions
 // ---------------------------------------------------------------------------
@@ -41,17 +48,21 @@ async function fetchPRData(prMonitor, token) {
     if (failures.length > 0) {
         warn(MODULE, `${failures.length} PR fetch(es) failed`);
     }
+    // Build star filter from cached repoScores so low-star repos are excluded
+    // from merged/closed histograms (#576). Repos with no cached star data pass through.
+    const state = getStateManager().getState();
+    const starFilter = buildStarFilter(state);
     // 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) => {
+        prMonitor.fetchUserMergedPRCounts(starFilter).catch((err) => {
             if (isRateLimitOrAuthError(err))
                 throw err;
             warn(MODULE, `Failed to fetch merged PR counts: ${errorMessage(err)}`);
             return emptyPRCountsResult();
         }),
-        prMonitor.fetchUserClosedPRCounts().catch((err) => {
+        prMonitor.fetchUserClosedPRCounts(starFilter).catch((err) => {
             if (isRateLimitOrAuthError(err))
                 throw err;
             warn(MODULE, `Failed to fetch closed PR counts: ${errorMessage(err)}`);
@@ -218,53 +229,6 @@ async function updateRepoScores(prMonitor, prs, mergedCounts, closedCounts) {
         warn(MODULE, `[ALL_TRUST_SYNCS_FAILED] All ${mergedCounts.size} trusted project sync(s) failed. This may indicate corrupted state.`);
     }
 }
-/**
- * Phase 3: Persist monthly chart analytics to state.
- * Stores merged, closed, and combined opened counts per month.
- * Each metric is isolated so partial failures don't produce inconsistent state.
- */
-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).
-    // 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 {
-        if (Object.keys(monthlyCounts).length > 0) {
-            stateManager.setMonthlyMergedCounts(monthlyCounts);
-        }
-    }
-    catch (error) {
-        warn(MODULE, `Failed to store monthly merged counts: ${errorMessage(error)}`);
-    }
-    try {
-        if (Object.keys(monthlyClosedCounts).length > 0) {
-            stateManager.setMonthlyClosedCounts(monthlyClosedCounts);
-        }
-    }
-    catch (error) {
-        warn(MODULE, `Failed to store monthly closed counts: ${errorMessage(error)}`);
-    }
-    try {
-        // Build combined monthly opened counts from merged + closed + currently-open PRs
-        const combinedOpenedCounts = { ...openedFromMerged };
-        for (const [month, count] of Object.entries(openedFromClosed)) {
-            combinedOpenedCounts[month] = (combinedOpenedCounts[month] || 0) + count;
-        }
-        // Add currently-open PR creation dates
-        for (const pr of prs) {
-            if (pr.createdAt) {
-                const month = pr.createdAt.slice(0, 7);
-                combinedOpenedCounts[month] = (combinedOpenedCounts[month] || 0) + 1;
-            }
-        }
-        if (Object.keys(combinedOpenedCounts).length > 0) {
-            stateManager.setMonthlyOpenedCounts(combinedOpenedCounts);
-        }
-    }
-    catch (error) {
-        warn(MODULE, `Failed to compute/store monthly opened counts: ${errorMessage(error)}`);
-    }
-}
 /**
  * Phase 4: Expire snoozes and partition PRs into active vs shelved buckets.
  * Auto-unshelves PRs where maintainers have engaged, generates the digest,
@@ -300,8 +264,9 @@ function partitionPRs(prMonitor, prs, recentlyClosedPRs, recentlyMergedPRs) {
                 shelvedPRs.push(toShelvedPRRef(pr));
             }
         }
-        else if (pr.status === 'dormant') {
-            // Dormant PRs are auto-shelved (not persisted — they return when activity resumes)
+        else if (pr.stalenessTier === 'dormant' && !CRITICAL_STATUSES.has(pr.status)) {
+            // Dormant PRs are auto-shelved unless they need addressing
+            // (e.g. maintainer commented on a stale PR — it should resurface)
             shelvedPRs.push(toShelvedPRRef(pr));
         }
         else {
@@ -459,7 +424,7 @@ async function executeDailyCheckInternal(token) {
     // Phase 2: Update repo scores (signals, star counts, trust sync)
     await updateRepoScores(prMonitor, prs, mergedCounts, closedCounts);
     // Phase 3: Persist monthly analytics
-    updateAnalytics(prs, monthlyCounts, monthlyClosedCounts, openedFromMerged, openedFromClosed);
+    updateMonthlyAnalytics(prs, monthlyCounts, monthlyClosedCounts, openedFromMerged, openedFromClosed);
     // Phase 4: Expire snoozes, partition PRs, generate and save digest
     const { activePRs, shelvedPRs, digest } = partitionPRs(prMonitor, prs, recentlyClosedPRs, recentlyMergedPRs);
     // Phase 5: Build structured output (capacity, dismiss filter, action menu)

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

@@ -3,7 +3,7 @@
  * 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, AgentState, CommentedIssue } from '../core/types.js';
+import { type DailyDigest, type AgentState, type CommentedIssue } from '../core/types.js';
 export interface DashboardStats {
     activePRs: number;
     shelvedPRs: number;
@@ -12,10 +12,31 @@ export interface DashboardStats {
     mergeRate: string;
 }
 export declare function buildDashboardStats(digest: DailyDigest, state: Readonly<AgentState>): DashboardStats;
+/**
+ * Merge fresh API counts into existing stored counts.
+ * Months present in the fresh data are updated; months only in the existing data are preserved.
+ * This prevents historical data loss when the API returns incomplete results
+ * (e.g. due to pagination limits or transient failures).
+ */
+export declare function mergeMonthlyCounts(existing: Record<string, number>, fresh: Record<string, number>): Record<string, number>;
+/**
+ * Persist monthly chart analytics (merged, closed, opened) to state.
+ * Each metric is isolated so partial failures don't produce inconsistent state.
+ * Fresh API results are merged into existing data so historical months are preserved.
+ * Skips updating when fresh data is empty to avoid wiping chart data on transient API failures.
+ */
+export declare function updateMonthlyAnalytics(prs: Array<{
+    createdAt?: string;
+}>, monthlyCounts: Record<string, number>, monthlyClosedCounts: Record<string, number>, openedFromMerged: Record<string, number>, openedFromClosed: Record<string, number>): void;
 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.

package/dist/commands/dashboard-data.js

@@ -4,9 +4,12 @@
  * Consumed by the dashboard HTTP server (dashboard-server.ts) for the SPA API.
  */
 import { getStateManager, PRMonitor, IssueConversationMonitor } from '../core/index.js';
-import { errorMessage, getHttpStatusCode } from '../core/errors.js';
+import { errorMessage, isRateLimitOrAuthError } from '../core/errors.js';
+import { warn } from '../core/logger.js';
 import { emptyPRCountsResult } from '../core/github-stats.js';
-import { toShelvedPRRef } from './daily.js';
+import { toShelvedPRRef, buildStarFilter } from './daily.js';
+const MODULE = 'dashboard-data';
+import { isBelowMinStars, } from '../core/types.js';
 export function buildDashboardStats(digest, state) {
     const summary = digest.summary || {
         totalActivePRs: 0,
@@ -22,58 +25,109 @@ export function buildDashboardStats(digest, state) {
         mergeRate: `${(summary.mergeRate ?? 0).toFixed(1)}%`,
     };
 }
+/**
+ * Merge fresh API counts into existing stored counts.
+ * Months present in the fresh data are updated; months only in the existing data are preserved.
+ * This prevents historical data loss when the API returns incomplete results
+ * (e.g. due to pagination limits or transient failures).
+ */
+export function mergeMonthlyCounts(existing, fresh) {
+    const merged = { ...existing };
+    for (const [month, count] of Object.entries(fresh)) {
+        merged[month] = count;
+    }
+    return merged;
+}
+/**
+ * Persist monthly chart analytics (merged, closed, opened) to state.
+ * Each metric is isolated so partial failures don't produce inconsistent state.
+ * Fresh API results are merged into existing data so historical months are preserved.
+ * Skips updating when fresh data is empty to avoid wiping chart data on transient API failures.
+ */
+export function updateMonthlyAnalytics(prs, monthlyCounts, monthlyClosedCounts, openedFromMerged, openedFromClosed) {
+    const stateManager = getStateManager();
+    const state = stateManager.getState();
+    try {
+        if (Object.keys(monthlyCounts).length > 0) {
+            stateManager.setMonthlyMergedCounts(mergeMonthlyCounts(state.monthlyMergedCounts || {}, monthlyCounts));
+        }
+    }
+    catch (error) {
+        warn(MODULE, `Failed to store monthly merged counts: ${errorMessage(error)}`);
+    }
+    try {
+        if (Object.keys(monthlyClosedCounts).length > 0) {
+            stateManager.setMonthlyClosedCounts(mergeMonthlyCounts(state.monthlyClosedCounts || {}, monthlyClosedCounts));
+        }
+    }
+    catch (error) {
+        warn(MODULE, `Failed to store monthly closed counts: ${errorMessage(error)}`);
+    }
+    try {
+        const combinedOpenedCounts = { ...openedFromMerged };
+        for (const [month, count] of Object.entries(openedFromClosed)) {
+            combinedOpenedCounts[month] = (combinedOpenedCounts[month] || 0) + count;
+        }
+        for (const pr of prs) {
+            if (pr.createdAt) {
+                const month = pr.createdAt.slice(0, 7);
+                combinedOpenedCounts[month] = (combinedOpenedCounts[month] || 0) + 1;
+            }
+        }
+        if (Object.keys(combinedOpenedCounts).length > 0) {
+            stateManager.setMonthlyOpenedCounts(mergeMonthlyCounts(state.monthlyOpenedCounts || {}, combinedOpenedCounts));
+        }
+    }
+    catch (error) {
+        warn(MODULE, `Failed to store monthly opened counts: ${errorMessage(error)}`);
+    }
+}
 /**
  * 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);
     const issueMonitor = new IssueConversationMonitor(token);
+    // Build star filter from cached repoScores (#576)
+    const starFilter = buildStarFilter(stateManager.getState());
     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)}`);
+            warn(MODULE, `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)}`);
+            warn(MODULE, `Failed to fetch recently merged PRs: ${errorMessage(err)}`);
             return [];
         }),
-        prMonitor.fetchUserMergedPRCounts().catch((err) => {
+        prMonitor.fetchUserMergedPRCounts(starFilter).catch((err) => {
             if (isRateLimitOrAuthError(err))
                 throw err;
-            console.error(`Warning: Failed to fetch merged PR counts: ${errorMessage(err)}`);
+            warn(MODULE, `Failed to fetch merged PR counts: ${errorMessage(err)}`);
             return emptyPRCountsResult();
         }),
-        prMonitor.fetchUserClosedPRCounts().catch((err) => {
+        prMonitor.fetchUserClosedPRCounts(starFilter).catch((err) => {
             if (isRateLimitOrAuthError(err))
                 throw err;
-            console.error(`Warning: Failed to fetch closed PR counts: ${errorMessage(err)}`);
+            warn(MODULE, `Failed to fetch closed PR counts: ${errorMessage(err)}`);
             return emptyPRCountsResult();
         }),
         issueMonitor.fetchCommentedIssues().catch((error) => {
+            if (isRateLimitOrAuthError(error))
+                throw error;
             const msg = errorMessage(error);
             if (msg.includes('No GitHub username configured')) {
-                console.error(`[DASHBOARD] Issue conversation tracking requires setup: ${msg}`);
+                warn(MODULE, `Issue conversation tracking requires setup: ${msg}`);
             }
             else {
-                console.error(`[DASHBOARD] Issue conversation fetch failed: ${msg}`);
+                warn(MODULE, `Issue conversation fetch failed: ${msg}`);
             }
             return {
                 issues: [],
@@ -83,54 +137,20 @@ export async function fetchDashboardData(token) {
     ]);
     const commentedIssues = fetchedIssues.issues;
     if (fetchedIssues.failures.length > 0) {
-        console.error(`[DASHBOARD] ${fetchedIssues.failures.length} issue conversation check(s) failed`);
+        warn(MODULE, `${fetchedIssues.failures.length} issue conversation check(s) failed`);
     }
     if (failures.length > 0) {
-        console.error(`Warning: ${failures.length} PR fetch(es) failed`);
+        warn(MODULE, `${failures.length} PR fetch(es) failed`);
     }
     // 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 {
-        if (Object.keys(monthlyCounts).length > 0) {
-            stateManager.setMonthlyMergedCounts(monthlyCounts);
-        }
-    }
-    catch (error) {
-        console.error('[DASHBOARD] Failed to store monthly merged counts:', errorMessage(error));
-    }
-    try {
-        if (Object.keys(monthlyClosedCounts).length > 0) {
-            stateManager.setMonthlyClosedCounts(monthlyClosedCounts);
-        }
-    }
-    catch (error) {
-        console.error('[DASHBOARD] Failed to store monthly closed counts:', errorMessage(error));
-    }
-    try {
-        const combinedOpenedCounts = { ...openedFromMerged };
-        for (const [month, count] of Object.entries(openedFromClosed)) {
-            combinedOpenedCounts[month] = (combinedOpenedCounts[month] || 0) + count;
-        }
-        for (const pr of prs) {
-            if (pr.createdAt) {
-                const month = pr.createdAt.slice(0, 7);
-                combinedOpenedCounts[month] = (combinedOpenedCounts[month] || 0) + 1;
-            }
-        }
-        if (Object.keys(combinedOpenedCounts).length > 0) {
-            stateManager.setMonthlyOpenedCounts(combinedOpenedCounts);
-        }
-    }
-    catch (error) {
-        console.error('[DASHBOARD] Failed to store monthly opened counts:', errorMessage(error));
-    }
+    updateMonthlyAnalytics(prs, monthlyCounts, monthlyClosedCounts, openedFromMerged, openedFromClosed);
     const digest = prMonitor.generateDigest(prs, recentlyClosedPRs, recentlyMergedPRs);
     // Apply shelve partitioning for display (auto-unshelve only runs in daily check)
-    // Dormant PRs are treated as shelved for display purposes
+    // Dormant PRs are treated as shelved unless they need addressing
     const shelvedUrls = new Set(stateManager.getState().config.shelvedPRUrls || []);
-    const freshShelved = prs.filter((pr) => shelvedUrls.has(pr.url) || pr.status === 'dormant');
+    const freshShelved = prs.filter((pr) => shelvedUrls.has(pr.url) || (pr.stalenessTier === 'dormant' && pr.status !== 'needs_addressing'));
     digest.shelvedPRs = freshShelved.map(toShelvedPRRef);
     digest.autoUnshelvedPRs = [];
     digest.summary.totalActivePRs = prs.length - freshShelved.length;
@@ -139,9 +159,9 @@ export async function fetchDashboardData(token) {
         stateManager.save();
     }
     catch (error) {
-        console.error('Warning: Failed to save dashboard digest to state:', errorMessage(error));
+        warn(MODULE, `Failed to save dashboard digest to state: ${errorMessage(error)}`);
     }
-    console.error(`Refreshed: ${prs.length} PRs fetched`);
+    warn(MODULE, `Refreshed: ${prs.length} PRs fetched`);
     return { digest, commentedIssues };
 }
 /**
@@ -156,8 +176,11 @@ export function computePRsByRepo(digest, state) {
             prsByRepo[pr.repo] = { active: 0, merged: 0, closed: 0 };
         prsByRepo[pr.repo].active++;
     }
-    // Add merged/closed counts from repo scores (historical data)
+    // Add merged/closed counts from repo scores (historical data), filtering by minStars (#576)
+    const minStars = state.config.minStars ?? 50;
     for (const [repo, score] of Object.entries(state.repoScores || {})) {
+        if (isBelowMinStars(score.stargazersCount, minStars))
+            continue;
         if (!prsByRepo[repo])
             prsByRepo[repo] = { active: 0, merged: 0, closed: 0 };
         prsByRepo[repo].merged = score.mergedPRCount;

package/dist/commands/dashboard-lifecycle.js

@@ -4,8 +4,9 @@
  * and detecting whether a server is already running.
  */
 import { spawn } from 'child_process';
-import { findRunningDashboardServer, isDashboardServerRunning, readDashboardServerInfo } from './dashboard-server.js';
+import { findRunningDashboardServer, isDashboardServerRunning, readDashboardServerInfo, removeDashboardServerInfo, } from './dashboard-server.js';
 import { resolveAssetsDir } from './dashboard.js';
+import { getCLIVersion } from '../core/index.js';
 const DEFAULT_PORT = 3000;
 const POLL_INTERVAL_MS = 200;
 const MAX_POLL_ATTEMPTS = 25; // 5 seconds total
@@ -30,7 +31,43 @@ export async function launchDashboardServer(options) {
     // 2. Check if a server is already running
     const existing = await findRunningDashboardServer();
     if (existing) {
-        return { url: existing.url, port: existing.port, alreadyRunning: true };
+        // If the running server is from a different CLI version, kill it and relaunch
+        // so the dashboard uses the current version's code (#548)
+        const info = readDashboardServerInfo();
+        const currentVersion = getCLIVersion();
+        if (!info) {
+            // PID file disappeared between health check and now (race condition).
+            // Fall through to launch a new server.
+        }
+        else if (info.version && currentVersion !== '0.0.0' && info.version !== currentVersion) {
+            console.error(`[STARTUP] Dashboard server version mismatch (running: ${info.version}, current: ${currentVersion}). Restarting...`);
+            let killed = false;
+            try {
+                process.kill(info.pid, 'SIGTERM');
+                killed = true;
+            }
+            catch (err) {
+                const code = err.code;
+                if (code === 'ESRCH') {
+                    killed = true; // Already exited
+                }
+                else {
+                    console.error(`[STARTUP] Could not kill outdated dashboard (PID ${info.pid}): ${err.message}`);
+                }
+            }
+            if (killed) {
+                removeDashboardServerInfo();
+            }
+            else {
+                // Could not kill old server (e.g. EPERM); return it rather than
+                // attempting a doomed spawn on the same port.
+                return { url: existing.url, port: existing.port, alreadyRunning: true };
+            }
+            // Fall through to launch a new server
+        }
+        else {
+            return { url: existing.url, port: existing.port, alreadyRunning: true };
+        }
     }
     // 3. Launch as detached child process
     const port = options?.port ?? DEFAULT_PORT;

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

@@ -1,7 +1,7 @@
 /**
  * Client-side JavaScript for the dashboard: theme toggle, filtering, Chart.js charts.
  */
-import type { DailyDigest, AgentState } from '../core/types.js';
+import { type DailyDigest, type AgentState } from '../core/types.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-scripts.js

@@ -1,6 +1,7 @@
 /**
  * Client-side JavaScript for the dashboard: theme toggle, filtering, Chart.js charts.
  */
+import { isBelowMinStars } from '../core/types.js';
 /** Static client-side JS: theme toggle + filter/search logic. */
 const THEME_AND_FILTER_SCRIPT = `
     // === Theme Toggle ===
@@ -144,7 +145,7 @@ export function generateDashboardScripts(stats, monthlyMerged, monthlyClosed, mo
             // Fail-open: repos without cached star data are shown (not excluded).
             // Unlike issue-discovery (fail-closed), the dashboard shows the user's own
             // contribution history — hiding repos just because a star fetch failed would be confusing.
-            if (score?.stargazersCount !== undefined && score.stargazersCount < starThreshold)
+            if (isBelowMinStars(score?.stargazersCount, starThreshold))
                 return true;
             return false;
         };

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

@@ -1,7 +1,7 @@
 /**
  * Dashboard HTTP server.
  * Serves the Preact SPA from packages/dashboard/dist/ and provides API endpoints
- * for live data fetching and state mutations (shelve, snooze, etc.).
+ * for live data fetching and state mutations (shelve, unshelve, override, etc.).
  *
  * Uses Node's built-in http module — no Express/Fastify.
  */
@@ -15,6 +15,7 @@ export interface DashboardServerInfo {
     pid: number;
     port: number;
     startedAt: string;
+    version?: string;
 }
 export declare function getDashboardPidPath(): string;
 export declare function writeDashboardServerInfo(info: DashboardServerInfo): void;