merge-steward 0.15.0 → 0.16.0

package/dist/cli/commands/pr-status.js

@@ -1,7 +1,7 @@
 import { SqliteStore } from "../../db/sqlite-store.js";
 import { formatJson, writeOutput } from "../output.js";
 import { ServiceApiError, fetchLocalJson, loadRepoConfigById } from "../system.js";
-import { resolvePrNumber, resolveRepo } from "../resolve.js";
+import { defaultResolveRunner, resolvePrNumber, resolveRepo } from "../resolve.js";
 import { parseIntegerFlag } from "../args.js";
 import { fetchPrGitHubOverview } from "./pr-github.js";
 export function classifyQueueEntry(entry) {
@@ -223,11 +223,7 @@ export async function handlePrStatus(options) {
     const resolvedPr = await resolvePrNumber({ parsed, helpTopic: "root", runCommand: resolveCommand });
     const { config } = loadRepoConfigById(resolvedRepo.repoId);
     const fetchGh = options.fetchGitHub
-        ?? ((repoFullName, prNumber) => fetchPrGitHubOverview(repoFullName, prNumber, resolveCommand ?? (async () => ({
-            exitCode: 127,
-            stdout: "",
-            stderr: "no resolveCommand provided",
-        }))));
+        ?? ((repoFullName, prNumber) => fetchPrGitHubOverview(repoFullName, prNumber, resolveCommand ?? defaultResolveRunner));
     const buildReport = async () => {
         const queueResult = await loadQueueEntry(config, resolvedPr.prNumber);
         if (queueResult.kind === "found") {

package/dist/watch/App.js

@@ -1,24 +1,13 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useMemo, useState } from "react";
 import { Box, Text, useApp, useInput } from "ink";
-import { dequeueEntry, fetchEntryDetail, fetchGatewayHealth, fetchSnapshot, triggerReconcile } from "./api.js";
-import { getDefaultEntryId, getVisibleEntries, matchRepoRef } from "./dashboard-model.js";
+import { fetchGatewayHealth, fetchSnapshot, triggerReconcile } from "./api.js";
+import { buildDashboard, matchRepoRef, repoSelector, stepRepo } from "./dashboard-model.js";
 import { HelpBar } from "./HelpBar.js";
 import { OverviewView } from "./OverviewView.js";
 import { ProjectDetailView } from "./ProjectDetailView.js";
 import { StatusBar } from "./StatusBar.js";
 const REFRESH_INTERVAL_MS = 1_500;
-function nextSelection(items, selectedId, direction) {
-    if (items.length === 0) {
-        return null;
-    }
-    const index = items.findIndex((item) => item.id === selectedId);
-    const currentIndex = index === -1 ? 0 : index;
-    const nextIndex = direction === "next"
-        ? (currentIndex + 1) % items.length
-        : (currentIndex - 1 + items.length) % items.length;
-    return items[nextIndex]?.id ?? null;
-}
 export function App({ gatewayBaseUrl, repos, initialRepoRef, initialPrNumber }) {
     const { exit } = useApp();
     const [repoStates, setRepoStates] = useState(() => repos.map((repo) => ({
@@ -30,25 +19,34 @@ export function App({ gatewayBaseUrl, repos, initialRepoRef, initialPrNumber })
         lastSnapshotReceivedAt: null,
     })));
     const [lastSnapshotReceivedAt, setLastSnapshotReceivedAt] = useState(null);
-    const [detail, setDetail] = useState(null);
     const [gatewayError, setGatewayError] = useState(null);
     const [selectedRepoId, setSelectedRepoId] = useState(() => {
         const initialRepo = repos.find((repo) => matchRepoRef(repo, initialRepoRef));
         return initialRepo?.repoId ?? repos[0]?.repoId ?? null;
     });
-    const [selectedEntryIds, setSelectedEntryIds] = useState({});
-    const [view, setView] = useState(initialRepoRef || initialPrNumber !== undefined ? "project" : "overview");
-    const [filter, setFilter] = useState("active");
+    const [view, setView] = useState(initialRepoRef || initialPrNumber !== undefined ? "detail" : "list");
     const [flashMessage, setFlashMessage] = useState(null);
     const [pendingInitialPrNumber, setPendingInitialPrNumber] = useState(initialPrNumber ?? null);
-    const repoSelectionItems = useMemo(() => repoStates.map((repo) => ({ id: repo.repoId })), [repoStates]);
-    const currentRepo = useMemo(() => repoStates.find((repo) => repo.repoId === selectedRepoId) ?? null, [repoStates, selectedRepoId]);
-    const currentVisibleEntries = useMemo(() => getVisibleEntries(currentRepo?.snapshot ?? null, filter), [currentRepo?.snapshot, filter]);
-    const selectedEntryId = currentRepo ? (selectedEntryIds[currentRepo.repoId] ?? null) : null;
+    const model = useMemo(() => buildDashboard(repoStates), [repoStates]);
+    useEffect(() => {
+        setSelectedRepoId((current) => repoSelector(model.repos, current));
+    }, [model]);
     useEffect(() => {
-        if (!flashMessage) {
+        if (pendingInitialPrNumber === null)
             return;
+        for (const repo of repoStates) {
+            const match = repo.snapshot?.entries.find((entry) => entry.prNumber === pendingInitialPrNumber);
+            if (match) {
+                setSelectedRepoId(repo.repoId);
+                setView("detail");
+                setPendingInitialPrNumber(null);
+                return;
+            }
         }
+    }, [pendingInitialPrNumber, repoStates]);
+    useEffect(() => {
+        if (!flashMessage)
+            return;
         const timeout = setTimeout(() => setFlashMessage(null), 2500);
         return () => clearTimeout(timeout);
     }, [flashMessage]);
@@ -57,9 +55,8 @@ export function App({ gatewayBaseUrl, repos, initialRepoRef, initialPrNumber })
         const refresh = async () => {
             try {
                 const health = await fetchGatewayHealth(gatewayBaseUrl);
-                if (!cancelled) {
+                if (!cancelled)
                     setGatewayError(null);
-                }
                 setRepoStates((current) => current.map((repo) => {
                     const runtime = health.repos.find((candidate) => candidate.repoId === repo.repoId);
                     if (!runtime) {
@@ -96,14 +93,12 @@ export function App({ gatewayBaseUrl, repos, initialRepoRef, initialPrNumber })
                         };
                     }
                 }));
-                if (cancelled) {
+                if (cancelled)
                     return;
-                }
                 setRepoStates((current) => current.map((repo) => {
                     const result = results.find((candidate) => candidate.repoId === repo.repoId);
-                    if (!result) {
+                    if (!result)
                         return repo;
-                    }
                     if (result.snapshot) {
                         return {
                             ...repo,
@@ -112,25 +107,19 @@ export function App({ gatewayBaseUrl, repos, initialRepoRef, initialPrNumber })
                             lastSnapshotReceivedAt: result.receivedAt,
                         };
                     }
-                    return {
-                        ...repo,
-                        error: result.error,
-                    };
+                    return { ...repo, error: result.error };
                 }));
                 const latest = results.reduce((max, result) => {
-                    if (result.receivedAt === null) {
+                    if (result.receivedAt === null)
                         return max;
-                    }
                     return max === null ? result.receivedAt : Math.max(max, result.receivedAt);
                 }, null);
-                if (latest !== null) {
+                if (latest !== null)
                     setLastSnapshotReceivedAt(latest);
-                }
             }
             catch (error) {
-                if (cancelled) {
+                if (cancelled)
                     return;
-                }
                 const message = error instanceof Error ? error.message : String(error);
                 setGatewayError(message);
                 setRepoStates((current) => current.map((repo) => ({
@@ -139,7 +128,6 @@ export function App({ gatewayBaseUrl, repos, initialRepoRef, initialPrNumber })
                     serviceMessage: message,
                     error: message,
                 })));
-                return;
             }
         };
         void refresh();
@@ -151,102 +139,12 @@ export function App({ gatewayBaseUrl, repos, initialRepoRef, initialPrNumber })
             clearInterval(interval);
         };
     }, [gatewayBaseUrl, repos]);
-    useEffect(() => {
-        if (pendingInitialPrNumber === null) {
-            return;
-        }
-        for (const repo of repoStates) {
-            const match = repo.snapshot?.entries.find((entry) => entry.prNumber === pendingInitialPrNumber);
-            if (!match) {
-                continue;
-            }
-            setSelectedRepoId(repo.repoId);
-            setSelectedEntryIds((current) => ({
-                ...current,
-                [repo.repoId]: match.id,
-            }));
-            setView("project");
-            setPendingInitialPrNumber(null);
-            return;
-        }
-    }, [pendingInitialPrNumber, repoStates]);
-    useEffect(() => {
-        if (!currentRepo) {
-            return;
-        }
-        const nextDefault = getDefaultEntryId(currentRepo.snapshot, filter, pendingInitialPrNumber);
-        setSelectedEntryIds((current) => {
-            const existing = current[currentRepo.repoId];
-            if (existing && currentVisibleEntries.some((entry) => entry.id === existing)) {
-                return current;
-            }
-            if (existing === nextDefault) {
-                return current;
-            }
-            return {
-                ...current,
-                [currentRepo.repoId]: nextDefault,
-            };
-        });
-    }, [currentRepo, currentVisibleEntries, filter, pendingInitialPrNumber]);
-    useEffect(() => {
-        if (view !== "project" || !currentRepo?.repoId || !selectedEntryId || currentRepo.serviceState !== "ready") {
-            setDetail(null);
-            return;
-        }
-        let cancelled = false;
-        const refresh = async () => {
-            try {
-                const nextDetail = await fetchEntryDetail(gatewayBaseUrl, currentRepo.repoId, selectedEntryId);
-                if (!cancelled) {
-                    setDetail(nextDetail);
-                }
-            }
-            catch (error) {
-                if (!cancelled) {
-                    setFlashMessage(error instanceof Error ? error.message : String(error));
-                }
-            }
-        };
-        void refresh();
-        const interval = setInterval(() => {
-            void refresh();
-        }, REFRESH_INTERVAL_MS);
-        return () => {
-            cancelled = true;
-            clearInterval(interval);
-        };
-    }, [gatewayBaseUrl, currentRepo?.repoId, currentRepo?.serviceState, selectedEntryId, view]);
-    async function refreshRepo(repoId) {
-        const nextSnapshot = await fetchSnapshot(gatewayBaseUrl, repoId);
-        const receivedAt = Date.now();
-        setRepoStates((current) => current.map((repo) => repo.repoId === repoId
-            ? { ...repo, serviceState: "ready", serviceMessage: null, snapshot: nextSnapshot, error: null, lastSnapshotReceivedAt: receivedAt }
-            : repo));
-        setLastSnapshotReceivedAt(receivedAt);
-    }
     async function runReconcile(repoId) {
-        if (!repoId) {
+        if (!repoId)
             return;
-        }
         try {
             const result = await triggerReconcile(gatewayBaseUrl, repoId);
             setFlashMessage(result.started ? `reconcile tick completed for ${repoId}` : `reconcile already running for ${repoId}`);
-            await refreshRepo(repoId);
-        }
-        catch (error) {
-            setFlashMessage(error instanceof Error ? error.message : String(error));
-        }
-    }
-    async function runDequeue() {
-        if (!currentRepo?.repoId || !selectedEntryId || currentRepo.serviceState !== "ready") {
-            return;
-        }
-        try {
-            const selectedEntry = currentRepo.snapshot?.entries.find((entry) => entry.id === selectedEntryId) ?? null;
-            await dequeueEntry(gatewayBaseUrl, currentRepo.repoId, selectedEntryId);
-            setFlashMessage(`dequeued ${selectedEntry ? `#${selectedEntry.prNumber}` : "entry"} from ${currentRepo.repoId}`);
-            await refreshRepo(currentRepo.repoId);
         }
         catch (error) {
             setFlashMessage(error instanceof Error ? error.message : String(error));
@@ -261,45 +159,22 @@ export function App({ gatewayBaseUrl, repos, initialRepoRef, initialPrNumber })
             void runReconcile(selectedRepoId);
             return;
         }
-        if (view === "overview") {
-            if (input === "j" || key.downArrow) {
-                setSelectedRepoId(nextSelection(repoSelectionItems, selectedRepoId, "next"));
-            }
-            else if (input === "k" || key.upArrow) {
-                setSelectedRepoId(nextSelection(repoSelectionItems, selectedRepoId, "prev"));
-            }
-            else if (key.return && selectedRepoId) {
-                setView("project");
-            }
+        if (input === "j" || key.downArrow) {
+            setSelectedRepoId((current) => stepRepo(model.repos, current, 1));
             return;
         }
-        if (input === "d") {
-            void runDequeue();
+        if (input === "k" || key.upArrow) {
+            setSelectedRepoId((current) => stepRepo(model.repos, current, -1));
             return;
         }
-        if (key.escape || key.backspace || key.delete) {
-            setView("overview");
+        if (view === "list") {
+            if (key.return)
+                setView("detail");
             return;
         }
-        if (input === "a") {
-            setFilter((current) => current === "active" ? "all" : "active");
-        }
-        else if (input === "j" || key.downArrow) {
-            if (currentRepo?.repoId) {
-                setSelectedEntryIds((current) => ({
-                    ...current,
-                    [currentRepo.repoId]: nextSelection(currentVisibleEntries, current[currentRepo.repoId] ?? null, "next"),
-                }));
-            }
-        }
-        else if (input === "k" || key.upArrow) {
-            if (currentRepo?.repoId) {
-                setSelectedEntryIds((current) => ({
-                    ...current,
-                    [currentRepo.repoId]: nextSelection(currentVisibleEntries, current[currentRepo.repoId] ?? null, "prev"),
-                }));
-            }
+        if (key.escape || key.backspace || key.delete) {
+            setView("list");
         }
     });
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(StatusBar, { repos: repoStates, currentRepo: currentRepo, view: view, filter: filter, lastSnapshotReceivedAt: lastSnapshotReceivedAt, expectedFreshMs: REFRESH_INTERVAL_MS * 2, gatewayError: gatewayError }), view === "overview" ? (_jsx(OverviewView, { repos: repoStates, selectedRepoId: selectedRepoId, gatewayError: gatewayError })) : (_jsx(ProjectDetailView, { repo: currentRepo, selectedEntryId: selectedEntryId, detail: detail, filter: filter })), flashMessage ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: flashMessage }) })) : null, _jsx(HelpBar, { view: view })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(StatusBar, { connected: model.repos.some((repo) => !repo.offlineMessage), lastSnapshotReceivedAt: lastSnapshotReceivedAt, gatewayError: gatewayError }), view === "detail" ? (_jsx(ProjectDetailView, { model: model, selectedRepoId: selectedRepoId })) : (_jsx(OverviewView, { model: model, selectedRepoId: selectedRepoId, showCursor: true })), flashMessage ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: flashMessage }) })) : null, _jsx(HelpBar, { view: view })] }));
 }

