@oss-autopilot/core 0.44.3 → 0.44.16

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

@@ -16,6 +16,23 @@ const MODULE = 'daily';
 // 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
 // ---------------------------------------------------------------------------
@@ -31,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)}`);
@@ -177,7 +198,7 @@ async function updateRepoScores(prMonitor, prs, mergedCounts, closedCounts) {
     }
     catch (error) {
         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).');
+        warn(MODULE, 'Repos without cached star data will be excluded from stats until star counts are fetched on the next successful run.');
         starCounts = new Map();
     }
     let starUpdateFailures = 0;
@@ -243,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 {

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,18 @@ 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.
- * Skips overwriting when data is empty to avoid wiping chart data on transient API failures.
+ * 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;

package/dist/commands/dashboard-data.js

@@ -7,7 +7,8 @@ import { getStateManager, PRMonitor, IssueConversationMonitor } from '../core/in
 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 { isBelowMinStars, } from '../core/types.js';
+import { toShelvedPRRef, buildStarFilter } from './daily.js';
 const MODULE = 'dashboard-data';
 export function buildDashboardStats(digest, state) {
     const summary = digest.summary || {
@@ -16,24 +17,40 @@ export function buildDashboardStats(digest, state) {
         mergeRate: 0,
         totalNeedingAttention: 0,
     };
+    const minStars = state.config.minStars ?? 50;
     return {
         activePRs: summary.totalActivePRs,
         shelvedPRs: (digest.shelvedPRs || []).length,
         mergedPRs: summary.totalMergedAllTime,
-        closedPRs: Object.values(state.repoScores || {}).reduce((sum, s) => sum + (s.closedWithoutMergeCount || 0), 0),
+        closedPRs: Object.values(state.repoScores || {}).reduce((sum, s) => sum + (isBelowMinStars(s.stargazersCount, minStars) ? 0 : s.closedWithoutMergeCount || 0), 0),
         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.
- * Skips overwriting when data is empty to avoid wiping chart data on transient API failures.
+ * 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(monthlyCounts);
+            stateManager.setMonthlyMergedCounts(mergeMonthlyCounts(state.monthlyMergedCounts || {}, monthlyCounts));
         }
     }
     catch (error) {
@@ -41,7 +58,7 @@ export function updateMonthlyAnalytics(prs, monthlyCounts, monthlyClosedCounts,
     }
     try {
         if (Object.keys(monthlyClosedCounts).length > 0) {
-            stateManager.setMonthlyClosedCounts(monthlyClosedCounts);
+            stateManager.setMonthlyClosedCounts(mergeMonthlyCounts(state.monthlyClosedCounts || {}, monthlyClosedCounts));
         }
     }
     catch (error) {
@@ -59,7 +76,7 @@ export function updateMonthlyAnalytics(prs, monthlyCounts, monthlyClosedCounts,
             }
         }
         if (Object.keys(combinedOpenedCounts).length > 0) {
-            stateManager.setMonthlyOpenedCounts(combinedOpenedCounts);
+            stateManager.setMonthlyOpenedCounts(mergeMonthlyCounts(state.monthlyOpenedCounts || {}, combinedOpenedCounts));
         }
     }
     catch (error) {
@@ -75,6 +92,8 @@ 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) => {
@@ -89,19 +108,21 @@ export async function fetchDashboardData(token) {
             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;
             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)}`);
             return emptyPRCountsResult();
         }),
         issueMonitor.fetchCommentedIssues().catch((error) => {
+            if (isRateLimitOrAuthError(error))
+                throw error;
             const msg = errorMessage(error);
             if (msg.includes('No GitHub username configured')) {
                 warn(MODULE, `Issue conversation tracking requires setup: ${msg}`);
@@ -128,9 +149,9 @@ export async function fetchDashboardData(token) {
     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;
@@ -156,8 +177,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 ===
@@ -141,10 +142,9 @@ export function generateDashboardScripts(stats, monthlyMerged, monthlyClosed, mo
             if (exOrgs?.some((o) => o.toLowerCase() === repoLower.split('/')[0]))
                 return true;
             const score = (state.repoScores || {})[repo];
-            // 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)
+            // Fail-closed: repos without cached star data are excluded from charts.
+            // Star data is populated by the daily check; repos appear once stars are fetched.
+            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;

package/dist/commands/dashboard-server.js

@@ -1,28 +1,21 @@
 /**
  * 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.
  */
 import * as http from 'http';
 import * as fs from 'fs';
 import * as path from 'path';
-import { getStateManager, getGitHubToken, getDataDir } from '../core/index.js';
+import { getStateManager, getGitHubToken, getDataDir, getCLIVersion } from '../core/index.js';
 import { errorMessage, ValidationError } from '../core/errors.js';
 import { warn } from '../core/logger.js';
-import { validateUrl, validateGitHubUrl, validateMessage, PR_URL_PATTERN, ISSUE_OR_PR_URL_PATTERN, } from './validation.js';
+import { validateUrl, validateGitHubUrl, PR_URL_PATTERN } from './validation.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',
-    'dismiss',
-    'undismiss',
-]);
+const VALID_ACTIONS = new Set(['shelve', 'unshelve', 'override_status']);
 const MODULE = 'dashboard-server';
 const MAX_BODY_BYTES = 10_240;
 const REQUEST_TIMEOUT_MS = 30_000;
@@ -35,6 +28,40 @@ const MIME_TYPES = {
     '.png': 'image/png',
     '.ico': 'image/x-icon',
 };
+/**
+ * Apply status overrides from state to the PR list.
+ * Overrides are auto-cleared if the PR has new activity since the override was set.
+ */
+function applyStatusOverrides(prs, state) {
+    const overrides = state.config.statusOverrides;
+    if (!overrides || Object.keys(overrides).length === 0)
+        return prs;
+    const stateManager = getStateManager();
+    // Snapshot keys before iteration — clearStatusOverride mutates the same object
+    const overrideUrls = new Set(Object.keys(overrides));
+    let didAutoClear = false;
+    const result = prs.map((pr) => {
+        const override = stateManager.getStatusOverride(pr.url, pr.updatedAt);
+        if (!override) {
+            if (overrideUrls.has(pr.url))
+                didAutoClear = true;
+            return pr;
+        }
+        if (override.status === pr.status)
+            return pr;
+        return { ...pr, status: override.status };
+    });
+    // Persist any auto-cleared overrides so they don't resurrect on restart
+    if (didAutoClear) {
+        try {
+            stateManager.save();
+        }
+        catch (err) {
+            warn(MODULE, `Failed to persist auto-cleared overrides — they may reappear on restart: ${errorMessage(err)}`);
+        }
+    }
+    return result;
+}
 // ── PID File Management ──────────────────────────────────────────────────────
 export function getDashboardPidPath() {
     return path.join(getDataDir(), 'dashboard-server.pid');
@@ -49,6 +76,8 @@ export function readDashboardServerInfo() {
         if (typeof parsed !== 'object' ||
             parsed === null ||
             typeof parsed.pid !== 'number' ||
+            !Number.isInteger(parsed.pid) ||
+            parsed.pid <= 0 ||
             typeof parsed.port !== 'number' ||
             typeof parsed.startedAt !== 'string') {
             warn(MODULE, 'PID file has invalid structure, ignoring');
@@ -133,9 +162,8 @@ function buildDashboardJson(digest, state, commentedIssues) {
         monthlyMerged,
         monthlyOpened,
         monthlyClosed,
-        activePRs: digest.openPRs || [],
+        activePRs: applyStatusOverrides(digest.openPRs || [], state),
         shelvedPRUrls: state.config.shelvedPRUrls || [],
-        dismissedUrls: Object.keys(state.config.dismissedIssues || {}),
         recentlyMergedPRs: digest.recentlyMergedPRs || [],
         recentlyClosedPRs: digest.recentlyClosedPRs || [],
         autoUnshelvedPRs: digest.autoUnshelvedPRs || [],
@@ -295,14 +323,10 @@ export async function startDashboardServer(options) {
             sendError(res, 400, 'Missing or invalid "url" field');
             return;
         }
-        // Validate URL format — same checks as CLI commands.
-        // Dismiss/undismiss accepts both PR and issue URLs; other actions are PR-only.
-        const isDismissAction = body.action === 'dismiss' || body.action === 'undismiss';
-        const urlPattern = isDismissAction ? ISSUE_OR_PR_URL_PATTERN : PR_URL_PATTERN;
-        const urlType = isDismissAction ? 'issue or PR' : 'PR';
+        // Validate URL format — all actions are PR-only now.
         try {
             validateUrl(body.url);
-            validateGitHubUrl(body.url, urlPattern, urlType);
+            validateGitHubUrl(body.url, PR_URL_PATTERN, 'PR');
         }
         catch (err) {
             if (err instanceof ValidationError) {
@@ -314,51 +338,30 @@ export async function startDashboardServer(options) {
             }
             return;
         }
-        // Validate snooze-specific fields
-        if (body.action === 'snooze') {
-            const days = body.days ?? 7;
-            if (typeof days !== 'number' || !Number.isFinite(days) || days <= 0) {
-                sendError(res, 400, 'Snooze days must be a positive finite number');
+        // Validate override_status-specific fields
+        if (body.action === 'override_status') {
+            if (!body.status || (body.status !== 'needs_addressing' && body.status !== 'waiting_on_maintainer')) {
+                sendError(res, 400, 'override_status requires a valid "status" field (needs_addressing or waiting_on_maintainer)');
                 return;
             }
-            if (body.reason !== undefined) {
-                try {
-                    validateMessage(String(body.reason));
-                }
-                catch (err) {
-                    if (err instanceof ValidationError) {
-                        sendError(res, 400, err.message);
-                    }
-                    else {
-                        warn(MODULE, `Unexpected error during message validation: ${errorMessage(err)}`);
-                        sendError(res, 400, 'Invalid reason');
-                    }
-                    return;
-                }
-            }
         }
         try {
             switch (body.action) {
                 case 'shelve':
                     stateManager.shelvePR(body.url);
-                    stateManager.undismissIssue(body.url); // prevent dual state
                     break;
                 case 'unshelve':
                     stateManager.unshelvePR(body.url);
                     break;
-                case 'snooze':
-                    stateManager.snoozePR(body.url, body.reason || 'Snoozed via dashboard', body.days ?? 7);
-                    break;
-                case 'unsnooze':
-                    stateManager.unsnoozePR(body.url);
-                    break;
-                case 'dismiss':
-                    stateManager.dismissIssue(body.url, new Date().toISOString());
-                    stateManager.unshelvePR(body.url); // prevent dual state
-                    break;
-                case 'undismiss':
-                    stateManager.undismissIssue(body.url);
+                case 'override_status': {
+                    // body.status is validated above — the early return ensures it's defined here
+                    const overrideStatus = body.status;
+                    // Find the PR to get its current updatedAt for auto-clear tracking
+                    const targetPR = (cachedDigest?.openPRs || []).find((pr) => pr.url === body.url);
+                    const lastActivityAt = targetPR?.updatedAt || new Date().toISOString();
+                    stateManager.setStatusOverride(body.url, overrideStatus, lastActivityAt);
                     break;
+                }
             }
             stateManager.save();
         }
@@ -480,7 +483,12 @@ export async function startDashboardServer(options) {
         }
     }
     // Write PID file so other processes can detect this running server
-    writeDashboardServerInfo({ pid: process.pid, port: actualPort, startedAt: new Date().toISOString() });
+    writeDashboardServerInfo({
+        pid: process.pid,
+        port: actualPort,
+        startedAt: new Date().toISOString(),
+        version: getCLIVersion(),
+    });
     const serverUrl = `http://localhost:${actualPort}`;
     warn(MODULE, `Dashboard server running at ${serverUrl}`);
     // ── Background refresh ─────────────────────────────────────────────────