fix(admin): open the date column newest-first

An admin coming back to /admin/accounts asks one question of "Tier
changed": what moved while I was away. The column opened ascending, so
the top of the table filled with the most settled accounts on the roster
— the ones nothing has happened to since last spring — and the answer
sat at the bottom, behind a second click, every visit. On a page whose
own lede says the sync jobs change things without telling anyone, that
is the wrong end of the column to land on.

`SORT_OPENS` gives each key the direction it opens on its FIRST press.
Name, Tier and Cryo keep ascending, which is right for a value you
already have in mind and are scanning for. Only `tierChangedAt` opens
descending. Once a column is active it toggles exactly as before — this
changes the opening direction and nothing else.

The spec asserts the URL, `aria-sort`, and the rendered row order, with
the two seeded accounts named so alphabetical order and recency order
disagree — otherwise a sort that did nothing at all would pass. The
tier-change instants are stamped with a direct update rather than by
widening `seedMember`, which five other spec files share. Verified to
fail with the fix reverted (`Received: …dir=asc`).

typecheck, eslint, prettier --check .: clean.
npm test: 77 files, 1134 tests passed.
npx playwright test: 233 passed, 233 ✓ lines counted.

Author: guarzo

e2e/admin.spec.ts

@@ -399,6 +399,64 @@ test("sortable headers say so at rest, without changing their accessible names",
   await expect(page.getByRole("link", { name: "Tier", exact: true })).toBeVisible();
 });
 
+/**
+ * The direction a column opens on its first click.
+ *
+ * Every header opened ascending, which is right for Name, Tier and Cryo — a
+ * value you already have in mind, found from the top. It is wrong for "Tier
+ * changed": nobody opens that column to find the account nothing has happened
+ * to since last spring. They open it to answer "what moved while I was away",
+ * and ascending answers the opposite question, putting the answer at the
+ * bottom of the roster behind a second click.
+ *
+ * Asserted through the URL and through the rendered order, because the URL
+ * alone would pass if `dir` stopped reaching the query.
+ */
+test("the date column opens newest-first; the others still open ascending", async ({
+  page,
+  context,
+}) => {
+  const admin = await seedMember(db, { name: "Boss", tier: "member", isAdmin: true });
+  await context.addCookies([await sessionCookieFor(db, admin.id)]);
+  // Two accounts whose tier moved a year apart, named so that alphabetical
+  // order and recency order disagree — otherwise a sort that did nothing at
+  // all would pass this test.
+  const ancient = await seedMember(db, { name: "Ancient", tier: "member" });
+  const zeta = await seedMember(db, { name: "Zeta", tier: "member" });
+  // `seedMember` does not take a tier-change instant — stamped here rather
+  // than by widening a helper five other spec files share.
+  await db
+    .update(account)
+    .set({ tierChangedAt: new Date("2024-01-01T00:00:00Z") })
+    .where(eq(account.id, ancient.id));
+  await db
+    .update(account)
+    .set({ tierChangedAt: new Date("2026-01-01T00:00:00Z") })
+    .where(eq(account.id, zeta.id));
+  await page.goto("/admin/accounts");
+
+  await page.getByRole("link", { name: "Tier changed", exact: true }).click();
+  await expect(page).toHaveURL(/[?&]sort=tierChangedAt(&|$)/);
+  await expect(page).toHaveURL(/[?&]dir=desc(&|$)/);
+  await expect(
+    page.getByRole("columnheader", { name: "Tier changed", exact: true }),
+  ).toHaveAttribute("aria-sort", "descending");
+  // Zeta moved last, so it is first. Boss and Ancient are older.
+  await expect(page.locator(".log--dense tbody tr").first()).toContainText("Zeta");
+
+  // Once active the column toggles as it always did — this change is about
+  // the first press only.
+  await page.getByRole("link", { name: /^Tier changed/ }).click();
+  await expect(page).toHaveURL(/[?&]dir=asc(&|$)/);
+  await expect(page.locator(".log--dense tbody tr").first()).toContainText("Ancient");
+
+  // A non-date column is untouched: still ascending on its first press.
+  await page.goto("/admin/accounts");
+  await page.getByRole("link", { name: "Tier", exact: true }).click();
+  await expect(page).toHaveURL(/[?&]sort=tier(&|$)/);
+  await expect(page).toHaveURL(/[?&]dir=asc(&|$)/);
+});
+
 test("tier controls: manual set locks; return-to-auto unlocks", async ({
   page,
   context,

src/app/admin/accounts/page.tsx

@@ -54,6 +54,28 @@ const SORTS: Array<{ key: AdminListSort; label: string }> = [
   { key: "status", label: "Cryo" },
   { key: "tierChangedAt", label: "Tier changed" },
 ];
+
+/**
+ * Which way a column opens on the FIRST click, before it has a direction of
+ * its own. Only the direction of that first press; once a column is active it
+ * toggles as it always did.
+ *
+ * `name`, `tier` and `status` open ascending because A-first and
+ * `member`-first are how someone looks for a value they already have in mind.
+ * `tierChangedAt` is not that kind of column. Nobody clicks "Tier changed"
+ * to find the account nothing has happened to since last spring; they click it
+ * to answer "what moved while I was away", and ascending answers the opposite
+ * question — the top of the table fills with the most settled accounts on the
+ * roster and the answer sits at the bottom, one more click away, on a page
+ * whose whole reason to exist is that the sync jobs change things without
+ * telling anyone.
+ */
+const SORT_OPENS: Record<AdminListSort, "asc" | "desc"> = {
+  name: "asc",
+  tier: "asc",
+  status: "asc",
+  tierChangedAt: "desc",
+};
 // What an admin may manually assign. Pending is deliberately absent: it is a
 // state accounts are born in, and setTierManual locks whatever it sets.
 const TIERS = ["member", "associate", "alumni"] as const;
@@ -420,7 +442,17 @@ export default async function AdminAccountsPage({
                   <a
                     href={qs({
                       sort: s.key,
-                      dir: sort === s.key && dir === "asc" ? "desc" : "asc",
+                      // Active column: toggle. Inactive: open the way the
+                      // column is worth reading (`SORT_OPENS`), rather than
+                      // ascending for everything — which cost a second click
+                      // on the one column where ascending is never the
+                      // question being asked.
+                      dir:
+                        sort === s.key
+                          ? dir === "asc"
+                            ? "desc"
+                            : "asc"
+                          : SORT_OPENS[s.key],
                     })}
                   >
                     {s.label}