package/dist/watch/HelpBar.d.ts

@@ -1,5 +1,5 @@
 interface HelpBarProps {
-    view: "overview" | "project";
+    view: "list" | "detail";
 }
 export declare function HelpBar({ view }: HelpBarProps): React.JSX.Element;
 export {};

package/dist/watch/HelpBar.js

@@ -1,14 +1,8 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { Box, Text, useStdout } from "ink";
+import { Box, Text } from "ink";
 export function HelpBar({ view }) {
-    const { stdout } = useStdout();
-    const compact = (stdout?.columns ?? 80) < 80;
-    const text = compact
-        ? (view === "overview"
-            ? "j/k select  Enter open  r refresh  q quit"
-            : "j/k select  Esc overview  a filter  r refresh  d dequeue  q quit")
-        : view === "overview"
-            ? "j/k: select project  Enter: open project  r: reconcile selected project  q: quit"
-            : "j/k: select PR  Esc: overview  a: filter  r: reconcile project  d: dequeue PR  q: quit";
+    const text = view === "list"
+        ? "↑↓ switch repo  enter detail  r reconcile  q quit"
+        : "↑↓ switch repo  esc back  r reconcile  q quit";
     return (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: text }) }));
 }

package/dist/watch/OverviewView.d.ts

@@ -1,8 +1,14 @@
-import type { DashboardRepoState } from "./dashboard-model.ts";
-interface OverviewViewProps {
-    repos: DashboardRepoState[];
+import type { DashboardModel, DashboardRepo } from "./dashboard-model.ts";
+interface ListViewProps {
+    model: DashboardModel;
     selectedRepoId: string | null;
-    gatewayError: string | null;
+    showCursor: boolean;
 }
-export declare function OverviewView({ repos, selectedRepoId, gatewayError }: OverviewViewProps): React.JSX.Element;
+export declare function RepoRow({ repo, selected, showCursor, width, }: {
+    repo: DashboardRepo;
+    selected: boolean;
+    showCursor: boolean;
+    width: number;
+}): React.JSX.Element;
+export declare function OverviewView({ model, selectedRepoId, showCursor }: ListViewProps): React.JSX.Element;
 export {};

package/dist/watch/OverviewView.js

@@ -1,44 +1,48 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text, useStdout } from "ink";
-import { ciStatusIcon, summarizeQueueBlock, truncate } from "./format.js";
-import { getClusterSummary, getRepoHealth, projectStatsSummary } from "./dashboard-model.js";
-import { getChainEntries } from "./dashboard-model.js";
-function clampWindowStart(selectedIndex, itemCount, maxItems) {
-    if (itemCount <= maxItems) {
-        return 0;
+function RepoTokens({ tokens, width }) {
+    if (tokens.length === 0 || width < 6)
+        return null;
+    const parts = [];
+    let used = 0;
+    for (const token of tokens) {
+        const text = `#${token.prNumber} ${token.glyph}`;
+        const separatorWidth = parts.length === 0 ? 0 : 2;
+        if (used + separatorWidth + text.length > width)
+            break;
+        used += separatorWidth + text.length;
+        parts.push({ token, text });
     }
-    const half = Math.floor(maxItems / 2);
-    return Math.max(0, Math.min(itemCount - maxItems, selectedIndex - half));
+    return (_jsx(Text, { children: parts.map((part, index) => (_jsx(Text, { color: part.token.color, children: index === 0 ? part.text : `  ${part.text}` }, `${part.token.prNumber}-${index}`))) }));
 }
-export function OverviewView({ repos, selectedRepoId, gatewayError }) {
+export function RepoRow({ repo, selected, showCursor, width, }) {
+    const cursorChar = showCursor && selected ? ">" : " ";
+    const repoLabelWidth = Math.min(28, Math.max(12, Math.floor(width * 0.35)));
+    const tokenWidth = Math.max(6, width - repoLabelWidth - 3);
+    const repoLabel = repo.repoFullName.length > repoLabelWidth
+        ? repo.repoFullName.slice(0, repoLabelWidth)
+        : repo.repoFullName.padEnd(repoLabelWidth, " ");
+    return (_jsxs(Box, { children: [_jsx(Text, { color: selected ? "cyan" : "gray", children: cursorChar }), _jsx(Text, { bold: selected, children: ` ${repoLabel}  ` }), repo.offlineMessage ? (_jsx(Text, { color: "red", children: repo.offlineMessage })) : (_jsx(RepoTokens, { tokens: repo.tokens, width: tokenWidth }))] }));
+}
+export function OverviewView({ model, selectedRepoId, showCursor }) {
     const { stdout } = useStdout();
-    const rows = stdout?.rows ?? 24;
-    const width = stdout?.columns ?? 80;
-    const compact = width < 90;
-    const cluster = getClusterSummary(repos);
-    const selectedIndex = Math.max(0, repos.findIndex((repo) => repo.repoId === selectedRepoId));
-    const maxItems = Math.max(1, Math.floor((rows - 8) / 2));
-    const startIndex = clampWindowStart(selectedIndex, repos.length, maxItems);
-    const visibleRepos = repos.slice(startIndex, startIndex + maxItems);
-    const summaryText = compact
-        ? `${cluster.total}p ${cluster.connected}c ${cluster.active}a ${cluster.blocked}b ${cluster.stuck}s`
-        : `${cluster.total} projects · ${cluster.connected} connected · ${cluster.active} active · ${cluster.blocked} blocked · ${cluster.stuck} stuck · ${cluster.attention} need attention`;
-    const idWidth = compact ? Math.max(14, Math.min(24, Math.floor(width * 0.44))) : 18;
-    const chainWidth = compact ? Math.max(12, width - 10) : 100;
-    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, children: "Queue Overview" }), _jsx(Text, { dimColor: true, children: summaryText }), gatewayError ? (_jsx(Text, { color: "red", children: `Gateway offline: ${truncate(gatewayError, 88)}. Run \`merge-steward service restart\`.` })) : null, repos.length === 0 ? (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["No repositories are attached yet. Run ", "`merge-steward repo attach <owner/repo>`", " first."] }) })) : (_jsx(Box, { marginTop: 1, flexDirection: "column", children: visibleRepos.map((repo) => {
-                    const health = getRepoHealth(repo);
-                    const queueBlockSummary = summarizeQueueBlock(repo.snapshot?.queueBlock);
-                    const chainEntries = getChainEntries(repo.snapshot);
-                    const chainText = repo.snapshot
-                        ? chainEntries.length > 0
-                            ? chainEntries.map((entry) => {
-                                const ci = ciStatusIcon(entry);
-                                return compact
-                                    ? `#${entry.prNumber}${ci.icon}`
-                                    : `#${entry.prNumber} ${ci.icon}`;
-                            }).join(" ")
-                            : compact ? "empty" : "queue is empty"
-                        : "queue data unavailable";
-                    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: repo.repoId === selectedRepoId ? "cyan" : "gray", children: repo.repoId === selectedRepoId ? ">" : " " }), _jsx(Text, { bold: true, children: truncate(repo.repoId, idWidth) }), compact ? null : _jsx(Text, { dimColor: true, children: `  ${truncate(repo.repoFullName, 28)}` }), _jsx(Text, { children: `  ` }), _jsx(Text, { color: health.color, children: compact ? health.label.slice(0, 5) : health.label }), _jsx(Text, { dimColor: true, children: `  ${projectStatsSummary(repo.snapshot, compact)}` })] }), _jsx(Box, { paddingLeft: 2, children: _jsx(Text, { dimColor: true, children: `Queue: ${truncate(chainText, chainWidth)}` }) }), compact ? null : (_jsx(Box, { paddingLeft: 2, children: _jsx(Text, { color: health.color, children: truncate(queueBlockSummary ?? health.detail, 110) }) }))] }, repo.repoId));
-                }) }))] }));
+    const rows = Math.max(3, stdout?.rows ?? 24);
+    const width = Math.max(40, stdout?.columns ?? 80);
+    const availableRows = Math.max(1, rows - 3);
+    const selectedIndex = model.repos.findIndex((repo) => repo.repoId === selectedRepoId);
+    const selected = selectedIndex >= 0 ? model.repos[selectedIndex] : model.repos[0];
+    const others = model.repos.filter((repo) => repo !== selected);
+    const ordered = [];
+    if (selected)
+        ordered.push(selected);
+    ordered.push(...others);
+    const quietLine = model.quietCount > 0 ? 1 : 0;
+    const maxRepoLines = Math.max(1, availableRows - quietLine);
+    const visible = ordered.slice(0, maxRepoLines);
+    const hiddenActive = ordered.length - visible.length;
+    const quietFooter = model.quietCount + hiddenActive;
+    if (visible.length === 0) {
+        return _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: " " }) });
+    }
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [visible.map((repo) => (_jsx(RepoRow, { repo: repo, selected: repo === selected, showCursor: showCursor, width: width - 2 }, repo.repoId))), quietFooter > 0 ? (_jsx(Box, { paddingLeft: 2, children: _jsx(Text, { dimColor: true, children: `+${quietFooter} quiet` }) })) : null] }));
 }

