Count decisions as decisions, and land the badge where it points

The dashboard's Needs-you widget said "0 of 12 decided" to someone who
had dismissed five findings and could only ever see eight: it counted
confirmations, called them decisions, and sized the queue with findings
the quotation check had already hidden. It now counts confirmed plus
dismissed, out of the queue a person is actually handed.

The awaiting badge sat on every screen and landed on every review ever
run, because the reviews list held its filter in component state where
no link could reach it. The list reads the filter from the URL now and
the badge points at it, which the toggle says out loud through
aria-pressed rather than through colour alone.

The projects widget was fetching the last review's date, its id and the
review count and drawing none of them. All three are on screen, the
outcome opens the review it describes, and every row offers the branch
review the plan asked for.

Author: Poolchaos

docs/DECISIONS.md

@@ -1921,3 +1921,31 @@ verified evidence, in writing, here.
   dashboard is the app's front door and was not in it, and the queue's
   caption claimed a stage timeline and a coverage panel that the shot no
   longer contains, both having moved inside the Run detail fold.
+- 2026-08-18 D-84 (review pass over the dashboard shell, M1-M6): six numbered
+  findings, all fixed in one diff before any new work started.
+  1. The Needs-you widget said "N of M decided" and counted neither. N was the
+  confirmed findings, so someone who had dismissed an entire queue was told
+  they had not started it; M included findings the quotation check killed,
+  which the queue never shows, so the target could not be reached. The
+  scoreboard now carries `decided` (confirmed plus dismissed) and a total that
+  is the size of the queue a person will actually be handed.
+  2. The awaiting badge in the top bar linked to `/reviews`, unfiltered, which
+  is the list someone pressing a count of three wants least. The filter lived
+  only in component state, so nothing could link to it. The reviews list now
+  seeds its filter from `?status=awaiting` and the badge points there.
+  3. The projects widget fetched the last review's timestamp and id and the
+  per-project review count, and rendered none of the three, while the plan's
+  own row asked for "when" and a way to review a branch. All three are on
+  screen now: the age, the count when there is more than one, an outcome chip
+  that opens the review it describes, and a Review link per row.
+  4. That widget's tally read "3 of 12" with no word saying what the numbers
+  were, where every other surface names its number. It says confirmed.
+  5. The dashboard's one-second clock was keyed to the polled object rather
+  than to whether anything is running, so every four-second poll tore the
+  interval down and started it again.
+  6. The e2e assertion for finding 2 was written first as a row scrape over
+  `ul > li`, which matches the projects list on the page it was navigating
+  away from: it passed against the old DOM and then read an empty list, which
+  is a flake and stop-the-line. Root-caused rather than retried, and replaced
+  with a wait on the URL plus the filter toggle's own `aria-pressed`, which
+  the toggle now carries because it is a toggle.

e2e/failure-paths.spec.ts

@@ -145,7 +145,21 @@ test("the top bar says how many reviews are waiting on a person", async ({ page
   await page.goto("/projects");
   const badge = page.getByLabel(/awaiting your decision/);
   await expect(badge).toBeVisible({ timeout: 30_000 });
-  // A link, not an ornament: the count is also the way to the queue.
-  await expect(badge).toHaveAttribute("href", "/reviews");
+  // A link, not an ornament: the count is also the way to the queue. It
+  // asserted a bare "/reviews" until 2026-08-18, which landed on every review
+  // ever run: the list someone pressing a count of three wants least.
+  await expect(badge).toHaveAttribute("href", "/reviews?status=awaiting");
   await expect(badge).toContainText(/\d+/);
+
+  // And the filter is actually applied on arrival, rather than the parameter
+  // being decoration on the href. Asserted through the toggle's own pressed
+  // state rather than by counting rows: how many reviews are waiting depends
+  // on what the tests before this one left behind, and the question here is
+  // whether the link arrives filtered.
+  await badge.click();
+  await expect(page).toHaveURL(/status=awaiting/);
+  await expect(page.getByRole("button", { name: /awaiting your decision/ })).toHaveAttribute(
+    "aria-pressed",
+    "true",
+  );
 });

src/app/page.tsx

@@ -40,7 +40,7 @@ interface AwaitingRow {
   projectName: string;
   fromBranch: string;
   intoBranch: string;
-  confirmed: number;
+  decided: number;
   total: number;
   since: string;
 }
@@ -202,12 +202,15 @@ export default function HomePage() {
   }, []);
 
   // Ticks only while something is running, so a quiet dashboard is not
