merge-steward 0.9.7 → 0.10.0

package/README.md

@@ -1,9 +1,11 @@
 # merge-steward
 
-Speculative merge queue service. It admits approved PRs whose required checks
-are green, builds cumulative speculative branches, waits for CI on those exact
-integrated SHAs, and then fast-forwards `main` to the tested result. On
-failure, it evicts with a durable incident record and GitHub check run.
+`merge-steward` is a self-hosted merge queue for bot-managed and human-managed
+GitHub pull requests. It admits approved PRs whose required checks are green,
+builds cumulative speculative branches, waits for CI on those exact integrated
+SHAs, and then fast-forwards `main` to the tested result. On failure, it evicts
+with a durable incident record and GitHub check run so an agent or human can
+repair the branch and re-queue it.
 
 Fully independent of PatchRelay. Communicates through GitHub — PRs, reviews,
 checks, labels, branches.
@@ -209,34 +211,67 @@ merge-steward doctor --repo repo
 merge-steward service status
 merge-steward queue status --repo repo
 merge-steward queue show --repo repo --pr 123
+merge-steward dashboard
 
 # Manual foreground start
 merge-steward serve
 
-# Live queue watch TUI
-merge-steward queue watch --repo app
+# Open one project directly in the dashboard
+merge-steward dashboard --repo app
 ```
 
-### Watch TUI
+### Dashboard
 
-`merge-steward queue watch --repo <id>` gives you a terminal view of the queue:
+`merge-steward dashboard` is the operator surface for day-to-day queue work.
 
-- which PRs are currently queued
-- which PR is head-of-line
-- current steward tick state
-- recent queue transitions
-- per-PR detail with incidents and event history
+The first screen shows all configured projects with:
+
+- project-level queue health
+- readable queue stats
+- a compact queue chain like `#123 ●  #124 ○`
+- clear bad states such as blocked, stuck, or needs attention
+
+Press `Enter` on a project to open the second screen. That project detail view shows:
+
+- the same top-level queue stats for that project
+- a readable list of PRs in the queue
+- recent queue activity in plain language
+- incidents for evicted PRs
+- direct actions like reconcile and dequeue
+
+Use `merge-steward dashboard --repo <id>` to open the project detail screen directly. Use `--pr <number>` to preselect a PR when you already know what you need to inspect.
 
 Controls:
 
 - `j` / `k` or arrows — move selection
-- `Enter` — open selected PR detail
-- `Esc` — return to queue view
-- `a` — toggle `active` vs `all`
-- `r` — run a reconcile tick now
-- `d` — dequeue the selected PR
+- `Enter` — open the selected project from overview
+- `Esc` — return to the overview
+- `a` — toggle `active` vs `all` in project view
+- `r` — run a reconcile tick for the selected project
+- `d` — dequeue the selected PR in project view
 - `q` — quit
 