package/dist/watch/ProjectDetailView.d.ts

@@ -1,10 +1,7 @@
-import type { QueueEntryDetail } from "../types.ts";
-import type { DashboardRepoState } from "./dashboard-model.ts";
+import { type DashboardModel } from "./dashboard-model.ts";
 interface ProjectDetailViewProps {
-    repo: DashboardRepoState | null;
-    selectedEntryId: string | null;
-    detail: QueueEntryDetail | null;
-    filter: "active" | "all";
+    model: DashboardModel;
+    selectedRepoId: string | null;
 }
-export declare function ProjectDetailView({ repo, selectedEntryId, detail, filter, }: ProjectDetailViewProps): React.JSX.Element;
+export declare function ProjectDetailView({ model, selectedRepoId }: ProjectDetailViewProps): React.JSX.Element;
 export {};

package/dist/watch/ProjectDetailView.js

@@ -1,93 +1,58 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text, useStdout } from "ink";
-import { buildDisplayEntries } from "./display-filter.js";
-import { describeEntry, getChainEntries, getRepoHealth, projectStatsSummary, runtimeSummary } from "./dashboard-model.js";
-import { ciStatusIcon, formatEventNarrative, humanStatus, postMergeStatusLine, relativeTime, shortSha, specChainLabel, summarizeQueueBlock, truncate } from "./format.js";
-function clampWindowStart(selectedIndex, itemCount, maxItems) {
-    if (itemCount <= maxItems) {
-        return 0;
-    }
-    const half = Math.floor(maxItems / 2);
-    return Math.max(0, Math.min(itemCount - maxItems, selectedIndex - half));
-}
-function selectedEntryIndex(snapshot, filter, entryId) {
-    if (!snapshot || !entryId) {
-        return 0;
-    }
-    const entries = buildDisplayEntries(snapshot.entries, filter);
-    const index = entries.findIndex((entry) => entry.id === entryId);
-    return index >= 0 ? index : 0;
+import { RepoRow } from "./OverviewView.js";
+import { clipSummary } from "./dashboard-model.js";
+const PR_ID_WIDTH = 7;
+const SUMMARY_INDENT = 9;
+function PrEntryRow({ entry, width, includeSummary, }) {
+    const idText = `#${entry.prNumber}`.padEnd(PR_ID_WIDTH, " ");
+    const summaryText = includeSummary
+        ? clipSummary(entry.summary, { maxLines: 3, width: Math.max(20, width - SUMMARY_INDENT) })
+        : "";
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: entry.color, children: idText }), _jsx(Text, { color: entry.color, children: entry.glyph }), _jsx(Text, { children: `  ${entry.phrase}` })] }), summaryText ? (_jsxs(Box, { children: [_jsx(Text, { children: " ".repeat(SUMMARY_INDENT) }), _jsx(Text, { dimColor: true, children: summaryText })] })) : null] }));
 }
