feat: add prize ledger

Co-authored-by: Codex <noreply@openai.com>

README.md

@@ -75,6 +75,12 @@ The `chapter` Gradio API endpoint and `Chapter` button export the public-facing
 one fate page per idea, each with verdict, score, targets, and closest cited pages. It is the shareable companion to
 the private Field Notes artifact.
 
+## Prize Ledger
+
+`/api/prize-ledger` and the in-app Prize Ledger panel expose submission evidence: the documented model stack, total
+parameter budget, Tiny Titan eligibility, runtime backend, and badge readiness. This keeps the demo's prize claims tied
+to visible app state rather than hidden notes.
+
 ## Wood Map
 
 Every scored fate page now carries a deterministic `wood_map` artifact: background dots for inked Spaces, red dots for

app.py

@@ -12,6 +12,7 @@ from hackathon_advisor.agent import AdvisorEngine
 from hackathon_advisor.chapter import build_chapter_markdown
 from hackathon_advisor.data import ProjectIndex
 from hackathon_advisor.field_notes import build_field_notes_markdown
+from hackathon_advisor.prize_ledger import prize_ledger
 from hackathon_advisor.tool_contracts import resolve_tool_call, tool_schemas
 from hackathon_advisor.tools import TARGETS
 from hackathon_advisor.trace_export import build_trace_jsonl, trace_metadata
@@ -57,15 +58,17 @@ def health() -> dict:
 
 @app.get("/api/bootstrap")
 def bootstrap() -> dict:
+    runtime_status = engine.runtime_status()
     return {
         "project_count": len(index.projects),
-        "runtime": engine.runtime_status(),
+        "runtime": runtime_status,
         **trace_metadata(index),
         "top_projects": [project.to_public_dict() for project in index.top_projects(limit=8)],
         "whitespace": [item.to_dict() for item in index.find_whitespace(limit=5)],
         "target_options": TARGETS,
         "default_targets": TARGETS[:3],
         "profile_fields": PROFILE_FIELDS,
+        "prize_ledger": prize_ledger(runtime_status),
     }
 
 
@@ -74,6 +77,11 @@ def runtime() -> dict:
     return engine.runtime_status()
 
 