+### Validation, Visibility, And Troubleshooting
+
+These are the first commands to reach for after setup or when a queue looks wrong:
+
+```bash
+merge-steward doctor --repo app
+merge-steward service status
+merge-steward dashboard
+merge-steward queue status --repo app
+merge-steward queue show --repo app --pr 123
+merge-steward service logs --lines 100
+```
+
+Use them this way:
+
+- `doctor` checks config, GitHub auth, branch rules, and required checks.
+- `dashboard` is the best live operator view across all configured projects.
+- `queue status` is the fastest text snapshot when you need one repo in a shell script or over SSH.
+- `queue show --pr <number>` is the most direct way to inspect one PR's queue events and incidents.
+- `service logs` helps when the queue is not reacting to webhooks, GitHub auth is failing, or reconcile ticks are erroring.
+
 ### systemd
 
 ```ini
@@ -264,15 +299,15 @@ WantedBy=multi-user.target
 | Endpoint | Method | Description |
 |-|-|-|
 | `/health` | GET | Liveness check |
-| `/queue/status` | GET | All queue entries |
-| `/queue/watch` | GET | Queue snapshot for the operator TUI |
-| `/queue/enqueue` | POST | Manually enqueue a PR |
-| `/queue/reconcile` | POST | Trigger one reconcile tick immediately |
-| `/queue/entries/:id/detail` | GET | Entry detail with recent events and incidents |
-| `/queue/entries/:id/dequeue` | POST | Remove from queue (non-destructive) |
-| `/queue/entries/:id/update-head` | POST | Update head SHA (force-push) |
-| `/queue/incidents/:id` | GET | Get incident details |
-| `/queue/entries/:id/incidents` | GET | List incidents for an entry |
+| `/repos/:repoId/queue/status` | GET | All queue entries for one configured repo |
+| `/repos/:repoId/queue/watch` | GET | Queue snapshot used by the dashboard |
+| `/repos/:repoId/queue/enqueue` | POST | Manually enqueue a PR |
+| `/repos/:repoId/queue/reconcile` | POST | Trigger one reconcile tick immediately |
+| `/repos/:repoId/queue/entries/:id/detail` | GET | Entry detail with recent events and incidents |
+| `/repos/:repoId/queue/entries/:id/dequeue` | POST | Remove from queue (non-destructive) |
+| `/repos/:repoId/queue/entries/:id/update-head` | POST | Update head SHA (force-push) |
+| `/repos/:repoId/queue/incidents/:id` | GET | Get incident details |
+| `/repos/:repoId/queue/entries/:id/incidents` | GET | List incidents for an entry |
 | `/webhooks/github` | POST | GitHub webhook receiver for all configured repos |
 
 ## Queue state machine

package/dist/cli/args.js

@@ -57,6 +57,11 @@ export function validateFlags(parsed) {
         case "serve":
             assertKnownFlags(parsed, "root", []);
             return;
+        case "dashboard":
+        case "dash":
+        case "d":
+            assertKnownFlags(parsed, "root", ["repo", "pr"]);
+            return;
         case "attach":
             assertKnownFlags(parsed, "repos", ["base-branch", "required-check", "label", "merge-queue-check-name", "refresh", "json"]);
             return;
@@ -97,15 +102,15 @@ export function validateFlags(parsed) {
             }
         case "queue":
             switch (subcommand) {
+                case "dashboard":
+                    assertKnownFlags(parsed, "queue", ["repo", "pr"]);
+                    return;
                 case "status":
                     assertKnownFlags(parsed, "queue", ["repo", "events", "json"]);
                     return;
                 case "show":
                     assertKnownFlags(parsed, "queue", ["repo", "entry", "pr", "events", "json"]);
                     return;
-                case "watch":
-                    assertKnownFlags(parsed, "queue", ["repo", "pr"]);
-                    return;
                 case "reconcile":
                     assertKnownFlags(parsed, "queue", ["repo", "json"]);
                     return;

package/dist/cli/commands/dashboard.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedArgs } from "../types.ts";
+export declare function handleDashboard(parsed: ParsedArgs): Promise<number>;

package/dist/cli/commands/dashboard.js

@@ -0,0 +1,24 @@
+import { parseIntegerFlag } from "../args.js";
+import { loadRepoConfigById } from "../system.js";
+export async function handleDashboard(parsed) {
+    const initialRepoRef = typeof parsed.flags.get("repo") === "string"
+        ? String(parsed.flags.get("repo"))
+        : undefined;
+    const initialPrNumber = parseIntegerFlag(parsed.flags.get("pr"), "--pr");
+    const options = {};
+    if (initialRepoRef) {
+        loadRepoConfigById(initialRepoRef);
+        options.initialRepoRef = initialRepoRef;
+    }
+    if (initialPrNumber !== undefined) {
+        options.initialPrNumber = initialPrNumber;
+    }
+    if (!process.stdin.isTTY || typeof process.stdin.setRawMode !== "function") {
+        process.stderr.write("merge-steward dashboard requires an interactive TTY.\n");
+        process.stderr.write("Use `merge-steward queue status --repo <id>` or run the dashboard from a terminal.\n");
+        return 1;
+    }
+    const { startDashboard } = await import("../../watch/index.js");
+    await startDashboard(options);
+    return 0;
+}

package/dist/cli/commands/queue.js

@@ -117,11 +117,11 @@ export async function handleQueue(parsed, stdout) {
         throw new UsageError("merge-steward queue requires a subcommand.", "queue");
     }
     if (subcommand === "watch") {
-        const repoId = resolveRepoId(parsed, 2, "queue");
-        const { configPath } = loadRepoConfigById(repoId);
-        const { startWatch } = await import("../../watch/index.js");
-        await startWatch(configPath, parseIntegerFlag(parsed.flags.get("pr"), "--pr"));
-        return 0;
+        throw new UsageError("`merge-steward queue watch` was replaced by `merge-steward dashboard [--repo <id>] [--pr <number>]`.", "queue");
+    }
+    if (subcommand === "dashboard") {
+        const { handleDashboard } = await import("./dashboard.js");
+        return await handleDashboard(parsed);
     }
     const repoId = resolveRepoId(parsed, 2, "queue");
     const { config } = loadRepoConfigById(repoId);

package/dist/cli/help.js

@@ -25,7 +25,7 @@ function rootHelpText() {
         "  queue status --repo <id> [--json]                      Show queue summary and current entries",
         "  queue show --repo <id> (--entry <id> | --pr <num>) [--events <count>] [--json]",
         "                                                          Show one queue entry with events and incidents",
-        "  queue watch --repo <id> [--pr <number>]                Open the queue watch TUI",
+        "  dashboard [--repo <id>] [--pr <number>]                Open the multi-repo merge queue dashboard",
         "",
         "Service management:",
         "  service install [--force] [--json]                     Reinstall the systemd unit",
@@ -94,9 +94,9 @@ function queueHelpText() {
         "  merge-steward queue <command> [options]",
         "",
         "Commands:",
+        "  dashboard [--repo <id>] [--pr <number>]            Open the multi-repo merge queue dashboard",
         "  status --repo <id>                                 Show queue summary and entries",
         "  show --repo <id> (--entry <id> | --pr <num>)       Show one queue entry with events and incidents",
-        "  watch --repo <id> [--pr <number>]                  Open the queue watch TUI",
         "  reconcile --repo <id> [--json]                     Ask the service to reconcile immediately",
     ].join("\n");
 }

package/dist/cli.js

@@ -21,7 +21,10 @@ export async function runCli(argv, options) {
             return 0;
         }
         validateFlags(parsed);
-        const command = parsed.positionals[0] ?? "help";
+        const requestedCommand = parsed.positionals[0] ?? "help";
+        const command = requestedCommand === "dash" || requestedCommand === "d"
+            ? "dashboard"
+            : requestedCommand;
         if (hasHelpFlag(parsed) || command === "help") {
             const topic = command === "help"
                 ? (parsed.positionals[1] ?? "root")
@@ -64,6 +67,8 @@ export async function runCli(argv, options) {
             }
             case "doctor":
                 return await (await import("./cli/commands/doctor.js")).handleDoctor(parsed, stdout);
+            case "dashboard":
+                return await (await import("./cli/commands/dashboard.js")).handleDashboard(parsed);
             case "service":
                 return await (await import("./cli/commands/service.js")).handleService(parsed, stdout, runCommand);
             case "queue":

package/dist/watch/App.d.ts

@@ -1,6 +1,9 @@
+import type { DashboardRepoConfig } from "./dashboard-model.ts";
 interface AppProps {
-    baseUrl: string;
+    gatewayBaseUrl: string;
+    repos: DashboardRepoConfig[];
+    initialRepoRef?: string | undefined;
     initialPrNumber?: number | undefined;
 }
-export declare function App({ baseUrl, initialPrNumber }: AppProps): React.JSX.Element;
+export declare function App({ gatewayBaseUrl, repos, initialRepoRef, initialPrNumber }: AppProps): React.JSX.Element;
 export {};

package/dist/watch/App.js

@@ -1,48 +1,47 @@
 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 { buildDisplayEntries } from "./display-filter.js";
 import { dequeueEntry, fetchEntryDetail, fetchSnapshot, triggerReconcile } from "./api.js";
-import { DetailView } from "./DetailView.js";
+import { getDefaultEntryId, getVisibleEntries, matchRepoRef } from "./dashboard-model.js";
 import { HelpBar } from "./HelpBar.js";
-import { QueueListView } from "./QueueListView.js";
+import { OverviewView } from "./OverviewView.js";
+import { ProjectDetailView } from "./ProjectDetailView.js";
 import { StatusBar } from "./StatusBar.js";
 const REFRESH_INTERVAL_MS = 1_500;
-function isActiveEntry(entry) {
-    return entry.status !== "merged" && entry.status !== "evicted" && entry.status !== "dequeued";
-}
-function nextSelection(entries, selectedEntryId, direction) {
-    if (entries.length === 0) {
+function nextSelection(items, selectedId, direction) {
+    if (items.length === 0) {
         return null;
     }
-    const index = entries.findIndex((entry) => entry.id === selectedEntryId);
+    const index = items.findIndex((item) => item.id === selectedId);
     const currentIndex = index === -1 ? 0 : index;
     const nextIndex = direction === "next"
-        ? (currentIndex + 1) % entries.length
-        : (currentIndex - 1 + entries.length) % entries.length;
-    return entries[nextIndex]?.id ?? null;
+        ? (currentIndex + 1) % items.length
+        : (currentIndex - 1 + items.length) % items.length;
+    return items[nextIndex]?.id ?? null;
 }
-export function App({ baseUrl, initialPrNumber }) {
+export function App({ gatewayBaseUrl, repos, initialRepoRef, initialPrNumber }) {
     const { exit } = useApp();
-    const [connected, setConnected] = useState(false);
-    const [snapshot, setSnapshot] = useState(null);
+    const [repoStates, setRepoStates] = useState(() => repos.map((repo) => ({
+        ...repo,
+        snapshot: null,
+        error: null,
+        lastSnapshotReceivedAt: null,
+    })));
     const [lastSnapshotReceivedAt, setLastSnapshotReceivedAt] = useState(null);
     const [detail, setDetail] = useState(null);
-    const [selectedEntryId, setSelectedEntryId] = useState(null);
-    const [view, setView] = useState("list");
+    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 [flashMessage, setFlashMessage] = useState(null);
-    const visibleEntries = useMemo(() => buildDisplayEntries(snapshot?.entries ?? [], filter), [filter, snapshot?.entries]);
-    const selectedEntry = useMemo(() => visibleEntries.find((entry) => entry.id === selectedEntryId) ?? null, [selectedEntryId, visibleEntries]);
-    const activeEntries = useMemo(() => (snapshot?.entries ?? []).filter(isActiveEntry), [snapshot?.entries]);
-    const selectedActiveIndex = useMemo(() => {
-        if (!selectedEntryId) {
-            return null;
-        }
-        const index = activeEntries.findIndex((entry) => entry.id === selectedEntryId);
-        return index === -1 ? null : index + 1;
-    }, [activeEntries, selectedEntryId]);
-    const isHeadSelected = activeEntries[0]?.id === selectedEntryId;
+    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;
     useEffect(() => {
         if (!flashMessage) {
             return;
@@ -53,32 +52,49 @@ export function App({ baseUrl, initialPrNumber }) {
     useEffect(() => {
         let cancelled = false;
         const refresh = async () => {
-            try {
-                const nextSnapshot = await fetchSnapshot(baseUrl);
-                if (cancelled) {
-                    return;
+            const results = await Promise.all(repos.map(async (repo) => {
+                try {
+                    const snapshot = await fetchSnapshot(gatewayBaseUrl, repo.repoId);
+                    return { repoId: repo.repoId, snapshot, receivedAt: Date.now(), error: null };
                 }
-                setSnapshot(nextSnapshot);
-                setLastSnapshotReceivedAt(Date.now());
-                setConnected(true);
-                setSelectedEntryId((current) => {
-                    if (current && nextSnapshot.entries.some((entry) => entry.id === current)) {
-                        return current;
-                    }
-                    if (initialPrNumber !== undefined) {
-                        const match = nextSnapshot.entries.find((entry) => entry.prNumber === initialPrNumber);
-                        if (match) {
-                            return match.id;
-                        }
-                    }
-                    return nextSnapshot.summary.headEntryId ?? nextSnapshot.entries[0]?.id ?? null;
-                });
+                catch (error) {
+                    return {
+                        repoId: repo.repoId,
+                        snapshot: null,
+                        receivedAt: null,
+                        error: error instanceof Error ? error.message : String(error),
+                    };
+                }
+            }));
+            if (cancelled) {
+                return;
             }
-            catch (error) {
-                if (!cancelled) {
-                    setConnected(false);
-                    setFlashMessage(error instanceof Error ? error.message : String(error));
+            setRepoStates((current) => current.map((repo) => {
+                const result = results.find((candidate) => candidate.repoId === repo.repoId);
+                if (!result) {
+                    return repo;
+                }
+                if (result.snapshot) {
+                    return {
+                        ...repo,
+                        snapshot: result.snapshot,
+                        error: null,
+                        lastSnapshotReceivedAt: result.receivedAt,
+                    };
+                }
+                return {
+                    ...repo,
+                    error: result.error,
+                };
+            }));
+            const latest = results.reduce((max, result) => {
+                if (result.receivedAt === null) {
+                    return max;
                 }
+                return max === null ? result.receivedAt : Math.max(max, result.receivedAt);
+            }, null);
+            if (latest !== null) {
+                setLastSnapshotReceivedAt(latest);
             }
         };
         void refresh();
@@ -89,16 +105,54 @@ export function App({ baseUrl, initialPrNumber }) {
             cancelled = true;
             clearInterval(interval);
         };
-    }, [baseUrl, initialPrNumber]);
+    }, [gatewayBaseUrl, repos]);
     useEffect(() => {
-        if (view !== "detail" || !selectedEntryId) {
+        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) {
             setDetail(null);
             return;
         }
         let cancelled = false;
         const refresh = async () => {
             try {
-                const nextDetail = await fetchEntryDetail(baseUrl, selectedEntryId);
+                const nextDetail = await fetchEntryDetail(gatewayBaseUrl, currentRepo.repoId, selectedEntryId);
                 if (!cancelled) {
                     setDetail(nextDetail);
                 }
@@ -117,31 +171,37 @@ export function App({ baseUrl, initialPrNumber }) {
             cancelled = true;
             clearInterval(interval);
         };
-    }, [baseUrl, selectedEntryId, view]);
-    async function runReconcile() {
+    }, [gatewayBaseUrl, currentRepo?.repoId, 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, snapshot: nextSnapshot, error: null, lastSnapshotReceivedAt: receivedAt }
+            : repo));
+        setLastSnapshotReceivedAt(receivedAt);
+    }
+    async function runReconcile(repoId) {
+        if (!repoId) {
+            return;
+        }
         try {
-            const result = await triggerReconcile(baseUrl);
-            setFlashMessage(result.started ? "reconcile tick completed" : "reconcile already running");
-            const nextSnapshot = await fetchSnapshot(baseUrl);
-            setSnapshot(nextSnapshot);
-            setLastSnapshotReceivedAt(Date.now());
-            setConnected(true);
+            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 (!selectedEntryId) {
+        if (!currentRepo?.repoId || !selectedEntryId) {
             return;
         }
         try {
-            await dequeueEntry(baseUrl, selectedEntryId);
-            setFlashMessage(`dequeued ${selectedEntry ? `#${selectedEntry.prNumber}` : "entry"}`);
-            const nextSnapshot = await fetchSnapshot(baseUrl);
-            setSnapshot(nextSnapshot);
-            setLastSnapshotReceivedAt(Date.now());
-            setConnected(true);
+            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));
@@ -153,38 +213,48 @@ export function App({ baseUrl, initialPrNumber }) {
             return;
         }
         if (input === "r") {
-            void runReconcile();
-            return;
-        }
-        if (input === "d") {
-            void runDequeue();
+            void runReconcile(selectedRepoId);
             return;
         }
-        if (view === "list") {
-            if (input === "a") {
-                setFilter((current) => (current === "active" ? "all" : "active"));
-            }
-            else if (input === "j" || key.downArrow) {
-                setSelectedEntryId(nextSelection(visibleEntries, selectedEntryId, "next"));
+        if (view === "overview") {
+            if (input === "j" || key.downArrow) {
+                setSelectedRepoId(nextSelection(repoSelectionItems, selectedRepoId, "next"));
             }
             else if (input === "k" || key.upArrow) {
-                setSelectedEntryId(nextSelection(visibleEntries, selectedEntryId, "prev"));
+                setSelectedRepoId(nextSelection(repoSelectionItems, selectedRepoId, "prev"));
             }
-            else if (key.return && selectedEntryId) {
-                setView("detail");
+            else if (key.return && selectedRepoId) {
+                setView("project");
             }
             return;
         }
+        if (input === "d") {
+            void runDequeue();
+            return;
+        }
         if (key.escape || key.backspace || key.delete) {
-            setView("list");
+            setView("overview");
             return;
         }
-        if (input === "j" || key.downArrow) {
-            setSelectedEntryId(nextSelection(visibleEntries, selectedEntryId, "next"));
+        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) {
-            setSelectedEntryId(nextSelection(visibleEntries, selectedEntryId, "prev"));
+            if (currentRepo?.repoId) {
+                setSelectedEntryIds((current) => ({
+                    ...current,
+                    [currentRepo.repoId]: nextSelection(currentVisibleEntries, current[currentRepo.repoId] ?? null, "prev"),
+                }));
+            }
         }
     });
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(StatusBar, { snapshot: snapshot, connected: connected, filter: filter, lastSnapshotReceivedAt: lastSnapshotReceivedAt, expectedFreshMs: REFRESH_INTERVAL_MS * 2 }), view === "detail" && selectedEntry && (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "Queue" }), _jsx(Text, { dimColor: true, children: " \u203A " }), _jsxs(Text, { bold: true, children: ["#", selectedEntry.prNumber] }), _jsxs(Text, { dimColor: true, children: [" (", selectedEntry.status, ")"] })] })), view === "list" ? (_jsx(QueueListView, { entries: visibleEntries, allEntries: snapshot?.entries ?? [], selectedEntryId: selectedEntryId, recentEvents: snapshot?.recentEvents ?? [], headEntryId: snapshot?.summary.headEntryId ?? null, queueBlock: snapshot?.queueBlock ?? null })) : (_jsx(DetailView, { detail: detail, isHead: isHeadSelected, activeIndex: selectedActiveIndex, activeCount: activeEntries.length, headPrNumber: snapshot?.summary.headPrNumber ?? null, queueBlock: snapshot?.queueBlock ?? null })), flashMessage && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: flashMessage }) })), _jsx(HelpBar, { view: view })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(StatusBar, { repos: repoStates, currentRepo: currentRepo, view: view, filter: filter, lastSnapshotReceivedAt: lastSnapshotReceivedAt, expectedFreshMs: REFRESH_INTERVAL_MS * 2 }), view === "overview" ? (_jsx(OverviewView, { repos: repoStates, selectedRepoId: selectedRepoId })) : (_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 })] }));
 }

package/dist/watch/HelpBar.d.ts

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

package/dist/watch/HelpBar.js

@@ -1,8 +1,8 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { Box, Text } from "ink";
 export function HelpBar({ view }) {
-    const text = view === "list"
-        ? "j/k: navigate  Enter: detail  a: filter  r: reconcile  d: dequeue  q: quit"
-        : "j/k: prev/next  Esc: list  r: reconcile  d: dequeue  q: quit";
+    const text = 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";
     return (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: text }) }));
 }

package/dist/watch/OverviewView.d.ts

@@ -0,0 +1,7 @@
+import type { DashboardRepoState } from "./dashboard-model.ts";
+interface OverviewViewProps {
+    repos: DashboardRepoState[];
+    selectedRepoId: string | null;
+}
+export declare function OverviewView({ repos, selectedRepoId }: OverviewViewProps): React.JSX.Element;
+export {};

package/dist/watch/OverviewView.js

@@ -0,0 +1,34 @@
+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 { getChainEntries, getClusterSummary, getRepoHealth, projectStatsSummary } from "./dashboard-model.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));
+}
+export function OverviewView({ repos, selectedRepoId }) {
+    const { stdout } = useStdout();
+    const rows = stdout?.rows ?? 24;
+    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);
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, children: "Queue Overview" }), _jsxs(Text, { dimColor: true, children: [cluster.total, " projects \u00B7 ", cluster.connected, " connected \u00B7 ", cluster.active, " active \u00B7 ", cluster.blocked, " blocked \u00B7 ", cluster.stuck, " stuck \u00B7 ", cluster.attention, " need attention"] }), 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 `#${entry.prNumber} ${ci.icon}`;
+                            }).join("  ")
+                            : "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 ? "\u25b8" : " " }), _jsx(Text, { bold: true, children: repo.repoId }), _jsx(Text, { dimColor: true, children: `  ${truncate(repo.repoFullName, 28)}` }), _jsx(Text, { children: `  ` }), _jsx(Text, { color: health.color, children: health.label }), _jsx(Text, { dimColor: true, children: `  ${projectStatsSummary(repo.snapshot)}` })] }), _jsx(Box, { paddingLeft: 2, children: _jsx(Text, { dimColor: true, children: `Queue: ${truncate(chainText, 100)}` }) }), _jsx(Box, { paddingLeft: 2, children: _jsx(Text, { color: health.color, children: truncate(queueBlockSummary ?? health.detail, 110) }) })] }, repo.repoId));
+                }) }))] }));
+}