-function compactEntryStatus(entryStatus) {
-    switch (entryStatus) {
-        case "queued":
-            return "waiting";
-        case "preparing_head":
-            return "prep";
-        case "validating":
-            return "testing";
-        case "merging":
-            return "merging";
-        case "merged":
-            return "merged";
-        case "evicted":
-            return "repair";
-        case "dequeued":
-            return "removed";
-        default:
-            return entryStatus;
-    }
-}
-export function ProjectDetailView({ repo, selectedEntryId, detail, filter, }) {
+export function ProjectDetailView({ model, selectedRepoId }) {
     const { stdout } = useStdout();
-    const rows = stdout?.rows ?? 24;
-    const width = stdout?.columns ?? 80;
-    const compact = width < 95;
+    const rows = Math.max(3, stdout?.rows ?? 24);
+    const width = Math.max(40, stdout?.columns ?? 80);
+    const repo = selectedRepoId
+        ? model.repos.find((candidate) => candidate.repoId === selectedRepoId) ?? model.repos[0] ?? null
+        : model.repos[0] ?? null;
     if (!repo) {
-        return (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "No project selected." }) }));
+        return _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: " " }) });
+    }
+    const availableRows = Math.max(1, rows - 3);
+    const afterRepoRow = Math.max(0, availableRows - 2);
+    const entries = repo.entries;
+    const planned = [];
+    let used = 0;
+    const maxSummaryLines = 3;
+    for (const entry of entries) {
+        if (used >= afterRepoRow)
+            break;
+        const phraseLine = 1;
+        if (used + phraseLine > afterRepoRow)
+            break;
+        planned.push({ entry, includeSummary: false, lines: phraseLine });
+        used += phraseLine;
     }
-    if (!repo.snapshot) {
-        return (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: repo.serviceState === "initializing" ? "cyan" : "red", children: repo.serviceState === "initializing"
-                        ? `Merge Steward is still initializing ${repo.repoId}.`
-                        : repo.serviceState === "failed"
-                            ? `Merge Steward failed to initialize ${repo.repoId}.`
-                            : `Queue data is unavailable for ${repo.repoId}.` }), repo.serviceMessage ? _jsx(Text, { dimColor: true, children: repo.serviceMessage }) : null, repo.error && repo.error !== repo.serviceMessage ? _jsx(Text, { dimColor: true, children: repo.error }) : null] }));
+    if (afterRepoRow - used >= 2) {
+        for (const item of planned) {
+            if (!item.entry.summary)
+                continue;
+            const summaryText = clipSummary(item.entry.summary, {
+                maxLines: maxSummaryLines,
+                width: Math.max(20, width - SUMMARY_INDENT),
+            });
+            if (!summaryText)
+                continue;
+            const summaryLines = summaryText.split("\n").length;
+            if (used + summaryLines > afterRepoRow)
+                break;
+            item.includeSummary = true;
+            item.lines += summaryLines;
+            used += summaryLines;
+        }
     }