+@app.get("/api/prize-ledger")
+def prize_ledger_endpoint() -> dict:
+    return prize_ledger(engine.runtime_status())
+
+
 @app.get("/api/tool-contracts")
 def tool_contracts() -> dict:
     return {

hackathon_advisor/prize_ledger.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+MODEL_STACK = [
+    {
+        "role": "LLM brain",
+        "model": "openbmb/MiniCPM5-1B",
+        "params_b": 1.08,
+        "status": "optional runtime adapter",
+        "runtime": "transformers / GGUF-ready",
+    },
+    {
+        "role": "Retriever",
+        "model": "offline TF-IDF snapshot",
+        "params_b": 0.0,
+        "status": "deployed",
+        "runtime": "local sparse index",
+    },
+    {
+        "role": "Planned embedder",
+        "model": "google/embeddinggemma-300m",
+        "params_b": 0.30,
+        "status": "documented build path",
+        "runtime": "sentence-transformers / llama.cpp",
+    },
+    {
+        "role": "Voice bonus",
+        "model": "nvidia/nemotron-speech-streaming-en-0.6b",
+        "params_b": 0.60,
+        "status": "deferred bonus",
+        "runtime": "batch ASR",
+    },
+]
+
+
+BADGE_LEDGER = [
+    {
+        "name": "Off the Grid",
+        "status": "ready",
+        "evidence": "Runtime uses a checked-in snapshot and local search; no proprietary inference API.",
+    },
+    {
+        "name": "Off-Brand",
+        "status": "ready",
+        "evidence": "Custom gr.Server frontend renders the agent as The Unwritten Almanac.",
+    },
+    {
+        "name": "Sharing is Caring",
+        "status": "ready",
+        "evidence": "JSONL trace export and checked-in sample trace are published with the Space.",
+    },
+    {
+        "name": "Field Notes",
+        "status": "ready",
+        "evidence": "Field Notes markdown export is generated from exact session state.",
+    },
+    {
+        "name": "Tiny Titan",
+        "status": "eligible",
+        "evidence": "Documented stack stays under 4B parameters; largest model is MiniCPM5-1B.",
+    },
+    {
+        "name": "Well-Tuned",
+        "status": "planned",
+        "evidence": "Plan includes a MiniCPM5 LoRA path; adapter publication remains a separate build milestone.",
+    },
+    {
+        "name": "Llama Champion",
+        "status": "planned",
+        "evidence": "MiniCPM5 GGUF and EmbeddingGemma GGUF paths are documented; runtime does not depend on them yet.",
+    },
+]
+
+
+def prize_ledger(runtime: dict[str, Any]) -> dict[str, Any]:
+    total_params = round(sum(float(item["params_b"]) for item in MODEL_STACK), 2)
+    largest = max(MODEL_STACK, key=lambda item: float(item["params_b"]))
+    return {
+        "runtime": runtime,
+        "model_stack": MODEL_STACK,
+        "total_params_b": total_params,
+        "largest_model": {
+            "model": largest["model"],
+            "params_b": largest["params_b"],
+        },
+        "tiny_titan_limit_b": 4.0,
+        "tiny_titan_eligible": total_params <= 4.0 and float(largest["params_b"]) <= 4.0,
+        "badges": BADGE_LEDGER,
+    }

static/app.js

@@ -10,6 +10,7 @@ const whitespaceEl = document.querySelector("#whitespace");
 const ideasEl = document.querySelector("#ideas");
 const targetsEl = document.querySelector("#targets");
 const profileEl = document.querySelector("#profile");
+const prizeLedgerEl = document.querySelector("#prize-ledger");
 const woodMapEl = document.querySelector("#wood-map");
 const scoreEl = document.querySelector("#score");
 const planEl = document.querySelector("#plan");
@@ -145,6 +146,7 @@ async function bootstrap() {
   renderProvenance(data);
   renderTargets(session.targets);
   renderProfile(session.profile);
+  renderPrizeLedger(data.prize_ledger || null);
   renderRestoredSession(data);
   renderWhitespace(data.whitespace || []);
 }
@@ -266,6 +268,37 @@ function renderProfile(profile) {
   }
 }
 