package/dist/watch/ProjectDetailView.d.ts

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

package/dist/watch/ProjectDetailView.js

@@ -0,0 +1,55 @@
+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, 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;
+}
+export function ProjectDetailView({ repo, selectedEntryId, detail, filter, }) {
+    const { stdout } = useStdout();
+    const rows = stdout?.rows ?? 24;
+    if (!repo) {
+        return (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "No project selected." }) }));
+    }
+    if (!repo.snapshot) {
+        return (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { color: "red", children: ["Queue data is unavailable for ", repo.repoId, "."] }), repo.error ? _jsx(Text, { dimColor: true, children: repo.error }) : null] }));
+    }
+    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 visibleEvents = detail
+        ? detail.events.slice(-6)
+        : snapshot.recentEvents.slice(-6);
+    const chainEntries = getChainEntries(snapshot);
+    const chainText = chainEntries.length > 0
+        ? chainEntries.map((entry) => `#${entry.prNumber}`).join(" -> ")
+        : "empty";
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, children: repo.repoId }), _jsx(Text, { dimColor: true, children: `  ${repo.repoFullName}` }), _jsx(Text, { children: `  ` }), _jsx(Text, { color: health.color, children: health.label })] }), _jsx(Text, { dimColor: true, children: projectStatsSummary(snapshot) }), _jsx(Text, { dimColor: true, children: runtimeSummary(snapshot) }), _jsx(Text, { dimColor: true, children: `Queue: main -> ${truncate(chainText, 96)}` }), queueBlockSummary ? _jsx(Text, { color: "yellow", children: queueBlockSummary }) : 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;
+                        return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: entry.id === selectedEntryId ? "cyan" : "gray", children: entry.id === selectedEntryId ? "\u25b8" : " " }), _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, { children: ` ` }), _jsx(Text, { ...(entry.status === "evicted" ? { color: "red" } : {}), children: humanStatus(entry.status, entry) }), _jsx(Text, { dimColor: true, children: `  updated ${relativeTime(entry.updatedAt)} ago` })] }), (entry.id === selectedEntryId || entry.status === "evicted" || (isHead && queueBlockSummary)) && (_jsx(Box, { paddingLeft: 2, children: _jsx(Text, { dimColor: true, children: truncate(describeEntry(entry, { isHead, queueBlockSummary }), 110) }) }))] }, entry.id));
+                    }))] }), selectedEntry && (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, children: `Selected PR #${selectedEntry.prNumber}` }), _jsxs(Text, { dimColor: true, children: [selectedEntry.branch, " \u00B7 head ", shortSha(selectedEntry.headSha), " \u00B7 base ", shortSha(selectedEntry.baseSha)] }), _jsx(Text, { dimColor: true, children: `Test branch: ${specChainLabel(selectedEntry, snapshot.entries)}` }), 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] })), _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: truncate(formatEventNarrative(event), 106) })] }, "id" in event && event.id ? String(event.id) : `${event.entryId}-${event.at}`))))] })] }));
+}

