From c8e75120a72a56df05ac07307d609358f4c80849 Mon Sep 17 00:00:00 2001
From: Agustin Kassis <webmaster@masize.com>
Date: Tue, 30 Jun 2026 11:47:33 -0300
Subject: [PATCH 1/2] feat(voting): judges' scores + combined final result (70%
 popular / 30% judges)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Add judges to the hackathon voting flow:

- Admin uploads judges' scores as CSV (`project,judge1,judge2,…`); the per-project
  judge score is the average of the judges. The backend matches projects by name,
  self-encrypts the scores (NIP-44, to La Crypta's own pubkey) and publishes a
  signed kind-30078 judges event (`d=lacrypta.dev:judges:<h>`) — kept secret until
  the final result.
- At close, the judges event is decrypted and merged with the popular tally into a
  final score using a *share* model: 100 × (0.70·popShare + 0.30·judgeShare), each
  dimension normalised by its total (projects without a judge score count as 0).
- The closed result publishes a full ranked table (1°…last) showing each judge's
  score, the average, the popular votes and the final score that set the position.

New: lib/judgesCsv.ts (parser + matcher), components/voting/FinalResultsTable.tsx,
JudgesDoc/FinalRow + computeFinalRanking in lib/voting.ts, the upload-judges admin
action + close merge in the voting route. tsc clean.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 app/api/hackathons/[id]/voting/route.ts | 138 ++++++++++++-
 app/hackathons/[id]/VotingSection.tsx   | 254 +++++++++++++++++++++++-
 components/voting/FinalResultsTable.tsx | 105 ++++++++++
 lib/judgesCsv.ts                        | 129 ++++++++++++
 lib/voting.ts                           | 147 ++++++++++++++
 lib/votingCache.ts                      |  57 ++++++
 6 files changed, 821 insertions(+), 9 deletions(-)
 create mode 100644 components/voting/FinalResultsTable.tsx
 create mode 100644 lib/judgesCsv.ts

diff --git a/app/api/hackathons/[id]/voting/route.ts b/app/api/hackathons/[id]/voting/route.ts
index 93e74c8..b37fc36 100644
--- a/app/api/hackathons/[id]/voting/route.ts
+++ b/app/api/hackathons/[id]/voting/route.ts
@@ -16,29 +16,38 @@ import { isDevMode } from "@/lib/devMode";
 import { devPubkeyForPubkey } from "@/lib/devImpersonation";
 import { nostrVotingTag } from "@/lib/nostrCacheTags";
 import {
+  fetchJudgesEventFromRelays,
   fetchVotingPeriodFromRelays,
   getCachedVotingPeriod,
 } from "@/lib/votingCache";
 import {
+  JUDGES_KIND,
+  JUDGES_T_TAG,
   VOTE_ENC,
   VOTING_KIND,
   VOTING_SCHEMA_VERSION,
   VOTING_T_TAG,
   buildEligibleVoters,
+  computeFinalRanking,
   computeVotingRanking,
   isVotingTestNamespace,
+  judgesDTag,
   parseBallotContent,
+  parseJudgesDoc,
+  serializeJudgesDoc,
   serializeVotingPeriod,
   tallyDecryptedBallots,
   voteDTag,
   votingPeriodDTag,
   type DecryptedBallot,
+  type JudgesDoc,
   type VotingEligibleVoter,
   type VotingPeriod,
   type VotingProjectRef,
   type VotingResults,
   type VotingWinner,
 } from "@/lib/voting";
+import { matchJudgesCsv, type JudgesCsv } from "@/lib/judgesCsv";
 
 const OPEN_ACTION = "open-voting";
 /** Legacy single-shot close (kept as an alias for close-confirm). */
@@ -52,6 +61,8 @@ const CLOSE_ACTIONS = new Set([
   CLOSE_PREVIEW_ACTION,
   CLOSE_CONFIRM_ACTION,
 ]);
+/** Admin uploads judges' CSV scores → server self-encrypts + publishes them. */
+const UPLOAD_JUDGES_ACTION = "upload-judges";
 const PROFILE_KIND = 0;
 const PROFILE_SOURCE_NPUB =
   "npub1rujdpkd8mwezrvpqd2rx2zphfaztqrtsfg6w3vdnljdghs2q8qrqtt9u68";
@@ -497,6 +508,28 @@ async function decryptBallotContent(
   }
 }
 
+/** Fetches + self-decrypts the judges' scores event (signed by La Crypta and
+ *  NIP-44 encrypted to its own pubkey). Returns null if absent/unreadable. */
+async function fetchJudgesDoc(
+  secret: Uint8Array,
+  hackathonId: string,
+): Promise<JudgesDoc | null> {
+  const ev = await fetchJudgesEventFromRelays(hackathonId);
+  if (!ev) return null;
+  try {
+    const { getPublicKey } = await import("nostr-tools/pure");
+    const nip44 = await import("nostr-tools/nip44");
+    const selfPub = getPublicKey(secret);
+    const plaintext = nip44.decrypt(
+      ev.content,
+      nip44.getConversationKey(secret, selfPub),
+    );
+    return parseJudgesDoc(plaintext);
+  } catch {
+    return null;
+  }
+}
+
 export type ClosePreview = {
   tally: VotingResults;
   winners: VotingWinner[];
@@ -593,8 +626,20 @@ async function buildClosePreview(
     total: Object.values(allocations).reduce((s, n) => s + n, 0),
   }));
 