+function renderPrizeLedger(ledger) {
+  prizeLedgerEl.innerHTML = "";
+  if (!ledger) {
+    prizeLedgerEl.innerHTML = `<div class="empty">No prize ledger loaded.</div>`;
+    return;
+  }
+  const readyBadges = (ledger.badges || []).filter((badge) => badge.status === "ready").length;
+  const badgeCount = (ledger.badges || []).length;
+  const header = document.createElement("div");
+  header.className = "ledger-summary";
+  header.innerHTML = `
+    <strong>${Number(ledger.total_params_b || 0).toFixed(2)}B params</strong>
+    <span>${ledger.tiny_titan_eligible ? "Tiny Titan eligible" : "Over Tiny Titan limit"}</span>
+    <span>${readyBadges}/${badgeCount} ready</span>
+    <span>${escapeHtml(ledger.runtime?.backend || "runtime")}</span>
+  `;
+  const badges = document.createElement("div");
+  badges.className = "badge-list";
+  for (const badge of (ledger.badges || []).slice(0, 7)) {
+    const item = document.createElement("div");
+    item.className = `badge-item ${badge.status || "planned"}`;
+    item.title = badge.evidence || badge.name;
+    item.innerHTML = `
+      <strong>${escapeHtml(badge.name)}</strong>
+      <span>${escapeHtml(badge.status)}</span>
+    `;
+    badges.append(item);
+  }
+  prizeLedgerEl.append(header, badges);
+}
+
 function handleEvent(event) {
   if (event.type === "start") {
     if (event.corrections?.length) {

static/index.html

@@ -61,6 +61,10 @@
                 <h2>Profile</h2>
                 <div id="profile" class="profile-grid"></div>
               </article>
+              <article class="wide-panel">
+                <h2>Prize Ledger</h2>
+                <div id="prize-ledger" class="prize-ledger"></div>
+              </article>
               <article>
                 <h2>Idea Board</h2>
                 <div id="ideas" class="idea-list"></div>

static/styles.css

@@ -302,7 +302,8 @@ button:disabled {
 .trace-list,
 .target-list,
 .profile-grid,
-.wood-map {
+.wood-map,
+.prize-ledger {
   display: grid;
   gap: 9px;
 }
@@ -426,6 +427,57 @@ button:disabled {
   box-shadow: 0 0 0 3px rgba(47, 122, 73, 0.13);
 }
 
+.ledger-summary {
+  display: grid;
+  grid-template-columns: repeat(4, minmax(0, 1fr));
+  gap: 8px;
+}
+
+.ledger-summary strong,
+.ledger-summary span,
+.badge-item {
+  min-width: 0;
+  border-left: 3px solid rgba(80, 47, 22, 0.48);
+  border-radius: 0 8px 8px 0;
+  background: rgba(255, 241, 196, 0.34);
+  padding: 8px 10px;
+  color: #2a170d;
+  font-size: 0.76rem;
+  line-height: 1.25;
+  font-weight: 900;
+}
+
+.badge-list {
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 7px;
+}
+
+.badge-item {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+}
+
+.badge-item.ready {
+  border-left-color: var(--leaf);
+}
+
+.badge-item.eligible {
+  border-left-color: var(--gold);
+}
+
+.badge-item.planned {
+  border-left-color: var(--muted-ink);
+}
+
+.badge-item span {
+  color: var(--muted-ink);
+  font-size: 0.68rem;
+  text-transform: uppercase;
+}
+
 .wood-map-field {
   position: relative;
   min-height: 138px;
@@ -526,6 +578,11 @@ button:disabled {
     grid-template-columns: 1fr;
   }
 
+  .ledger-summary,
+  .badge-list {
+    grid-template-columns: 1fr;
+  }
+
   .command-row {
     grid-template-columns: repeat(3, minmax(0, 1fr));
   }

tests/test_app.py

@@ -7,6 +7,7 @@ from app import (
     field_notes_artifact,
     health,
     index,
+    prize_ledger_endpoint,
     runtime,
     tool_contract_check,
     tool_contracts,
@@ -34,6 +35,7 @@ def test_bootstrap_exposes_index_metadata() -> None:
     assert payload["top_projects"]
     assert payload["default_targets"] == payload["target_options"][:3]
     assert "skills" in payload["profile_fields"]
+    assert payload["prize_ledger"]["tiny_titan_eligible"] is True
 
 
 def test_trace_artifact_endpoint_exports_jsonl() -> None:
@@ -94,3 +96,11 @@ def test_runtime_endpoint_reports_planner() -> None:
     assert payload["backend"] == "rules"
     assert payload["model_id"] == "deterministic-tool-router"
     assert payload["loaded"] is True
+
+
+def test_prize_ledger_endpoint_reports_submission_evidence() -> None:
+    payload = prize_ledger_endpoint()
+
+    assert payload["runtime"]["backend"] == "rules"
+    assert payload["tiny_titan_eligible"] is True
+    assert any(badge["name"] == "Sharing is Caring" for badge in payload["badges"])

tests/test_prize_ledger.py

@@ -0,0 +1,13 @@
+from hackathon_advisor.prize_ledger import prize_ledger
+
+
+def test_prize_ledger_tracks_param_budget_and_badges() -> None:
+    payload = prize_ledger({"backend": "rules", "model_id": "deterministic-tool-router"})
+
+    assert payload["runtime"]["backend"] == "rules"
+    assert payload["total_params_b"] <= payload["tiny_titan_limit_b"]
+    assert payload["tiny_titan_eligible"] is True
+    assert payload["largest_model"]["model"] == "openbmb/MiniCPM5-1B"
+    badges = {badge["name"]: badge["status"] for badge in payload["badges"]}
+    assert badges["Off the Grid"] == "ready"
+    assert badges["Well-Tuned"] == "planned"