package/dist/watch/StatusBar.d.ts

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

package/dist/watch/StatusBar.js

@@ -1,37 +1,32 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text, useStdout } from "ink";
-import { formatDuration, relativeTime, runtimeLabel, summarizeQueueBlock, truncate } from "./format.js";
+import { getClusterSummary, getRepoHealth } from "./dashboard-model.js";
+import { truncate } from "./format.js";
 import { FreshnessBadge } from "./FreshnessBadge.js";
-const TERMINAL = new Set(["merged", "evicted", "dequeued"]);
-export function StatusBar({ snapshot, connected, filter, lastSnapshotReceivedAt, expectedFreshMs, }) {
+export function StatusBar({ repos, currentRepo, view, filter, lastSnapshotReceivedAt, expectedFreshMs, }) {
     const { stdout } = useStdout();
     const width = stdout?.columns ?? 80;
-    if (!snapshot) {
-        const left = "merge-steward";
-        const availableLeft = Math.max(1, width - 28);
-        return (_jsxs(Box, { justifyContent: "space-between", children: [_jsx(Text, { bold: true, children: truncate(left, availableLeft) }), _jsx(FreshnessBadge, { connected: connected, lastSnapshotReceivedAt: lastSnapshotReceivedAt, expectedFreshMs: expectedFreshMs })] }));
-    }
-    const { summary, runtime } = snapshot;
-    const queueBlockLabel = summarizeQueueBlock(snapshot.queueBlock);
-    const activeEntries = snapshot.entries.filter((e) => !TERMINAL.has(e.status));
-    const avgWaitMs = activeEntries.length > 0
-        ? activeEntries.reduce((sum, e) => sum + (Date.now() - new Date(e.enqueuedAt).getTime()), 0) / activeEntries.length
-        : 0;
-    const queueHealth = queueBlockLabel
-        ? `waiting on main`
-        : summary.headPrNumber !== null
-            ? `head #${summary.headPrNumber} active`
-            : "queue idle";
-    const leftParts = [
-        snapshot.repoFullName,
-        `base:${snapshot.baseBranch}`,
-        `${summary.total} entries ${summary.active} active`,
-        queueHealth,
-        queueBlockLabel ?? null,
-        avgWaitMs > 0 ? `wait ~${formatDuration(avgWaitMs)}` : null,
-        `last tick ${runtimeLabel(runtime)} ${relativeTime(runtime.lastTickCompletedAt ?? runtime.lastTickStartedAt)}`,
-        filter,
-    ].filter(Boolean).join(" | ");
+    const cluster = getClusterSummary(repos);
+    const connected = cluster.connected > 0;
+    const repoHealth = currentRepo ? getRepoHealth(currentRepo) : null;
+    const leftParts = view === "project" && currentRepo
+        ? [
+            "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(" | ")
+        : [
+            "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 = 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 })] }));
 }

package/dist/watch/api.d.ts

@@ -1,8 +1,8 @@
 import type { QueueEntryDetail, QueueWatchSnapshot } from "../types.ts";
-export declare function fetchSnapshot(baseUrl: string): Promise<QueueWatchSnapshot>;
-export declare function fetchEntryDetail(baseUrl: string, entryId: string): Promise<QueueEntryDetail>;
-export declare function triggerReconcile(baseUrl: string): Promise<{
+export declare function fetchSnapshot(gatewayBaseUrl: string, repoId: string): Promise<QueueWatchSnapshot>;
+export declare function fetchEntryDetail(gatewayBaseUrl: string, repoId: string, entryId: string): Promise<QueueEntryDetail>;
+export declare function triggerReconcile(gatewayBaseUrl: string, repoId: string): Promise<{
     ok: true;
     started: boolean;
 }>;
-export declare function dequeueEntry(baseUrl: string, entryId: string): Promise<void>;
+export declare function dequeueEntry(gatewayBaseUrl: string, repoId: string, entryId: string): Promise<void>;

package/dist/watch/api.js

@@ -33,15 +33,19 @@ function buildUrl(baseUrl, path, params) {
     }
     return url.toString();
 }
-export async function fetchSnapshot(baseUrl) {
-    return await requestJson(buildUrl(baseUrl, "/queue/watch", { eventLimit: "40" }));
+function repoBaseUrl(gatewayBaseUrl, repoId) {
+    const base = gatewayBaseUrl.replace(/\/$/, "");
+    return `${base}/repos/${encodeURIComponent(repoId)}`;
 }
-export async function fetchEntryDetail(baseUrl, entryId) {
-    return await requestJson(buildUrl(baseUrl, `/queue/entries/${encodeURIComponent(entryId)}/detail`, { eventLimit: "120" }));
+export async function fetchSnapshot(gatewayBaseUrl, repoId) {
+    return await requestJson(buildUrl(repoBaseUrl(gatewayBaseUrl, repoId), "/queue/watch", { eventLimit: "40" }));
 }
-export async function triggerReconcile(baseUrl) {
-    return await requestJson(buildUrl(baseUrl, "/queue/reconcile"), { method: "POST" });
+export async function fetchEntryDetail(gatewayBaseUrl, repoId, entryId) {
+    return await requestJson(buildUrl(repoBaseUrl(gatewayBaseUrl, repoId), `/queue/entries/${encodeURIComponent(entryId)}/detail`, { eventLimit: "120" }));
 }
-export async function dequeueEntry(baseUrl, entryId) {
-    await requestJson(buildUrl(baseUrl, `/queue/entries/${encodeURIComponent(entryId)}/dequeue`), { method: "POST" });
+export async function triggerReconcile(gatewayBaseUrl, repoId) {
+    return await requestJson(buildUrl(repoBaseUrl(gatewayBaseUrl, repoId), "/queue/reconcile"), { method: "POST" });
+}
+export async function dequeueEntry(gatewayBaseUrl, repoId, entryId) {
+    await requestJson(buildUrl(repoBaseUrl(gatewayBaseUrl, repoId), `/queue/entries/${encodeURIComponent(entryId)}/dequeue`), { method: "POST" });
 }

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

@@ -0,0 +1,38 @@
+import type { QueueEntry, QueueWatchSnapshot } from "../types.ts";
+export interface DashboardRepoConfig {
+    repoId: string;
+    repoFullName: string;
+    baseBranch: string;
+}
+export interface DashboardRepoState extends DashboardRepoConfig {
+    snapshot: QueueWatchSnapshot | null;
+    error: string | null;
+    lastSnapshotReceivedAt: number | null;
+}
+export interface RepoHealthSummary {
+    kind: "offline" | "blocked" | "stuck" | "attention" | "active" | "idle";
+    label: string;
+    color: "red" | "yellow" | "green" | "gray" | "cyan";
+    detail: string;
+}
+export interface ClusterSummary {
+    total: number;
+    connected: number;
+    blocked: number;
+    stuck: number;
+    attention: number;
+    active: number;
+}
+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): string;
+export declare function runtimeSummary(snapshot: QueueWatchSnapshot | null): string;
+export declare function describeEntry(entry: QueueEntry, options: {
+    isHead: boolean;
+    queueBlockSummary: string | null;
+}): string;

package/dist/watch/dashboard-model.js

@@ -0,0 +1,192 @@
+import { buildChainEntries, buildDisplayEntries } from "./display-filter.js";
+import { formatDuration, humanStatus, nextStepLabel, 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;
+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) {
+    if (!snapshot) {
+        return [];
+    }
+    return snapshot.entries.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 ?? snapshot.entries[0]?.id ?? null;
+}
+export function getRepoHealth(repo, now = Date.now()) {
+    const snapshot = repo.snapshot;
+    const staleForMs = repo.lastSnapshotReceivedAt === null ? Infinity : now - repo.lastSnapshotReceivedAt;
+    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 = snapshot.entries.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(snapshot.entries[0]?.updatedAt)} 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) {
+    if (!snapshot) {
+        return "No queue data yet.";
+    }
+    const { summary } = 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 parts = [
+        `${summary.active} active`,
+        `${summary.queued} waiting`,
+        `${summary.validating} testing`,
+        `${summary.merging} merging`,
+    ];
+    if (summary.evicted > 0) {
+        parts.push(`${summary.evicted} need repair`);
+    }
+    if (avgWaitMs > 0) {
+        parts.push(`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 === "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/dist/watch/format.d.ts

@@ -28,6 +28,7 @@ export declare function specChainLabel(entry: {
 export declare function runtimeLabel(runtime: QueueRuntimeStatus): string;
 export declare function formatEventSummary(event: QueueEventSummary): string;
 export declare function formatEntryEvent(event: QueueEventRecord): string;
+export declare function formatEventNarrative(event: QueueEventRecord | QueueEventSummary): string;
 export declare function formatDuration(ms: number): string;
 export declare function progressBar(current: number, total: number, width: number): string;
 export declare function truncate(value: string, width: number): string;

package/dist/watch/format.js

@@ -149,6 +149,40 @@ export function formatEntryEvent(event) {
     const detail = event.detail ? ` (${shortenHashes(event.detail)})` : "";
     return `${transition}${detail}`;
 }
+function withDetail(text, detail) {
+    if (!detail) {
+        return text;
+    }
+    return `${text} ${shortenHashes(detail)}`;
+}
+export function formatEventNarrative(event) {
+    const prPrefix = "prNumber" in event ? `PR #${event.prNumber} ` : "This PR ";
+    if (!event.fromStatus && event.toStatus === "queued") {
+        return withDetail(`${prPrefix}entered the merge queue.`, event.detail);
+    }
+    if (event.toStatus === "preparing_head") {
+        return withDetail(`${prPrefix}started preparing its combined test branch.`, event.detail);
+    }
+    if (event.toStatus === "validating") {
+        return withDetail(`${prPrefix}started running CI.`, event.detail);
+    }
+    if (event.toStatus === "merging") {
+        return withDetail(`${prPrefix}passed CI and started merging to main.`, event.detail);
+    }
+    if (event.toStatus === "merged") {
+        return withDetail(`${prPrefix}landed on main.`, event.detail);
+    }
+    if (event.toStatus === "evicted") {
+        return withDetail(`${prPrefix}was evicted and needs repair before it can rejoin the queue.`, event.detail);
+    }
+    if (event.toStatus === "dequeued") {
+        return withDetail(`${prPrefix}was removed from the queue.`, event.detail);
+    }
+    if (event.toStatus === "queued" && event.fromStatus) {
+        return withDetail(`${prPrefix}was re-queued for another attempt.`, event.detail);
+    }
+    return withDetail(`${prPrefix}moved from ${displayStatus(event.fromStatus ?? "start")} to ${displayStatus(event.toStatus)}.`, event.detail);
+}
 export function formatDuration(ms) {
     const seconds = Math.floor(ms / 1000);
     if (seconds < 60)

package/dist/watch/index.d.ts

@@ -1 +1,4 @@
-export declare function startWatch(configPath?: string, initialPrNumber?: number): Promise<void>;
+export declare function startDashboard(options?: {
+    initialRepoRef?: string;
+    initialPrNumber?: number;
+}): Promise<void>;

package/dist/watch/index.js

@@ -1,10 +1,10 @@
 import { createElement } from "react";
 import { render } from "ink";
-import { loadConfig } from "../config.js";
 import { App } from "./App.js";
 import { parseHomeConfigObject } from "../steward-home.js";
 import { getDefaultConfigPath } from "../runtime-paths.js";
 import { readFileSync, existsSync } from "node:fs";
+import { loadAllRepoConfigs } from "../install.js";
 function resolveGatewayBaseUrl() {
     const configPath = getDefaultConfigPath();
     if (!existsSync(configPath)) {
@@ -17,13 +17,21 @@ function resolveGatewayBaseUrl() {
     const port = homeConfig.server.gateway_port ?? (homeConfig.server.port_base - 1);
     return `http://${bind}:${port}`;
 }
-export async function startWatch(configPath, initialPrNumber) {
-    const config = loadConfig(configPath);
+export async function startDashboard(options) {
+    const configs = await loadAllRepoConfigs();
     const gatewayBase = resolveGatewayBaseUrl();
-    const baseUrl = `${gatewayBase}/repos/${config.repoId}`;
     process.stderr.write("\u001b[?1049h\u001b[2J\u001b[H");
     try {
-        const instance = render(createElement(App, { baseUrl, ...(initialPrNumber !== undefined ? { initialPrNumber } : {}) }), { stdout: process.stderr, stdin: process.stdin, patchConsole: false });
+        const instance = render(createElement(App, {
+            gatewayBaseUrl: gatewayBase,
+            repos: configs.map((config) => ({
+                repoId: config.repoId,
+                repoFullName: config.repoFullName,
+                baseBranch: config.baseBranch,
+            })),
+            initialRepoRef: options?.initialRepoRef,
+            ...(options?.initialPrNumber !== undefined ? { initialPrNumber: options.initialPrNumber } : {}),
+        }), { stdout: process.stderr, stdin: process.stdin, patchConsole: false });
         await instance.waitUntilExit();
     }
     finally {

package/package.json

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