-    const snapshot = repo.snapshot;
-    const health = getRepoHealth(repo);
-    const queueBlockSummary = summarizeQueueBlock(snapshot.queueBlock);
-    const entries = buildDisplayEntries(snapshot.entries, filter);
-    const currentSelectedIndex = selectedEntryIndex(snapshot, filter, selectedEntryId);
-    const maxEntryRows = Math.max(3, Math.floor((rows - 16) / 2));
-    const entryWindowStart = clampWindowStart(currentSelectedIndex, entries.length, maxEntryRows);
-    const visibleEntries = entries.slice(entryWindowStart, entryWindowStart + maxEntryRows);
-    const selectedEntry = entries.find((entry) => entry.id === selectedEntryId)
-        ?? snapshot.entries.find((entry) => entry.id === selectedEntryId)
-        ?? null;
-    const eventRows = compact ? 4 : 6;
-    const visibleEvents = detail
-        ? detail.events.slice(-eventRows)
-        : snapshot.recentEvents.slice(-eventRows);
-    const chainEntries = getChainEntries(snapshot);
-    const chainText = chainEntries.length > 0
-        ? chainEntries.map((entry) => {
-            const ci = ciStatusIcon(entry);
-            return `#${entry.prNumber}${ci.icon}`;
-        }).join(" ")
-        : "empty";
-    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, children: repo.repoId }), _jsx(Text, { children: `  ` }), _jsx(Text, { color: health.color, children: health.label })] }), _jsx(Text, { dimColor: true, children: ` ${projectStatsSummary(snapshot, compact)}` }), compact ? null : _jsx(Text, { dimColor: true, children: runtimeSummary(snapshot) }), _jsx(Text, { dimColor: true, children: compact
-                    ? `Queue: ${truncate(chainText, width - 10)}`
-                    : `Queue: main -> ${truncate(chainText, width - 18)}` }), compact ? null : queueBlockSummary ? _jsx(Text, { color: "yellow", children: queueBlockSummary }) : null, compact ? null : (_jsxs(_Fragment, { children: [_jsxs(Text, { dimColor: true, children: ["GitHub required checks: ", snapshot.githubPolicy.requiredChecks.length > 0 ? snapshot.githubPolicy.requiredChecks.join(", ") : "(none)"] }), snapshot.githubPolicy.fetchedAt ? (_jsxs(Text, { dimColor: true, children: ["Policy fetched ", relativeTime(snapshot.githubPolicy.fetchedAt), " ago", snapshot.githubPolicy.lastRefreshReason
-                                ? ` via ${snapshot.githubPolicy.lastRefreshReason}${snapshot.githubPolicy.lastRefreshChanged === null ? "" : snapshot.githubPolicy.lastRefreshChanged ? " (changed)" : " (unchanged)"}`
-                                : ""] })) : null] })), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Pull Requests" }), visibleEntries.length === 0 ? (_jsx(Text, { dimColor: true, children: "No queue entries in this filter." })) : (visibleEntries.map((entry) => {
-                        const ci = ciStatusIcon(entry);
-                        const isHead = snapshot.summary.headEntryId === entry.id;
-                        const isSelected = entry.id === selectedEntryId;
-                        const statusColor = entry.status === "evicted" ? "red" : ci.color;
-                        const baseStatusText = compact ? compactEntryStatus(entry.status) : humanStatus(entry.status, entry);
-                        const statusText = entry.status === "merged" ? `${baseStatusText}: ${postMergeStatusLine(entry)}` : baseStatusText;
-                        return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: isSelected ? "cyan" : "gray", children: isSelected ? ">" : " " }), _jsx(Text, { bold: true, children: `#${entry.prNumber}` }), entry.issueKey ? _jsx(Text, { children: ` ${entry.issueKey}` }) : null, _jsx(Text, { children: `  ` }), _jsx(Text, { color: ci.color, children: ci.icon }), _jsx(Text, { color: statusColor, children: ` ${statusText}` }), compact ? null : (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: `  updated ${relativeTime(entry.updatedAt)} ago` }), isHead ? _jsx(Text, { dimColor: true, children: `  · ${humanStatus(entry.status, entry)} head` }) : null] }))] }), (isSelected || entry.status === "evicted" || (isHead && queueBlockSummary)) && (_jsx(Box, { paddingLeft: 2, children: _jsx(Text, { dimColor: true, children: describeEntry(entry, { isHead, queueBlockSummary }) }) }))] }, entry.id));
-                    }))] }), selectedEntry ? (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, children: `Selected PR #${selectedEntry.prNumber}` }), compact ? (_jsx(Text, { dimColor: true, children: `head ${shortSha(selectedEntry.headSha)} · base ${shortSha(selectedEntry.baseSha)}` })) : (_jsxs(Text, { dimColor: true, children: [selectedEntry.branch, " \u00B7 head ", shortSha(selectedEntry.headSha), " \u00B7 base ", shortSha(selectedEntry.baseSha)] })), compact ? null : _jsx(Text, { dimColor: true, children: `Test branch: ${specChainLabel(selectedEntry, snapshot.entries)}` }), selectedEntry.status === "merged" ? (_jsx(Text, { dimColor: true, children: `Post-merge: ${postMergeStatusLine(selectedEntry)}${selectedEntry.postMergeCheckedAt ? ` · ${relativeTime(selectedEntry.postMergeCheckedAt)} ago` : ""}` })) : null, detail?.incidents.length
-                        ? detail.incidents.slice(-2).map((incident) => (_jsxs(Text, { color: "red", children: [relativeTime(incident.at), " ago \u00B7 ", incident.failureClass, " \u00B7 ", incident.outcome] }, incident.id)))
-                        : null] })) : null, _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, children: detail ? "Selected PR Activity" : "Recent Project Activity" }), visibleEvents.length === 0 ? (_jsx(Text, { dimColor: true, children: "No queue events yet." })) : (visibleEvents.map((event) => (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: relativeTime(event.at).padStart(4, " ") }), _jsx(Text, { children: formatEventNarrative(event, selectedEntry ? { prNumber: selectedEntry.prNumber } : {}) })] }, "id" in event && event.id ? String(event.id) : `${event.entryId}-${event.at}`))))] })] }));
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(RepoRow, { repo: repo, selected: false, showCursor: false, width: width - 2 }), planned.length > 0 ? _jsx(Box, { children: _jsx(Text, { children: " " }) }) : null, planned.map(({ entry, includeSummary }) => (_jsx(PrEntryRow, { entry: entry, width: width, includeSummary: includeSummary }, entry.prNumber)))] }));
 }

package/dist/watch/StatusBar.d.ts

@@ -1,12 +1,7 @@
-import type { DashboardRepoState } from "./dashboard-model.ts";
 interface StatusBarProps {
-    repos: DashboardRepoState[];
-    currentRepo: DashboardRepoState | null;
-    view: "overview" | "project";
-    filter: "active" | "all";
+    connected: boolean;
     lastSnapshotReceivedAt: number | null;
-    expectedFreshMs: number;
     gatewayError: string | null;
 }
-export declare function StatusBar({ repos, currentRepo, view, filter, lastSnapshotReceivedAt, expectedFreshMs, gatewayError, }: StatusBarProps): React.JSX.Element;
+export declare function StatusBar({ connected, lastSnapshotReceivedAt, gatewayError }: StatusBarProps): React.JSX.Element;
 export {};

package/dist/watch/StatusBar.js

@@ -1,37 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Box, Text, useStdout } from "ink";
-import { getClusterSummary, getRepoHealth } from "./dashboard-model.js";
-import { truncate } from "./format.js";
+import { Box, Text } from "ink";
 import { FreshnessBadge } from "./FreshnessBadge.js";
