From 0b129c0dcebf2449d0c769eab12d6d94596c23fd Mon Sep 17 00:00:00 2001
From: Bhushan Agrawal <bhushan.agrawal4work@gmail.com>
Date: Fri, 23 Oct 2026 08:30:13 +0530
Subject: [PATCH 01/16] fix: link no-card page to the leaderboard and issues
 (#73) (#82)

---
 src/index.ts      |  8 ++++++--
 src/page.ts       | 10 ++++++++--
 test/card.test.ts | 23 ++++++++++++++++++++++-
 3 files changed, 36 insertions(+), 5 deletions(-)

diff --git a/src/index.ts b/src/index.ts
index 690d5ec..3ce1e5c 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -263,10 +263,14 @@ async function handleContributor(
       "No card yet",
       [
         `${login} has no counted pull requests in ${program.title}.`,
-        `A card appears with the first merged pull request that counts. The leaderboard is at ${new URL(boardPath, request.url).href}`,
+        "A card appears with the first merged pull request that counts.",
       ],
       false,
-      "No card"
+      "No card",
+      [
+        { label: "See the leaderboard", href: boardPath },
+        { label: "Find an issue", href: env.ISSUES_URL },
+      ]
     );
     return new Response(body, { status: 404, headers: { ...PAGE_HEADERS, "Cache-Control": "no-store", "Content-Security-Policy": CONTRIBUTOR_CSP } });
   }
