@oss-autopilot/core 0.44.2 → 0.44.15

package/dist/commands/dashboard-server.js

@@ -1,28 +1,24 @@
 /**
  * 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 { validateUrl, validateGitHubUrl, validateMessage, PR_URL_PATTERN, ISSUE_OR_PR_URL_PATTERN, } from './validation.js';
+import { warn } from '../core/logger.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;
 const MIME_TYPES = {
     '.html': 'text/html',
     '.js': 'application/javascript',
@@ -32,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');
@@ -46,9 +76,11 @@ 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') {
-            console.error('[DASHBOARD] PID file has invalid structure, ignoring');
+            warn(MODULE, 'PID file has invalid structure, ignoring');
             return null;
         }
         return parsed;
@@ -56,7 +88,7 @@ export function readDashboardServerInfo() {
     catch (err) {
         const code = err.code;
         if (code !== 'ENOENT') {
-            console.error(`[DASHBOARD] Failed to read PID file: ${err.message}`);
+            warn(MODULE, `Failed to read PID file: ${err.message}`);
         }
         return null;
     }
@@ -68,7 +100,7 @@ export function removeDashboardServerInfo() {
     catch (err) {
         const code = err.code;
         if (code !== 'ENOENT') {
-            console.error(`[DASHBOARD] Failed to remove PID file: ${err.message}`);
+            warn(MODULE, `Failed to remove PID file: ${err.message}`);
         }
     }
 }
@@ -98,7 +130,7 @@ export async function findRunningDashboardServer() {
     catch (err) {
         const code = err.code;
         if (code !== 'ESRCH' && code !== 'EPERM') {
-            console.error(`[DASHBOARD] Unexpected error checking PID ${info.pid}: ${err.message}`);
+            warn(MODULE, `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
@@ -130,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 || [],
@@ -170,10 +201,32 @@ function readBody(req, maxBytes = MAX_BODY_BYTES) {
         });
     });
 }
+/**
+ * Set security headers on every response.
+ */
+function setSecurityHeaders(res) {
+    res.setHeader('X-Content-Type-Options', 'nosniff');
+    res.setHeader('X-Frame-Options', 'DENY');
+    res.setHeader('Content-Security-Policy', "default-src 'self'; script-src 'self' https://cdn.jsdelivr.net; style-src 'self' 'unsafe-inline'; img-src 'self' data:; connect-src 'self'");
+    res.setHeader('Referrer-Policy', 'strict-origin-when-cross-origin');
+}
+/**
+ * Validate that POST requests originate from the local dashboard.
+ * Returns true if the Origin is acceptable, false otherwise.
+ */
+function isValidOrigin(req, port) {
+    const origin = req.headers['origin'];
+    if (!origin)
+        return true; // No Origin header = same-origin request (non-browser or same-page)
+    const allowed = [`http://localhost:${port}`, `http://127.0.0.1:${port}`];
+    return allowed.includes(origin);
+}
 /**
  * Send a JSON response.
  */
 function sendJson(res, statusCode, data) {
+    setSecurityHeaders(res);
+    res.setHeader('Cache-Control', 'no-store');
     const body = JSON.stringify(data);
     res.writeHead(statusCode, {
         'Content-Type': 'application/json',
@@ -199,9 +252,7 @@ export async function startDashboardServer(options) {
     let cachedDigest = stateManager.getState().lastDigest;
     let cachedCommentedIssues = [];
     if (!cachedDigest) {
-        console.error('No dashboard data available. Run the daily check first:');
-        console.error('  GITHUB_TOKEN=$(gh auth token) npm start -- daily');
-        process.exit(1);
+        throw new Error('No dashboard data available. Run the daily check first: GITHUB_TOKEN=$(gh auth token) npm start -- daily');
     }
     // ── Build cached JSON response ───────────────────────────────────────────
     let cachedJsonData;
@@ -209,9 +260,7 @@ export async function startDashboardServer(options) {
         cachedJsonData = buildDashboardJson(cachedDigest, stateManager.getState(), cachedCommentedIssues);
     }
     catch (error) {
-        console.error('Failed to build dashboard data from cached digest:', error);
-        console.error('Your state data may be corrupted. Try running: daily --json');
-        process.exit(1);
+        throw new Error(`Failed to build dashboard data: ${errorMessage(error)}. State data may be corrupted — try running: daily --json`, { cause: error });
     }
     // ── Request handler ──────────────────────────────────────────────────────
     const server = http.createServer(async (req, res) => {
@@ -224,10 +273,18 @@ export async function startDashboardServer(options) {
                 return;
             }
             if (url === '/api/action' && method === 'POST') {
+                if (!isValidOrigin(req, actualPort)) {
+                    sendError(res, 403, 'Invalid origin');
+                    return;
+                }
                 await handleAction(req, res);
                 return;
             }
             if (url === '/api/refresh' && method === 'POST') {
+                if (!isValidOrigin(req, actualPort)) {
+                    sendError(res, 403, 'Invalid origin');
+                    return;
+                }
                 await handleRefresh(req, res);
                 return;
             }
@@ -239,12 +296,13 @@ export async function startDashboardServer(options) {
             sendError(res, 405, 'Method not allowed');
         }
         catch (error) {
-            console.error('Unhandled request error:', method, url, error);
+            warn(MODULE, `Unhandled request error: ${method} ${url} ${errorMessage(error)}`);
             if (!res.headersSent) {
                 sendError(res, 500, 'Internal server error');
             }
         }
     });
+    server.requestTimeout = REQUEST_TIMEOUT_MS;
     // ── POST /api/action handler ─────────────────────────────────────────────
     async function handleAction(req, res) {
         let body;
@@ -265,76 +323,51 @@ 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) {
                 sendError(res, 400, err.message);
             }
             else {
-                console.error('Unexpected error during URL validation:', err);
+                warn(MODULE, `Unexpected error during URL validation: ${errorMessage(err)}`);
                 sendError(res, 400, 'Invalid URL');
             }
             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 {
-                        console.error('Unexpected error during message validation:', 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();
         }
         catch (error) {
-            console.error('Action failed:', body.action, body.url, error);
-            sendError(res, 500, `Action failed: ${errorMessage(error)}`);
+            warn(MODULE, `Action failed: ${body.action} ${body.url} ${errorMessage(error)}`);
+            sendError(res, 500, 'Action failed');
             return;
         }
         // Rebuild dashboard data from cached digest + updated state
@@ -349,7 +382,7 @@ export async function startDashboardServer(options) {
             return;
         }
         try {
-            console.error('Refreshing dashboard data from GitHub...');
+            warn(MODULE, 'Refreshing dashboard data from GitHub...');
             const result = await fetchDashboardData(currentToken);
             cachedDigest = result.digest;
             cachedCommentedIssues = result.commentedIssues;
@@ -357,8 +390,8 @@ export async function startDashboardServer(options) {
             sendJson(res, 200, cachedJsonData);
         }
         catch (error) {
-            console.error('Dashboard refresh failed:', error);
-            sendError(res, 500, `Refresh failed: ${errorMessage(error)}`);
+            warn(MODULE, `Dashboard refresh failed: ${errorMessage(error)}`);
+            sendError(res, 500, 'Refresh failed');
         }
     }
     // ── Static file serving ──────────────────────────────────────────────────
@@ -368,8 +401,8 @@ export async function startDashboardServer(options) {
         try {
             urlPath = decodeURIComponent(requestUrl.split('?')[0]);
         }
-        catch (err) {
-            console.error('Malformed URL received:', requestUrl, err);
+        catch (_err) {
+            warn(MODULE, `Malformed URL received: ${requestUrl}`);
             sendError(res, 400, 'Malformed URL');
             return;
         }
@@ -399,7 +432,7 @@ export async function startDashboardServer(options) {
                 filePath = path.join(resolvedAssetsDir, 'index.html');
             }
             else {
-                console.error('Failed to stat file:', filePath, err);
+                warn(MODULE, `Failed to stat file: ${filePath}`);
                 sendError(res, 500, 'Internal server error');
                 return;
             }
@@ -408,9 +441,11 @@ export async function startDashboardServer(options) {
         const contentType = MIME_TYPES[ext] || 'application/octet-stream';
         try {
             const content = fs.readFileSync(filePath);
+            setSecurityHeaders(res);
             res.writeHead(200, {
                 'Content-Type': contentType,
                 'Content-Length': content.length,
+                'Cache-Control': 'public, max-age=3600',
             });
             res.end(content);
         }
@@ -420,7 +455,7 @@ export async function startDashboardServer(options) {
                 sendError(res, 404, 'Not found');
             }
             else {
-                console.error('Failed to serve static file:', filePath, error);
+                warn(MODULE, `Failed to serve static file: ${filePath}`);
                 sendError(res, 500, 'Failed to read file');
             }
         }
@@ -440,18 +475,22 @@ export async function startDashboardServer(options) {
         catch (err) {
             const nodeErr = err;
             if (nodeErr.code === 'EADDRINUSE' && attempt < MAX_PORT_ATTEMPTS - 1) {
-                console.error(`Port ${actualPort} is in use, trying ${actualPort + 1}...`);
+                warn(MODULE, `Port ${actualPort} is in use, trying ${actualPort + 1}...`);
                 actualPort++;
                 continue;
             }
-            console.error(`Failed to start server: ${nodeErr.message}`);
-            process.exit(1);
+            throw new Error(`Failed to start server: ${nodeErr.message}`, { cause: err });
         }
     }
     // 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}`;
-    console.error(`Dashboard server running at ${serverUrl}`);
+    warn(MODULE, `Dashboard server running at ${serverUrl}`);
     // ── Background refresh ─────────────────────────────────────────────────
     // Port is bound and PID file written — now fetch fresh data from GitHub
     // so subsequent /api/data requests get live data instead of cached state.
@@ -461,10 +500,10 @@ export async function startDashboardServer(options) {
             cachedDigest = result.digest;
             cachedCommentedIssues = result.commentedIssues;
             cachedJsonData = buildDashboardJson(cachedDigest, stateManager.getState(), cachedCommentedIssues);
-            console.error('Background data refresh complete');
+            warn(MODULE, 'Background data refresh complete');
         })
             .catch((error) => {
-            console.error('Background data refresh failed (serving cached data):', errorMessage(error));
+            warn(MODULE, `Background data refresh failed (serving cached data): ${errorMessage(error)}`);
         });
     }
     // ── Open browser ─────────────────────────────────────────────────────────
@@ -473,7 +512,7 @@ export async function startDashboardServer(options) {
     }
     // ── Clean shutdown ───────────────────────────────────────────────────────
     const shutdown = () => {
-        console.error('\nShutting down dashboard server...');
+        warn(MODULE, 'Shutting down dashboard server...');
         removeDashboardServerInfo();
         server.close(() => {
             process.exit(0);

package/dist/commands/dashboard-templates.js

@@ -13,36 +13,22 @@ import { generateDashboardScripts } from './dashboard-scripts.js';
 export { escapeHtml } from './dashboard-formatters.js';
 export { buildDashboardStats } from './dashboard-data.js';
 export function generateDashboardHtml(stats, monthlyMerged, monthlyClosed, monthlyOpened, digest, state, issueResponses = []) {
-    const approachingDormantDays = state.config?.approachingDormantDays ?? 25;
     const shelvedPRs = digest.shelvedPRs || [];
     const autoUnshelvedPRs = digest.autoUnshelvedPRs || [];
     const recentlyMerged = digest.recentlyMergedPRs || [];
     const shelvedUrls = new Set(shelvedPRs.map((pr) => pr.url));
     const activePRList = (digest.openPRs || []).filter((pr) => !shelvedUrls.has(pr.url));
     // Action Required: contributor must do something
-    const actionRequired = [
-        ...(digest.prsNeedingResponse || []),
-        ...(digest.needsChangesPRs || []),
-        ...(digest.ciFailingPRs || []),
-        ...(digest.mergeConflictPRs || []),
-        ...(digest.incompleteChecklistPRs || []),
-        ...(digest.missingRequiredFilesPRs || []),
-        ...(digest.needsRebasePRs || []),
-    ];
+    const actionRequired = digest.needsAddressingPRs || [];
     // Waiting on Others: informational, no contributor action needed
-    const waitingOnOthers = [
-        ...(digest.changesAddressedPRs || []),
-        ...(digest.waitingOnMaintainerPRs || []),
-        ...(digest.ciBlockedPRs || []),
-        ...(digest.ciNotRunningPRs || []),
-    ];
+    const waitingOnOthers = digest.waitingOnMaintainerPRs || [];
     return `<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   <title>OSS Autopilot - Mission Control</title>
-  <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+  <script src="https://cdn.jsdelivr.net/npm/chart.js@4.5.1" integrity="sha384-jb8JQMbMoBUzgWatfe6COACi2ljcDdZQ2OxczGA3bGNeWe+6DChMTBJemed7ZnvJ" crossorigin="anonymous"></script>
   <link rel="preconnect" href="https://fonts.googleapis.com">
   <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
   <link href="https://fonts.googleapis.com/css2?family=Geist:wght@400;500;600;700&family=Geist+Mono:wght@400;500&display=swap" rel="stylesheet">
@@ -127,22 +113,12 @@ export function generateDashboardHtml(stats, monthlyMerged, monthlyClosed, month
       <input type="text" class="filter-search" id="searchInput" placeholder="Search by PR title..." />
       <select class="filter-select" id="statusFilter">
         <option value="all">All Statuses</option>
-        <option value="needs-response">Needs Response</option>
-        <option value="needs-changes">Needs Changes</option>
-        <option value="ci-failing">CI Failing</option>
-        <option value="conflict">Merge Conflict</option>
-        <option value="changes-addressed">Changes Addressed</option>
-        <option value="waiting-maintainer">Waiting on Maintainer</option>
-        <option value="ci-blocked">CI Blocked</option>
-        <option value="ci-not-running">CI Not Running</option>
-        <option value="incomplete-checklist">Incomplete Checklist</option>
-        <option value="missing-files">Missing Files</option>
-        <option value="needs-rebase">Needs Rebase</option>
+        <option value="needs-addressing">Needs Addressing</option>
+        <option value="waiting-on-maintainer">Waiting on Maintainer</option>
         <option value="shelved">Shelved</option>
         <option value="merged">Recently Merged</option>
         <option value="closed">Recently Closed</option>
         <option value="auto-unshelved">Auto-Unshelved</option>
-        <option value="active">Active (No Issues)</option>
       </select>
       <select class="filter-select" id="repoFilter">
         <option value="all">All Repositories</option>
@@ -184,15 +160,7 @@ export function generateDashboardHtml(stats, monthlyMerged, monthlyClosed, month
         <span class="health-badge">${actionRequired.length} issue${actionRequired.length !== 1 ? 's' : ''}</span>
       </div>
       <div class="health-items">
-        ${renderHealthItems(digest.prsNeedingResponse || [], 'needs-response', SVG_ICONS.comment, 'Needs Response', (pr) => pr.lastMaintainerComment
-            ? `@${escapeHtml(pr.lastMaintainerComment.author)}: ${truncateTitle(pr.lastMaintainerComment.body, 40)}`
-            : truncateTitle(pr.title))}
-        ${renderHealthItems(digest.needsChangesPRs || [], 'needs-changes', SVG_ICONS.edit, 'Needs Changes', titleMeta)}
-        ${renderHealthItems(digest.ciFailingPRs || [], 'ci-failing', SVG_ICONS.xCircle, 'CI Failing', titleMeta)}
-        ${renderHealthItems(digest.mergeConflictPRs || [], 'conflict', SVG_ICONS.conflict, 'Merge Conflict', titleMeta)}
-        ${renderHealthItems(digest.incompleteChecklistPRs || [], 'incomplete-checklist', SVG_ICONS.checklist, (pr) => `Incomplete Checklist${pr.checklistStats ? ` (${pr.checklistStats.checked}/${pr.checklistStats.total})` : ''}`, titleMeta)}
-        ${renderHealthItems(digest.missingRequiredFilesPRs || [], 'missing-files', SVG_ICONS.file, 'Missing Required Files', (pr) => (pr.missingRequiredFiles ? escapeHtml(pr.missingRequiredFiles.join(', ')) : truncateTitle(pr.title)))}
-        ${renderHealthItems(digest.needsRebasePRs || [], 'needs-rebase', SVG_ICONS.refresh, (pr) => `Needs Rebase${pr.commitsBehindUpstream ? ` (${pr.commitsBehindUpstream} behind)` : ''}`, titleMeta)}
+        ${renderHealthItems(actionRequired, 'needs-addressing', SVG_ICONS.xCircle, (pr) => pr.displayLabel, (pr) => escapeHtml(pr.displayDescription))}
       </div>
     </section>
     `
@@ -210,10 +178,7 @@ export function generateDashboardHtml(stats, monthlyMerged, monthlyClosed, month
         <span class="health-badge" style="background: var(--accent-info-dim); color: var(--accent-info);">${waitingOnOthers.length} PR${waitingOnOthers.length !== 1 ? 's' : ''}</span>
       </div>
       <div class="health-items">
-        ${renderHealthItems(digest.changesAddressedPRs || [], 'changes-addressed', SVG_ICONS.checkCircle, 'Changes Addressed', (pr) => `Awaiting re-review${pr.lastMaintainerComment ? ` from @${escapeHtml(pr.lastMaintainerComment.author)}` : ''}`)}
-        ${renderHealthItems(digest.waitingOnMaintainerPRs || [], 'waiting-maintainer', SVG_ICONS.clock, 'Waiting on Maintainer', titleMeta)}
-        ${renderHealthItems(digest.ciBlockedPRs || [], 'ci-blocked', SVG_ICONS.lock, 'CI Blocked', titleMeta)}
-        ${renderHealthItems(digest.ciNotRunningPRs || [], 'ci-not-running', SVG_ICONS.infoCircle, 'CI Not Running', titleMeta)}
+        ${renderHealthItems(waitingOnOthers, 'waiting-on-maintainer', SVG_ICONS.clock, (pr) => pr.displayLabel, (pr) => escapeHtml(pr.displayDescription))}
       </div>
     </section>
     `
@@ -230,7 +195,7 @@ export function generateDashboardHtml(stats, monthlyMerged, monthlyClosed, month
         <h2>Health Status</h2>
       </div>
       <div class="health-empty">
-        All PRs are healthy - no CI failures, conflicts, or pending responses
+        All PRs are on track - no CI failures, conflicts, or pending responses
       </div>
     </section>
     `
@@ -313,7 +278,7 @@ export function generateDashboardHtml(stats, monthlyMerged, monthlyClosed, month
         <span class="health-badge" style="background: var(--accent-info-dim); color: var(--accent-info);">${autoUnshelvedPRs.length} unshelved</span>
       </div>
       <div class="health-items">
-        ${renderHealthItems(autoUnshelvedPRs, 'auto-unshelved', SVG_ICONS.bell, (pr) => 'Auto-Unshelved (' + pr.status.replace(/_/g, ' ') + ')', titleMeta)}
+        ${renderHealthItems(autoUnshelvedPRs, 'auto-unshelved', SVG_ICONS.bell, (pr) => `Auto-Unshelved (${pr.status.replace(/_/g, ' ')})`, titleMeta)}
       </div>
     </section>
     `
@@ -396,27 +361,14 @@ export function generateDashboardHtml(stats, monthlyMerged, monthlyClosed, month
       <div class="pr-list">
         ${activePRList
             .map((pr) => {
-            const hasIssues = pr.ciStatus === 'failing' ||
-                pr.hasMergeConflict ||
-                (pr.hasUnrespondedComment && pr.status !== 'changes_addressed') ||
-                pr.status === 'needs_changes';
-            const isStale = pr.daysSinceActivity >= approachingDormantDays;
-            const itemClass = hasIssues ? 'has-issues' : isStale ? 'stale' : '';
-            const prStatus = pr.ciStatus === 'failing'
-                ? 'ci-failing'
-                : pr.hasMergeConflict
-                    ? 'conflict'
-                    : pr.hasUnrespondedComment && pr.status !== 'changes_addressed' && pr.status !== 'failing_ci'
-                        ? 'needs-response'
-                        : pr.status === 'needs_changes'
-                            ? 'needs-changes'
-                            : pr.status === 'changes_addressed'
-                                ? 'changes-addressed'
-                                : 'active';
+            const isNeedsAddressing = pr.status === 'needs_addressing';
+            const isStale = pr.stalenessTier !== 'active';
+            const itemClass = isNeedsAddressing ? 'has-issues' : isStale ? 'stale' : '';
+            const prStatus = pr.status === 'needs_addressing' ? 'needs-addressing' : 'waiting-on-maintainer';
             return `
         <div class="pr-item ${itemClass}" data-status="${prStatus}" data-repo="${escapeHtml(pr.repo)}" data-title="${escapeHtml(pr.title.toLowerCase())}">
           <div class="pr-status-indicator">
-            ${hasIssues
+            ${isNeedsAddressing
                 ? `
             <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
               <circle cx="12" cy="12" r="10"/>
@@ -438,13 +390,7 @@ export function generateDashboardHtml(stats, monthlyMerged, monthlyClosed, month
               <span class="pr-repo">${escapeHtml(pr.repo)}#${pr.number}</span>
             </div>
             <div class="pr-badges">
-              ${pr.ciStatus === 'failing' ? '<span class="badge badge-ci-failing">CI Failing</span>' : ''}
-              ${pr.ciStatus === 'passing' ? '<span class="badge badge-passing">CI Passing</span>' : ''}
-              ${pr.ciStatus === 'pending' ? '<span class="badge badge-pending">CI Pending</span>' : ''}
-              ${pr.hasMergeConflict ? '<span class="badge badge-conflict">Merge Conflict</span>' : ''}
-              ${pr.hasUnrespondedComment && pr.status === 'changes_addressed' ? '<span class="badge badge-changes-addressed">Changes Addressed</span>' : ''}
-              ${pr.hasUnrespondedComment && pr.status !== 'changes_addressed' && pr.status !== 'failing_ci' ? '<span class="badge badge-needs-response">Needs Response</span>' : ''}
-              ${pr.reviewDecision === 'changes_requested' ? '<span class="badge badge-changes-requested">Changes Requested</span>' : ''}
+              <span class="badge ${isNeedsAddressing ? 'badge-ci-failing' : 'badge-passing'}">${escapeHtml(pr.displayLabel)}</span>
               ${isStale ? `<span class="badge badge-stale">${pr.daysSinceActivity}d inactive</span>` : ''}
             </div>
           </div>

package/dist/commands/override.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Override command
+ * Manually override a PR's status (needs_addressing ↔ waiting_on_maintainer).
+ * Overrides auto-clear when the PR has new activity.
+ */
+import type { FetchedPRStatus } from '../core/types.js';
+export interface OverrideOutput {
+    url: string;
+    status: FetchedPRStatus;
+}
+export interface ClearOverrideOutput {
+    url: string;
+    cleared: boolean;
+}
+export declare function runOverride(options: {
+    prUrl: string;
+    status: string;
+}): Promise<OverrideOutput>;
+export declare function runClearOverride(options: {
+    prUrl: string;
+}): Promise<ClearOverrideOutput>;

package/dist/commands/override.js

@@ -0,0 +1,35 @@
+/**
+ * Override command
+ * Manually override a PR's status (needs_addressing ↔ waiting_on_maintainer).
+ * Overrides auto-clear when the PR has new activity.
+ */
+import { getStateManager } from '../core/index.js';
+import { PR_URL_PATTERN, validateGitHubUrl, validateUrl } from './validation.js';
+const VALID_STATUSES = ['needs_addressing', 'waiting_on_maintainer'];
+export async function runOverride(options) {
+    validateUrl(options.prUrl);
+    validateGitHubUrl(options.prUrl, PR_URL_PATTERN, 'PR');
+    if (!VALID_STATUSES.includes(options.status)) {
+        throw new Error(`Invalid status "${options.status}". Must be one of: ${VALID_STATUSES.join(', ')}`);
+    }
+    const status = options.status;
+    const stateManager = getStateManager();
+    // Use current time as lastActivityAt — the CLI doesn't have cached PR data.
+    // This means the override will auto-clear on the next daily run if the PR's
+    // updatedAt is after this timestamp (which is the desired behavior: the override
+    // will persist until new activity occurs on the PR).
+    const lastActivityAt = new Date().toISOString();
+    stateManager.setStatusOverride(options.prUrl, status, lastActivityAt);
+    stateManager.save();
+    return { url: options.prUrl, status };
+}
+export async function runClearOverride(options) {
+    validateUrl(options.prUrl);
+    validateGitHubUrl(options.prUrl, PR_URL_PATTERN, 'PR');
+    const stateManager = getStateManager();
+    const cleared = stateManager.clearStatusOverride(options.prUrl);
+    if (cleared) {
+        stateManager.save();
+    }
+    return { url: options.prUrl, cleared };
+}

package/dist/core/checklist-analysis.js

@@ -32,8 +32,10 @@ export function analyzeChecklist(body) {
         return { hasIncompleteChecklist: false };
     // Filter out conditional checklist items that are intentionally unchecked
     const nonConditionalUnchecked = uncheckedLines.filter((line) => !isConditionalChecklistItem(line));
+    // Use consistent total that excludes conditional items (matches hasIncompleteChecklist logic)
+    const effectiveTotal = checked + nonConditionalUnchecked.length;
     return {
         hasIncompleteChecklist: nonConditionalUnchecked.length > 0,
-        checklistStats: { checked, total },
+        checklistStats: { checked, total: effectiveTotal },
     };
 }