-export function StatusBar({ repos, currentRepo, view, filter, lastSnapshotReceivedAt, expectedFreshMs, gatewayError, }) {
-    const { stdout } = useStdout();
-    const width = stdout?.columns ?? 80;
-    const compact = width < 88;
-    const cluster = getClusterSummary(repos);
-    const connected = cluster.connected > 0;
-    const repoHealth = currentRepo ? getRepoHealth(currentRepo) : null;
-    const leftParts = view === "project" && currentRepo
-        ? compact && currentRepo.repoId
-            ? `ms ${currentRepo.repoId} ${repoHealth?.label ?? ""} a:${currentRepo.snapshot?.summary.active ?? 0} h:${currentRepo.snapshot?.summary.headPrNumber ?? "?"}`
-            : [
-                "merge-steward dashboard",
-                currentRepo.repoId,
-                repoHealth?.label ?? null,
-                currentRepo.snapshot ? `${currentRepo.snapshot.summary.active} active` : null,
-                currentRepo.snapshot?.summary.headPrNumber ? `head #${currentRepo.snapshot.summary.headPrNumber}` : "no head PR",
-                `filter:${filter}`,
-            ].filter(Boolean).join(" | ")
-        : compact
-            ? `${cluster.total}p ${cluster.connected}c ${cluster.active}a ${cluster.blocked}b`
-            : [
-                "merge-steward dashboard",
-                `${cluster.total} projects`,
-                `${cluster.connected} connected`,
-                `${cluster.active} active`,
-                `${cluster.blocked} blocked`,
-                `${cluster.stuck} stuck`,
-                `${cluster.attention} need attention`,
-            ].join(" | ");
-    const availableLeft = compact ? Math.max(1, width - 14) : Math.max(1, width - 28);
-    return (_jsxs(Box, { justifyContent: "space-between", children: [_jsx(Text, { bold: true, children: truncate(leftParts, availableLeft) }), _jsx(FreshnessBadge, { connected: connected, lastSnapshotReceivedAt: lastSnapshotReceivedAt, expectedFreshMs: expectedFreshMs, gatewayError: gatewayError })] }));
+const EXPECTED_FRESH_MS = 3_000;
+export function StatusBar({ connected, lastSnapshotReceivedAt, gatewayError }) {
+    return (_jsxs(Box, { justifyContent: "space-between", children: [_jsx(Text, { bold: true, children: "merge-steward" }), _jsx(FreshnessBadge, { connected: connected, lastSnapshotReceivedAt: lastSnapshotReceivedAt, expectedFreshMs: EXPECTED_FRESH_MS, gatewayError: gatewayError })] }));
 }

package/dist/watch/dashboard-model.d.ts

@@ -12,31 +12,42 @@ export interface DashboardRepoState extends DashboardRepoConfig {
     error: string | null;
     lastSnapshotReceivedAt: number | null;
 }
-export interface RepoHealthSummary {
-    kind: "offline" | "initializing" | "failed" | "blocked" | "stuck" | "attention" | "active" | "idle";
-    label: string;
-    color: "red" | "yellow" | "green" | "gray" | "cyan";
-    detail: string;
+export type DashboardTokenColor = "red" | "yellow" | "green" | "gray" | "white";
+export type DashboardTokenKind = "running" | "queued" | "approved" | "declined" | "error" | "cancelled" | "superseded";
+export interface DashboardToken {
+    prNumber: number;
+    glyph: string;
+    color: DashboardTokenColor;
+    kind: DashboardTokenKind;
 }
-export interface ClusterSummary {
-    total: number;
-    connected: number;
-    blocked: number;
-    stuck: number;
-    attention: number;
-    active: number;
+export interface DashboardPrEntry extends DashboardToken {
+    phrase: string;
+    summary?: string;
+    eventAt: number;
 }
-export declare function buildQueueSummary(entries: QueueEntry[]): QueueWatchSnapshot["summary"];
-export declare function matchRepoRef(repo: DashboardRepoConfig, repoRef: string | undefined): boolean;
-export declare function getVisibleEntries(snapshot: QueueWatchSnapshot | null, filter: "active" | "all"): QueueEntry[];
-export declare function getChainEntries(snapshot: QueueWatchSnapshot | null): QueueEntry[];
-export declare function getActiveEntries(snapshot: QueueWatchSnapshot | null): QueueEntry[];
-export declare function getDefaultEntryId(snapshot: QueueWatchSnapshot | null, filter: "active" | "all", preferredPrNumber?: number | null): string | null;
-export declare function getRepoHealth(repo: DashboardRepoState, now?: number): RepoHealthSummary;
-export declare function getClusterSummary(repos: DashboardRepoState[], now?: number): ClusterSummary;
-export declare function projectStatsSummary(snapshot: QueueWatchSnapshot | null, compact?: boolean): string;
-export declare function runtimeSummary(snapshot: QueueWatchSnapshot | null): string;
-export declare function describeEntry(entry: QueueEntry, options: {
-    isHead: boolean;
-    queueBlockSummary: string | null;
+export interface DashboardRepo {
+    repoId: string;
+    repoFullName: string;
+    tokens: DashboardToken[];
+    entries: DashboardPrEntry[];
+    latestActivityAt: number;
+    hasActivity: boolean;
+    offlineMessage: string | null;
+}
+export interface DashboardModel {
+    repos: DashboardRepo[];
+    quietCount: number;
+}
+export declare function buildDashboard(repos: DashboardRepoState[], opts?: {
+    windowMs?: number;
+    now?: number;
+}): DashboardModel;
+export declare function clipSummary(summary: string | undefined, opts?: {
+    maxLines?: number;
+    width?: number;
 }): string;
+export declare function repoSelector(repos: DashboardRepo[], selected: string | null): string | null;
+export declare function stepRepo(repos: DashboardRepo[], selected: string | null, direction: 1 | -1): string | null;
+export declare function findRepo(repos: DashboardRepo[], selected: string | null): DashboardRepo | null;
+export declare function matchRepoRef(repo: DashboardRepoConfig, repoRef: string | undefined): boolean;
+export declare function buildQueueSummary(entries: QueueEntry[]): QueueWatchSnapshot["summary"];

package/dist/watch/dashboard-model.js

@@ -1,40 +1,293 @@
-import { buildChainEntries, buildDisplayEntries } from "./display-filter.js";
-import { formatDuration, humanStatus, nextStepLabel, postMergeStatusLine, relativeTime, summarizeQueueBlock } from "./format.js";
-const RECENT_EVICTION_MS = 60 * 60 * 1_000;
-const STUCK_ENTRY_MS = 25 * 60 * 1_000;
-const OFFLINE_STALE_MS = 10 * 1_000;
+import { TERMINAL_STATUSES } from "../types.js";
+import { mergeWaitState } from "./format.js";
+const DECIDED_WINDOW_MS = 24 * 60 * 60 * 1000;
+const GLYPH = {
+    running: "\u25cf",
+    queued: "\u25cb",
+    approved: "\u2713",
+    declined: "\u2717",
+    error: "\u26a0",
+    cancelled: "\u2013",
+    superseded: "\u21bb",
+};
+const COLOR = {
+    running: "yellow",
+    queued: "gray",
+    approved: "green",
+    declined: "red",
+    error: "red",
+    cancelled: "gray",
+    superseded: "gray",
+};
+function timestamp(value) {
+    if (!value)
+        return 0;
+    const ms = new Date(value).getTime();
+    return Number.isFinite(ms) ? ms : 0;
+}
 function isLaterEntry(left, right) {
     if (left.position !== right.position) {
         return left.position > right.position;
     }
-    return new Date(left.updatedAt).getTime() >= new Date(right.updatedAt).getTime();
+    return timestamp(left.updatedAt) >= timestamp(right.updatedAt);
 }
-function getLatestEntries(snapshot) {
-    if (!snapshot) {
-        return [];
-    }
+function pickLatestPerPR(entries) {
     const byPR = new Map();
-    for (const entry of snapshot.entries) {
+    for (const entry of entries) {
         const existing = byPR.get(entry.prNumber);
         if (!existing || isLaterEntry(entry, existing)) {
             byPR.set(entry.prNumber, entry);
         }
     }
-    return [...byPR.values()].sort((a, b) => a.position - b.position);
+    return [...byPR.values()];
 }
-function getMostRecentActivityAt(snapshot) {
-    const latestEntries = getLatestEntries(snapshot);
-    if (latestEntries.length === 0) {
-        return undefined;
+function entryKind(entry) {
+    switch (entry.status) {
+        case "queued":
+            return "queued";
+        case "preparing_head":
+        case "validating":
+        case "merging":
+            return "running";
+        case "merged":
+            if (entry.postMergeStatus === "fail")
+                return "declined";
+            if (entry.postMergeStatus === "pending")
+                return "running";
+            return "approved";
+        case "evicted":
+            return "error";
+        case "dequeued":
+            return "cancelled";
     }
-    return latestEntries.reduce((latest, entry) => {
-        if (!latest) {
-            return entry.updatedAt;
+}
+function entryPhrase(entry, opts) {
+    if (opts.isHead && opts.queueBlocked) {
+        return "main broken";
+    }
+    switch (entry.status) {
+        case "queued":
+            return opts.isHead ? "queued" : "behind head";
+        case "preparing_head":
+            return entry.lastFailedBaseSha ? "has conflicts" : "preparing";
+        case "validating":
+            return "testing";
+        case "merging": {
+            const wait = mergeWaitState({ status: entry.status, waitDetail: entry.waitDetail });
+            if (wait === "approval")
+                return "waiting for approval";
+            if (wait === "main")
+                return "waiting for main";
+            return "merging";
         }
-        return new Date(entry.updatedAt).getTime() > new Date(latest).getTime()
-            ? entry.updatedAt
-            : latest;
-    }, undefined);
+        case "merged":
+            if (entry.postMergeStatus === "fail")
+                return "post-merge failed";
+            if (entry.postMergeStatus === "pending")
+                return "merged, post-merge pending";
+            return "merged";
+        case "evicted":
+            return "evicted";
+        case "dequeued":
+            return "dequeued";
+    }
+}
+function entrySummary(entry) {
+    if (entry.status === "merged" && entry.postMergeStatus === "fail" && entry.postMergeSummary) {
+        return entry.postMergeSummary;
+    }
+    return undefined;
+}
+function isActive(status) {
+    return !TERMINAL_STATUSES.includes(status);
+}
+function tokenSortOrder(kind) {
+    switch (kind) {
+        case "running":
+            return 0;
+        case "queued":
+            return 1;
+        case "approved":
+        case "declined":
+        case "error":
+            return 2;
+        case "cancelled":
+        case "superseded":
+            return 3;
+    }
+}
+function overrideKind(kind, override) {
+    if (override === "main_broken")
+        return "error";
+    return kind;
+}
+function repoEntriesFromSnapshot(snapshot, cutoff) {
+    const latest = pickLatestPerPR(snapshot.entries);
+    const head = latest
+        .filter((entry) => isActive(entry.status))
+        .sort((a, b) => a.position - b.position)[0] ?? null;
+    const queueBlocked = Boolean(snapshot.queueBlock);
+    const byPr = new Map();
+    for (const entry of latest) {
+        const active = isActive(entry.status);
+        if (!active && timestamp(entry.updatedAt) < cutoff)
+            continue;
+        if (entry.status === "dequeued")
+            continue;
+        const isHead = head !== null && entry.id === head.id;
+        const rawKind = entryKind(entry);
+        const kind = overrideKind(rawKind, isHead && queueBlocked ? "main_broken" : null);
+        const glyph = GLYPH[kind];
+        const color = COLOR[kind];
+        const phrase = entryPhrase(entry, { isHead, queueBlocked });
+        const item = {
+            prNumber: entry.prNumber,
+            glyph,
+            color,
+            kind,
+            phrase,
+            eventAt: timestamp(entry.updatedAt),
+        };
+        const summary = entrySummary(entry);
+        if (summary)
+            item.summary = summary;
+        byPr.set(entry.prNumber, item);
+    }
+    return [...byPr.values()].sort((left, right) => {
+        const leftOrder = tokenSortOrder(left.kind);
+        const rightOrder = tokenSortOrder(right.kind);
+        if (leftOrder !== rightOrder)
+            return leftOrder - rightOrder;
+        if (left.eventAt !== right.eventAt)
+            return right.eventAt - left.eventAt;
+        return right.prNumber - left.prNumber;
+    });
+}
+export function buildDashboard(repos, opts = {}) {
+    const windowMs = opts.windowMs ?? DECIDED_WINDOW_MS;
+    const now = opts.now ?? Date.now();
+    const cutoff = now - windowMs;
+    const mapped = repos.map((repo) => {
+        const snapshot = repo.snapshot;
+        if (!snapshot) {
+            const message = repo.serviceState === "initializing"
+                ? repo.serviceMessage ?? "initializing"
+                : repo.serviceState === "failed"
+                    ? repo.serviceMessage ?? "init failed"
+                    : repo.error ?? "offline";
+            return {
+                repoId: repo.repoId,
+                repoFullName: repo.repoFullName,
+                tokens: [],
+                entries: [],
+                latestActivityAt: 0,
+                hasActivity: false,
+                offlineMessage: message,
+            };
+        }
+        const entries = repoEntriesFromSnapshot(snapshot, cutoff);
+        const latestActivityAt = entries.reduce((max, entry) => Math.max(max, entry.eventAt), 0);
+        return {
+            repoId: repo.repoId,
+            repoFullName: repo.repoFullName,
+            tokens: entries.map(({ prNumber, glyph, color, kind }) => ({ prNumber, glyph, color, kind })),
+            entries,
+            latestActivityAt,
+            hasActivity: entries.length > 0,
+            offlineMessage: null,
+        };
+    });
+    const active = mapped.filter((repo) => repo.hasActivity || repo.offlineMessage);
+    active.sort((left, right) => {
+        if (left.offlineMessage !== null && right.offlineMessage === null)
+            return 1;
+        if (right.offlineMessage !== null && left.offlineMessage === null)
+            return -1;
+        const leftHasActive = left.entries.some((entry) => entry.kind === "running" || entry.kind === "queued");
+        const rightHasActive = right.entries.some((entry) => entry.kind === "running" || entry.kind === "queued");
+        if (leftHasActive !== rightHasActive)
+            return leftHasActive ? -1 : 1;
+        if (left.latestActivityAt !== right.latestActivityAt)
+            return right.latestActivityAt - left.latestActivityAt;
+        return left.repoFullName.localeCompare(right.repoFullName);
+    });
+    const quietCount = mapped.length - active.length;
+    return { repos: active, quietCount };
+}
+export function clipSummary(summary, opts = {}) {
+    if (!summary)
+        return "";
+    const maxLines = opts.maxLines ?? 3;
+    const width = Math.max(20, opts.width ?? 80);
+    const collapsed = summary.replace(/\s+/g, " ").trim();
+    if (collapsed.length === 0)
+        return "";
+    const sentenceRe = /[^.!?]+[.!?]+(?:\s|$)|[^.!?]+$/g;
+    const sentences = (collapsed.match(sentenceRe) ?? [collapsed])
+        .map((value) => value.trim())
+        .filter((value) => value.length > 0);
+    let buffer = "";
+    for (const sentence of sentences) {
+        const candidate = buffer.length === 0 ? sentence : `${buffer} ${sentence}`;
+        if (wrapLines(candidate, width).length <= maxLines) {
+            buffer = candidate;
+        }
+        else {
+            break;
+        }
+    }
+    if (buffer.length === 0) {
+        const first = sentences[0] ?? collapsed;
+        return wrapLines(first, width).slice(0, maxLines).join("\n");
+    }
+    return wrapLines(buffer, width).slice(0, maxLines).join("\n");
+}
+function wrapLines(text, width) {
+    const words = text.split(/\s+/).filter((word) => word.length > 0);
+    const lines = [];
+    let current = "";
+    for (const word of words) {
+        if (current.length === 0) {
+            current = word;
+            continue;
+        }
+        if (current.length + 1 + word.length <= width) {
+            current = `${current} ${word}`;
+        }
+        else {
+            lines.push(current);
+            current = word;
+        }
+    }
+    if (current.length > 0)
+        lines.push(current);
+    return lines.length === 0 ? [""] : lines;
+}
+export function repoSelector(repos, selected) {
+    if (repos.length === 0)
+        return null;
+    if (selected && repos.some((repo) => repo.repoId === selected)) {
+        return selected;
+    }
+    return repos[0]?.repoId ?? null;
+}
+export function stepRepo(repos, selected, direction) {
+    if (repos.length === 0)
+        return null;
+    const index = repos.findIndex((repo) => repo.repoId === selected);
+    const currentIndex = index === -1 ? 0 : index;
+    const nextIndex = (currentIndex + direction + repos.length) % repos.length;
+    return repos[nextIndex]?.repoId ?? null;
+}
+export function findRepo(repos, selected) {
+    if (!selected)
+        return repos[0] ?? null;
+    return repos.find((repo) => repo.repoId === selected) ?? repos[0] ?? null;
+}
+export function matchRepoRef(repo, repoRef) {
+    if (!repoRef)
+        return false;
+    return repo.repoId === repoRef || repo.repoFullName === repoRef;
 }
 export function buildQueueSummary(entries) {
     const summary = {
@@ -50,7 +303,7 @@ export function buildQueueSummary(entries) {
         headEntryId: null,
         headPrNumber: null,
     };
-    const activeEntries = entries.filter((entry) => !["merged", "evicted", "dequeued"].includes(entry.status));
+    const activeEntries = entries.filter((entry) => !TERMINAL_STATUSES.includes(entry.status));
     if (activeEntries.length > 0) {
         summary.headEntryId = activeEntries[0].id;
         summary.headPrNumber = activeEntries[0].prNumber;
@@ -83,218 +336,3 @@ export function buildQueueSummary(entries) {
     }
     return summary;
 }
-export function matchRepoRef(repo, repoRef) {
-    if (!repoRef) {
-        return false;
-    }
-    return repo.repoId === repoRef || repo.repoFullName === repoRef;
-}
-export function getVisibleEntries(snapshot, filter) {
-    if (!snapshot) {
-        return [];
-    }
-    return buildDisplayEntries(snapshot.entries, filter);
-}
-export function getChainEntries(snapshot) {
-    if (!snapshot) {
-        return [];
-    }
-    return buildChainEntries(snapshot.entries);
-}
-export function getActiveEntries(snapshot) {
-    return getLatestEntries(snapshot).filter((entry) => (entry.status !== "merged" && entry.status !== "evicted" && entry.status !== "dequeued"));
-}
-export function getDefaultEntryId(snapshot, filter, preferredPrNumber) {
-    if (!snapshot) {
-        return null;
-    }
-    const visibleEntries = getVisibleEntries(snapshot, filter);
-    if (preferredPrNumber !== undefined && preferredPrNumber !== null) {
-        const match = visibleEntries.find((entry) => entry.prNumber === preferredPrNumber)
-            ?? snapshot.entries.find((entry) => entry.prNumber === preferredPrNumber);
-        if (match) {
-            return match.id;
-        }
-    }
-    return snapshot.summary.headEntryId ?? visibleEntries[0]?.id ?? null;
-}
-export function getRepoHealth(repo, now = Date.now()) {
-    const snapshot = repo.snapshot;
-    const staleForMs = repo.lastSnapshotReceivedAt === null ? Infinity : now - repo.lastSnapshotReceivedAt;
-    if (repo.serviceState === "initializing") {
-        return {
-            kind: "initializing",
-            label: "Initializing",
-            color: "cyan",
-            detail: repo.serviceMessage ?? "Loading GitHub policy and local clone state.",
-        };
-    }
-    if (repo.serviceState === "failed") {
-        return {
-            kind: "failed",
-            label: "Init failed",
-            color: "red",
-            detail: repo.serviceMessage ?? "Repo initialization failed in merge-steward.",
-        };
-    }
-    if (!snapshot || (repo.error && staleForMs > OFFLINE_STALE_MS)) {
-        return {
-            kind: "offline",
-            label: "Offline",
-            color: "red",
-            detail: repo.error ?? "No queue data from merge-steward yet.",
-        };
-    }
-    if (snapshot.queueBlock) {
-        return {
-            kind: "blocked",
-            label: "Blocked",
-            color: "yellow",
-            detail: summarizeQueueBlock(snapshot.queueBlock) ?? `Waiting for ${snapshot.baseBranch} to recover.`,
-        };
-    }
-    if (snapshot.runtime.lastTickOutcome === "failed") {
-        return {
-            kind: "stuck",
-            label: "Stuck",
-            color: "red",
-            detail: snapshot.runtime.lastTickError?.split(/\r?\n/, 1)[0] ?? "The last reconcile tick failed.",
-        };
-    }
-    const activeEntries = getActiveEntries(snapshot);
-    const headEntry = activeEntries[0];
-    if (headEntry) {
-        const ageMs = now - new Date(headEntry.updatedAt).getTime();
-        if (ageMs >= STUCK_ENTRY_MS) {
-            return {
-                kind: "stuck",
-                label: "Stuck",
-                color: "red",
-                detail: `Head PR #${headEntry.prNumber} has not moved for ${relativeTime(headEntry.updatedAt)}.`,
-            };
-        }
-    }
-    const recentEvicted = getLatestEntries(snapshot).find((entry) => (entry.status === "evicted"
-        && now - new Date(entry.updatedAt).getTime() <= RECENT_EVICTION_MS));
-    if (recentEvicted) {
-        return {
-            kind: "attention",
-            label: "Needs attention",
-            color: "yellow",
-            detail: `PR #${recentEvicted.prNumber} was evicted and needs repair before it can rejoin the queue.`,
-        };
-    }
-    if (activeEntries.length > 0) {
-        return {
-            kind: "active",
-            label: "Running",
-            color: "cyan",
-            detail: headEntry
-                ? `Head PR #${headEntry.prNumber} is ${humanStatus(headEntry.status, headEntry)}.`
-                : `${activeEntries.length} PRs are active in the queue.`,
-        };
-    }
-    return {
-        kind: "idle",
-        label: "Idle",
-        color: "green",
-        detail: snapshot.summary.total > 0
-            ? `No active queue work right now. Last activity was ${relativeTime(getMostRecentActivityAt(snapshot))} ago.`
-            : "No pull requests are queued right now.",
-    };
-}
-export function getClusterSummary(repos, now = Date.now()) {
-    const initial = {
-        total: repos.length,
-        connected: 0,
-        blocked: 0,
-        stuck: 0,
-        attention: 0,
-        active: 0,
-    };
-    return repos.reduce((summary, repo) => {
-        const health = getRepoHealth(repo, now);
-        if (health.kind !== "offline") {
-            summary.connected += 1;
-        }
-        if (health.kind === "blocked") {
-            summary.blocked += 1;
-        }
-        if (health.kind === "stuck") {
-            summary.stuck += 1;
-        }
-        if (health.kind === "attention") {
-            summary.attention += 1;
-        }
-        if (repo.snapshot && getActiveEntries(repo.snapshot).length > 0) {
-            summary.active += 1;
-        }
-        return summary;
-    }, initial);
-}
-export function projectStatsSummary(snapshot, compact = false) {
-    if (!snapshot) {
-        return "No queue data yet.";
-    }
-    const latestEntries = getLatestEntries(snapshot);
-    const activeEntries = getActiveEntries(snapshot);
-    const avgWaitMs = activeEntries.length > 0
-        ? activeEntries.reduce((sum, entry) => sum + (Date.now() - new Date(entry.enqueuedAt).getTime()), 0) / activeEntries.length
-        : 0;
-    const queued = latestEntries.filter((entry) => entry.status === "queued").length;
-    const validating = latestEntries.filter((entry) => entry.status === "validating" || entry.status === "preparing_head").length;
-    const merging = latestEntries.filter((entry) => entry.status === "merging").length;
-    const evicted = latestEntries.filter((entry) => entry.status === "evicted").length;
-    const parts = compact
-        ? [
-            `${activeEntries.length}a`,
-            `${queued}w`,
-            `${validating}t`,
-            `${merging}m`,
-        ]
-        : [
-            `${activeEntries.length} active`,
-            `${queued} waiting`,
-            `${validating} testing`,
-            `${merging} merging`,
-        ];
-    if (evicted > 0) {
-        parts.push(compact ? `${evicted}x` : `${evicted} need repair`);
-    }
-    if (avgWaitMs > 0) {
-        parts.push(compact ? `w ${formatDuration(avgWaitMs)}` : `avg wait ${formatDuration(avgWaitMs)}`);
-    }
-    return parts.join(" · ");
-}
-export function runtimeSummary(snapshot) {
-    if (!snapshot) {
-        return "No runtime data yet.";
-    }
-    if (snapshot.runtime.tickInProgress) {
-        return `Reconcile tick is running now. Last completed ${relativeTime(snapshot.runtime.lastTickCompletedAt)} ago.`;
-    }
-    if (snapshot.runtime.lastTickOutcome === "failed") {
-        return `Last reconcile tick failed ${relativeTime(snapshot.runtime.lastTickCompletedAt ?? snapshot.runtime.lastTickStartedAt)} ago.`;
-    }
-    if (snapshot.runtime.lastTickCompletedAt) {
-        return `Last reconcile tick ${snapshot.runtime.lastTickOutcome} ${relativeTime(snapshot.runtime.lastTickCompletedAt)} ago.`;
-    }
-    return "No reconcile tick has completed yet.";
-}
-export function describeEntry(entry, options) {
-    if (options.isHead && options.queueBlockSummary) {
-        return options.queueBlockSummary;
-    }
-    if (entry.status === "merged") {
-        return `Landed on main. ${postMergeStatusLine(entry)}`
-            + (entry.postMergeCheckedAt ? ` (${relativeTime(entry.postMergeCheckedAt)} ago).` : ".");
-    }
-    if (entry.status === "queued") {
-        if (entry.position > 1) {
-            return `Waiting behind ${entry.position - 1} earlier PRs.`;
-        }
-        return "First in line and waiting for the next reconcile tick.";
-    }
-    const nextStep = nextStepLabel(entry.status, entry);
-    return `${humanStatus(entry.status, entry)}: ${nextStep}.`;
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "merge-steward",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "description": "Serial merge queue for GitHub — rebase, CI-gate, and merge PRs one at a time",
   "type": "module",
   "repository": {