diff --git a/src/page.ts b/src/page.ts
index c0b8b41..f2e6a2c 100644
--- a/src/page.ts
+++ b/src/page.ts
@@ -232,7 +232,13 @@ ${links.others.length ? `<section class="others">\n<h2>Other programs</h2>\n<ul>
 }
 
 /** A small page with a heading and a few paragraphs, for the result of /link. Everything is escaped. */
-export function noticePage(title: string, lines: string[], ok: boolean, label = ok ? "Done" : "Not linked"): string {
+export function noticePage(
+  title: string,
+  lines: string[],
+  ok: boolean,
+  label = ok ? "Done" : "Not linked",
+  links: { label: string; href: string }[] = []
+): string {
   return `<!doctype html>
 <html lang="en">
 <head>
@@ -250,7 +256,7 @@ export function noticePage(title: string, lines: string[], ok: boolean, label =
 <section class="rules">
 ${lines.map((line) => `<p>${escapeHtml(line)}</p>`).join("\n")}
 </section>
-<p class="status ${ok ? "running" : ""}">${escapeHtml(label)}</p>
+${links.length ? `<div class="cta">\n${links.map((link) => `<a href="${escapeHtml(link.href)}">${escapeHtml(link.label)}</a>`).join("\n")}\n</div>\n` : ""}<p class="status ${ok ? "running" : ""}">${escapeHtml(label)}</p>
 </main>
 </body>
 </html>`;
diff --git a/test/card.test.ts b/test/card.test.ts
index 37f56f8..8cb5d73 100644
--- a/test/card.test.ts
+++ b/test/card.test.ts
@@ -2,7 +2,7 @@ import { beforeEach, afterEach, describe, expect, it, vi } from "vitest";
 import { boardSvg, boardVersion, cardSvg, escapeXml, fitMono, progressBar } from "../src/card";
 import { getConfig } from "../src/config";
 import worker from "../src/index";
-import { contributorPage } from "../src/page";
+import { contributorPage, noticePage } from "../src/page";
 import { FakeCache, makeCtx, makeEnv, mockFetch } from "./helpers";
 
 // The real module needs the WebAssembly rasterizer and the font files, which
@@ -266,6 +266,24 @@ describe("contributorPage", () => {
   });
 });
 
+describe("noticePage links", () => {
+  it("shows supplied links with the cta styling and escapes labels and destinations", () => {
+    const html = noticePage("No card yet", ["Nothing here."], false, "No card", [
+      { label: `<script>"label"</script>`, href: `https://example.com/?a="b"&c=<d>` },
+    ]);
+    expect(html).toContain('<div class="cta">');
+    expect(html).toContain('href="https://example.com/?a=&quot;b&quot;&amp;c=&lt;d&gt;"');
+    expect(html).toContain("&lt;script&gt;&quot;label&quot;&lt;/script&gt;");
+    expect(html).not.toContain("<script>");
+  });
+
+  it("leaves pages without links as they were", () => {
+    const html = noticePage("GitHub linked", ["Everything is linked."], true);
+    expect(html).not.toContain('<div class="cta">');
+    expect(html).toContain('<section class="rules">\n<p>Everything is linked.</p>\n</section>\n<p class="status running">Done</p>');
+  });
+});
+
 describe("GET /leaderboard/{id}/u/{login}", () => {
   let env = makeEnv();
   const ctx = { waitUntil() {}, passThroughOnException() {} } as unknown as ExecutionContext;
@@ -325,6 +343,9 @@ describe("GET /leaderboard/{id}/u/{login}", () => {
     const html = await page.text();
     expect(html).toContain("<h1>No card yet</h1>");
     expect(html).toContain("bob has no counted pull requests in Hacktoberfest 2026.");
+    expect(html).toContain('<a href="/leaderboard/2026-10">See the leaderboard</a>');
+    expect(html).toContain('<a href="https://github.com/search?q=example">Find an issue</a>');
+    expect(html).not.toContain("The leaderboard is at");
     expect((await get("/leaderboard/2026-10/u/bob.png")).status).toBe(404);
     expect((await get("/leaderboard/2025-01/u/ada")).status).toBe(404);
     expect((await get("/leaderboard/2026-10/u/-ada")).status).toBe(404);

From eed9145acc5eb0fc83c6b2ca35fc0e34674cfbf8 Mon Sep 17 00:00:00 2001
From: Sanketh Kumar <sankethkumarbg1995@gmail.com>
Date: Fri, 23 Oct 2026 08:54:39 +0530
Subject: [PATCH 02/16] fix: show the /link ask and closing note in
 /leaderboard after the end (#83)

The final results post asks unlinked winners to run /link and ends with the closing note, but /leaderboard built the same final message without those options. Pass linking and finalNote the way the cron does; both only apply once the program has ended.
---
 src/commands.ts      |  2 ++
 test/linking.test.ts | 39 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 41 insertions(+)

diff --git a/src/commands.ts b/src/commands.ts
index 5efbb7d..c4bdd0f 100644
--- a/src/commands.ts
+++ b/src/commands.ts
@@ -83,7 +83,9 @@ export async function runCommand(
         return leaderboardMessage(board, program, {
           final: programStatus(program, now) === "ended",
           url: leaderboardUrl(cfg, program),
+          finalNote: cfg.finalResultsNote,
           members: await linkedMembers(env, board.rows.slice(0, 10).map((r) => r.login)),
+          linking: linkingEnabled(env),
         });
       }
       case "link": {
diff --git a/test/linking.test.ts b/test/linking.test.ts
index 552ac4b..e0ca2c6 100644
--- a/test/linking.test.ts
+++ b/test/linking.test.ts
@@ -343,6 +343,45 @@ describe("/link, /unlink and /me", () => {
     expect((await run("me")).content).toBe("You haven't linked a GitHub account yet. Run `/link` first.");
   });
 
+  describe("/leaderboard after the program ends", () => {
+    const after = new Date("2026-11-01T10:00:00Z");
+    const endedEnv = (linking: boolean) =>
+      makeEnv({
+        ...(linking ? { LINKING: "on", DISCORD_CLIENT_SECRET: SECRET } : {}),
+        FINAL_RESULTS_NOTE: "See you next year.",
+      });
+
+    it("asks unlinked winners to run /link and ends with the closing note", async () => {
+      const e = endedEnv(true);
+      mockFetch(search(5));
+      const reply = await runCommand({ name: "leaderboard" }, user, e, getConfig(e), after);
+      const text = reply.embeds?.[0]?.description ?? "";
+      expect(text).toContain("Congratulations to **Ada**");
+      expect(text).toContain("run `/link` in this server");
+      expect(text).toContain("See you next year.");
+    });
+
+    it("leaves out the /link line when linking is off", async () => {
+      const e = endedEnv(false);
+      mockFetch(search(5));
+      const reply = await runCommand({ name: "leaderboard" }, user, e, getConfig(e), after);
+      const text = reply.embeds?.[0]?.description ?? "";
+      expect(text).toContain("Congratulations to **Ada**");
+      expect(text).not.toContain("/link");
+      expect(text).toContain("See you next year.");
+    });
+
+    it("keeps the reply for a running program unchanged", async () => {
+      const e = endedEnv(true);
+      mockFetch(search(5));
+      const reply = await runCommand({ name: "leaderboard" }, user, e, getConfig(e), now);
+      const text = reply.embeds?.[0]?.description ?? "";
+      expect(text).not.toContain("Congratulations");
+      expect(text).not.toContain("/link");
+      expect(text).not.toContain("See you next year.");
+    });
+  });
+
   it("/me shows the member's count, their place in the current program and any role they were owed", async () => {
     await saveLink(env, ada);
     const fetched = mockFetch(search(4), discordApi({ memberRoles: [] }));

From 9e7879e15dc9fb627d53c895e69fec952d6c1947 Mon Sep 17 00:00:00 2001
From: Anurag Verma <78868769+anurag629@users.noreply.github.com>
Date: Fri, 23 Oct 2026 09:31:36 +0530
Subject: [PATCH 03/16] fix: key the share image cache on the server's version
 (#89)

The board image and the contributor card were cached under the full request
address, so every new ?v= value (or a login in different letter case) drew the
PNG again and fetched the avatars again. Key both on the path and the version
the page itself puts in og:image.
---
 src/index.ts      | 41 +++++++++++++++++++++------------------
 test/card.test.ts | 49 +++++++++++++++++++++++++++++++++++++++++++++--
 2 files changed, 69 insertions(+), 21 deletions(-)

diff --git a/src/index.ts b/src/index.ts
index 3ce1e5c..41aac0a 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -146,6 +146,16 @@ async function handleLeaderboardPage(request: Request, env: Env, id: string | un
   }
 }
 
+// The cache key for a drawn image: its path and the version worked out here,
+// whatever `?v=` the request carries. Keyed on the address asked for, every new
+// `?v=` value would mean a new picture to draw. The key is always a GET, because
+// the cache only takes those, so a HEAD finds and stores the image under the
+// same key as a GET (otherwise the cache would throw, and the image would be
+// left empty for the next GET).
+function imageKey(path: string, version: string, request: Request): Request {
+  return new Request(new URL(`${path}?v=${encodeURIComponent(version)}`, request.url).href);
+}
+
 // A program's leaderboard as a share image: /leaderboard/{id}.png. The page's
 // og:image points here.
 async function handleLeaderboardImage(request: Request, env: Env, ctx: ExecutionContext, id: string): Promise<Response> {
@@ -156,13 +166,6 @@ async function handleLeaderboardImage(request: Request, env: Env, ctx: Execution
 
   // The image is the same for everyone and costs some CPU to draw, so keep it at the edge.
   const cache = typeof caches !== "undefined" ? await caches.open("cards").catch(() => undefined) : undefined;
-  // The cache only takes GET requests, and it keys on the address. So a HEAD
-  // asks for the image under the key a GET uses, and stores it there too:
-  // otherwise the cache would throw, and the image would be left empty for the
-  // next GET.
-  const cacheKey = request.method === "GET" ? request : new Request(request.url);
-  const cached = await cache?.match(cacheKey);
-  if (cached) return cached;
 
   let board;
   try {
@@ -175,6 +178,10 @@ async function handleLeaderboardImage(request: Request, env: Env, ctx: Execution
     });
   }
 
+  const cacheKey = imageKey(`/leaderboard/${program.id}.png`, boardVersion(board.rows, program, now), request);
+  const cached = await cache?.match(cacheKey);
+  if (cached) return cached;
+
   // Loaded on demand: this module pulls in the rasterizer and the fonts.
   const { fetchAvatar, renderPng } = await import("./card-image");
   const avatars = await Promise.all(board.rows.slice(0, BOARD_ROWS).map((row) => fetchAvatar(row.login)));
@@ -234,16 +241,6 @@ async function handleContributor(
   const program = findProgram(cfg, programId);
   if (!program) return new Response("not found", { status: 404 });
 
-  // The card is the same for everyone and costs some CPU to draw, so keep it at the edge.
-  const cache = asPng && typeof caches !== "undefined" ? await caches.open("cards").catch(() => undefined) : undefined;
-  // The cache only takes GET requests, and it keys on the address. So a HEAD
-  // asks for the card under the key a GET uses, and stores it there too:
-  // otherwise the cache would throw, and the card would be left empty for the
-  // next GET.
-  const cacheKey = request.method === "GET" ? request : new Request(request.url);
-  const cached = await cache?.match(cacheKey);
-  if (cached) return cached;
-
   let board;
   try {
     board = await getLeaderboard(env, cfg, program);
@@ -279,8 +276,16 @@ async function handleContributor(
   const of = board.rows.length;
   const status = programStatus(program, now);
   const path = `${boardPath}/u/${encodeURIComponent(row.login)}`;
+  // The version makes share previews pick up a new image when the numbers change.
+  const version = `${row.count}-${rank}-${of}-${status}`;
 
   if (asPng) {
+    // The card is the same for everyone and costs some CPU to draw, so keep it at the edge.
+    const cache = typeof caches !== "undefined" ? await caches.open("cards").catch(() => undefined) : undefined;
+    const cacheKey = imageKey(`${path}.png`, version, request);
+    const cached = await cache?.match(cacheKey);
+    if (cached) return cached;
+
     // Loaded on demand: this module pulls in the rasterizer and the fonts.
     const { fetchAvatar, renderPng } = await import("./card-image");
     const svg = cardSvg({
@@ -300,8 +305,6 @@ async function handleContributor(
     return response;
   }
 
-  // The version makes share previews pick up a new image when the numbers change.
-  const version = `${row.count}-${rank}-${of}-${status}`;
   const prsQuery = `org:${cfg.org} is:pr is:merged author:${row.login} label:"${program.label}" merged:${program.start.toISOString().slice(0, 10)}..${program.end.toISOString().slice(0, 10)}`;
   const html = contributorPage(
     { program, row, rank, of, generatedAt: board.generatedAt },
diff --git a/test/card.test.ts b/test/card.test.ts
index 8cb5d73..f2f57a9 100644
--- a/test/card.test.ts
+++ b/test/card.test.ts
@@ -447,7 +447,10 @@ describe("the card cache", () => {
     const { ctx, settle } = makeCtx();
     await worker.fetch(new Request("https://bot.example/leaderboard/2026-10/u/Ada.png", { method: "HEAD" }), env, ctx);
     await settle();
-    const stored = cache.entries.get("https://bot.example/leaderboard/2026-10/u/Ada.png");
+    const keys = [...cache.entries.keys()];
+    expect(keys).toHaveLength(1);
+    expect(keys[0]).toMatch(/^https:\/\/bot\.example\/leaderboard\/2026-10\/u\/Ada\.png\?v=1-1-1-/);
+    const stored = cache.entries.get(keys[0]!);
     expect(stored).toBeDefined();
     expect(stored!.body.byteLength).toBeGreaterThan(0);
 
@@ -455,6 +458,18 @@ describe("the card cache", () => {
     const res = await worker.fetch(new Request("https://bot.example/leaderboard/2026-10/u/Ada.png"), env, ctx);
     expect([...new Uint8Array(await res.arrayBuffer())]).toEqual([0x89, 0x50, 0x4e, 0x47]);
   });
+
+  it("draws the card once per version, whatever ?v= or letter case the address has", async () => {
+    mockFetch(search);
+    const { ctx, settle } = makeCtx();
+    for (const path of ["/leaderboard/2026-10/u/Ada.png?v=1", "/leaderboard/2026-10/u/ada.png?v=2", "/leaderboard/2026-10/u/ADA.png", "/leaderboard/2026-10/u/Ada.png?v=x&y=z"]) {
+      const res = await worker.fetch(new Request(`https://bot.example${path}`), env, ctx);
+      expect(res.status).toBe(200);
+      await settle();
+    }
+    expect(rendered).toHaveLength(1);
+    expect(cache.entries.size).toBe(1);
+  });
 });
 
 describe("GET /leaderboard/{id}.png", () => {
@@ -584,8 +599,38 @@ describe("the board image cache", () => {
     const { ctx, settle } = makeCtx();
     await worker.fetch(new Request("https://bot.example/leaderboard/2026-10.png", { method: "HEAD" }), env, ctx);
     await settle();
-    const stored = cache.entries.get("https://bot.example/leaderboard/2026-10.png");
+    const keys = [...cache.entries.keys()];
+    expect(keys).toHaveLength(1);
+    const stored = cache.entries.get(keys[0]!);
     expect(stored).toBeDefined();
     expect(stored!.body.byteLength).toBeGreaterThan(0);
   });
+
+  it("draws the image once per board version, whatever ?v= the address has", async () => {
+    mockFetch(search);
+    const { ctx, settle } = makeCtx();
+    const html = await (await worker.fetch(new Request("https://bot.example/leaderboard/2026-10"), env, ctx)).text();
+    const image = /<meta property="og:image" content="([^"]+)">/.exec(html)![1]!;
+    for (const query of ["?v=1", "?v=2", "", "?v=x&y=z"]) {
+      const res = await worker.fetch(new Request(`https://bot.example/leaderboard/2026-10.png${query}`), env, ctx);
+      expect(res.status).toBe(200);
+      await settle();
+    }
+    expect(rendered).toHaveLength(1);
+    // Stored under the address the page shares, so a preview of it finds the copy.
+    expect([...cache.entries.keys()]).toEqual([image]);
+  });
+
+  it("draws a new image once the board changes", async () => {
+    mockFetch(search);
+    const { ctx, settle } = makeCtx();
+    await worker.fetch(new Request("https://bot.example/leaderboard/2026-10.png?v=1"), env, ctx);
+    await settle();
+    env = makeEnv();
+    mockFetch(() => ({ ...search(), total_count: 2, items: [...search().items, { ...search().items[0]!, html_url: "https://github.com/codercops/toolbelt/pull/2", number: 2 }] }));
+    await worker.fetch(new Request("https://bot.example/leaderboard/2026-10.png?v=1"), env, ctx);
+    await settle();
+    expect(rendered).toHaveLength(2);
+    expect(cache.entries.size).toBe(2);
+  });
 });

From 7b9d220e5b856ac33f94eb8d3297460dfcdc72b0 Mon Sep 17 00:00:00 2001
From: Varun-pahuja <varunpahuja2005@gmail.com>
Date: Fri, 23 Oct 2026 12:27:24 +0530
Subject: [PATCH 04/16] feat: name unlinked qualifiers on the leaderboard (#90)

* feat: name unlinked qualifiers on the leaderboard

When linking is enabled, handleLeaderboardPage calls linkedMembers for
qualifying rows (one KV read per login) and passes the map to
leaderboardPage. The page renders a line above the board with GitHub
profile links for qualifying (or winning, after end) users who haven't
linked. No line when linking off, no qualifiers, or all linked. KV
lookup failures are logged and the page renders without the line.
JSON endpoint unchanged.

Closes #55

* fix(page): say 'won but hasn't linked' after program ends

Updates the unlinked notice for ended programs to say winners 'won but
hasn't linked' instead of 'qualifies but hasn't linked... if you win'.
Updates the test accordingly.

Addresses feedback from #55 review.
---
 src/index.ts      |  16 +++++-
 src/page.ts       |  26 ++++++++-
 test/page.test.ts | 141 ++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 181 insertions(+), 2 deletions(-)

diff --git a/src/index.ts b/src/index.ts
index 41aac0a..4b99ad1 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -123,8 +123,22 @@ async function handleLeaderboardPage(request: Request, env: Env, id: string | un
       .filter((p) => p.id !== program.id)
       .reverse()
       .map((p) => ({ title: p.title, path: `/leaderboard/${p.id}` }));
+
+    // When linking is enabled, look up which qualifying users have linked their GitHub account.
+    const linking = linkingEnabled(env);
+    let members: Map<string, string> | undefined;
+    if (linking) {
+      const qualifying = board.rows.filter((r) => r.qualifies).map((r) => r.login);
+      try {
+        members = await linkedMembers(env, qualifying);
+      } catch (err) {
+        console.error("failed to look up linked members", err);
+      }
+    }
+
     const html = leaderboardPage(board, program, { issues: env.ISSUES_URL, discord: env.DISCORD_INVITE, self, image, others }, now, {
-      linking: linkingEnabled(env),
+      linking,
+      members,
     });
     return new Response(html, {
       headers: {
diff --git a/src/page.ts b/src/page.ts
index f2e6a2c..dcf9138 100644
--- a/src/page.ts
+++ b/src/page.ts
@@ -111,6 +111,7 @@ h1{font:700 clamp(28px,6vw,40px)/1.15 ui-monospace,SFMono-Regular,Menlo,monospac
 .status{display:inline-block;font:600 13px/1 ui-monospace,SFMono-Regular,Menlo,monospace;padding:7px 11px;border-radius:999px;border:1px solid var(--line);color:var(--muted);margin:0 0 28px}
 .status.running{color:var(--cyan);border-color:var(--cyan)}
 .status.ended{color:var(--gold);border-color:var(--gold)}
+.unlinked{margin:0 0 24px;color:var(--muted);font-size:14px;line-height:1.5}
 .lede{margin-bottom:14px}
 .others{margin:0 0 36px}
 .others h2{font:600 13px/1 ui-monospace,SFMono-Regular,Menlo,monospace;letter-spacing:.18em;text-transform:uppercase;color:var(--muted);margin:0 0 10px}
@@ -147,13 +148,15 @@ export interface PageLinks {
   others: { title: string; path: string }[];
 }
 
+const joinNames = (names: string[]) => names.join(", ").replace(/, ([^,]*)$/, " and $1");
+
 export function leaderboardPage(
   board: Leaderboard,
   program: Program,
   links: PageLinks,
   now: Date,
   /** `linking`: members can link their GitHub account with /link, which is how we find a winner on Discord. */
-  opts: { linking?: boolean } = {}
+  opts: { linking?: boolean; members?: Map<string, string> } = {}
 ): string {
   const { title, label, start, end, minPrs, topN, reward, note } = program;
   const heading = `${title} leaderboard`;
@@ -169,6 +172,26 @@ export function leaderboardPage(
     ? `Share image: ${heading}. ${top}.`
     : `Share image: ${heading}. No merged pull requests counted yet.`;
 
+  let unlinkedNotice = "";
+  if (opts.linking && opts.members) {
+    const candidates = state.status === "ended"
+      ? board.rows.filter((r) => r.winner)
+      : board.rows.filter((r) => r.qualifies);
+    const unlinked = candidates.filter((r) => !opts.members?.has(r.login.toLowerCase()));
+    if (unlinked.length > 0) {
+      const names = joinNames(
+        unlinked.map((r) => `<a href="https://github.com/${encodeURIComponent(r.login)}">${escapeHtml(r.login)}</a>`)
+      );
+      if (state.status === "ended") {
+        const verb = unlinked.length === 1 ? "won but hasn't" : "won but haven't";
+        unlinkedNotice = `<p class="unlinked">${names} ${verb} linked their GitHub yet. <a href="${escapeHtml(links.discord)}">Join the Discord</a> and run <code>/link</code> there, so we can reach you.</p>`;
+      } else {
+        const qualifyVerb = unlinked.length === 1 ? "qualifies but hasn't" : "qualify but haven't";
+        unlinkedNotice = `<p class="unlinked">${names} ${qualifyVerb} linked their GitHub yet. <a href="${escapeHtml(links.discord)}">Join the Discord</a> and run <code>/link</code> there, so we can reach you if you win.</p>`;
+      }
+    }
+  }
+
   const rows = board.rows
     .map((row, i) => {
       const login = escapeHtml(row.login);
@@ -211,6 +234,7 @@ export function leaderboardPage(
 <h1>${escapeHtml(heading)}</h1>
 <p class="lede">Merged pull requests in ${escapeHtml(repos)}, ${when}.</p>
 <p class="status ${state.status}">${escapeHtml(state.text)}</p>
+${unlinkedNotice}
 ${board.rows.length ? `<ol class="board">\n${rows}\n</ol>` : `<div class="board"><p class="empty">${state.status === "ended" ? "No merged pull requests were counted." : "No merged pull requests counted yet. Pick an issue and be the first."}</p></div>`}
 <section class="rules">
 <h2>How it works</h2>
diff --git a/test/page.test.ts b/test/page.test.ts
index 8cad5be..ceba489 100644
--- a/test/page.test.ts
+++ b/test/page.test.ts
@@ -105,6 +105,65 @@ describe("leaderboardPage", () => {
     expect(leaderboardPage(board, program, links, after, { linking: true })).toContain("We contact the winners by Discord DM.");
   });
 
+  it("names everyone who qualifies and hasn't linked, in board order, with links to their profiles", () => {
+    const unlinked = leaderboardPage(board, program, links, during, { linking: true, members: new Map() });
+    expect(unlinked).toContain(
+      '<p class="unlinked"><a href="https://github.com/ada">ada</a> and <a href="https://github.com/bob">bob</a> qualify but haven\'t linked their GitHub yet. <a href="https://discord.gg/example">Join the Discord</a> and run <code>/link</code> there, so we can reach you if you win.</p>'
+    );
+    // Board order: ada before bob
+    expect(unlinked.indexOf(">ada<")).toBeLessThan(unlinked.indexOf(">bob<"));
+
+    // Nobody who has linked is named; singular verb when only one remains
+    const adaLinked = leaderboardPage(board, program, links, during, { linking: true, members: new Map([["ada", "42"]]) });
+    expect(adaLinked).toContain(
+      '<p class="unlinked"><a href="https://github.com/bob">bob</a> qualifies but hasn\'t linked their GitHub yet. <a href="https://discord.gg/example">Join the Discord</a> and run <code>/link</code> there, so we can reach you if you win.</p>'
+    );
+    expect(adaLinked).not.toContain("ada and");
+  });
+
+  it("names only winners who haven't linked after the end", () => {
+    // In 'after', ada is a winner (winner: true), bob qualifies but is outside top 5 (winner: false)
+    const ended = leaderboardPage(board, program, links, after, { linking: true, members: new Map() });
+    expect(ended).toContain(
+      '<p class="unlinked"><a href="https://github.com/ada">ada</a> won but hasn\'t linked their GitHub yet. <a href="https://discord.gg/example">Join the Discord</a> and run <code>/link</code> there, so we can reach you.</p>'
+    );
+    // The unlinked notice should only mention winners (ada), not qualifiers like bob
+    const unlinkedPart = ended.slice(ended.indexOf('<p class="unlinked"'), ended.indexOf('</p>', ended.indexOf('<p class="unlinked"')) + 4);
+    expect(unlinkedPart).not.toContain("bob");
+  });
+
+  it("adds no unlinked line when linking is off, nobody qualifies, or everyone has linked", () => {
+    // Linking is off
+    expect(leaderboardPage(board, program, links, during, { linking: false, members: new Map() })).not.toContain('class="unlinked"');
+    // Members map not passed / lookup not performed
+    expect(leaderboardPage(board, program, links, during, { linking: true })).not.toContain('class="unlinked"');
+    // Nobody qualifies
+    const nobodyQualifies = { ...board, rows: [row("cy", 2), row("dee", 4)] };
+    expect(leaderboardPage(nobodyQualifies, program, links, during, { linking: true, members: new Map() })).not.toContain('class="unlinked"');
+    // Everyone who qualifies has linked
+    const allLinked = new Map([["ada", "42"], ["bob", "43"]]);
+    expect(leaderboardPage(board, program, links, during, { linking: true, members: allLinked })).not.toContain('class="unlinked"');
+  });
+
+  it("escapes logins in the unlinked line", () => {
+    const evil = leaderboardPage(
+      { ...board, rows: [row('"><script>alert(1)</script>', 6, true, true)] },
+      program,
+      links,
+      during,
+      { linking: true, members: new Map() }
+    );
+    expect(evil).not.toContain("<script>alert(1)</script>");
+    expect(evil).toContain("&lt;script&gt;alert(1)&lt;/script&gt;");
+  });
+
+  it("shows the unlinked line at phone width", () => {
+    const htmlWithNotice = leaderboardPage(board, program, links, during, { linking: true, members: new Map() });
+    expect(htmlWithNotice).toContain('class="unlinked"');
+    expect(htmlWithNotice).toContain("@media (max-width:520px){.chip{display:none}}");
+    expect(htmlWithNotice).not.toContain(".unlinked{display:none}");
+  });
+
   it("links to issues, Discord and the platform, with escaped URLs", () => {
     expect(html).toContain('href="https://github.com/search?q=x&amp;type=issues"');
     expect(html).toContain('href="https://discord.gg/example"');
@@ -363,4 +422,86 @@ describe("GET /leaderboard", () => {
     expect(res.status).toBe(503);
     expect(res.headers.get("Retry-After")).toBe("60");
   });
+
+  it("names qualifying unlinked members when linking is enabled", async () => {
+    env = makeEnv({ LINKING: "on", DISCORD_CLIENT_SECRET: "secret" });
+    mockFetch(() => ({
+      total_count: 11,
+      items: [
+        ...Array.from({ length: 6 }, (_, i) => ({
+          html_url: `https://github.com/codercops/toolbelt/pull/${i + 1}`,
+          number: i + 1,
+          title: "PR",
+          repository_url: "https://api.github.com/repos/codercops/toolbelt",
+          user: { login: "ada" },
+          pull_request: { merged_at: "2026-10-02T00:00:00Z" },
+        })),
+        ...Array.from({ length: 5 }, (_, i) => ({
+          html_url: `https://github.com/codercops/toolbelt/pull/${i + 7}`,
+          number: i + 7,
+          title: "PR",
+          repository_url: "https://api.github.com/repos/codercops/toolbelt",
+          user: { login: "bob" },
+          pull_request: { merged_at: "2026-10-03T00:00:00Z" },
+        })),
+      ],
+    }));
+
+    const res = await worker.fetch(new Request("https://bot.example/leaderboard"), env, ctx);
+    expect(res.status).toBe(200);
+    const text = await res.text();
+    expect(text).toContain('class="unlinked"');
+    expect(text).toContain(">ada<");
+    expect(text).toContain(">bob<");
+    expect(text).toContain("qualify but haven't linked their GitHub yet");
+  });
+
+  it("only looks up qualifying rows in KV and keeps the page working if the lookup fails", async () => {
+    env = makeEnv({ LINKING: "on", DISCORD_CLIENT_SECRET: "secret" });
+    mockFetch(() => ({
+      total_count: 6,
+      items: [
+        ...Array.from({ length: 5 }, (_, i) => ({
+          html_url: `https://github.com/codercops/toolbelt/pull/${i + 1}`,
+          number: i + 1,
+          title: "PR",
+          repository_url: "https://api.github.com/repos/codercops/toolbelt",
+          user: { login: "ada" },
+          pull_request: { merged_at: "2026-10-02T00:00:00Z" },
+        })),
+        {
+          html_url: "https://github.com/codercops/toolbelt/pull/6",
+          number: 6,
+          title: "PR",
+          repository_url: "https://api.github.com/repos/codercops/toolbelt",
+          user: { login: "nonqualifying" },
+          pull_request: { merged_at: "2026-10-02T00:00:00Z" },
+        },
+      ],
+    }));
+
+    const lookups: string[] = [];
+    const origGet = env.STATE.get.bind(env.STATE);
+    env.STATE.get = (async (key: string, type?: "json") => {
+      lookups.push(key);
+      return origGet(key, type as any);
+    }) as any;
+
+    const res = await worker.fetch(new Request("https://bot.example/leaderboard"), env, ctx);
+    expect(res.status).toBe(200);
+    // Only ada qualified (5 PRs >= minPrs 5), nonqualifying had 1 PR
+    const linkLookups = lookups.filter((k) => k.startsWith("link:github:"));
+    expect(linkLookups).toEqual(["link:github:ada"]);
+    expect(linkLookups).not.toContain("link:github:nonqualifying");
+
+    // If KV lookup throws for link keys, page still renders 200 without the line
+    env.STATE.get = (async (key: string, type?: "json") => {
+      if (key.startsWith("link:github:")) throw new Error("KV read failed");
+      return origGet(key, type as any);
+    }) as any;
+    const failRes = await worker.fetch(new Request("https://bot.example/leaderboard"), env, ctx);
+    expect(failRes.status).toBe(200);
+    const failHtml = await failRes.text();
+    expect(failHtml).not.toContain('class="unlinked"');
+  });
 });
\ No newline at end of file

From 33a0ba55a3a40d6b375a81570515e507292bfc45 Mon Sep 17 00:00:00 2001
From: Pratham Pansare <145864145+Pratham2511@users.noreply.github.com>
Date: Fri, 23 Oct 2026 13:28:04 +0530
Subject: [PATCH 05/16] fix: recover renamed GitHub accounts in /me (#91)

---
 src/commands.ts      |  31 ++++++++++--
 src/github.ts        |   9 ++++
 test/linking.test.ts | 110 +++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 146 insertions(+), 4 deletions(-)

diff --git a/src/commands.ts b/src/commands.ts
index c4bdd0f..721c0e5 100644
--- a/src/commands.ts
+++ b/src/commands.ts
@@ -3,9 +3,9 @@
 import { listCheckins, localDate, rankStreaks, recordCheckin } from "./checkin";
 import type { Config, Env } from "./config";
 import type { MessagePayload } from "./discord";
-import { countMergedPrs, GithubError, listStarterIssues } from "./github";
+import { countMergedPrs, getLoginById, GithubError, listStarterIssues } from "./github";
 import { getLeaderboard } from "./leaderboard";
-import { getLink, linkedMembers, removeLink } from "./links";
+import { getLink, linkedMembers, removeLink, saveLink } from "./links";
 import { checkinReply, helpReply, leaderboardMessage, linkPrompt, meReply, starterIssuesReply, streaksMessage } from "./messages";
 import { authorizeUrl, linkingEnabled, signState } from "./oauth";
 import { grantEarnedRoles, isMaintainer, removeTierRoles } from "./roles";
@@ -23,6 +23,7 @@ export interface CommandUser {
 }
 
 const IN_SERVER_ONLY: MessagePayload = { content: "Run this inside the server, not in a DM." };
+const RELINK_GITHUB: MessagePayload = { content: "I couldn't find your linked GitHub account. Run `/link` again to reconnect it." };
 
 export async function runCommand(
   data: CommandData,
@@ -107,9 +108,31 @@ export async function runCommand(
       }
       case "me": {
         if (!user) return IN_SERVER_ONLY;
-        const link = await getLink(env, user.id);
+        let link = await getLink(env, user.id);
         if (!link) return { content: "You haven't linked a GitHub account yet. Run `/link` first." };
-        const merged = await countMergedPrs(env, cfg, link.githubLogin);
+        let merged: number;
+        try {
+          merged = await countMergedPrs(env, cfg, link.githubLogin);
+        } catch (err) {
+          if (!(err instanceof GithubError) || err.status !== 422) throw err;
+          let login: string | null;
+          try {
+            login = await getLoginById(env, link.githubId);
+          } catch (lookupError) {
+            if (lookupError instanceof GithubError && (lookupError.status === 403 || lookupError.status === 429)) throw lookupError;
+            return RELINK_GITHUB;
+          }
+          if (!login) return RELINK_GITHUB;
+          link = { ...link, githubLogin: login };
+          await saveLink(env, link);
+          // Retry once; another invalid login must not restart recovery.
+          try {
+            merged = await countMergedPrs(env, cfg, login);
+          } catch (retryError) {
+            if (retryError instanceof GithubError && retryError.status === 422) return RELINK_GITHUB;
+            throw retryError;
+          }
+        }
         // Catches up on a role if a merge was missed.
         const newRoles = await grantEarnedRoles(env, cfg, link, merged).catch((err) => {
           console.error("granting roles failed", err);
diff --git a/src/github.ts b/src/github.ts
index 98b32b7..ac0da7f 100644
--- a/src/github.ts
+++ b/src/github.ts
@@ -43,6 +43,15 @@ async function gh<T>(env: Env, path: string): Promise<T> {
   return (await res.json()) as T;
 }
 
+/** Resolves a linked account's current login using the id that survives renames. */
+export async function getLoginById(env: Env, githubId: string): Promise<string | null> {
+  if (!/^[1-9]\d*$/.test(githubId)) return null;
+  const user = await gh<{ id?: number; login?: unknown } | null>(env, `/user/${githubId}`);
+  if (!user || String(user.id) !== githubId || typeof user.login !== "string") return null;
+  // Apply the same login constraints as the verified Discord connection in oauth.ts.
+  return /^[a-z\d](?:[a-z\d-]{0,38})$/i.test(user.login) ? user.login : null;
+}
+
 export interface StarterIssue {
   repo: string;
   number: number;
diff --git a/test/linking.test.ts b/test/linking.test.ts
index e0ca2c6..62d655b 100644
--- a/test/linking.test.ts
+++ b/test/linking.test.ts
@@ -382,6 +382,114 @@ describe("/link, /unlink and /me", () => {
     });
   });
 
+  it("/me recovers a renamed GitHub login by id and uses it for counts, roles and standing", async () => {
+    await saveLink(env, ada);
+    const other = { ...ada, discordId: "77", githubLogin: "bob", githubId: "9002" };
+    await saveLink(env, other);
+    const fetched = mockFetch((url) => {
+      if (url.pathname === "/user/9001") return { id: 9001, login: "Ada-new" };
+      if (url.searchParams.get("q")?.includes("author:Ada ")) return jsonResponse({}, 422);
+      return { ...search(2)(), items: search(2)().items.map((item) => ({ ...item, user: { login: "Ada-new" } })) };
+    }, discordApi());
+
+    const reply = await run("me");
+    expect(reply.content).toContain("You're linked to **Ada-new** on GitHub.");
+    expect(reply.content).toContain("Merged PRs in our repos: **2**.");
+    expect(reply.content).toContain("2 merged PRs, 1st of 1");
+    expect(reply.content).toContain("You now have the **Contributor** role.");
+    expect(await getLink(env, "42")).toEqual({ ...ada, githubLogin: "Ada-new" });
+    expect(await getLinkByGithub(env, "Ada")).toBeNull();
+    expect(await getLinkByGithub(env, "ada-NEW")).toEqual({ ...ada, githubLogin: "Ada-new" });
+    expect(await getLink(env, "77")).toEqual(other);
+    const github = fetched.calls.filter((c) => new URL(c.url).hostname === "api.github.com");
+    expect(github.map((c) => new URL(c.url).pathname)).toEqual(["/search/issues", "/user/9001", "/search/issues", "/search/issues"]);
+    expect(new URL(github[2]!.url).searchParams.get("q")).toContain("author:Ada-new ");
+    expect(github.every((c) => c.userAgent === "codercops-discord-bot")).toBe(true);
+    expect(fetched.calls.filter((c) => c.method === "PUT").map((c) => new URL(c.url).pathname)).toEqual([
+      "/api/v10/guilds/guild-1/members/42/roles/role-contributor",
+    ]);
+
+    fetched.clear();
+    expect((await run("me")).content).toContain("**Ada-new**");
+    expect(fetched.calls.some((c) => new URL(c.url).pathname.startsWith("/user/"))).toBe(false);
+  });
+
+  it("/me uses the recovered login when deciding whether a member is a maintainer", async () => {
+    await saveLink(env, ada);
+    const fetched = mockFetch((url) => {
+      if (url.pathname === "/user/9001") return { id: 9001, login: "anurag629" };
+      return url.searchParams.get("q")?.includes("author:Ada ") ? jsonResponse({}, 422) : search(40)();
+    }, discordApi());
+    const reply = await run("me");
+    expect(reply.content).toContain("You're linked to **anurag629**");
+    expect(reply.content).toContain("You're a maintainer");
+    expect(fetched.discord()).toHaveLength(0);
+    expect(fetched.calls).toHaveLength(3);
+  });
+
+  it.each([
+    ["missing user", () => jsonResponse({}, 404)],
+    ["failed lookup", () => jsonResponse({}, 500)],
+    ["network failure", () => { throw new TypeError("offline"); }],
+    ["invalid JSON", () => new Response("not json")],
+    ["null user", () => null],
+    ["missing login", () => ({ id: 9001 })],
+    ["empty login", () => ({ id: 9001, login: "" })],
+    ["missing id", () => ({ login: "Ada-new" })],
+    ["invalid login", () => ({ id: 9001, login: "other repo:private" })],
+    ["non-string login", () => ({ id: 9001, login: 123 })],
+    ["wrong identity", () => ({ id: 9002, login: "Ada-new" })],
+  ])("/me asks to relink after a %s during rename recovery", async (_name, lookup) => {
+    await saveLink(env, ada);
+    const fetched = mockFetch((url) => url.pathname === "/user/9001" ? lookup() : jsonResponse({}, 422), discordApi());
+    const reply = await run("me");
+    expect(reply.content).toContain("Run `/link` again");
+    expect(reply.content).not.toContain("Something went wrong");
+    expect(await getLink(env, "42")).toEqual(ada);
+    expect(await getLinkByGithub(env, "Ada")).toEqual(ada);
+    expect(fetched.calls.map((c) => new URL(c.url).pathname)).toEqual(["/search/issues", "/user/9001"]);
+  });
+
+  it.each(["", "9001/other", "-1"])("/me asks to relink for an invalid stored id %s", async (githubId) => {
+    const invalid = { ...ada, githubId };
+    await saveLink(env, invalid);
+    const fetched = mockFetch(() => jsonResponse({}, 422));
+    expect((await run("me")).content).toContain("Run `/link` again");
+    expect(await getLink(env, "42")).toEqual(invalid);
+    expect(fetched.calls).toHaveLength(1);
+  });
+
+  it.each([403, 429])("/me preserves rate limiting when the id lookup returns %s", async (status) => {
+    await saveLink(env, ada);
+    const fetched = mockFetch((url) => jsonResponse({}, url.pathname === "/user/9001" ? status : 422));
+    expect((await run("me")).content).toBe("GitHub is rate limiting me right now. Try again in a minute.");
+    expect(await getLink(env, "42")).toEqual(ada);
+    expect(fetched.calls).toHaveLength(2);
+  });
+
+  it.each([401, 403, 404, 429, 500, 503])("/me does not recover an initial %s search error", async (status) => {
+    await saveLink(env, ada);
+    const fetched = mockFetch(() => jsonResponse({}, status));
+    const reply = await run("me");
+    expect(reply.content).toBe(status === 403 || status === 429
+      ? "GitHub is rate limiting me right now. Try again in a minute."
+      : "Something went wrong on my side. Try again in a bit.");
+    expect(await getLink(env, "42")).toEqual(ada);
+    expect(fetched.calls).toHaveLength(1);
+  });
+
+  it.each([422, 500])("/me stops after one recovery when the refreshed search returns %s", async (status) => {
+    await saveLink(env, ada);
+    const fetched = mockFetch((url) => {
+      if (url.pathname === "/user/9001") return { id: 9001, login: "Ada-new" };
+      return jsonResponse({}, url.searchParams.get("q")?.includes("author:Ada ") ? 422 : status);
+    }, discordApi());
+    const reply = await run("me");
+    expect(reply.content).toContain(status === 422 ? "Run `/link` again" : "Something went wrong");
+    expect(fetched.calls).toHaveLength(3);
+    expect(fetched.discord()).toHaveLength(0);
+  });
+
   it("/me shows the member's count, their place in the current program and any role they were owed", async () => {
     await saveLink(env, ada);
     const fetched = mockFetch(search(4), discordApi({ memberRoles: [] }));
@@ -395,6 +503,8 @@ describe("/link, /unlink and /me", () => {
         "Your card to share: <https://bot.example/leaderboard/2026-10/u/Ada>",
       ].join("\n")
     );
+    expect(await getLink(env, "42")).toEqual(ada);
+    expect(fetched.calls.some((c) => new URL(c.url).pathname.startsWith("/user/"))).toBe(false);
     const lifetime = fetched.calls.find((c) => c.url.includes("api.github.com") && decodeURIComponent(c.url).includes("author:Ada"));
     expect(decodeURIComponent(lifetime!.url).replace(/\+/g, " ")).toContain("is:pr is:merged author:Ada repo:codercops/chatcops repo:codercops/ogcops repo:codercops/toolbelt");
   });

From 0fd29824c62abb23e4af415564f739f9a07c391c Mon Sep 17 00:00:00 2001
From: Sanketh Kumar <sankethkumarbg1995@gmail.com>
Date: Fri, 23 Oct 2026 13:57:57 +0530
Subject: [PATCH 06/16] fix(messages): empty final results use past tense and
 add closing note (#92)

When a program ends with no counted PRs, the final post (and /leaderboard after the end) now says "No merged pull requests were counted." instead of the running-program line, and appends the configured finalNote. The running empty board keeps its original wording.

Closes #86
---
 src/messages.ts       |  7 ++++++-
 test/messages.test.ts | 12 ++++++++++--
 2 files changed, 16 insertions(+), 3 deletions(-)

diff --git a/src/messages.ts b/src/messages.ts
index 9b0e637..da27415 100644
--- a/src/messages.ts
+++ b/src/messages.ts
@@ -163,7 +163,12 @@ export function leaderboardMessage(
 
   let description: string;
   if (lines.length === 0) {
-    description = "No merged PRs counted yet. Pick a starter issue and be the first.";
+    if (opts.final) {
+      description = "No merged pull requests were counted.";
+      if (opts.finalNote) description += `\n\n${opts.finalNote}`;
+    } else {
+      description = "No merged PRs counted yet. Pick a starter issue and be the first.";
+    }
   } else {
     description = lines.join("\n");
     if (opts.final) {
diff --git a/test/messages.test.ts b/test/messages.test.ts
index 4678d64..8367837 100644
--- a/test/messages.test.ts
+++ b/test/messages.test.ts
@@ -245,10 +245,18 @@ describe("leaderboardMessage", () => {
   });
 
   it("handles a final result with no qualifiers and an empty board", () => {
-    const none = leaderboardMessage({ ...board, rows: [row("bob", 2)] }, program, { final: true }).embeds?.[0];
-    expect(none?.description).toContain("Nobody reached 5 merged PRs");
+    const empty = leaderboardMessage({ ...board, rows: [] }, program, { final: true }).embeds?.[0];
+    expect(empty?.description).toContain("No merged pull requests were counted.");
+    expect(empty?.description).not.toContain("be the first");
+    // closing note should be added
+    const withNote = leaderboardMessage({ ...board, rows: [] }, program, { final: true, finalNote: "Add it to your profile." }).embeds?.[0];
+    expect(withNote?.description).toContain("Add it to your profile.");
+  });
+
+  it("handles a running empty board", () => {
     const empty = leaderboardMessage({ ...board, rows: [] }, program).embeds?.[0];
     expect(empty?.description).toContain("No merged PRs counted yet");
+    expect(empty?.description).toContain("be the first");
   });
 });
 

From e009a5a8f2f9902cacf7e6ddc908f6941a2272c1 Mon Sep 17 00:00:00 2001
From: Bhushan Agrawal <bhushan.agrawal4work@gmail.com>
Date: Fri, 23 Oct 2026 17:22:40 +0530
Subject: [PATCH 07/16] fix: show full leaderboard logins on phones (#93)

* fix: show full leaderboard logins on phones

* fix: keep leaderboard names single-line on phones
---
 src/page.ts       |  4 ++--
 test/page.test.ts | 24 ++++++++++++++++++++++--
 2 files changed, 24 insertions(+), 4 deletions(-)

diff --git a/src/page.ts b/src/page.ts
index dcf9138..a8674a0 100644
--- a/src/page.ts
+++ b/src/page.ts
@@ -133,7 +133,7 @@ main.wide{max-width:920px}
 h2.small{font:600 13px/1 ui-monospace,SFMono-Regular,Menlo,monospace;letter-spacing:.18em;text-transform:uppercase;color:var(--muted);margin:0 0 12px}
 @media (max-width:520px){.tiles{grid-template-columns:1fr}.cta a{flex:1 1 100%;text-align:center}}
 footer{color:var(--muted);font-size:13px}
-@media (max-width:520px){.chip{display:none}}
+@media (max-width:520px){.board summary{gap:8px}.rank{width:auto}.board img{width:28px;height:28px}.chip,.count-label{display:none}}
 `;
 
 export interface PageLinks {
@@ -204,7 +204,7 @@ export function leaderboardPage(
             `<li><a href="${escapeHtml(pr.url)}"><span class="repo">${escapeHtml(pr.repo)}#${pr.number}</span>${escapeHtml(pr.title)}</a></li>`
         )
         .join("\n");
-      return `<li><details><summary><span class="rank">${i + 1}</span><img src="https://github.com/${encodeURIComponent(row.login)}.png?size=72" alt="" width="36" height="36" loading="lazy"><span class="who"><a href="https://github.com/${encodeURIComponent(row.login)}">${login}</a></span><span class="count">${row.count} merged ${row.count === 1 ? "PR" : "PRs"}</span>${chipHtml}${card}</summary>\n<ul class="prs">\n${prList}\n</ul></details></li>`;
+      return `<li><details><summary><span class="rank">${i + 1}</span><img src="https://github.com/${encodeURIComponent(row.login)}.png?size=72" alt="" width="36" height="36" loading="lazy"><span class="who"><a href="https://github.com/${encodeURIComponent(row.login)}">${login}</a></span><span class="count">${row.count}<span class="count-label"> merged ${row.count === 1 ? "PR" : "PRs"}</span></span>${chipHtml}${card}</summary>\n<ul class="prs">\n${prList}\n</ul></details></li>`;
     })
     .join("\n");
 
diff --git a/test/page.test.ts b/test/page.test.ts
index ceba489..ad42636 100644
--- a/test/page.test.ts
+++ b/test/page.test.ts
@@ -82,11 +82,31 @@ describe("leaderboardPage", () => {
     expect(html).toContain("<h1>Hacktoberfest 2026 leaderboard</h1>");
     expect(html.indexOf(">ada<")).toBeLessThan(html.indexOf(">bob<"));
     expect(html).toContain('<a href="https://github.com/ada">ada</a>');
-    expect(html).toContain("6 merged PRs");
+    expect(html).toContain('<span class="count">6<span class="count-label"> merged PRs</span></span>');
     expect(html).toContain('<span class="chip top">In the top 5</span>');
     expect(html).toContain('<span class="chip progress">3 more to qualify</span>');
   });
 
+  it("keeps the merged PR label in its own span and uses compact, single-line phone styles", () => {
+    expect(html).toContain('<span class="count">6<span class="count-label"> merged PRs</span></span>');
+    const one = leaderboardPage({ ...board, rows: [row("ada", 1)] }, program, links, during);
+    expect(one).toContain('<span class="count">1<span class="count-label"> merged PR</span></span>');
+
+    const style = html.slice(html.indexOf("<style>") + 7, html.indexOf("</style>"));
+    const start = style.indexOf("@media (max-width:520px){.board summary");
+    const phoneRule = style.slice(start, style.indexOf("\n", start));
+    expect(phoneRule).toContain(".board summary{gap:8px}");
+    expect(phoneRule).toContain(".rank{width:auto}");
+    expect(phoneRule).toContain(".board img{width:28px;height:28px}");
+    expect(phoneRule).toContain(".chip,.count-label{display:none}");
+    expect(phoneRule).not.toContain(".who{");
+    expect(style).toContain(".who{flex:1;min-width:0;font-weight:600;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}");
+    expect(style).not.toContain("overflow-wrap:anywhere");
+    expect(phoneRule).not.toContain(".count{display:none}");
+    expect(phoneRule).not.toContain(".cardlink{display:none}");
+    expect(html).toContain('<a class="cardlink" href="/leaderboard/2026-10/u/ada"');
+  });
+
   it("states the rules, the window and who the reward comes from", () => {
     expect(html).toContain("Merged pull requests in chatcops, ogcops and toolbelt, Oct 1 to Oct 31, 2026 (UTC).");
     expect(html).toContain('<p class="status running">Running now. 20 days left.</p>');
@@ -160,7 +180,7 @@ describe("leaderboardPage", () => {
   it("shows the unlinked line at phone width", () => {
     const htmlWithNotice = leaderboardPage(board, program, links, during, { linking: true, members: new Map() });
     expect(htmlWithNotice).toContain('class="unlinked"');
-    expect(htmlWithNotice).toContain("@media (max-width:520px){.chip{display:none}}");
+    expect(htmlWithNotice).toContain(".chip,.count-label{display:none}");
     expect(htmlWithNotice).not.toContain(".unlinked{display:none}");
   });
 

From d487c6150bd8b92df62a97ed5b5a1df3564741b4 Mon Sep 17 00:00:00 2001
From: Varun-pahuja <varunpahuja2005@gmail.com>
Date: Fri, 23 Oct 2026 20:06:26 +0530
Subject: [PATCH 08/16] fix: say 'qualified' in the final results post (#85)
 (#96)

---
 src/messages.ts       | 4 +++-
 test/messages.test.ts | 9 +++++++++
 2 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/src/messages.ts b/src/messages.ts
index da27415..be7d457 100644
--- a/src/messages.ts
+++ b/src/messages.ts
@@ -156,7 +156,9 @@ export function leaderboardMessage(
     const prs = `${row.count} merged ${row.count === 1 ? "PR" : "PRs"}`;
     // Same as the chips on the page: a countdown while it runs, nothing once it's over.
     const countdown = opts.final ? "" : ` · ${minPrs - row.count} more to qualify`;
-    const note = row.winner ? (opts.final ? " · winner" : " · in the top " + topN) : row.qualifies ? " · qualifies" : countdown;
+    const note = row.winner
+      ? opts.final ? " · winner" : " · in the top " + topN
+      : row.qualifies ? (opts.final ? " · qualified" : " · qualifies") : countdown;
     return `${i + 1}. ${who(row.login)} · ${prs}${note}`;
   });
   const winners = board.rows.filter((r) => r.winner);
diff --git a/test/messages.test.ts b/test/messages.test.ts
index 8367837..cf052a7 100644
--- a/test/messages.test.ts
+++ b/test/messages.test.ts
@@ -225,6 +225,15 @@ describe("leaderboardMessage", () => {
     expect(embed?.description).not.toContain("more to qualify");
   });
 
+  it("says 'qualified' for qualifiers who didn't win once the program is over", () => {
+    const qualifiers = { ...board, rows: [row("ada", 6, true, true), row("bob", 5, true)] };
+    const final = leaderboardMessage(qualifiers, program, { final: true }).embeds?.[0]?.description;
+    expect(final).toContain("2. **bob** · 5 merged PRs · qualified");
+    // While it runs, they are still in the running.
+    const running = leaderboardMessage(qualifiers, program).embeds?.[0]?.description;
+    expect(running).toContain("2. **bob** · 5 merged PRs · qualifies");
+  });
+
   it("asks winners who haven't linked to run /link, since the form goes out by DM", () => {
     const winners = { ...board, rows: [row("ada", 6, true, true), row("Bob", 5, true, true), row("cy", 5, true, true)] };
     const text = (members: Map<string, string>) =>

From 9425d28a6b61c2e39e464076200495d98575bbd8 Mon Sep 17 00:00:00 2001
From: Pratham Pansare <145864145+Pratham2511@users.noreply.github.com>
Date: Fri, 23 Oct 2026 22:28:17 +0530
Subject: [PATCH 09/16] fix: show ended program message on no-card pages (#94)

* fix: show ended program message on no-card pages

* fix: use neutral wording on ended no-card pages
---
 src/index.ts      |  6 ++++--
 test/card.test.ts | 36 +++++++++++++++++++++++++++++++++++-
 2 files changed, 39 insertions(+), 3 deletions(-)

diff --git a/src/index.ts b/src/index.ts
index 4b99ad1..e8ef841 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -268,13 +268,16 @@ async function handleContributor(
   const index = board.rows.findIndex((r) => r.login.toLowerCase() === login.toLowerCase());
   const row = board.rows[index];
   const boardPath = `/leaderboard/${program.id}`;
+  const status = programStatus(program, now);
   if (!row) {
     if (asPng) return new Response("not found", { status: 404 });
     const body = noticePage(
       "No card yet",
       [
         `${login} has no counted pull requests in ${program.title}.`,
-        "A card appears with the first merged pull request that counts.",
+        status === "ended"
+            ? `${program.title} is over, so no more pull requests can count.`
+          : "A card appears with the first merged pull request that counts.",
       ],
       false,
       "No card",
@@ -288,7 +291,6 @@ async function handleContributor(
 
   const rank = index + 1;
   const of = board.rows.length;
-  const status = programStatus(program, now);
   const path = `${boardPath}/u/${encodeURIComponent(row.login)}`;
   // The version makes share previews pick up a new image when the numbers change.
   const version = `${row.count}-${rank}-${of}-${status}`;
diff --git a/test/card.test.ts b/test/card.test.ts
index f2f57a9..a0b54df 100644
--- a/test/card.test.ts
+++ b/test/card.test.ts
@@ -3,7 +3,7 @@ import { boardSvg, boardVersion, cardSvg, escapeXml, fitMono, progressBar } from
 import { getConfig } from "../src/config";
 import worker from "../src/index";
 import { contributorPage, noticePage } from "../src/page";
-import { FakeCache, makeCtx, makeEnv, mockFetch } from "./helpers";
+import { FakeCache, makeCtx, makeEnv, mockFetch, OCTOBER } from "./helpers";
 
 // The real module needs the WebAssembly rasterizer and the font files, which
 // only the Workers bundler can load. The route is tested with a stand-in.
@@ -354,6 +354,40 @@ describe("GET /leaderboard/{id}/u/{login}", () => {
     expect(rendered).toHaveLength(0);
   });
 
+  it.each([
+    { id: "ended", start: "2025-10-01T00:00:00Z", end: "2025-10-31T23:59:59Z", ended: true },
+    { id: "running", start: "2000-01-01T00:00:00Z", end: "2099-12-31T23:59:59Z", ended: false },
+    { id: "upcoming", start: "2100-10-01T00:00:00Z", end: "2100-10-31T23:59:59Z", ended: false },
+  ])("keeps the no-card page accurate for an $id program", async ({ id, start, end, ended }) => {
+    env = makeEnv({ PROGRAMS: [{ ...OCTOBER, id, title: "Community program", start, end }] });
+    mockFetch(() => ({ total_count: 0, items: [] }));
+
+    const res = await get(`/leaderboard/${id}/u/bob`);
+    expect(res.status).toBe(404);
+    expect(res.headers.get("Content-Type")).toBe("text/html; charset=utf-8");
+    expect(res.headers.get("Cache-Control")).toBe("no-store");
+    expect(res.headers.get("X-Content-Type-Options")).toBe("nosniff");
+    expect(res.headers.get("Referrer-Policy")).toBe("strict-origin-when-cross-origin");
+    expect(res.headers.get("Content-Security-Policy")).toBe(
+      "default-src 'none'; style-src 'unsafe-inline'; img-src 'self'; base-uri 'none'; form-action 'none'; frame-ancestors 'none'"
+    );
+    const html = await res.text();
+    expect(html).toContain("<h1>No card yet</h1>");
+    expect(html).toContain("bob has no counted pull requests in Community program.");
+    expect(html).toContain(`<a href="/leaderboard/${id}">See the leaderboard</a>`);
+    expect(html).toContain('<a href="https://github.com/search?q=example">Find an issue</a>');
+    const futureCard = "A card appears with the first merged pull request that counts.";
+    const endedMessage = "Community program is over, so no more pull requests can count.";
+    expect(html).toContain(ended ? endedMessage : futureCard);
+    expect(html).not.toContain(ended ? futureCard : endedMessage);
+    expect(html).not.toContain("you had no counted PRs");
+
+    const image = await get(`/leaderboard/${id}/u/bob.png`);
+    expect(image.status).toBe(404);
+    expect(await image.text()).toBe("not found");
+    expect(rendered).toHaveLength(0);
+  });
+
   it("answers 503 when GitHub can't be reached", async () => {
     globalThis.fetch = (async () => new Response("{}", { status: 403 })) as typeof fetch;
     const res = await get("/leaderboard/2026-10/u/ada");

From 4129fae90ea5fff66d0f27d7c3b7533ae4b1e7c6 Mon Sep 17 00:00:00 2001
From: Bhushan Agrawal <bhushan.agrawal4work@gmail.com>
Date: Fri, 23 Oct 2026 22:58:26 +0530
Subject: [PATCH 10/16] fix: add CORS to JSON leaderboard errors (#99)

---
 src/index.ts      |  4 ++--
 test/page.test.ts | 17 +++++++++++++++--
 2 files changed, 17 insertions(+), 4 deletions(-)

diff --git a/src/index.ts b/src/index.ts
index e8ef841..182f846 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -106,7 +106,7 @@ async function handleLeaderboardPage(request: Request, env: Env, id: string | un
   const cfg = getConfig(env);
   const now = new Date();
   const program = id === undefined ? currentProgram(cfg, now) : findProgram(cfg, id);
-  if (!program) return new Response("not found", { status: 404 });
+  if (!program) return new Response("not found", { status: 404, headers: asJson ? { "Access-Control-Allow-Origin": "*" } : undefined });
   // Browsers and the edge may reuse the response for five minutes.
   const cache = "public, max-age=300";
   try {
@@ -155,7 +155,7 @@ async function handleLeaderboardPage(request: Request, env: Env, id: string | un
     console.error("leaderboard page failed", err);
     return new Response(limited ? "GitHub is rate limiting us. Try again in a minute." : "The leaderboard is unavailable right now.", {
       status: 503,
-      headers: { "Content-Type": "text/plain; charset=utf-8", "Retry-After": "60" },
+      headers: { "Content-Type": "text/plain; charset=utf-8", "Retry-After": "60", ...(asJson ? { "Access-Control-Allow-Origin": "*" } : {}) },
     });
   }
 }
diff --git a/test/page.test.ts b/test/page.test.ts
index ad42636..498622e 100644
--- a/test/page.test.ts
+++ b/test/page.test.ts
@@ -407,7 +407,13 @@ describe("GET /leaderboard", () => {
     const json = await worker.fetch(new Request("https://bot.example/leaderboard/2026-10.json"), env, ctx);
     expect(((await json.json()) as { id: string }).id).toBe("2026-10");
 
-    expect((await worker.fetch(new Request("https://bot.example/leaderboard/2025-10"), env, ctx)).status).toBe(404);
+    const unknownHtml = await worker.fetch(new Request("https://bot.example/leaderboard/2025-10"), env, ctx);
+    expect(unknownHtml.status).toBe(404);
+    expect(unknownHtml.headers.get("Access-Control-Allow-Origin")).toBeNull();
+    expect(await unknownHtml.text()).toBe("not found");
+    const unknownJson = await worker.fetch(new Request("https://bot.example/leaderboard/2025-10.json"), env, ctx);
+    expect(unknownJson.status).toBe(404);
+    expect(unknownJson.headers.get("Access-Control-Allow-Origin")).toBe("*");
     expect((await worker.fetch(new Request("https://bot.example/leaderboard", { method: "POST" }), env, ctx)).status).toBe(404);
     const none = await worker.fetch(new Request("https://bot.example/leaderboard"), makeEnv({ PROGRAMS: [] }), ctx);
     expect(none.status).toBe(404);
@@ -441,6 +447,13 @@ describe("GET /leaderboard", () => {
     const res = await worker.fetch(new Request("https://bot.example/leaderboard"), env, ctx);
     expect(res.status).toBe(503);
     expect(res.headers.get("Retry-After")).toBe("60");
+    expect(res.headers.get("Access-Control-Allow-Origin")).toBeNull();
+    expect(await res.text()).toBe("GitHub is rate limiting us. Try again in a minute.");
+    const json = await worker.fetch(new Request("https://bot.example/leaderboard.json"), env, ctx);
+    expect(json.status).toBe(503);
+    expect(json.headers.get("Content-Type")).toBe("text/plain; charset=utf-8");
+    expect(json.headers.get("Access-Control-Allow-Origin")).toBe("*");
+    expect(await json.text()).toBe("GitHub is rate limiting us. Try again in a minute.");
   });
 
   it("names qualifying unlinked members when linking is enabled", async () => {
@@ -524,4 +537,4 @@ describe("GET /leaderboard", () => {
     const failHtml = await failRes.text();
     expect(failHtml).not.toContain('class="unlinked"');
   });
-});
\ No newline at end of file
+});

From 416cca60722b8afab979eeefd5bb682715bbd118 Mon Sep 17 00:00:00 2001
From: Sanketh Kumar <sankethkumarbg1995@gmail.com>
Date: Mon, 26 Oct 2026 10:02:06 +0530
Subject: [PATCH 11/16] [FIX]: Scope contributor PR links to program repos
 (#103)

Build the contributor page's GitHub search from program.repos, the same way searchMergedPrs does, instead of searching the whole organization.

Closes #101
---
 src/github.ts     | 26 ++++++++++++++++++--------
 src/index.ts      |  4 ++--
 test/card.test.ts | 14 +++++++++++++-
 3 files changed, 33 insertions(+), 11 deletions(-)

diff --git a/src/github.ts b/src/github.ts
index ac0da7f..f3a8916 100644
--- a/src/github.ts
+++ b/src/github.ts
@@ -119,17 +119,27 @@ interface SearchResult {
   items: { html_url: string; number: number; title: string; repository_url: string; user: { login: string } | null; pull_request?: { merged_at: string | null } }[];
 }
 
-/** Every merged PR that counts for a program: labeled, in its repos, merged inside its window. */
-export async function searchMergedPrs(env: Env, cfg: Config, program: Program): Promise<MergedPr[]> {
-  const { label, start, end } = program;
-  const iso = (d: Date) => d.toISOString().replace(/\.\d{3}Z$/, "Z");
-  const q = [
+/** The GitHub search query for a program's merged PRs. */
+export function mergedPrQuery(
+  cfg: Config,
+  program: Program,
+  { author, dayOnly = false }: { author?: string; dayOnly?: boolean } = {}
+): string {
+  const date = (d: Date) =>
+    dayOnly ? d.toISOString().slice(0, 10) : d.toISOString().replace(/\.\d{3}Z$/, "Z");
+  return [
     "is:pr",
     "is:merged",
-    `label:"${label}"`,
-    `merged:${iso(start)}..${iso(end)}`,
-    ...program.repos.map((r) => `repo:${cfg.org}/${r}`),
+    ...(author ? [`author:${author}`] : []),
+    `label:"${program.label}"`,
+    `merged:${date(program.start)}..${date(program.end)}`,
+    ...program.repos.map((repo) => `repo:${cfg.org}/${repo}`),
   ].join(" ");
+}
+
+/** Every merged PR that counts for a program: labeled, in its repos, merged inside its window. */
+export async function searchMergedPrs(env: Env, cfg: Config, program: Program): Promise<MergedPr[]> {
+  const q = mergedPrQuery(cfg, program);
 
   const prs: MergedPr[] = [];
   // The search API returns at most 1000 results (10 pages of 100).
diff --git a/src/index.ts b/src/index.ts
index 182f846..f3d0560 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -3,7 +3,7 @@ import { runCommand, type CommandData, type CommandUser } from "./commands";
 import { DAILY_CRON, getConfig, WELCOME_CRON, type Config, type Env } from "./config";
 import { editInteractionReply, sendMessage } from "./discord";
 import { getLeaderboard } from "./leaderboard";
-import { GithubError } from "./github";
+import { GithubError, mergedPrQuery } from "./github";
 import { linkedMembers } from "./links";
 import { completeLink } from "./linking";
 import { leaderboardMessage, LINK_BUTTON_ID, streaksMessage } from "./messages";
@@ -321,7 +321,7 @@ async function handleContributor(
     return response;
   }
 
-  const prsQuery = `org:${cfg.org} is:pr is:merged author:${row.login} label:"${program.label}" merged:${program.start.toISOString().slice(0, 10)}..${program.end.toISOString().slice(0, 10)}`;
+  const prsQuery = mergedPrQuery(cfg, program, { author: row.login, dayOnly: true });
   const html = contributorPage(
     { program, row, rank, of, generatedAt: board.generatedAt },
     {
diff --git a/test/card.test.ts b/test/card.test.ts
index a0b54df..07b8a83 100644
--- a/test/card.test.ts
+++ b/test/card.test.ts
@@ -314,7 +314,19 @@ describe("GET /leaderboard/{id}/u/{login}", () => {
     expect(html).toContain("https://bot.example/leaderboard/2026-10/u/Ada.png?v=2-1-2-");
     const prs = /href="(https:\/\/github\.com\/search\?[^"]+)"/.exec(html)![1]!.replace(/&amp;/g, "&");
     expect(new URL(prs).searchParams.get("q")).toBe(
-      'org:codercops is:pr is:merged author:Ada label:"hacktoberfest-accepted" merged:2026-10-01..2026-10-31'
+      'is:pr is:merged author:Ada label:"hacktoberfest-accepted" merged:2026-10-01..2026-10-31 repo:codercops/chatcops repo:codercops/ogcops repo:codercops/toolbelt'
+    );
+  });
+
+  it("links to a search scoped to the program's own repos", async () => {
+    env = makeEnv({ PROGRAMS: [{ ...OCTOBER, repos: ["special-repo", "another-repo"] }] });
+    mockFetch(search);
+    const res = await get("/leaderboard/2026-10/u/ada");
+    expect(res.status).toBe(200);
+    const html = await res.text();
+    const prs = /href="(https:\/\/github\.com\/search\?[^"]+)"/.exec(html)![1]!.replace(/&amp;/g, "&");
+    expect(new URL(prs).searchParams.get("q")).toBe(
+      'is:pr is:merged author:Ada label:"hacktoberfest-accepted" merged:2026-10-01..2026-10-31 repo:codercops/special-repo repo:codercops/another-repo'
     );
   });
 

From e4df97c7a3559c61826dd8af3ec7d89db7e965d9 Mon Sep 17 00:00:00 2001
From: SrujanKaleru <srujankaleru2007@gmail.com>
Date: Mon, 26 Oct 2026 19:54:45 +0530
Subject: [PATCH 12/16] fix: add Open Graph type to leaderboard (#104)

---
 src/page.ts       | 1 +
 test/page.test.ts | 6 ++++++
 2 files changed, 7 insertions(+)

diff --git a/src/page.ts b/src/page.ts
index a8674a0..192e53d 100644
--- a/src/page.ts
+++ b/src/page.ts
@@ -215,6 +215,7 @@ export function leaderboardPage(
 <meta name="viewport" content="width=device-width, initial-scale=1">
 <title>${escapeHtml(heading)}</title>
 <meta name="description" content="${escapeHtml(description)}">
+<meta property="og:type" content="website">
 <meta property="og:title" content="${escapeHtml(heading)}">
 <meta property="og:description" content="${escapeHtml(description)}">
 <meta property="og:image" content="${escapeHtml(links.image)}">
diff --git a/test/page.test.ts b/test/page.test.ts
index 498622e..c1e5c2f 100644
--- a/test/page.test.ts
+++ b/test/page.test.ts
@@ -220,6 +220,12 @@ describe("leaderboardPage", () => {
     expect(html).toContain('<link rel="icon" type="image/svg+xml" href="/favicon.svg">');
   });
 
+  it("declares the leaderboard page as an Open Graph website", () => {
+    expect(html.match(/<meta property="og:type" content="[^"]+">/g)).toEqual([
+      '<meta property="og:type" content="website">',
+    ]);
+  });
+
   it("has the same share preview tags as a contributor page, pointing at its own image", () => {
     expect(html).toContain('<meta property="og:image" content="https://bot.example/leaderboard/2026-10.png?v=abc">');
     expect(html).toContain('<meta property="og:image:width" content="1200">');

From ec255d7477115929a66b2cf6aabfb730e208dc36 Mon Sep 17 00:00:00 2001
From: Harshit Bharti <slothisdoped@gmail.com>
Date: Tue, 27 Oct 2026 02:23:19 +0530
Subject: [PATCH 13/16] fix: edit merged PR shoutout when the program label
 lands late (#105)

A merged PR whose program label is added after the merge used to keep
a shoutout with no count, and the board only refreshed when the cache
ran out. Handle the labeled event for an already-merged PR: count it
the same way a merge does, refresh the board, and edit the stored
shoutout so it reads like it had the label at the merge, including
the qualify line. A shoutout that already has the count, an open PR,
or any other label changes nothing.

Closes #59

Co-authored-by: harshit-exe-dev <harshit-exe-dev@users.noreply.github.com>
---
 src/webhook.ts       | 181 +++++++++++++++++++++++++++++++++----------
 test/webhook.test.ts | 117 ++++++++++++++++++++++++++++
 2 files changed, 257 insertions(+), 41 deletions(-)

diff --git a/src/webhook.ts b/src/webhook.ts
index bfa1d4a..019f412 100644
--- a/src/webhook.ts
+++ b/src/webhook.ts
@@ -1,5 +1,5 @@
 // Handles GitHub webhook events: releases, starter issues and merged PRs.
-import type { Config, Env } from "./config";
+import type { Config, Env, Program } from "./config";
 import { DiscordError, editMessage, sendMessage } from "./discord";
 import { countMergedPrs, getIssue, type GithubIssue, type StarterIssue } from "./github";
 import { cacheLeaderboard, invalidateLeaderboard, recentMerges, rememberMerges, searchCountedPrs } from "./leaderboard";
@@ -30,6 +30,8 @@ interface IssuesEvent {
 interface PullRequestEvent {
   action: string;
   repository: Repository;
+  /** The label that was added, on labeled events. */
+  label?: { name: string };
   pull_request: {
     number: number;
     title: string;
@@ -199,12 +201,78 @@ export async function resyncStarterIssues(env: Env, cfg: Config): Promise<void>
   }
 }
 
+/** The shoutout a merged PR got, so a late label can edit it instead of posting again. */
+interface ShoutoutRecord {
+  messageId: string;
+  /** True when the shoutout already carries a count line. */
+  counted: boolean;
+  discordId?: string;
+  linking?: boolean;
+  newRoles?: string[];
+}
+
+const shoutoutKey = (repo: string, number: number) => `merged-pr:${repo}#${number}`;
+/** A late label usually lands soon after the merge, so a few days is plenty. */
+const SHOUTOUT_TTL_SECONDS = 3 * 24 * 60 * 60;
+
+/**
+ * Counts a PR for a program and caches the board, the way a merge does.
+ * Returns undefined when the count couldn't be worked out; the cached board
+ * is cleared then, so a stale one is never served.
+ */
+async function countForProgram(
+  env: Env,
+  cfg: Config,
+  program: Program,
+  e: PullRequestEvent,
+  mergedAt: Date
+): Promise<Parameters<typeof mergedPrMessage>[1] | undefined> {
+  const pr = e.pull_request;
+  try {
+    // GitHub's search index can lag a few seconds behind the merge, so add
+    // this event's PR, and the ones merged just before it that search doesn't
+    // have yet either, before counting and caching the leaderboard.
+    const login = pr.user.login.toLowerCase();
+    const searched = await searchCountedPrs(env, cfg, program);
+    const indexed = new Set(searched.map((p) => p.url));
+    const pending = [
+      ...(await recentMerges(env, program)),
+      {
+        login: pr.user.login,
+        mergedAt: mergedAt.toISOString(),
+        url: pr.html_url,
+        title: pr.title,
+        repo: e.repository.name,
+        number: pr.number,
+      },
+    ].filter((p, i, all) => !indexed.has(p.url) && all.findIndex((q) => q.url === p.url) === i);
+    await rememberMerges(env, program, pending);
+    const prs = [...searched, ...pending];
+    await cacheLeaderboard(env, cfg, program, prs);
+    const others = prs.filter(
+      (p) => p.login.toLowerCase() === login && p.url !== pr.html_url && Date.parse(p.mergedAt) <= mergedAt.getTime()
+    );
+    const count = others.length + 1;
+    return {
+      count,
+      label: program.title,
+      // Said once, on the merge that takes them to the minimum.
+      qualified: count === program.minPrs ? { topN: program.topN, reward: program.reward, note: program.note } : undefined,
+    };
+  } catch {
+    // The shoutout matters more than the count; don't serve an old board.
+    await invalidateLeaderboard(env, program);
+    return undefined;
+  }
+}
+
 async function onPullRequest(e: PullRequestEvent, env: Env, cfg: Config): Promise<string> {
   const pr = e.pull_request;
-  if (e.action !== "closed" || !pr.merged || !ours(cfg, e.repository)) return "ignored pull request";
+  if (!ours(cfg, e.repository)) return "ignored pull request";
   if (pr.user.type === "Bot" || cfg.excludedUsers.has(pr.user.login.toLowerCase())) return "ignored pull request author";
+  if (e.action === "labeled") return onLateLabel(e, env, cfg);
+  if (e.action !== "closed" || !pr.merged) return "ignored pull request";
 
-  let countInWindow: Parameters<typeof mergedPrMessage>[1];
   const mergedAt = pr.merged_at ? new Date(pr.merged_at) : new Date();
   // The program this PR counts for, if any.
   const program = cfg.programs.find(
@@ -214,43 +282,7 @@ async function onPullRequest(e: PullRequestEvent, env: Env, cfg: Config): Promis
       mergedAt >= p.start &&
       mergedAt <= p.end
   );
-  if (program) {
-    try {
-      // GitHub's search index can lag a few seconds behind the merge, so add
-      // this event's PR, and the ones merged just before it that search doesn't
-      // have yet either, before counting and caching the leaderboard.
-      const login = pr.user.login.toLowerCase();
-      const searched = await searchCountedPrs(env, cfg, program);
-      const indexed = new Set(searched.map((p) => p.url));
-      const pending = [
-        ...(await recentMerges(env, program)),
-        {
-          login: pr.user.login,
-          mergedAt: mergedAt.toISOString(),
-          url: pr.html_url,
-          title: pr.title,
-          repo: e.repository.name,
-          number: pr.number,
-        },
-      ].filter((p, i, all) => !indexed.has(p.url) && all.findIndex((q) => q.url === p.url) === i);
-      await rememberMerges(env, program, pending);
-      const prs = [...searched, ...pending];
-      await cacheLeaderboard(env, cfg, program, prs);
-      const others = prs.filter(
-        (p) => p.login.toLowerCase() === login && p.url !== pr.html_url && Date.parse(p.mergedAt) <= mergedAt.getTime()
-      );
-      const count = others.length + 1;
-      countInWindow = {
-        count,
-        label: program.title,
-        // Said once, on the merge that takes them to the minimum.
-        qualified: count === program.minPrs ? { topN: program.topN, reward: program.reward, note: program.note } : undefined,
-      };
-    } catch {
-      // The shoutout matters more than the count; don't serve an old board.
-      await invalidateLeaderboard(env, program);
-    }
-  }
+  const countInWindow = program ? await countForProgram(env, cfg, program, e, mergedAt) : undefined;
 
   // If the author linked their GitHub account, show who they are here and
   // hand out any role this merge earned. The shoutout goes out either way.
@@ -265,7 +297,7 @@ async function onPullRequest(e: PullRequestEvent, env: Env, cfg: Config): Promis
     }
   }
 
-  await sendMessage(
+  const messageId = await sendMessage(
     env,
     env.CHANNEL_MERGED_PRS,
     mergedPrMessage(
@@ -282,5 +314,72 @@ async function onPullRequest(e: PullRequestEvent, env: Env, cfg: Config): Promis
       countInWindow
     )
   );
+  // Kept so a program label added after the merge can edit this shoutout
+  // instead of posting a second one. It expires on its own.
+  await env.STATE.put(
+    shoutoutKey(e.repository.name, pr.number),
+    JSON.stringify({
+      messageId,
+      counted: countInWindow !== undefined,
+      discordId: link?.discordId,
+      linking: linkingEnabled(env),
+      newRoles,
+    } satisfies ShoutoutRecord),
+    { expirationTtl: SHOUTOUT_TTL_SECONDS }
+  );
   return "posted merged pull request";
 }
+
+/**
+ * A program label added after the merge, e.g. by the accepted-label workflow
+ * when a maintainer missed it. The PR already has its shoutout, so this edits
+ * that message to the text it would have had at the merge, and refreshes the
+ * board. A PR whose shoutout already has the count, or a label that isn't a
+ * program's, changes nothing.
+ */
+async function onLateLabel(e: PullRequestEvent, env: Env, cfg: Config): Promise<string> {
+  const pr = e.pull_request;
+  if (!pr.merged || !pr.merged_at) return "ignored pull request";
+  const added = e.label?.name;
+  if (!added) return "ignored pull request";
+  const mergedAt = new Date(pr.merged_at);
+  const program = cfg.programs.find(
+    (p) => p.repos.includes(e.repository.name) && p.label === added && mergedAt >= p.start && mergedAt <= p.end
+  );
+  if (!program) return "ignored pull request";
+
+  const record = await env.STATE.get<ShoutoutRecord>(shoutoutKey(e.repository.name, pr.number), "json");
+  if (record?.counted) return "ignored pull request";
+
+  const countInWindow = await countForProgram(env, cfg, program, e, mergedAt);
+  if (!countInWindow) return "late label, shoutout unchanged";
+  // No stored shoutout (it predates this, or its record expired): the board
+  // is refreshed, but there's no message to edit, and guessing at one would
+  // risk editing the wrong message.
+  if (!record) return "late label, board refreshed";
+
+  await editMessage(
+    env,
+    env.CHANNEL_MERGED_PRS,
+    record.messageId,
+    mergedPrMessage(
+      {
+        repo: e.repository.name,
+        number: pr.number,
+        title: pr.title,
+        url: pr.html_url,
+        login: pr.user.login,
+        discordId: record.discordId,
+        linking: record.linking,
+        newRoles: record.newRoles,
+      },
+      countInWindow
+    )
+  );
+  await env.STATE.put(
+    shoutoutKey(e.repository.name, pr.number),
+    JSON.stringify({ ...record, counted: true } satisfies ShoutoutRecord),
+    { expirationTtl: SHOUTOUT_TTL_SECONDS }
+  );
+  return "updated merged pull request shoutout";
+}
diff --git a/test/webhook.test.ts b/test/webhook.test.ts
index 9248e0f..e2e9b97 100644
--- a/test/webhook.test.ts
+++ b/test/webhook.test.ts
@@ -609,6 +609,123 @@ describe("merged pull requests", () => {
   });
 });
 
+describe("late program label on a merged pull request", () => {
+  const mergedPr = (over: Record<string, unknown> = {}) => ({
+    number: 139,
+    title: "fix(url-encoder): show an error",
+    html_url: "https://github.com/codercops/toolbelt/pull/139",
+    repository_url: "https://api.github.com/repos/codercops/toolbelt",
+    merged: true,
+    merged_at: "2026-10-11T16:20:00Z",
+    user: { login: "ada", type: "User" },
+    labels: [{ name: "hacktoberfest-accepted" }],
+    ...over,
+  });
+  const prEvent = (action: string, overPr: Record<string, unknown> = {}, label?: string) => ({
+    action,
+    repository,
+    ...(label ? { label: { name: label } } : {}),
+    pull_request: mergedPr(overPr),
+  });
+  const earlier = (n: number) => ({
+    total_count: n,
+    items: Array.from({ length: n }, (_, i) => ({
+      html_url: `https://github.com/codercops/toolbelt/pull/${i + 1}`,
+      number: i + 1,
+      title: "Fix a thing",
+      repository_url: "https://api.github.com/repos/codercops/toolbelt",
+      user: { login: "ada" },
+      pull_request: { merged_at: `2026-10-0${i + 1}T00:00:00Z` },
+    })),
+  });
+  // A merge that arrived without the program label, so its shoutout has no count yet.
+  // No search runs for it, so the mock's search answer doesn't matter here.
+  const postUncountedShoutout = async () => {
+    await handleGithubEvent("pull_request", prEvent("closed", { labels: [] }), env, cfg);
+  };
+  const board = () => JSON.parse(env.STATE.store.get("leaderboard:v3:2026-10") ?? "{}");
+
+  it("edits the shoutout to the count and qualify lines, and refreshes the board", async () => {
+    const fetched = mockFetch(() => earlier(4));
+    await postUncountedShoutout();
+    expect(fetched.discord()).toHaveLength(1);
+    expect(fetched.discord()[0]?.body.embeds[0].description).not.toContain("That's their");
+    fetched.clear();
+
+    expect(await handleGithubEvent("pull_request", prEvent("labeled", {}, "hacktoberfest-accepted"), env, cfg)).toBe(
+      "updated merged pull request shoutout"
+    );
+    const edits = fetched.discord();
+    expect(edits).toHaveLength(1);
+    expect(edits[0]?.method).toBe("PATCH");
+    expect(edits[0]?.url).toBe("https://discord.com/api/v10/channels/chan-merged/messages/msg-1");
+    const description = edits[0]?.body.embeds[0].description as string;
+    expect(description).toContain("That's their 5th merged PR on the Hacktoberfest 2026 leaderboard.");
+    expect(description).toContain("With 5 they now qualify");
+    expect(board().rows).toEqual([expect.objectContaining({ login: "ada", count: 5 })]);
+  });
+
+  it("edits in the count without the qualify line when the minimum isn't reached", async () => {
+    const fetched = mockFetch(() => earlier(1));
+    await postUncountedShoutout();
+    fetched.clear();
+    await handleGithubEvent("pull_request", prEvent("labeled", {}, "hacktoberfest-accepted"), env, cfg);
+    const description = fetched.discord()[0]?.body.embeds[0].description as string;
+    expect(description).toContain("That's their 2nd merged PR");
+    expect(description).not.toContain("they now qualify");
+    expect(board().rows).toEqual([expect.objectContaining({ login: "ada", count: 2 })]);
+  });
+
+  it("doesn't count twice when search already includes this PR", async () => {
+    const fetched = mockFetch(() => ({
+      total_count: 5,
+      items: [
+        ...earlier(4).items,
+        { html_url: "https://github.com/codercops/toolbelt/pull/139", number: 139, title: "fix(url-encoder): show an error", repository_url: "https://api.github.com/repos/codercops/toolbelt", user: { login: "ada" }, pull_request: { merged_at: "2026-10-11T16:20:00Z" } },
+      ],
+    }));
+    await postUncountedShoutout();
+    fetched.clear();
+    await handleGithubEvent("pull_request", prEvent("labeled", {}, "hacktoberfest-accepted"), env, cfg);
+    expect(fetched.discord()[0]?.body.embeds[0].description).toContain("That's their 5th merged PR");
+    expect(board().rows).toEqual([expect.objectContaining({ login: "ada", count: 5 })]);
+  });
+
+  it("changes nothing for an open PR, another label, or a shoutout that already has the count", async () => {
+    const fetched = mockFetch(() => earlier(0));
+    expect(await handleGithubEvent("pull_request", prEvent("labeled", { merged: false, merged_at: null }, "hacktoberfest-accepted"), env, cfg)).toBe("ignored pull request");
+    expect(await handleGithubEvent("pull_request", prEvent("labeled", { labels: [{ name: "bug" }] }, "bug"), env, cfg)).toBe("ignored pull request");
+    expect(await handleGithubEvent("pull_request", prEvent("labeled", { merged_at: "2026-11-02T00:00:00Z" }, "hacktoberfest-accepted"), env, cfg)).toBe("ignored pull request");
+    expect(fetched.discord()).toHaveLength(0);
+
+    // This merge had the label all along, so its shoutout already has the count.
+    await handleGithubEvent("pull_request", prEvent("closed"), env, cfg);
+    fetched.clear();
+    expect(await handleGithubEvent("pull_request", prEvent("labeled", {}, "hacktoberfest-accepted"), env, cfg)).toBe("ignored pull request");
+    expect(fetched.discord()).toHaveLength(0);
+  });
+
+  it("refreshes the board but doesn't edit when the shoutout record is gone", async () => {
+    const fetched = mockFetch(() => earlier(4));
+    await postUncountedShoutout();
+    await env.STATE.delete("merged-pr:toolbelt#139");
+    fetched.clear();
+    expect(await handleGithubEvent("pull_request", prEvent("labeled", {}, "hacktoberfest-accepted"), env, cfg)).toBe("late label, board refreshed");
+    expect(fetched.discord()).toHaveLength(0);
+    expect(board().rows).toEqual([expect.objectContaining({ login: "ada", count: 5 })]);
+  });
+
+  it("leaves the shoutout alone and clears the board when search fails", async () => {
+    mockFetch(() => earlier(4));
+    await postUncountedShoutout();
+    await env.STATE.put("leaderboard:v3:2026-10", JSON.stringify({ rows: [], generatedAt: "earlier" }));
+    const fetched = mockFetch(() => new Response("unavailable", { status: 503 }));
+    expect(await handleGithubEvent("pull_request", prEvent("labeled", {}, "hacktoberfest-accepted"), env, cfg)).toBe("late label, shoutout unchanged");
+    expect(fetched.discord()).toHaveLength(0);
+    expect(env.STATE.store.has("leaderboard:v3:2026-10")).toBe(false);
+  });
+});
+
 const rateLimit = () => new Response(JSON.stringify({ retry_after: 30 }), { status: 429 });
 const onGithub = (over: Record<string, unknown> = {}) => () => ({ ...issueEvent("edited").issue, ...over });
 

From dba2c2a538354e0ba9b21d5e39fbdc84fc900484 Mon Sep 17 00:00:00 2001
From: SrujanKaleru <srujankaleru2007@gmail.com>
Date: Wed, 28 Oct 2026 22:52:25 +0530
Subject: [PATCH 14/16] fix: give leaderboard Card links accessible names
 (#106)

---
 src/page.ts       | 2 +-
 test/page.test.ts | 7 +++++++
 2 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/src/page.ts b/src/page.ts
index 192e53d..9856df4 100644
--- a/src/page.ts
+++ b/src/page.ts
@@ -197,7 +197,7 @@ export function leaderboardPage(
       const login = escapeHtml(row.login);
       const chip = standing(row, program, state.status);
       const chipHtml = chip ? `<span class="chip ${chip.kind}">${escapeHtml(chip.text)}</span>` : "";
-      const card = `<a class="cardlink" href="/leaderboard/${escapeHtml(program.id)}/u/${encodeURIComponent(row.login)}" title="${login}'s share card">Card</a>`;
+      const card = `<a class="cardlink" href="/leaderboard/${escapeHtml(program.id)}/u/${encodeURIComponent(row.login)}" title="${login}'s share card" aria-label="${login}'s share card">Card</a>`;
       const prList = row.prs
         .map(
           (pr) =>
diff --git a/test/page.test.ts b/test/page.test.ts
index c1e5c2f..77a71b4 100644
--- a/test/page.test.ts
+++ b/test/page.test.ts
@@ -107,6 +107,13 @@ describe("leaderboardPage", () => {
     expect(html).toContain('<a class="cardlink" href="/leaderboard/2026-10/u/ada"');
   });
 
+  it("gives each Card link the person's share card accessible name", () => {
+    const cards = html.match(/<a class="cardlink"[^>]*>Card<\/a>/g);
+    expect(cards).toEqual(board.rows.map(({ login }) =>
+      `<a class="cardlink" href="/leaderboard/2026-10/u/${login}" title="${login}'s share card" aria-label="${login}'s share card">Card</a>`
+    ));
+  });
+
   it("states the rules, the window and who the reward comes from", () => {
     expect(html).toContain("Merged pull requests in chatcops, ogcops and toolbelt, Oct 1 to Oct 31, 2026 (UTC).");
     expect(html).toContain('<p class="status running">Running now. 20 days left.</p>');

From c6cbd3e28ecfe0b46e6e27a2754b21c7b11ff8a7 Mon Sep 17 00:00:00 2001
From: Nalla Prakash <81852531+prakashNalla@users.noreply.github.com>
Date: Fri, 30 Oct 2026 11:44:56 +0530
Subject: [PATCH 15/16] fix: post prereleases once they're promoted to a full
 release (#110)

---
 src/webhook.ts       |  2 +-
 test/index.test.ts   |  2 +-
 test/webhook.test.ts | 17 +++++++++++++----
 3 files changed, 15 insertions(+), 6 deletions(-)

diff --git a/src/webhook.ts b/src/webhook.ts
index 019f412..e32f604 100644
--- a/src/webhook.ts
+++ b/src/webhook.ts
@@ -62,7 +62,7 @@ export async function handleGithubEvent(event: string, payload: unknown, env: En
 }
 
 async function onRelease(e: ReleaseEvent, env: Env, cfg: Config): Promise<string> {
-  if (e.action !== "published" || e.release.draft || e.release.prerelease || !ours(cfg, e.repository)) {
+  if (e.action !== "released" || e.release.draft || e.release.prerelease || !ours(cfg, e.repository)) {
     return "ignored release";
   }
   await sendMessage(env, env.CHANNEL_RELEASES, releaseMessage(e.repository.name, e.release));
diff --git a/test/index.test.ts b/test/index.test.ts
index c4da0ae..964a12a 100644
--- a/test/index.test.ts
+++ b/test/index.test.ts
@@ -250,7 +250,7 @@ describe("POST /github", () => {
     globalThis.fetch = (async () => new Response("nope", { status: 500 })) as typeof fetch;
     const { ctx } = makeCtx();
     const body = {
-      action: "published",
+      action: "released",
       repository: { name: "toolbelt", owner: { login: "codercops" } },
       release: { name: "v1", tag_name: "v1", body: "", html_url: "https://github.com/codercops/toolbelt/releases/tag/v1", draft: false, prerelease: false },
     };
diff --git a/test/webhook.test.ts b/test/webhook.test.ts
index e2e9b97..1db29d5 100644
--- a/test/webhook.test.ts
+++ b/test/webhook.test.ts
@@ -301,9 +301,9 @@ describe("starter issue feed", () => {
 describe("releases", () => {
   const release = { name: "v0.6.2", tag_name: "v0.6.2", body: "Fixes", html_url: "https://github.com/codercops/toolbelt/releases/tag/v0.6.2", draft: false, prerelease: false };
 
-  it("posts published releases to the releases channel", async () => {
+  it("posts releases to the releases channel", async () => {
     const fetched = mockFetch();
-    expect(await handleGithubEvent("release", { action: "published", repository, release }, env, cfg)).toBe("posted release");
+    expect(await handleGithubEvent("release", { action: "released", repository, release }, env, cfg)).toBe("posted release");
     expect(fetched.discord()[0]?.url).toBe("https://discord.com/api/v10/channels/chan-releases/messages");
     expect(fetched.discord()[0]?.body.embeds[0].title).toBe("toolbelt v0.6.2");
   });
@@ -311,10 +311,19 @@ describe("releases", () => {
   it("ignores drafts, prereleases and other actions", async () => {
     const fetched = mockFetch();
     await handleGithubEvent("release", { action: "created", repository, release }, env, cfg);
-    await handleGithubEvent("release", { action: "published", repository, release: { ...release, draft: true } }, env, cfg);
-    await handleGithubEvent("release", { action: "published", repository, release: { ...release, prerelease: true } }, env, cfg);
+    await handleGithubEvent("release", { action: "published", repository, release }, env, cfg);
+    await handleGithubEvent("release", { action: "released", repository, release: { ...release, draft: true } }, env, cfg);
+    await handleGithubEvent("release", { action: "released", repository, release: { ...release, prerelease: true } }, env, cfg);
     expect(fetched.discord()).toHaveLength(0);
   });
+
+  it("posts a prerelease once it's promoted to a full release", async () => {
+    const fetched = mockFetch();
+    await handleGithubEvent("release", { action: "published", repository, release: { ...release, prerelease: true } }, env, cfg);
+    await handleGithubEvent("release", { action: "edited", repository, release }, env, cfg);
+    expect(await handleGithubEvent("release", { action: "released", repository, release }, env, cfg)).toBe("posted release");
+    expect(fetched.discord()).toHaveLength(1);
+  });
 });
 
 describe("merged pull requests", () => {

From beb0162d2a83932ca785c52629e2860e2bbc3f2f Mon Sep 17 00:00:00 2001
From: Anurag Verma <78868769+anurag629@users.noreply.github.com>
Date: Fri, 30 Oct 2026 11:45:15 +0530
Subject: [PATCH 16/16] chore: version 0.4.0 (#111)

---
 package-lock.json | 4 ++--
 package.json      | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 0bfb907..2146031 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "codercops-discord-bot",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "codercops-discord-bot",
-      "version": "0.3.0",
+      "version": "0.4.0",
       "license": "MIT",
       "dependencies": {
         "@resvg/resvg-wasm": "^2.6.2"
diff --git a/package.json b/package.json
index 9cc3fc3..7d63136 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "codercops-discord-bot",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "private": true,
   "description": "The CODERCOPS community bot: posts releases, starter issues and merged PRs from our open source repos into Discord.",
   "license": "MIT",