+  // Merge judges' scores (if uploaded): 70% popular share + 30% judges share.
+  const judgesDoc = await fetchJudgesDoc(secret, hackathonId);
+  const finalRanking = judgesDoc
+    ? computeFinalRanking(results.tally, judgesDoc)
+    : null;
+
   return {
-    tally: { ...results, winners },
+    tally: {
+      ...results,
+      winners,
+      ...(finalRanking
+        ? { judges: finalRanking.judges, final: finalRanking.rows }
+        : {}),
+    },
     winners,
     countedBallotIds: results.countedBallotIds ?? [],
     perVoter,
@@ -635,11 +680,16 @@ export async function POST(
   // Normalize slug → canonical id so voting data keys off "zaps", not "gaming".
   const id = hackathon.id;
 
-  let body: { request?: SignedEvent; ballots?: SignedEvent[] };
+  let body: {
+    request?: SignedEvent;
+    ballots?: SignedEvent[];
+    judges?: JudgesCsv;
+  };
   try {
     body = (await req.json()) as {
       request?: SignedEvent;
       ballots?: SignedEvent[];
+      judges?: JudgesCsv;
     };
   } catch {
     return jsonError("Body JSON invalido.");
@@ -664,13 +714,95 @@ export async function POST(
       return jsonError("Request expirado.", 401);
     }
     const action = requestTagValue(request, "action") ?? "";
-    if (action !== OPEN_ACTION && !CLOSE_ACTIONS.has(action)) {
+    if (
+      action !== OPEN_ACTION &&
+      action !== UPLOAD_JUDGES_ACTION &&
+      !CLOSE_ACTIONS.has(action)
+    ) {
       return jsonError("Request no autorizado para administrar la votación.", 401);
     }
     if (requestTagValue(request, "h") !== id) {
       return jsonError("El request no corresponde a este hackatón.", 401);
     }
 
+    // ── Upload judges' CSV: match → self-encrypt → publish (admin-gated) ──
+    if (action === UPLOAD_JUDGES_ACTION) {
+      const csv = body.judges;
+      if (
+        !csv ||
+        !Array.isArray(csv.judges) ||
+        csv.judges.length === 0 ||
+        !Array.isArray(csv.rows)
+      ) {
+        return jsonError("Falta el CSV de jueces (judges/rows).");
+      }
+      const projects = await votableProjects(id);
+      const match = matchJudgesCsv(csv, projects.map((p) => ({ id: p.id, name: p.name })));
+      if (Object.keys(match.scores).length === 0) {
+        return NextResponse.json(
+          {
+            error: "Ningún proyecto del CSV coincidió con los proyectos votables.",
+            unmatched: match.unmatched,
+            invalid: match.invalid,
+          },
+          { status: 422 },
+        );
+      }
+
+      const doc: JudgesDoc = {
+        version: VOTING_SCHEMA_VERSION,
+        hackathonId: id,
+        judges: match.judges,
+        scores: match.scores,
+      };
+
+      const { getPublicKey } = await import("nostr-tools/pure");
+      const nip44 = await import("nostr-tools/nip44");
+      const selfPub = getPublicKey(secret);
+      const ciphertext = nip44.encrypt(
+        serializeJudgesDoc(doc),
+        nip44.getConversationKey(secret, selfPub),
+      );
+
+      const existingJudges = await fetchJudgesEventFromRelays(id);
+      const createdAt = Math.max(
+        Math.floor(Date.now() / 1000),
+        (existingJudges?.created_at ?? 0) + 1,
+      );
+      const signed = finalizeEvent(
+        {
+          kind: JUDGES_KIND,
+          created_at: createdAt,
+          content: ciphertext,
+          tags: [
+            ["d", judgesDTag(id)],
+            ["t", JUDGES_T_TAG],
+            ["h", id],
+            ["enc", VOTE_ENC],
+            ["client", "La Crypta Dev"],
+          ],
+        },
+        secret,
+      ) as SignedEvent;
+
+      const relays = await publishToRelays(signed, DEFAULT_RELAYS);
+      if (!relays.some((r) => r.ok)) {
+        return NextResponse.json(
+          { error: "Ningún relay aceptó el evento de jueces.", relays },
+          { status: 502 },
+        );
+      }
+      return NextResponse.json({
+        ok: true,
+        judges: match.judges,
+        matched: match.matched.map((m) => ({ projectId: m.projectId, name: m.name, scores: m.scores })),
+        unmatched: match.unmatched,
+        invalid: match.invalid,
+        eventId: signed.id,
+        relays,
+      });
+    }
+
     // ── Close step 1: decrypt + tally + return preview (admin-gated, no publish) ──
     if (action === CLOSE_PREVIEW_ACTION) {
       const existing = await fetchVotingPeriodFromRelays(id);
diff --git a/app/hackathons/[id]/VotingSection.tsx b/app/hackathons/[id]/VotingSection.tsx
index fc014e2..d825fd8 100644
--- a/app/hackathons/[id]/VotingSection.tsx
+++ b/app/hackathons/[id]/VotingSection.tsx
@@ -9,6 +9,7 @@ import {
   useMemo,
   useRef,
   useState,
+  type ChangeEvent,
   type ReactNode,
 } from "react";
 import { createPortal } from "react-dom";
@@ -17,6 +18,7 @@ import {
   CheckCircle2,
   ChevronDown,
   Coins,
+  Gavel,
   Loader2,
   Lock,
   Megaphone,
@@ -25,6 +27,7 @@ import {
   Plus,
   Radio,
   Trophy,
+  Upload,
   Vote,
   X,
   Users,
@@ -53,10 +56,17 @@ import {
   subscribeToVotingPeriod,
 } from "@/lib/votingClient";
 import LiveTally from "@/components/voting/LiveTally";
+import FinalResultsTable from "@/components/voting/FinalResultsTable";
 import {
   useAdminLiveTally,
   type AdminVoterAllocation,
 } from "@/lib/useAdminLiveTally";
+import {
+  matchJudgesCsv,
+  parseJudgesCsv,
+  type JudgesCsv,
+  type JudgesMatch,
+} from "@/lib/judgesCsv";
 
 /** Shape of the close-preview the backend returns (decrypted, admin-only). */
 type ClosePreviewData = {
@@ -72,6 +82,16 @@ type ClosePreviewData = {
   rejected: { pubkey: string; reason: string }[];
 };
 
+/** Server response after uploading the judges' CSV. */
+type JudgesUploadResult = {
+  ok?: boolean;
+  judges?: string[];
+  matched?: { projectId: string; name: string; scores: number[] }[];
+  unmatched?: string[];
+  invalid?: string[];
+  eventId?: string;
+};
+
 type Pubkeys = { adminPubkey: string | null; publisherPubkey: string | null };
 
 type VoterRow = {
@@ -664,12 +684,21 @@ function VotingSectionInner() {
               {period.status === "closed" && results && (
                 <>
                   <LiveTally results={results} closed />
-                  {results.winners && results.winners.length > 0 && (
-                    <WinnersPanel
-                      winners={results.winners}
+                  {results.final && results.final.length > 0 ? (
+                    <FinalResultsTable
+                      judges={results.judges ?? []}
+                      rows={results.final}
                       hackathonId={hackathonId}
-                      countedBallots={results.countedBallotIds?.length ?? 0}
                     />
+                  ) : (
+                    results.winners &&
+                    results.winners.length > 0 && (
+                      <WinnersPanel
+                        winners={results.winners}
+                        hackathonId={hackathonId}
+                        countedBallots={results.countedBallotIds?.length ?? 0}
+                      />
+                    )
                   )}
                 </>
               )}
@@ -1208,7 +1237,49 @@ function useAdminVoting(
     }
   }, [auth, busy, hackathonId, onPeriod, push, signRequest]);
 
-  return { step, busy, runAction, closePreview, closeConfirm };
+  /** Upload judges' CSV: the backend matches, self-encrypts and publishes the
+   *  judges event (kept secret until the final result is published at close). */
+  const uploadJudges = useCallback(
+    async (csv: JudgesCsv): Promise<JudgesUploadResult | null> => {
+      if (!auth || busy) return null;
+      setStep("publishing");
+      try {
+        const request = await signRequest("upload-judges");
+        const res = await fetch(`/api/hackathons/${hackathonId}/voting`, {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({ request, judges: csv }),
+        });
+        const data = (await res.json().catch(() => ({}))) as JudgesUploadResult & {
+          error?: string;
+        };
+        if (!res.ok || !data.ok) {
+          throw new Error(
+            data.error || "No se pudieron guardar los votos de jueces.",
+          );
+        }
+        push({
+          kind: "success",
+          title: "Jueces guardados",
+          description: `${data.matched?.length ?? 0} proyecto(s) · evento encriptado publicado.`,
+        });
+        return data;
+      } catch (error) {
+        push({
+          kind: "error",
+          title: "Error al guardar jueces",
+          description:
+            error instanceof Error ? error.message : "Error desconocido.",
+        });
+        return null;
+      } finally {
+        setStep("idle");
+      }
+    },
+    [auth, busy, hackathonId, push, signRequest],
+  );
+
+  return { step, busy, runAction, closePreview, closeConfirm, uploadJudges };
 }
 
 type AdminVoting = ReturnType<typeof useAdminVoting>;
@@ -1220,7 +1291,8 @@ function AdminVotingControls({
   period: VotingPeriod | null;
   admin: AdminVoting;
 }) {
-  const { step, busy, runAction, closePreview, closeConfirm } = admin;
+  const { step, busy, runAction, closePreview, closeConfirm, uploadJudges } =
+    admin;
   const [preview, setPreview] = useState<ClosePreviewData | null>(null);
   useScrollLock(!!preview);
 
@@ -1287,6 +1359,10 @@ function AdminVotingControls({
         )}
       </div>
 
+      {period?.status === "open" && (
+        <JudgesUpload period={period} busy={busy} onUpload={uploadJudges} />
+      )}
+
       {preview && period && (
         <CloseReviewModal
           period={period}
@@ -1303,6 +1379,172 @@ function AdminVotingControls({
   );
 }
 
+/* ─────────────────── Judges' CSV upload (admin only) ─────────────────────── */
+
+const avg = (xs: number[]) =>
+  xs.length ? xs.reduce((s, n) => s + n, 0) / xs.length : 0;
+
+function JudgesUpload({
+  period,
+  busy,
+  onUpload,
+}: {
+  period: VotingPeriod;
+  busy: boolean;
+  onUpload: (csv: JudgesCsv) => Promise<JudgesUploadResult | null>;
+}) {
+  const [text, setText] = useState("");
+  const [parsed, setParsed] = useState<JudgesCsv | null>(null);
+  const [match, setMatch] = useState<JudgesMatch | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const [saved, setSaved] = useState<JudgesUploadResult | null>(null);
+
+  const projects = useMemo(
+    () => period.projects.map((p) => ({ id: p.id, name: p.name })),
+    [period.projects],
+  );
+
+  const apply = useCallback(
+    (raw: string) => {
+      setText(raw);
+      setSaved(null);
+      if (!raw.trim()) {
+        setParsed(null);
+        setMatch(null);
+        setError(null);
+        return;
+      }
+      try {
+        const csv = parseJudgesCsv(raw);
+        setParsed(csv);
+        setMatch(matchJudgesCsv(csv, projects));
+        setError(null);
+      } catch (e) {
+        setParsed(null);
+        setMatch(null);
+        setError(e instanceof Error ? e.message : "CSV inválido.");
+      }
+    },
+    [projects],
+  );
+
+  async function onFile(e: ChangeEvent<HTMLInputElement>) {
+    const file = e.target.files?.[0];
+    if (!file) return;
+    apply(await file.text());
+  }
+
+  async function submit() {
+    if (!parsed) return;
+    const res = await onUpload(parsed);
+    if (res) setSaved(res);
+  }
+
+  const canSubmit =
+    !!parsed && !!match && Object.keys(match.scores).length > 0 && !busy;
+
+  return (
+    <div className="mt-4 rounded-xl border border-nostr/30 bg-nostr/[0.04] p-4">
+      <div className="flex items-center gap-2">
+        <Gavel className="h-4 w-4 text-nostr" />
+        <span className="text-[10px] font-mono font-semibold tracking-widest text-nostr uppercase">
+          Votos de jueces (CSV)
+        </span>
+      </div>
+      <p className="mt-1 text-[11px] font-mono text-foreground-subtle">
+        Formato: <code>project,juez1,juez2,…</code>. El promedio de los jueces se
+        guarda en un evento <span className="text-nostr">encriptado</span> firmado
+        por La Crypta y se combina al cerrar (30% jueces · 70% popular).
+      </p>
+
+      <div className="mt-3 flex flex-wrap items-center gap-2">
+        <label className="inline-flex items-center gap-2 rounded-lg border border-border bg-white/[0.03] px-3 py-1.5 text-[11px] font-mono font-bold uppercase tracking-widest text-foreground-muted hover:bg-white/[0.06] cursor-pointer transition-colors">
+          <Upload className="h-3.5 w-3.5" />
+          Elegir CSV
+          <input type="file" accept=".csv,text/csv,text/plain" onChange={onFile} className="hidden" />
+        </label>
+        <button
+          type="button"
+          onClick={submit}
+          disabled={!canSubmit}
+          className="inline-flex items-center gap-2 rounded-lg border border-nostr/40 bg-nostr/10 px-3 py-1.5 text-[11px] font-mono font-bold uppercase tracking-widest text-nostr hover:bg-nostr/20 disabled:opacity-50 disabled:cursor-not-allowed transition-colors"
+        >
+          {busy ? <Loader2 className="h-3.5 w-3.5 animate-spin" /> : <Gavel className="h-3.5 w-3.5" />}
+          Generar evento de jueces
+        </button>
+      </div>
+
+      <textarea
+        value={text}
+        onChange={(e) => apply(e.target.value)}
+        rows={4}
+        spellCheck={false}
+        placeholder={"project,gorilaltor,gorilatron,claudio\nMi Proyecto,8,7,9"}
+        className="mt-3 w-full rounded-lg border border-border bg-background/60 px-3 py-2 font-mono text-[11px] text-foreground placeholder:text-foreground-subtle focus:border-nostr/50 focus:outline-none"
+      />
+
+      {error && (
+        <p className="mt-2 text-[11px] font-mono text-danger">{error}</p>
+      )}
+
+      {match && (
+        <div className="mt-3 space-y-2">
+          <div className="text-[10px] font-mono text-foreground-subtle">
+            {match.judges.length} juez(ces): {match.judges.join(" · ")} —{" "}
+            <span className="text-success">{match.matched.length} matcheados</span>
+            {match.unmatched.length > 0 && (
+              <span className="text-danger"> · {match.unmatched.length} sin match</span>
+            )}
+            {match.invalid.length > 0 && (
+              <span className="text-bitcoin"> · {match.invalid.length} inválidos</span>
+            )}
+          </div>
+          {match.matched.length > 0 && (
+            <div className="overflow-x-auto rounded-lg border border-border">
+              <table className="w-full text-left text-[11px] font-mono">
+                <thead>
+                  <tr className="text-foreground-subtle bg-white/[0.02]">
+                    <th className="px-2 py-1">proyecto</th>
+                    {match.judges.map((j) => (
+                      <th key={j} className="px-2 py-1 text-right">{j}</th>
+                    ))}
+                    <th className="px-2 py-1 text-right text-nostr">prom.</th>
+                  </tr>
+                </thead>
+                <tbody className="divide-y divide-border">
+                  {match.matched.map((m) => (
+                    <tr key={m.projectId}>
+                      <td className="px-2 py-1 truncate max-w-[12rem]">{m.name}</td>
+                      {m.scores.map((s, i) => (
+                        <td key={i} className="px-2 py-1 text-right tabular-nums">{s}</td>
+                      ))}
+                      <td className="px-2 py-1 text-right tabular-nums text-nostr">
+                        {avg(m.scores).toFixed(2)}
+                      </td>
+                    </tr>
+                  ))}
+                </tbody>
+              </table>
+            </div>
+          )}
+          {match.unmatched.length > 0 && (
+            <p className="text-[10px] font-mono text-danger">
+              Sin match (revisá el nombre): {match.unmatched.join(", ")}
+            </p>
+          )}
+        </div>
+      )}
+
+      {saved?.ok && (
+        <p className="mt-2 inline-flex items-center gap-1.5 text-[11px] font-mono text-success">
+          <CheckCircle2 className="h-3.5 w-3.5" />
+          Evento de jueces encriptado y publicado ({saved.matched?.length ?? 0} proyectos).
+        </p>
+      )}
+    </div>
+  );
+}
+
 /* ─────────────────── Close review modal (admin verifies) ─────────────────── */
 
 function CloseReviewModal({
diff --git a/components/voting/FinalResultsTable.tsx b/components/voting/FinalResultsTable.tsx
new file mode 100644
index 0000000..165d585
--- /dev/null
+++ b/components/voting/FinalResultsTable.tsx
@@ -0,0 +1,105 @@
+import Link from "next/link";
+import { Trophy } from "lucide-react";
+import { hackathonSlugForId } from "@/lib/hackathons";
+import {
+  JUDGES_WEIGHT,
+  POPULAR_WEIGHT,
+  type FinalRow,
+} from "@/lib/voting";
+import { cn } from "@/lib/cn";
+
+const MEDAL = ["🥇", "🥈", "🥉"];
+
+/**
+ * Final combined ranking: popular votes + judges, weighted 70/30. One row per
+ * project ordered by `finalScore`, showing each judge's score, the judges'
+ * average, the popular votes and the final score that decided the position.
+ */
+export default function FinalResultsTable({
+  judges,
+  rows,
+  hackathonId,
+}: {
+  judges: string[];
+  rows: FinalRow[];
+  hackathonId: string;
+}) {
+  const slug = hackathonSlugForId(hackathonId);
+  return (
+    <div className="mt-6">
+      <div className="flex items-center justify-between gap-2 mb-2">
+        <span className="inline-flex items-center gap-2 text-[10px] font-mono font-semibold tracking-widest text-foreground-subtle uppercase">
+          <Trophy className="h-4 w-4 text-bitcoin" />
+          Resultado final
+        </span>
+        <span className="text-[10px] font-mono text-foreground-subtle">
+          {Math.round(POPULAR_WEIGHT * 100)}% popular · {Math.round(JUDGES_WEIGHT * 100)}% jueces
+        </span>
+      </div>
+
+      <div className="overflow-x-auto rounded-lg border border-border">
+        <table className="w-full text-left text-[11px] font-mono">
+          <thead>
+            <tr className="text-foreground-subtle bg-white/[0.02] uppercase tracking-wider text-[9px]">
+              <th className="px-2 py-2 w-8 text-center">#</th>
+              <th className="px-2 py-2">Proyecto</th>
+              {judges.map((j) => (
+                <th key={j} className="px-2 py-2 text-right" title={`Juez: ${j}`}>
+                  {j}
+                </th>
+              ))}
+              <th className="px-2 py-2 text-right text-nostr">Prom. jueces</th>
+              <th className="px-2 py-2 text-right">Votos</th>
+              <th className="px-2 py-2 text-right text-bitcoin">Final</th>
+            </tr>
+          </thead>
+          <tbody className="divide-y divide-border">
+            {rows.map((r) => {
+              const leader = r.position === 1;
+              return (
+                <tr
+                  key={r.projectId}
+                  className={cn(leader && "bg-bitcoin/5")}
+                >
+                  <td className="px-2 py-2 text-center text-sm tabular-nums">
+                    {MEDAL[r.position - 1] ?? `${r.position}°`}
+                  </td>
+                  <td className="px-2 py-2 max-w-[14rem]">
+                    <Link
+                      href={`/hackathons/${slug}/${r.projectId}`}
+                      className="block truncate font-semibold hover:text-bitcoin transition-colors"
+                    >
+                      {r.name}
+                    </Link>
+                  </td>
+                  {r.judgeScores.map((s, i) => (
+                    <td key={i} className="px-2 py-2 text-right tabular-nums text-foreground-muted">
+                      {s}
+                    </td>
+                  ))}
+                  <td className="px-2 py-2 text-right tabular-nums text-nostr">
+                    {r.judgeAvg.toFixed(2)}
+                  </td>
+                  <td className="px-2 py-2 text-right tabular-nums">{r.popularVotes}</td>
+                  <td
+                    className={cn(
+                      "px-2 py-2 text-right tabular-nums font-bold",
+                      leader ? "text-bitcoin" : "text-foreground",
+                    )}
+                  >
+                    {r.finalScore.toFixed(1)}
+                  </td>
+                </tr>
+              );
+            })}
+          </tbody>
+        </table>
+      </div>
+
+      <p className="mt-2 text-[10px] font-mono text-foreground-subtle">
+        Puntaje final = 100 × ({POPULAR_WEIGHT}·cuota de votos + {JUDGES_WEIGHT}·cuota de
+        jueces). Cada dimensión se normaliza por su total.
+      </p>
+    </div>
+  );
+}
diff --git a/lib/judgesCsv.ts b/lib/judgesCsv.ts
new file mode 100644
index 0000000..15d4216
--- /dev/null
+++ b/lib/judgesCsv.ts
@@ -0,0 +1,129 @@
+/**
+ * Parse + match helpers for the judges' scores CSV, shared by the admin upload
+ * UI (client) and the API route (server). No dependencies — the repo has no CSV
+ * library and the format is simple: `project,<judge1>,<judge2>,…`.
+ */
+
+export type JudgesCsvRow = { project: string; scores: number[] };
+export type JudgesCsv = { judges: string[]; rows: JudgesCsvRow[] };
+
+/** Split one CSV line, honouring double-quoted fields. */
+function splitCsvLine(line: string): string[] {
+  const out: string[] = [];
+  let cur = "";
+  let inQuotes = false;
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (inQuotes) {
+      if (ch === '"') {
+        if (line[i + 1] === '"') {
+          cur += '"';
+          i++;
+        } else {
+          inQuotes = false;
+        }
+      } else {
+        cur += ch;
+      }
+    } else if (ch === '"') {
+      inQuotes = true;
+    } else if (ch === ",") {
+      out.push(cur);
+      cur = "";
+    } else {
+      cur += ch;
+    }
+  }
+  out.push(cur);
+  return out.map((s) => s.trim());
+}
+
+/**
+ * Parse the judges CSV. Header must be `project,<judge1>,<judge2>,…`. Each data
+ * row is a project name followed by one numeric score per judge. Throws on a
+ * malformed header; non-numeric/blank scores become NaN (validate downstream).
+ */
+export function parseJudgesCsv(text: string): JudgesCsv {
+  const lines = text
+    .split(/\r?\n/)
+    .map((l) => l.trim())
+    .filter((l) => l.length > 0);
+  if (lines.length === 0) throw new Error("CSV vacío.");
+  const header = splitCsvLine(lines[0] as string);
+  if (header.length < 2 || (header[0] ?? "").toLowerCase() !== "project") {
+    throw new Error('El encabezado debe empezar con la columna "project".');
+  }
+  const judges = header.slice(1).filter((j) => j.length > 0);
+  if (judges.length === 0) throw new Error("El CSV no tiene columnas de jueces.");
+  const rows: JudgesCsvRow[] = [];
+  for (const line of lines.slice(1)) {
+    const cells = splitCsvLine(line);
+    const project = cells[0] ?? "";
+    if (!project) continue;
+    const scores = judges.map((_, i) => {
+      const raw = cells[i + 1];
+      if (raw === undefined || raw === "") return NaN;
+      return Number(raw);
+    });
+    rows.push({ project, scores });
+  }
+  return { judges, rows };
+}
+
+/** Normalise a name for project↔CSV matching (diacritics, case, whitespace). */
+export function normalizeName(name: string): string {
+  return name
+    .normalize("NFD")
+    .replace(/\p{Diacritic}/gu, "")
+    .trim()
+    .toLowerCase()
+    .replace(/\s+/g, " ");
+}
+
+export type JudgesMatch = {
+  judges: string[];
+  /** projectId → raw scores aligned to judges[]. */
+  scores: Record<string, number[]>;
+  matched: { project: string; projectId: string; name: string; scores: number[] }[];
+  /** CSV project names that didn't match any votable project. */
+  unmatched: string[];
+  /** CSV rows with a non-numeric / missing score. */
+  invalid: string[];
+};
+
+/**
+ * Match parsed CSV rows to votable projects by normalised name (falling back to
+ * id). Returns the per-id score map plus matched/unmatched/invalid breakdowns
+ * for the admin preview and server validation.
+ */
+export function matchJudgesCsv(
+  csv: JudgesCsv,
+  projects: { id: string; name: string }[],
+): JudgesMatch {
+  const byName = new Map(projects.map((p) => [normalizeName(p.name), p]));
+  const byId = new Map(projects.map((p) => [normalizeName(p.id), p]));
+  const scores: Record<string, number[]> = {};
+  const matched: JudgesMatch["matched"] = [];
+  const unmatched: string[] = [];
+  const invalid: string[] = [];
+  for (const row of csv.rows) {
+    const key = normalizeName(row.project);
+    const project = byName.get(key) ?? byId.get(key);
+    if (!project) {
+      unmatched.push(row.project);
+      continue;
+    }
+    if (row.scores.length !== csv.judges.length || row.scores.some((n) => !Number.isFinite(n))) {
+      invalid.push(row.project);
+      continue;
+    }
+    scores[project.id] = row.scores;
+    matched.push({
+      project: row.project,
+      projectId: project.id,
+      name: project.name,
+      scores: row.scores,
+    });
+  }
+  return { judges: csv.judges, scores, matched, unmatched, invalid };
+}
diff --git a/lib/voting.ts b/lib/voting.ts
index 4732d4e..ea1e9ba 100644
--- a/lib/voting.ts
+++ b/lib/voting.ts
@@ -28,6 +28,14 @@ export const VOTE_ENC = "nip44";
  *  different projects rather than backing a single one. */
 export const VOTES_PER_HACKATHON = 5;
 
+/** Judges' scores event (server-signed, NIP-44 self-encrypted), merged into the
+ *  final result at close. `d = lacrypta.dev:judges:<hackathonId>`. */
+export const JUDGES_KIND = 30078;
+export const JUDGES_T_TAG = "lacrypta-dev-judges";
+/** Weight split for the combined final score — must sum to 1. */
+export const POPULAR_WEIGHT = 0.7;
+export const JUDGES_WEIGHT = 0.3;
+
 /**
  * Dev/test isolation: with `NEXT_PUBLIC_VOTING_NS=test` every d-tag moves to
  * the `lacrypta.dev:test:` namespace, so test events on the public relays are
@@ -50,6 +58,10 @@ export function voteDTag(hackathonId: string): string {
   return `${dTagPrefix()}:vote:${hackathonId}`;
 }
 
+export function judgesDTag(hackathonId: string): string {
+  return `${dTagPrefix()}:judges:${hackathonId}`;
+}
+
 export type VotingEligibleVoter = {
   pubkey: string;
   name: string;
@@ -95,6 +107,38 @@ export type VotingResults = {
   /** The exact ballot event ids counted into this result — the FREEZE set.
    *  Ballots re-published after close (new ids) are never in this set. */
   countedBallotIds?: string[];
+  /** Judge column names, present when a judges event was merged at close. */
+  judges?: string[];
+  /** Combined final ranking (70% popular + 30% judges), present when judges
+   *  were merged. Authoritative ranking when present. */
+  final?: FinalRow[];
+};
+
+/** Decrypted judges document — per-project raw scores aligned to `judges[]`. */
+export type JudgesDoc = {
+  version: number;
+  hackathonId: string;
+  /** Judge names in column order, e.g. ["gorilaltor","gorilatron","claudio"]. */
+  judges: string[];
+  /** projectId → raw score per judge, aligned to `judges[]`. */
+  scores: Record<string, number[]>;
+};
+
+/** A row of the combined final ranking (popular + judges). */
+export type FinalRow = {
+  /** 1-based rank by finalScore. */
+  position: number;
+  projectId: string;
+  name: string;
+  popularVotes: number;
+  popularVoters: number;
+  /** Raw per-judge scores aligned to `judges[]` (0-filled if missing). */
+  judgeScores: number[];
+  judgeAvg: number;
+  popShare: number;
+  judgeShare: number;
+  /** 0–100: 100 × (POPULAR_WEIGHT·popShare + JUDGES_WEIGHT·judgeShare). */
+  finalScore: number;
 };
 
 /** A ballot whose encrypted content has already been decrypted (by the backend
@@ -461,6 +505,109 @@ export function computeVotingRanking(
     }));
 }
 
+// ── Judges' scores ──────────────────────────────────────────────────────────
+
+export function serializeJudgesDoc(doc: JudgesDoc): string {
+  return JSON.stringify(doc);
+}
+
+/** Defensive parse of a decrypted judges document — null on garbage. */
+export function parseJudgesDoc(content: string): JudgesDoc | null {
+  try {
+    const parsed = JSON.parse(content) as Partial<JudgesDoc>;
+    if (
+      !parsed ||
+      typeof parsed !== "object" ||
+      typeof parsed.hackathonId !== "string" ||
+      !Array.isArray(parsed.judges) ||
+      !parsed.scores ||
+      typeof parsed.scores !== "object" ||
+      Array.isArray(parsed.scores)
+    ) {
+      return null;
+    }
+    const judges = parsed.judges.filter((j): j is string => typeof j === "string");
+    const scores: Record<string, number[]> = {};
+    for (const [projectId, arr] of Object.entries(parsed.scores)) {
+      if (!Array.isArray(arr)) continue;
+      scores[projectId] = arr.map((n) =>
+        typeof n === "number" && Number.isFinite(n) ? n : 0,
+      );
+    }
+    return {
+      version:
+        typeof parsed.version === "number" ? parsed.version : VOTING_SCHEMA_VERSION,
+      hackathonId: parsed.hackathonId,
+      judges,
+      scores,
+    };
+  } catch {
+    return null;
+  }
+}
+
+/** Average of a judge score array; empty/missing → 0. */
+export function judgeAverage(scores: number[] | undefined): number {
+  if (!scores || scores.length === 0) return 0;
+  return scores.reduce((s, n) => s + n, 0) / scores.length;
+}
+
+/**
+ * Combines the popular tally with judges' averages into the final ranking using
+ * the *share* model: each dimension is normalised by its total, then weighted
+ * (70% popular / 30% judges) and scaled to 0–100. Projects missing a judge score
+ * get judgeAvg = 0. Sorted by finalScore desc (tiebreak popularVotes desc, name).
+ */
+export function computeFinalRanking(
+  tally: VotingTallyRow[],
+  judgesDoc: Pick<JudgesDoc, "judges" | "scores"> | null,
+  weights: { popular: number; judges: number } = {
+    popular: POPULAR_WEIGHT,
+    judges: JUDGES_WEIGHT,
+  },
+): { judges: string[]; rows: FinalRow[] } {
+  const judges = judgesDoc?.judges ?? [];
+  const totalVotes = tally.reduce((s, r) => s + r.votes, 0);
+  const judgeAvgById = new Map<string, number>(
+    tally.map((r) => [r.projectId, judgeAverage(judgesDoc?.scores[r.projectId])]),
+  );
+  const totalJudgeAvg = [...judgeAvgById.values()].reduce((s, n) => s + n, 0);
+
+  const rows: FinalRow[] = tally
+    .map((r) => {
+      const judgeAvg = judgeAvgById.get(r.projectId) ?? 0;
+      const popShare = totalVotes > 0 ? r.votes / totalVotes : 0;
+      const judgeShare = totalJudgeAvg > 0 ? judgeAvg / totalJudgeAvg : 0;
+      const finalScore =
+        100 * (weights.popular * popShare + weights.judges * judgeShare);
+      const raw = judgesDoc?.scores[r.projectId] ?? [];
+      const judgeScores = judges.map((_, i) =>
+        typeof raw[i] === "number" ? raw[i] : 0,
+      );
+      return {
+        position: 0,
+        projectId: r.projectId,
+        name: r.name,
+        popularVotes: r.votes,
+        popularVoters: r.voters,
+        judgeScores,
+        judgeAvg,
+        popShare,
+        judgeShare,
+        finalScore,
+      };
+    })
+    .sort(
+      (a, b) =>
+        b.finalScore - a.finalScore ||
+        b.popularVotes - a.popularVotes ||
+        a.name.localeCompare(b.name),
+    )
+    .map((r, i) => ({ ...r, position: i + 1 }));
+
+  return { judges, rows };
+}
+
 /** @deprecated v1 plaintext live tally. v2 hides the tally until close. */
 export function tallyBallots(
   events: VotingEventLike[],
diff --git a/lib/votingCache.ts b/lib/votingCache.ts
index 7c79f91..b59ac47 100644
--- a/lib/votingCache.ts
+++ b/lib/votingCache.ts
@@ -10,7 +10,9 @@ import { cacheLife, cacheTag } from "next/cache";
 import { DEFAULT_RELAYS } from "./nostrRelayConfig";
 import { nostrVotingTag } from "./nostrCacheTags";
 import {
+  JUDGES_KIND,
   VOTING_KIND,
+  judgesDTag,
   parseVotingPeriod,
   votingPeriodDTag,
   type VotingPeriod,
@@ -89,6 +91,61 @@ export async function fetchVotingPeriodFromRelays(
   return null;
 }
 
+/**
+ * Uncached relay fetch of the judges' scores event (raw, still NIP-44
+ * encrypted). The caller decrypts it server-side with LACRYPTA_NSEC (the event
+ * is self-encrypted: author == La Crypta, encrypted to its own pubkey).
+ */
+export async function fetchJudgesEventFromRelays(
+  hackathonId: string,
+  timeoutMs = 4500,
+): Promise<{ content: string; pubkey: string; created_at: number } | null> {
+  const publisherPubkey = await publisherPubkeyFromNsec();
+  if (!publisherPubkey) return null;
+
+  const relays = DEFAULT_RELAYS;
+  const { SimplePool } = await import("nostr-tools/pool");
+  const pool = new SimplePool();
+  const events: IncomingEvent[] = [];
+
+  const closer = pool.subscribe(
+    relays,
+    {
+      kinds: [JUDGES_KIND],
+      authors: [publisherPubkey],
+      "#d": [judgesDTag(hackathonId)],
+    },
+    {
+      onevent(ev: IncomingEvent) {
+        events.push(ev);
+      },
+      oneose() {
+        /* timeout-driven */
+      },
+    },
+  );
+
+  await new Promise((r) => setTimeout(r, timeoutMs));
+  try {
+    closer.close();
+  } catch {
+    /* noop */
+  }
+  try {
+    pool.close(relays);
+  } catch {
+    /* noop */
+  }
+
+  events.sort((a, b) => b.created_at - a.created_at || a.id.localeCompare(b.id));
+  for (const ev of events) {
+    const d = ev.tags.find((t) => t[0] === "d")?.[1];
+    if (d !== judgesDTag(hackathonId)) continue;
+    return { content: ev.content, pubkey: ev.pubkey, created_at: ev.created_at };
+  }
+  return null;
+}
+
 export async function getCachedVotingPeriod(
   hackathonId: string,
 ): Promise<VotingPeriod | null> {

From ce109a79f4d46b8f802e2063f548f221159d352d Mon Sep 17 00:00:00 2001
From: Agustin Kassis <webmaster@masize.com>
Date: Tue, 30 Jun 2026 17:38:30 -0300
Subject: [PATCH 2/2] feat(voting): badge "Puntaje de Jueces publicado" +
 resultado final en hero cerrado
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Badge "Puntaje de Jueces publicado" en el panel de carga de jueces: detecta
  el evento de jueces ya publicado en el relay (nuevo helper
  subscribeToJudgesEvent), no solo el upload de la sesión actual.
- VotingHero (ClosedHero): renderiza FinalResultsTable con el ranking combinado
  70% popular / 30% jueces cuando la votación cerró con jueces cargados.
- Fix typo gorilaltor → gorilator (placeholder del CSV y comentario de tipo).
- devSeed: +6 proyectos dummy para el hackatón gaming (zaps), variando autores
  y equipos, para poblar mejor la página al testear.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 app/hackathons/[id]/VotingSection.tsx | 22 +++++++++-
 components/voting/VotingHero.tsx      | 12 ++++++
 lib/devSeed.ts                        |  6 +++
 lib/voting.ts                         |  2 +-
 lib/votingClient.ts                   | 62 +++++++++++++++++++++++++++
 5 files changed, 102 insertions(+), 2 deletions(-)

diff --git a/app/hackathons/[id]/VotingSection.tsx b/app/hackathons/[id]/VotingSection.tsx
index d825fd8..0285d71 100644
--- a/app/hackathons/[id]/VotingSection.tsx
+++ b/app/hackathons/[id]/VotingSection.tsx
@@ -53,6 +53,7 @@ import {
   fetchAllBallotEvents,
   publishBallot,
   subscribeToBallots,
+  subscribeToJudgesEvent,
   subscribeToVotingPeriod,
 } from "@/lib/votingClient";
 import LiveTally from "@/components/voting/LiveTally";
@@ -1393,11 +1394,24 @@ function JudgesUpload({
   busy: boolean;
   onUpload: (csv: JudgesCsv) => Promise<JudgesUploadResult | null>;
 }) {
+  const { pubkeys } = useVotingContext();
   const [text, setText] = useState("");
   const [parsed, setParsed] = useState<JudgesCsv | null>(null);
   const [match, setMatch] = useState<JudgesMatch | null>(null);
   const [error, setError] = useState<string | null>(null);
   const [saved, setSaved] = useState<JudgesUploadResult | null>(null);
+  // Detect an already-published judges event for this hackathon (e.g. on a
+  // reload after a previous upload) so we can flag it even without `saved`.
+  const [judgesPublished, setJudgesPublished] = useState(false);
+
+  useEffect(() => {
+    if (!pubkeys.publisherPubkey) return;
+    return subscribeToJudgesEvent(
+      period.hackathonId,
+      pubkeys.publisherPubkey,
+      () => setJudgesPublished(true),
+    );
+  }, [period.hackathonId, pubkeys.publisherPubkey]);
 
   const projects = useMemo(
     () => period.projects.map((p) => ({ id: p.id, name: p.name })),
@@ -1450,6 +1464,12 @@ function JudgesUpload({
         <span className="text-[10px] font-mono font-semibold tracking-widest text-nostr uppercase">
           Votos de jueces (CSV)
         </span>
+        {(judgesPublished || saved?.ok) && (
+          <span className="ml-auto inline-flex items-center gap-1 rounded-full border border-success/40 bg-success/10 px-2 py-0.5 text-[9px] font-mono font-bold uppercase tracking-widest text-success">
+            <CheckCircle2 className="h-3 w-3" />
+            Puntaje de Jueces publicado
+          </span>
+        )}
       </div>
       <p className="mt-1 text-[11px] font-mono text-foreground-subtle">
         Formato: <code>project,juez1,juez2,…</code>. El promedio de los jueces se
@@ -1479,7 +1499,7 @@ function JudgesUpload({
         onChange={(e) => apply(e.target.value)}
         rows={4}
         spellCheck={false}
-        placeholder={"project,gorilaltor,gorilatron,claudio\nMi Proyecto,8,7,9"}
+        placeholder={"project,gorilator,gorilatron,claudio\nMi Proyecto,8,7,9"}
         className="mt-3 w-full rounded-lg border border-border bg-background/60 px-3 py-2 font-mono text-[11px] text-foreground placeholder:text-foreground-subtle focus:border-nostr/50 focus:outline-none"
       />
 
diff --git a/components/voting/VotingHero.tsx b/components/voting/VotingHero.tsx
index 6f92f00..5287a31 100644
--- a/components/voting/VotingHero.tsx
+++ b/components/voting/VotingHero.tsx
@@ -27,6 +27,7 @@ import {
 } from "@/lib/voting";
 import { cn } from "@/lib/cn";
 import LiveTally from "@/components/voting/LiveTally";
+import FinalResultsTable from "@/components/voting/FinalResultsTable";
 
 /**
  * Gamified, live "community voting" hero. Reused on the home page and the
@@ -662,6 +663,17 @@ function ClosedHero({
           )}
         </div>
       )}
+
+      {/* Official combined ranking (70% popular · 30% judges). Present only when
+       *  the admin uploaded judges' scores before closing — the podium above is
+       *  the community vote; this table is the prize-deciding blended result. */}
+      {period.results?.final && period.results.final.length > 0 && (
+        <FinalResultsTable
+          judges={period.results.judges ?? []}
+          rows={period.results.final}
+          hackathonId={hackathonId}
+        />
+      )}
     </div>
   );
 }
diff --git a/lib/devSeed.ts b/lib/devSeed.ts
index b43df84..2699241 100644
--- a/lib/devSeed.ts
+++ b/lib/devSeed.ts
@@ -71,6 +71,12 @@ const PROJECTS: ProjectSpec[] = [
   { id: "dummy-soberano", name: "Soberano", description: "Wallet de identidad + pagos.", repo: "https://github.com/dummy/soberano", hackathon: "identity", author: 7, team: [0] },
   { id: "dummy-tienda-zap", name: "TiendaZap", description: "Catálogo y cobros Lightning.", repo: "https://github.com/dummy/tienda-zap", hackathon: "commerce", author: 7 },
   { id: "dummy-arcade", name: "SatArcade", description: "Arcade retro pay-per-play.", repo: "https://github.com/dummy/sat-arcade", hackathon: "zaps", author: 7 },
+  { id: "dummy-lightning-runner", name: "Lightning Runner", description: "Endless runner que mina sats al correr.", repo: "https://github.com/dummy/lightning-runner", hackathon: "zaps", author: 3, team: [1] },
+  { id: "dummy-zap-chess", name: "ZapChess", description: "Ajedrez por dinero: cada jaque mate cobra el bote.", repo: "https://github.com/dummy/zap-chess", hackathon: "zaps", author: 2 },
+  { id: "dummy-block-blast", name: "BlockBlast", description: "Battle royale on-chain con leaderboards Nostr.", repo: "https://github.com/dummy/block-blast", hackathon: "zaps", author: 4, team: [5, 3] },
+  { id: "dummy-sat-snake", name: "SatSnake", description: "Snake multijugador donde la manzana es un zap.", repo: "https://github.com/dummy/sat-snake", hackathon: "zaps", author: 0 },
+  { id: "dummy-pixel-pump", name: "PixelPump", description: "Plataforma de mini-juegos con login Nostr y premios.", repo: "https://github.com/dummy/pixel-pump", hackathon: "zaps", author: 5, team: [6] },
+  { id: "dummy-bolt-quest", name: "BoltQuest", description: "RPG por turnos con recompensas Lightning.", repo: "https://github.com/dummy/bolt-quest", hackathon: "zaps", author: 6, team: [7] },
 ];
 
 function avatarFor(name: string): string {
diff --git a/lib/voting.ts b/lib/voting.ts
index ea1e9ba..e55454f 100644
--- a/lib/voting.ts
+++ b/lib/voting.ts
@@ -118,7 +118,7 @@ export type VotingResults = {
 export type JudgesDoc = {
   version: number;
   hackathonId: string;
-  /** Judge names in column order, e.g. ["gorilaltor","gorilatron","claudio"]. */
+  /** Judge names in column order, e.g. ["gorilator","gorilatron","claudio"]. */
   judges: string[];
   /** projectId → raw score per judge, aligned to `judges[]`. */
   scores: Record<string, number[]>;
diff --git a/lib/votingClient.ts b/lib/votingClient.ts
index 37dd629..92a80ea 100644
--- a/lib/votingClient.ts
+++ b/lib/votingClient.ts
@@ -9,11 +9,13 @@
 import { FAST_USER_RELAYS, DEFAULT_RELAYS } from "./nostrRelayConfig";
 import type { SignedEvent, UserSigner } from "./nostrSigner";
 import {
+  JUDGES_KIND,
   VOTE_ENC,
   VOTE_T_TAG,
   VOTING_KIND,
   VOTING_SCHEMA_VERSION,
   dedupeBallots,
+  judgesDTag,
   parseBallotContent,
   parseVotingPeriod,
   voteDTag,
@@ -245,6 +247,66 @@ export function subscribeToBallots(
   };
 }
 
+/**
+ * Live-subscribe to the judges' scores event published by La Crypta. Fires
+ * `onFound` with the event's created_at whenever a (fresher) one exists — used
+ * to surface the "judges published" badge. The content stays NIP-44 encrypted;
+ * only its existence is observable here.
+ */
+export function subscribeToJudgesEvent(
+  hackathonId: string,
+  publisherPubkey: string,
+  onFound: (eventCreatedAt: number) => void,
+): () => void {
+  let closed = false;
+  let teardown: (() => void) | null = null;
+  let freshest = 0;
+  const dTag = judgesDTag(hackathonId);
+  const relays = [...FAST_USER_RELAYS];
+
+  void (async () => {
+    const { SimplePool } = await import("nostr-tools/pool");
+    if (closed) return;
+    const pool = new SimplePool();
+    const closer = pool.subscribe(
+      relays,
+      {
+        kinds: [JUDGES_KIND],
+        authors: [publisherPubkey],
+        "#d": [dTag],
+      },
+      {
+        onevent(ev) {
+          const event = ev as SignedEvent;
+          const d = event.tags.find((t) => t[0] === "d")?.[1];
+          if (d !== dTag) return;
+          if (event.pubkey !== publisherPubkey) return;
+          if (event.created_at <= freshest) return;
+          freshest = event.created_at;
+          onFound(event.created_at);
+        },
+        oneose() {
+          // Keep open so a fresh judges upload flips the badge live.
+        },
+      },
+    );
+    teardown = () => {
+      closer.close();
+      try {
+        pool.close(relays);
+      } catch {
+        /* noop */
+      }
+    };
+    if (closed) teardown();
+  })();
+
+  return () => {
+    closed = true;
+    teardown?.();
+  };
+}
+
 /**
  * Live-subscribe to the voting period event published by La Crypta. Calls
  * `onPeriod` with the freshest valid period whenever one arrives, so open and