-  // re-rendered once a second for ever.
+  // re-rendered once a second for ever. Keyed to whether a run exists rather
+  // than to the polled object, which is a new identity every four seconds and
+  // would restart the clock each time it arrived.
+  const running = live !== null;
   useEffect(() => {
-    if (!live) return;
+    if (!running) return;
     const tick = setInterval(() => setNow(Date.now()), 1000);
     return () => clearInterval(tick);
-  }, [live]);
+  }, [running]);
 
   useEffect(() => {
     let cancelled = false;
@@ -359,9 +362,7 @@ export default function HomePage() {
                           </span>
                         </span>
                         <span className="text-dense tabular-nums">
-                          {row.total > 0
-                            ? `${row.confirmed} of ${row.total} decided`
-                            : "no findings"}
+                          {row.total > 0 ? `${row.decided} of ${row.total} decided` : "no findings"}
                           <span className="ml-3 text-[var(--color-ink-muted)]">
                             waiting {ago(row.since, now)}
                           </span>
@@ -482,20 +483,41 @@ export default function HomePage() {
                         {project.name}
                       </Link>
                       {project.latest ? (
-                        <span className="flex items-center gap-2 text-aside">
-                          <Badge tone={statusTone(project.latest.status)}>
-                            {statusLabel(project.latest.status)}
-                          </Badge>
+                        <span className="flex flex-wrap items-center gap-x-2 gap-y-1 text-aside">
+                          {/* The outcome is the way into the review that
+                              produced it: a status worth reading is a status
+                              worth opening. */}
+                          <Link href={`/reviews/${project.latest.id}`}>
+                            <Badge tone={statusTone(project.latest.status)}>
+                              {statusLabel(project.latest.status)}
+                            </Badge>
+                          </Link>
                           <span className="text-[var(--color-ink-muted)] tabular-nums">
                             {project.latest.total > 0
-                              ? `${project.latest.confirmed} of ${project.latest.total}`
+                              ? `${project.latest.confirmed} of ${project.latest.total} confirmed`
                               : "no findings"}
                           </span>
+                          {/* When, and how many times. A project reviewed once
+                              last March is a different thing from one reviewed
+                              nine times this week, and the widget said neither. */}
+                          <span className="text-[var(--color-ink-faint)]">
+                            {ago(project.latest.at, now)}
+                            {project.reviews > 1 ? ` · ${project.reviews} reviews` : ""}
+                          </span>
+                          <Link
+                            href={`/reviews/new?projectId=${project.id}`}
+                            className="text-[var(--color-accent)] underline underline-offset-2"
+                          >
+                            Review
+                          </Link>
                         </span>
                       ) : (
-                        <span className="text-aside text-[var(--color-ink-faint)]">
-                          never reviewed
-                        </span>
+                        <Link
+                          href={`/reviews/new?projectId=${project.id}`}
+                          className="text-aside text-[var(--color-accent)] underline underline-offset-2"
+                        >
+                          Review a branch
+                        </Link>
                       )}
                     </li>
                   ))}

src/app/reviews/page.tsx

@@ -10,7 +10,8 @@
  */
 
 import Link from "next/link";
-import { useCallback, useEffect, useState } from "react";
+import { useSearchParams } from "next/navigation";
+import { Suspense, useCallback, useEffect, useState } from "react";
 import { PageBody, PageHeader } from "@/components/page";
 import {
   Badge,
@@ -57,10 +58,16 @@ function ranFor(startedAt: string | null, completedAt: string | null): string |
 /** Statuses that own a running process, so the row offers no delete. */
 const RUNNING = new Set(["running", "verifying"]);
 
-export default function ReviewsPage() {
+function ReviewsList() {
+  const search = useSearchParams();
   const [reviews, setReviews] = useState<Row[] | null>(null);
   const [project, setProject] = useState("");
-  const [status, setStatus] = useState("");
+  // Seeded from the URL so the awaiting badge in the top bar can land on the
+  // filtered list rather than on every review ever run, which is the list
+  // someone pressing a count of three is least interested in.
+  const [status, setStatus] = useState(() =>
+    search.get("status") === "awaiting" ? "awaiting" : "",
+  );
   const [confirming, setConfirming] = useState("");
   const [busy, setBusy] = useState("");
   const [error, setError] = useState("");
@@ -129,6 +136,9 @@ export default function ReviewsPage() {
             {awaiting > 0 ? (
               <Button
                 variant={status === "awaiting" ? "primary" : "quiet"}
+                // It is a toggle, so it says whether it is on rather than
+                // leaving that to colour alone.
+                aria-pressed={status === "awaiting"}
                 onClick={() => setStatus(status === "awaiting" ? "" : "awaiting")}
               >
                 {awaiting} awaiting your decision
@@ -249,3 +259,22 @@ export default function ReviewsPage() {
     </>
   );
 }
+
+export default function ReviewsPage() {
+  // Required because the list reads a search param. The fallback is the header
+  // it is about to render anyway, so nothing flashes empty.
+  return (
+    <Suspense
+      fallback={
+        <>
+          <PageHeader title="Reviews" />
+          <PageBody>
+            <p className="text-body text-[var(--color-ink-muted)]">Reading the reviews...</p>
+          </PageBody>
+        </>
+      }
+    >
+      <ReviewsList />
+    </Suspense>
+  );
+}

src/components/topbar.tsx

@@ -140,7 +140,7 @@ export function TopBar() {
       <div className="ml-auto flex shrink-0 items-center gap-2">
         {awaiting > 0 ? (
           <Link
-            href="/reviews"
+            href="/reviews?status=awaiting"
             aria-label={`${awaiting} awaiting your decision`}
             className="flex items-center gap-1.5 rounded-md border border-[var(--color-question)] bg-[var(--color-question-soft)] px-2 py-1 text-aside font-medium text-[var(--color-question)]"
           >

src/server/db/repositories/scoreboard.ts

@@ -45,7 +45,17 @@ export interface AwaitingReview {
   projectName: string;
   fromBranch: string;
   intoBranch: string;
-  confirmed: number;
+  /**
+   * Confirmed or dismissed. Both are decisions, and counting only the
+   * confirmed ones told someone who had dismissed a whole queue that they
+   * had not started it.
+   */
+  decided: number;
+  /**
+   * The size of the queue this person will actually be shown, so killed
+   * findings are not in it: the quotation check hides those, and a total
+   * that counts them can never be reached.
+   */
   total: number;
   /** When the review stopped and started waiting on a person. */
   since: string;
@@ -107,16 +117,22 @@ export function readScoreboard(db: Db, recentLimit = 12): Scoreboard {
     .from(findings)
     .all();
 
-  const byReview = new Map<string, { confirmed: number; total: number }>();
+  const byReview = new Map<
+    string,
+    { confirmed: number; decided: number; queued: number; total: number }
+  >();
   const byRule = new Map<string, RuleYield>();
   let confirmed = 0;
   let dismissed = 0;
   let killed = 0;
 
   for (const row of findingRows) {
-    const tally = byReview.get(row.reviewId) ?? { confirmed: 0, total: 0 };
+    const tally = byReview.get(row.reviewId) ?? { confirmed: 0, decided: 0, queued: 0, total: 0 };
     tally.total += 1;
     if (row.status === "confirmed") tally.confirmed += 1;
+    if (row.status === "confirmed" || row.status === "dismissed") tally.decided += 1;
+    // Everything the queue will show. A killed finding is not in it.
+    if (row.status !== "killed") tally.queued += 1;
     byReview.set(row.reviewId, tally);
 
     if (row.status === "confirmed") confirmed += 1;
@@ -187,8 +203,8 @@ export function readScoreboard(db: Db, recentLimit = 12): Scoreboard {
         projectName: review.projectName,
         fromBranch: review.fromBranch,
         intoBranch: review.intoBranch,
-        confirmed: byReview.get(review.id)?.confirmed ?? 0,
-        total: byReview.get(review.id)?.total ?? 0,
+        decided: byReview.get(review.id)?.decided ?? 0,
+        total: byReview.get(review.id)?.queued ?? 0,
         // When it stopped, which is when the waiting began. A review that
         // never finished a run has only its creation to go on.
         since: review.completedAt ?? review.createdAt,

tests/server/db/scoreboard.test.ts

@@ -158,6 +158,28 @@ describe("what the dashboard widgets need", () => {
     expect(board.awaitingReviews[0]?.fromBranch).toBe("feature/x");
   });
 
+  it("counts a dismissal as a decision, and leaves killed findings out of the queue", () => {
+    // The widget's whole job is saying how much is left. Counting only the
+    // confirmed ones told someone who had dismissed a queue that they had not
+    // started it, and counting killed findings in the total set a target the
+    // queue never shows and so can never reach.
+    const kept = candidate();
+    const dropped = candidate({ issue: "Second" });
+    const untouched = candidate({ issue: "Third" });
+    for (const finding of [kept, dropped, untouched]) markVerified(db, finding.id, evidence);
+    confirmFinding(db, kept.id);
+    dismissFinding(db, dropped.id, "Guarded upstream.");
+    markKilled(db, candidate({ issue: "Invented" }).id, "Quoted code that was not there.");
+
+    transitionReview(db, reviewId, "running");
+    transitionReview(db, reviewId, "verifying");
+    transitionReview(db, reviewId, "awaiting_confirmation");
+
+    const row = readScoreboard(db).awaitingReviews[0];
+    expect(row?.decided).toBe(2);
+    expect(row?.total).toBe(3);
+  });
+
   it("keeps two projects with the same name apart", () => {
     // Two remotes can end in the same repository name. Matching on it would
     // report one project's last finding as another's.