fix: align space metadata

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

.gitattributes

@@ -1,35 +1,3 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Auto detect text files and perform LF normalization
+* text=auto
+static/assets/parchment.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,181 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor  
+#  Cursor is an AI-powered code editor.`.cursorignore` specifies files/directories to 
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore

DESIGN.md

@@ -0,0 +1,492 @@
+# Build Small Hackathon Advisor — Design & Implementation Notes
+
+> A **small-model agent** (text-first; voice is a later bonus) that investigates what other people have already built
+> for the [Build Small Hackathon](https://huggingface.co/build-small-hackathon) and brainstorms an original new design
+> *with you*. Output = streaming text + live visuals (no TTS). All models small, open-weight, run locally.
+>
+> The literal "advisor" is the **engine**; the user-facing experience is **The Unwritten Almanac** — Mothback, an
+> owl-moth archivist, keeps the Wood's book of fates and divines you a still-unwritten project page (ink **bleeds +
+> cites real Spaces** if you overlap, **blooms gold** if it's new). This project is itself a Build Small submission
+> (hack window 2026-06-05 → 2026-06-15).
+
+---
+
+## 1. Locked decisions & review corrections (2026-06-07)
+
+A multi-agent adversarial review (5 dimensions, web-verified) set the direction below. **This section is the
+authoritative decision log; the rest of the doc is written to be consistent with it.**
+
+**Locked decisions (Jacob):**
+1. **Concept = The Unwritten Almanac** (chosen 2026-06-07 from a 12-concept brainstorm). Mothback the owl-moth
+   archivist divines a fate-page; ink **bleeds and cites the real Spaces** you overlap (page 47, page 112…), or
+   **blooms gold + sprouts a leaf** when it's unwritten. Engine unchanged underneath (crawl → whitespace/originality →
+   score). The dry "advisor" stays under the hood. Full spec + de-risking grafts in §2.
+2. **Text-first.** Ship a fully demoable text-input (type / button) vertical slice first. Voice (push-to-talk → batch
+   ASR) is a later BONUS layer. Real-time streaming + in-browser turn detection are **deferred** (see §13 appendix).
+3. **Add a 🎯 Well-Tuned fine-tune** — a small LoRA (MiniCPM5 advisor persona / tool-calling), trained on Modal,
+   published to the Hub → 6/6 badges → strong shot at 🎖️ Bonus Quest Champion ($2,000).
+4. **ASR = Nemotron primary (batch) + Parakeet fallback.** `nvidia/nemotron-speech-streaming-en-0.6b` used in BATCH
+   per-turn mode (`transcribe([wav])` — simple API). Day-1 spike confirms it builds + runs in one `@spaces.GPU` call;
+   if the ZeroGPU *environment* fights it, drop in `nvidia/parakeet-tdt-0.6b-v3` (native transformers, same batch API).
+
+**Verified corrections:**
+- **Drop SGLang.** It needs a persistent GPU process → incompatible with ZeroGPU (same root cause as vLLM). Run
+  MiniCPM5 via plain `transformers` inside `@spaces.GPU` and parse its XML tool calls in our own code.
+- **gr.Server SSE generator streaming IS shipped** (the launch blog only deferred the *explanation*). On ZeroGPU the
+  browser MUST call endpoints via **`@gradio/client`** (`client.predict`/`submit`) — it forwards the HF iframe auth
+  headers for GPU quota; a raw `fetch`/`EventSource` POST silently breaks quota.
+- **OpenAI Track has NO model requirement** ("OpenAI's own podium across all submissions") → auto-entered; a free
+  lottery ticket. Do NOT add gpt-oss (breaks Tiny Titan, dilutes the small-model thesis). Deliberate non-target.
+- **Badges = 6 total** (Tiny Titan is a $1.5k *special award*, not a badge). Decision #3 takes us from 5/6 → 6/6.
+- **Tiny Titan** = "best ≤4B model"; our largest single model is MiniCPM5 (1.08B), total stack ~1.9B → eligible.
+
+**New build requirements surfaced by the review (designed into the sections below):**
+- **Jargon alias layer (§7):** a 0.6B ASR mistranscribes our own vocab (Nemotron, MiniCPM5, EmbeddingGemma, ZeroGPU…).
+  Deterministic code-side fuzzy/alias map over our small CLOSED vocab, applied before any tool call and before display.
+  Surface "heard: neutron → Nemotron" as a delightful trust moment. (Active once voice is added.)
+- **Tool-call degradation ladder (§8):** the 1B brain WILL emit broken tool calls (MiniCPM5-1B has a documented
+  "broken tool calling" report). Wrap parse in try/except, retry once at low temp, validate name+args vs JSON-Schema in
+  code (reject-and-repair), canned lines for empty results, a token **watchdog** that shows "trying again" instead of
+  dead air (the screen is the only feedback channel — no TTS).
+- **Latency / optimistic UI (§9/§11):** ZeroGPU cold start + 1B generation = seconds of potential dead air. Optimistic
+  UI on submit, pre-animate the project wall, set a latency budget. (The torch.compile cold-start penalty does NOT
+  apply — we don't use it.)
+
+**Day-1 go/no-go spikes (before any feature work):**
+- Trivial `@spaces.GPU` hello-cuda build GREEN on torch 2.8+, deps pinned, heavy deps added one at a time.
+- `gr.Server` minimal: static `index.html` + one `@app.api()` generator streaming tokens, called via `@gradio/client`,
+  on the real ZeroGPU Space.
+- Nemotron `nemo_toolkit[asr]` install + one batch `transcribe()` inside `@spaces.GPU` (decision #4; else Parakeet).
+
+---
+
+## 2. Concept — The Unwritten Almanac (text-first)
+
+The engine, regardless of skin:
+
+1. **Investigate** the `build-small-hackathon` HF org — what Spaces exist, which models, what's saturated, and where
+   the **whitespace** is — using a local EmbeddingGemma index.
+2. **Brainstorm** with the user: propose ideas, **score** them against a fixed rubric (originality vs. existing
+   projects, delight, AI-necessity, feasibility, param budget, prize-fit), and maintain an **idea board**.
+3. **Respond** as streaming text + live visuals in a custom `gr.Server` frontend (no TTS — the visual is the "voice").
+
+**The skin (chosen): The Unwritten Almanac.** **Mothback**, a dusty owl-moth archivist, keeps the Wood's *book of
+fates*. Every project already built in the org is an inked page; she divines you a destined entry on a still-blank page,
+the ink writing itself live.
+
+**The two-beat wow (this IS the engine, rendered):**
+- You type one line about yourself / your idea. Inked pages riffle past (each = a real crawled Space).
+- **Bleed:** if your idea overlaps existing work, the ink **seeps blood-red** and cites the exact real Spaces — "the
+  Wood already wrote this, on page 47 and page 112" (= `get_project` overlap on the top retrieval hits). The burn is
+  **factual**, so it can't fall flat the way a 1B's invented joke can.
+- **Bloom:** you say "write bolder"; the next entry flows **gold**, a green leaf sprouts — "this page has never been
+  inked" (= a `find_whitespace` gold candidate).
+- A **wax seal** presses in, lighting five quadrants as the idea qualifies (= `score_idea`: Originality, Delight,
+  AI-Necessity, Feasibility, Prize-Fit).
+
+**Engine ↔ skin mapping:** `search_projects`/`get_project` overlap → the bleed + citations; `find_whitespace` → the
+blank/gold pages; `score_idea` → the wax-seal quadrants; `save_idea` → the written fate-page; agent persona =
+**Mothback** (Layer A system prompt + the 🎯 Well-Tuned LoRA = her voice).
+
+**Shareable artifact (Community Choice):** the page exports as a PNG that looks **torn from an ancient grimoire** —
+aged parchment, a coined fate-name as title, the self-written prophecy, the five-quadrant seal, and a verdict stamp
+(**"UNWRITTEN · 0 echoes"** vs **"ECHO ×3"**). Built-in caption: "Mothback inked my fate page for #BuildSmall —
+UNWRITTEN." People compile draws into a "chapter" and dare friends to get a page that doesn't bleed.
+
+**Grafted de-risking (from runner-up concepts):**
+- **Tone = dry-but-benevolent** (Roastleaf's whiplash): the bleed-citation gently stings, the gold-bloom is sincerely
+  delighted; the burn is true-by-construction (real cited Spaces).
+- **Templated structure (key risk-killer):** bank entry/roast templates (citation + dry verdict + redemptive branch);
+  the 1B only fills in real Space titles + the idea — **never improvises whole comedy**.
+- **Latin-binomial fate-names** (e.g. "Ludus Vocalis Infantium") via templated scaffolds — built-in wit, backstops a
+  1B that might produce corny names.
+- **"You vs the Wood" margin glyph:** a tiny cluster-dot thumbnail on the page showing your gold page among the inked
+  crowd — cheap SVG, visual PROOF the gap is real.
+- **Thin-org mitigation (load-bearing):** precompute whitespace clusters at Modal build-time and pin several DISTINCT
+  blank-page candidates so "write bolder" always lands on a real, varied gap (the org may be only ~30–60 Spaces). Tune
+  the echo threshold toward *more frequent bleed* so the demo always has its "low" before the "wow".
+
+**Defaults (revisit if time):** single-page artifact first (chapter compiler later); page-numbers visible, real titles
+on hover (keep the burn aimed at the idea, not a named builder); seal animation = safe typewriter + static-stamp floor
+first, bespoke ink-reveal last (graceful degradation); voice input stays text-first, a post-MVP flourish.
+
+Input is **text-first**; the experience is fully delightful with typed input alone.
+
+AI is genuinely **load-bearing**: embeddings power the whitespace/originality analysis and the LLM drives the
+investigate → ideate → score loop — the experience collapses without the models (supports 🤖 Best Agent + TTW
+"AI necessity").
+
+---
+
+## 3. Model stack (confirmed exact repo IDs)
+
+| Role | Model | Params | Runtime | License | Prize hook |
+|---|---|---|---|---|---|
+| STT (batch, voice-later) | **`nvidia/nemotron-speech-streaming-en-0.6b`** (used in batch) | 0.6B | NeMo, GPU+CUDA | NVIDIA Open Model (commercial OK) | 🟩 NVIDIA Nemotron Quest |
+| ↳ fallback | `nvidia/parakeet-tdt-0.6b-v3` | 0.6B | **transformers** (no NeMo) | CC-BY-4.0 | 🟩 (Quest brand — verify, §5.1) |
+| LLM brain | **`openbmb/MiniCPM5-1B`** ("OpenCPM5") | 1.08B | **transformers** (self-parse XML) / llama.cpp | **Apache-2.0** | 🏮 OpenBMB |
+| Turn detection (voice-later) | **`pipecat-ai/smart-turn-v3`** | ~8M | ONNX Runtime (browser) | BSD-2 | (natural voice UX) |
+| Embedder | **`google/embeddinggemma-300m`** | ~300M | sentence-transformers / llama.cpp | Gemma (gated) | 🔌 Off the Grid · 🦙 Llama Champion |
+| Fine-tune (to add) | LoRA on MiniCPM5 → published to Hub | — | PEFT / Modal | — | 🎯 Well-Tuned |
+
+**Total ≈ 1.9B params → ≤4B → 🐜 Tiny Titan eligible.** All open-weight, all runnable locally → 🔌 Off the Grid.
+
+> Naming: "OpenCPM5 1B" = `openbmb/MiniCPM5-1B` (MiniCPM 5.0, ~May 2026). "EmbeddingGemma 270M" =
+> `google/embeddinggemma-300m` (308M total; 270M = non-embedding transformer params). **SGLang dropped** (ZeroGPU
+> incompatible). STT used in **batch per-turn** mode, not streaming.
+
+---
+
+## 4. Deployment & architecture (single path)
+
+With **text-first + batch ASR**, the old "streaming ASR vs ZeroGPU" Config A/B tension dissolves — there is one path:
+
+- **ZeroGPU Gradio-SDK Space** (free). GPU is attached only inside `@spaces.GPU` calls (default 60s, max ~120s,
+  RTX Pro 6000 Blackwell, `large`=48 GB). Per-turn inference fits this model exactly.
+- **Text-first runtime loop:** user types → `gr.Server` `@app.api()` endpoint (called via `@gradio/client`) → one
+  `@spaces.GPU` call runs MiniCPM5 (tool loop, in `transformers`) → SSE-stream text tokens + drive live visuals.
+- **Voice (later bonus):** push-to-talk records an utterance → POST blob → the same `@spaces.GPU` call also runs
+  Nemotron/Parakeet ASR (batch) before the brain. No persistent stream, no WebRTC, **no TURN server**.
+- **Modal (build-time only):** crawl the org + build the EmbeddingGemma index offline; the Space ships with the index
+  artifact. Runtime never calls Modal → 🔌 Off the Grid holds (see §10).
+
+> Off the Grid = no proprietary cloud inference APIs. Open weights on an HF GPU Space / local box / Modal all qualify.
+
+**Deferred (voice-later appendix, §13):** real-time streaming ASR (`conformer_stream_step`), in-browser Smart Turn +
+Silero VAD turn detection, FastRTC. Documented but not on the text-first critical path.
+
+---
+
+## 5. Per-model implementation notes
+
+### 5.1 ASR — `nvidia/nemotron-speech-streaming-en-0.6b` (batch) · fallback `parakeet-tdt-0.6b-v3`
+
+- **Primary, batch usage (simple):**
+  ```python
+  import nemo.collections.asr as nemo_asr
+  asr = nemo_asr.models.ASRModel.from_pretrained("nvidia/nemotron-speech-streaming-en-0.6b")
+  text = asr.transcribe(["utterance.wav"])      # 16 kHz mono WAV in; punctuated EN text out
+  ```
+  Install (heavy; CUDA): `apt-get install -y libsndfile1 ffmpeg` + `pip install Cython packaging` +
+  `pip install "git+https://github.com/NVIDIA/NeMo.git@main#egg=nemo_toolkit[asr]"` (NeMo ≥ 25.11).
+  **Day-1 spike** must confirm this installs + runs in one `@spaces.GPU` call (load with `map_location="cpu"` at module
+  level, `.to("cuda")` inside the decorator; watch NeMo CUDA-at-import + the RNNT CUDA-graphs path).
+- **Fallback (if the ZeroGPU env fights NeMo):** `nvidia/parakeet-tdt-0.6b-v3` has **native transformers** support —
+  ```python
+  from transformers import pipeline
+  asr = pipeline("automatic-speech-recognition", model="nvidia/parakeet-tdt-0.6b-v3")
+  text = asr("utterance.wav")
+  ```
+  Same 0.6B, CC-BY-4.0, 25 languages, one clean `@spaces.GPU` batch call, no NeMo/git build.
+- **Quest caveat:** the award says "standout **Nemotron** builds." Parakeet is the encoder *inside* the Nemotron-Speech
+  family but is branded "Parakeet" → if we ship Parakeet, **confirm Quest eligibility with organizers**, or keep
+  Nemotron documented as the Quest narrative. Hosted NVIDIA NIM API would break Off the Grid — never in the badge demo.
+
+### 5.2 MiniCPM5-1B brain — `openbmb/MiniCPM5-1B` (transformers, self-parsed XML)
+
+- Context 128K, bilingual (EN/ZH), Apache-2.0. `enable_thinking=False`, `temperature=0.7, top_p=0.95` for fast tool calls.
+  ```python
+  from transformers import AutoModelForCausalLM, AutoTokenizer
+  tok = AutoTokenizer.from_pretrained("openbmb/MiniCPM5-1B")
+  model = AutoModelForCausalLM.from_pretrained("openbmb/MiniCPM5-1B", torch_dtype="auto", device_map="auto")
+  inputs = tok.apply_chat_template(messages, tools=TOOLS, add_generation_prompt=True, enable_thinking=False,
+                                   tokenize=True, return_dict=True, return_tensors="pt").to(model.device)
+  ```
+- **Tool calling:** pass JSON-Schema tools via the chat template `tools=` arg; the model emits **XML**
+  `<function name="get_weather">{"city":"New York"}</function>`. **Parse this ourselves** (SGLang dropped). Wrap parse
+  in try/except and validate against the schema — see the degradation ladder (§8).
+- **Local / CPU & llama.cpp (Off the Grid · Llama Champion):** `openbmb/MiniCPM5-1B-GGUF:Q4_K_M` (688 MB) via llama.cpp
+  or Ollama (CPU-viable). fp16 ≈ 3–4 GB VRAM. `openbmb/MiniCPM5-1B-MLX` for Apple Silicon. (llama.cpp MiniCPM5
+  tool-calling is a pending PR — verify before relying on it for the badge runtime.)
+- **1B discipline:** small tool schemas, few params each, clear descriptions, low temp, single-hop tool calls.
+
+### 5.3 Smart Turn v3 — `pipecat-ai/smart-turn-v3` (voice-later)
+
+- Whisper-tiny encoder + linear head, ~8M params, ONNX (`smart-turn-v3.1.onnx`), 8 MB int8 / 32 MB fp32, BSD-2.
+- Input: 16 kHz mono PCM float32, ≤8 s (front-padded). Output: sigmoid prob; **>0.5 = "user finished."** ~12 ms CPU.
+  ```python
+  import numpy as np, onnxruntime as ort
+  from transformers import WhisperFeatureExtractor
+  fe = WhisperFeatureExtractor(chunk_length=8); sess = ort.InferenceSession("smart-turn-v3.1.onnx")
+  def turn_complete(audio):
+      x = fe(audio, sampling_rate=16000, return_tensors="np", padding="max_length",
+             max_length=8*16000, truncation=True, do_normalize=True).input_features.astype("float32")
+      return sess.run(None, {"input_features": x})[0][0].item() > 0.5
+  ```
+- **Browser path (voice-later):** runs via ONNX Runtime Web / Transformers.js. The `.onnx` needs Whisper **log-mel
+  input_features** (128 mel bins, 8 s, NOT whisper-tiny's 80-mel) — no upstream JS example exists, so a small POC is
+  required before relying on it; fallbacks: port pipecat's numpy-only mel extractor to JS, or do feature-extraction +
+  onnx **server-side** per posted blob. Pair with `@ricky0123/vad-web` (Silero) for the speech start/stop gate.
+
+### 5.4 EmbeddingGemma — `google/embeddinggemma-300m`
+
+- **Gated** — accept Gemma terms + `HF_TOKEN`. 2048-token ctx, 100+ langs, mean pooling, **fp32/bf16 only (no fp16)**.
+  ```python
+  from sentence_transformers import SentenceTransformer
+  m = SentenceTransformer("google/embeddinggemma-300m", truncate_dim=256)   # Matryoshka 768→512→256→128
+  q = m.encode_query("voice game for kids")          # prefix: "task: search result | query: "
+  d = m.encode_document(project_descriptions)        # prefix: "title: none | text: "
+  ```
+- **Exact prefixes matter:** query → `task: search result | query: `; document → `title: {title} | text: `; whitespace
+  clustering → prompt `Clustering` (`task: clustering | query: `). 256-dim is a good speed/quality tradeoff.
+- Footprint ~1.2 GB fp32 / ~0.6 GB bf16; QAT Q4_0/Q8_0 + ONNX (`onnx-community/embeddinggemma-300m-ONNX`).
+
+### 5.5 llama.cpp support (🦙 Llama Champion)
+
+The two **language** models run on llama.cpp; the two **audio** models use their own runtimes. Running the core LLM on
+llama.cpp earns the badge.
+
+| Model | llama.cpp? | Runtime | Notes |
+|---|---|---|---|
+| `openbmb/MiniCPM5-1B` | ✅ | llama.cpp / Ollama | `openbmb/MiniCPM5-1B-GGUF` (Q4_K_M 688 MB); standard Llama arch |
+| `google/embeddinggemma-300m` | ✅ | `llama-embedding` | `gemma-embedding` arch (build ≥ b6384); `ggml-org/embeddinggemma-300M-GGUF` |
+| ASR (Nemotron / Parakeet) | ❌ | NeMo / transformers | FastConformer-RNNT |
+| `pipecat-ai/smart-turn-v3` | ❌ | ONNX Runtime | Whisper encoder + classifier head |
+
+Verify-before-ship: EmbeddingGemma GGUF quant accuracy drifts ([#19040](https://github.com/ggml-org/llama.cpp/issues/19040))
+→ prefer Q8_0 or keep the embedder on sentence-transformers; MiniCPM5 tool-calling via llama.cpp is a pending PR.
+
+---
+
+## 6. Agent context design (built for a 1B brain)
+
+Core principle: **the 1B model is a router + arg-filler. All heavy work (crawl, summarize, score, rank, dedup) lives in
+code.** Keep live context to ~800–1200 tokens of *curated* view, never raw data.
+
+- **Layer A — System (static, ~250 tok):** identity/character; hackathon hard rules (≤32B, Gradio Space, demo video) so
+  it self-filters infeasible ideas; targeted prizes (biases ideation); reply style (short, one question at a time);
+  explicit tool-use instructions + the canonical jargon vocabulary (so it can self-correct, §7).
+- **Layer B — Session state (re-rendered each turn by code, ~300 tok):** user profile; locked decisions (track, side
+  quests, models); **idea board** (2–3 candidates, one line + scores); compact "projects already seen" summary.
+- **Layer C — Ephemeral (~300 tok):** last 2–3 turns; the most recent tool result as a **refined card** (not raw JSON).
+
+---
+
+## 7. Agent tool design
+
+Few tools, few params each, short descriptions (1B-friendly). Heavy logic in code.
+
+**Jargon alias layer (input normalization).** Before any tool call and before display, run ASR/user text through a
+deterministic fuzzy/alias map over our small CLOSED vocab (model names, prize names, side quests) — e.g. RapidFuzz
+`token_set_ratio` / double-metaphone — mapping "neutron"/"nemo tron" → Nemotron, "mini cpm" → MiniCPM5, "zero gpu" →
+ZeroGPU. Surface the correction ("heard: neutron → Nemotron") as a trust-building, slightly delightful moment.
+
+**Research — investigate existing projects (the core value).** Data = `build-small-hackathon` org Spaces, pre-crawled
+into a local snapshot + EmbeddingGemma index (keeps Off the Grid at runtime).
+
+| Tool | Signature | Returns (refined) | Heavy work |
+|---|---|---|---|
+| `list_projects` | `(track?, sort?)` | top-N project cards | HF Hub API + summarize |
+| `search_projects` | `(query)` | top 5 cards | EmbeddingGemma retrieval |
+| `get_project` | `(id)` | card + overlap-vs-board verdict | code computes overlap |
+| `find_whitespace` | `()` | under-explored niches | cluster the index, find gaps |
+
+`find_whitespace` is the originality engine (TTW judges originality) — it names where nobody has built yet.
+
+**Ideation / state.**
+
+| Tool | Signature | Purpose |
+|---|---|---|
+| `save_idea` | `(title, pitch, track, models[], side_quests[])` | add/update a candidate on the idea board |
+| `score_idea` | `(id)` | fixed (hardcoded) rubric → scores + gaps; the 1B only triggers + verbalizes |
+| `compare_ideas` | `()` | rank the board, articulate tradeoffs |
+| `make_plan` | `(id)` | build plan + side quests it picks up "for free" |
+| `update_profile` | `(field, value)` | record skills/time/prefs → Layer B |
+| `set_target` | `(side_quests[])` | change targeted prizes → updates Layer A bias |
+
+---
+
+## 8. Agent loop (single-hop + degradation ladder)
+
+```
+on user input (text; or voice → batch ASR → text):
+  normalize via jargon alias layer
+  ctx = LayerA + render_state(LayerB) + last_turns + last_tool_card
+  out = MiniCPM5(ctx, tools=TOOLS, enable_thinking=False, temp=0.7)   # → tool_call | reply
+  try: parse XML tool call
+  except / invalid name|args (vs JSON-Schema):                         # degradation ladder
+      retry once (temp≈0.3, "emit ONLY one valid tool call")
+      still bad → run a safe default tool (find_whitespace) so the screen never freezes
+  if tool_call: card = run_tool(out); reply = MiniCPM5(ctx + card)     # single follow-up, no long ReAct
+  empty/zero result → canned advisor line (never say nothing)
+  stream reply tokens → custom UI   |   token watchdog: no token in N s → "trying again" visual (not dead air)
+  update_state(LayerB)
+```
+
+**Max one tool-call then reply.** A 1B can't sustain multi-step ReAct; wrap multi-step flows (`search → get_project →
+score`) into one *code* "research" action the model calls once. The degradation ladder is a **first-class UX surface**
+(§11), not an error branch — the screen is the only feedback channel (no TTS).
+
+---
+
+## 9. ZeroGPU deployment notes
+
+- `import spaces; @spaces.GPU(duration=…)`. GPU only inside decorated fns; **Gradio-SDK Space only** (no Docker ZeroGPU).
+- Load models at **module level**, `.to('cuda')` once (emulated until first real GPU call); real compute inside the
+  decorator. torch 2.8+; **no `torch.compile`** (use AOT). Quota PRO ~40 min/day → never idle-hold the GPU.
+- **Frontend → backend via `@gradio/client`** (`client.predict`/`submit`), NOT raw fetch — it forwards the HF iframe
+  auth headers ZeroGPU needs for quota. Generator `@app.api()` endpoints stream tokens over SSE.
+- All four models fit in `large` (48 GB). Keep each `@spaces.GPU` call short for queue priority.
+
+---
+
+## 10. Modal — offline pipeline (build-time only → preserves Off the Grid)
+
+Modal = build-time; runtime never calls it. This is how we claim **both** 🟢 Modal **and** 🔌 Off the Grid. Modal also
+trains the 🎯 Well-Tuned LoRA. Crawl org Spaces → embed with EmbeddingGemma → build vector index → commit to a Volume;
+the Space ships the index artifact and searches locally.
+
+```python
+import modal
+app = modal.App("bsh-advisor-index")
+CACHE = "/cache"
+hf_vol    = modal.Volume.from_name("hf-cache", create_if_missing=True)
+index_vol = modal.Volume.from_name("bsh-index", create_if_missing=True)
+image = (modal.Image.debian_slim("3.12")
+         .pip_install("sentence-transformers", "huggingface_hub", "requests", "numpy", "faiss-cpu")
+         .env({"HF_HUB_ENABLE_HF_TRANSFER": "1", "HF_HOME": CACHE}))
+
+@app.function(image=image)                                   # CPU: crawl one Space
+def crawl(space_id):
+    import requests
+    m = requests.get(f"https://huggingface.co/api/spaces/{space_id}").json()
+    return {"id": space_id, "text": m.get("cardData", {}).get("short_description", "")}
+
+@app.cls(image=image, gpu="T4", volumes={CACHE: hf_vol}, scaledown_window=120)
+class Embedder:
+    @modal.enter()
+    def load(self):
+        from sentence_transformers import SentenceTransformer
+        self.m = SentenceTransformer("google/embeddinggemma-300m", cache_folder=CACHE, truncate_dim=256)
+    @modal.method()
+    def embed(self, docs): return self.m.encode_document(docs).tolist()
+
+@app.local_entrypoint()
+def main(org="build-small-hackathon"):
+    import requests
+    ids  = [s["id"] for s in requests.get(f"https://huggingface.co/api/spaces?author={org}").json()]
+    docs = [d for d in crawl.map(ids) if d["text"]]
+    vecs = Embedder().embed.remote([d["text"] for d in docs])
+    # build FAISS index → write to index_vol → index_vol.commit()
+```
+
+- T4/CPU is plenty (pennies; $30/mo free credits). `gpu="T4"`/`"L4"` (note `"A10"`, not `"A10G"`). `volume.commit()`
+  after writing. `HF_TOKEN` via `modal.Secret` for the gated EmbeddingGemma download. Crawl on CPU, embed on GPU.
+
+---
+
+## 11. Frontend — `gr.Server` custom UI (🎨 Off-Brand)
+
+No TTS → the **visual output is the agent's "voice"**; it must carry the delight (this is what earns Off-Brand, and the
+TTW polish + Best Demo score). The visual world is **The Unwritten Almanac** (§2): a candlelit tree-hollow with a heavy
+open grimoire as the hero component.
+
+- `gradio.Server` is a FastAPI subclass keeping Gradio's queue/SSE/ZeroGPU/`gradio_client` engine while serving **your
+  own frontend**. `@app.api(name=...)` fns are queued + client-callable + ZeroGPU-aware; plain `@app.post()` are not.
+  ```python
+  from gradio import Server
+  from fastapi.responses import HTMLResponse
+  app = Server()
+
+  @app.api(name="agent_turn", concurrency_limit=2)
+  async def agent_turn(message: str):
+      for token in run_agent_stream(message):   # generator → SSE
+          yield token
+
+  @app.get("/", response_class=HTMLResponse)     # custom UI replaces Gradio's default page
+  async def home(): return open("index.html").read()
+  app.launch()
+  ```
+- Frontend calls via `@gradio/client`: `client.predict("/agent_turn", { message })` (NOT raw fetch — ZeroGPU auth).
+- **UI surfaces (the grimoire is the canvas):** streaming reply = ink writing itself (typewriter on already-streaming
+  tokens); `search_projects`/overlap → **bleed** animation + page-number citations (real titles on hover);
+  `find_whitespace` → **gold bloom** + sprouting leaf + a one-shaft light-mask ("the page chooses you");
+  `score_idea` → **wax-seal** five-quadrant stamp; the riffling inked pages (fast page-flip of real Spaces) double as
+  the project-wall; export = the torn-grimoire PNG artifact (§2). Jargon-correction toasts (§7) read as Mothback's
+  margin notes; optimistic-UI loading + watchdog states (§8) are her "the page is choosing its words…". Cheap SFX:
+  page-flip, quill scratch, wax-seal thunk.
+- **Build the animation floor first:** safe typewriter + static stamp ships first (graceful degradation — the judges
+  credited this); upgrade the ink-bleed / gold-bloom / seal-press last.
+- **Fallback:** the backend (`tools.py`/`agent.py`) is UI-agnostic — if gr.Server misbehaves, fall back to
+  `gr.Blocks` + `gr.HTML`, losing only the $1500 Off-Brand badge, never the submission.
+
+---
+
+## 12. Prize mapping
+
+| Target | How it's earned |
+|---|---|
+| 🍄 Thousand Token Wood | **The Unwritten Almanac** (§2) — the bleed-citation wow IS the engine rendered; AI load-bearing; original |
+| 🐜 Tiny Titan (special, $1.5k) | total ~1.9B, every model ≤4B; largest single = MiniCPM5 1.08B |
+| 🔌 Off the Grid (badge) | all open weights run locally; offline index; no cloud inference at runtime |
+| 🎯 Well-Tuned (badge) | published LoRA fine-tune of MiniCPM5 on the Hub (§10) → **6/6 badges** |
+| 🎨 Off-Brand (badge + $1.5k) | `gr.Server` custom UI is the agent's output surface |
+| 🏮 OpenBMB ($10k) | brain = MiniCPM5-1B ("OpenBMB pick") |
+| 🟩 NVIDIA Quest (2× RTX 5080) | ASR = Nemotron (verify if Parakeet qualifies, §5.1) |
+| 🦙 Llama Champion (badge) | MiniCPM5 + EmbeddingGemma run through llama.cpp (§5.5) |
+| 📡 Sharing is Caring (badge) | publish the agent's tool-call trace to the Hub |
+| 📓 Field Notes (badge) | this DESIGN.md → a build blog post |
+| 🎖️ Bonus Quest Champion ($2k) | 6/6 badges (needs the Well-Tuned fine-tune) |
+| 🤖 Best Agent ($1k) | real multi-tool loop: investigate → ideate → score → plan |
+| 🟢 Modal ($20k credits) | offline crawl+embed + LoRA training on Modal (build-time, separated from runtime) |
+| 🎬 Best Demo ($1k) | the mandatory demo video, made to sing (shared artifact + wow beat) |
+| 🌀 OpenAI ($10k) | auto-entered ("across all submissions"); free lottery ticket, not a target |
+| ❤️ Community Choice ($2k) | shareable tweetable artifact from the experience |
+
+**6 badges** = Off the Grid, Well-Tuned, Off-Brand, Llama Champion, Sharing is Caring, Field Notes. Awards stack across
+categories. Single-winner awards (Tiny Titan, Best Agent, Off-Brand, Best Demo) are eligibility ≠ win — the shared
+lever is §11 custom-UI polish.
+
+---
+
+## 13. Risks / open items
+
+1. **Day-1 spikes are go/no-go** (§1): ZeroGPU hello-cuda build; gr.Server `@gradio/client` SSE streaming; Nemotron
+   batch in `@spaces.GPU` (else Parakeet). Do these before feature work.
+2. **EmbeddingGemma is gated** — accept Gemma terms + `HF_TOKEN` before any crawl/build.
+3. **MiniCPM5 tool-call reliability at 1B** — covered by the degradation ladder (§8); validate name+args in code.
+4. **NVIDIA Quest brand** — Parakeet is not "Nemotron"-branded; confirm eligibility with organizers or keep Nemotron
+   primary (§5.1).
+5. **Concept skin** — **chosen: The Unwritten Almanac** (§2). Make-or-break is the bleed/bloom hero animation; build the
+   safe typewriter + static-stamp floor first (graceful degradation), upgrade ink last. Watch the thin-org echo
+   threshold + the dry-but-benevolent tone (real cited Spaces, never punch at a named builder).
+6. **Param-budget claim** — document the 1.9B total in the README/Space card for Tiny Titan judging.
+
+---
+
+## 14. Build order
+
+**Text-first vertical slice first; voice as a bonus layer.** Always keep a demoable artifact.
+
+0. **Day-1 spikes** (§1) — get the three go/no-go builds green.
+1. **`crawler.py` + Modal index** — crawl the org, embed with EmbeddingGemma, build the local index. *You immediately
+   see what everyone's building and where the whitespace is.*
+2. **`tools.py`** — research + ideation tools + the hardcoded `score_idea` rubric + the jargon alias layer, over the index.
+3. **`agent.py`** — 3-layer context + single-hop loop + degradation ladder, MiniCPM5 via `transformers` (self-parsed XML).
+4. **`app.py`** — `gr.Server` custom frontend (idea board, project/whitespace wall, streaming text), called via
+   `@gradio/client`; concept skin applied.
+5. **Well-Tuned LoRA** — small fine-tune on Modal → publish to Hub (→ 6/6 badges).
+6. **Polish + submission** — demo video + social post (Best Demo / Community Choice), publish agent trace (📡),
+   write up Field Notes (📓).
+
+**Voice bonus (only if time):** push-to-talk record → batch ASR (Nemotron/Parakeet) in the existing `@spaces.GPU` call.
+**Deferred:** real-time streaming ASR, in-browser Smart Turn + Silero VAD, FastRTC + TURN. (Original streaming design is
+preserved in git history if revisited.)
+
+---
+
+## 15. Sources
+
+**Models:** [nemotron-speech-streaming-en-0.6b](https://huggingface.co/nvidia/nemotron-speech-streaming-en-0.6b) ·
+[parakeet-tdt-0.6b-v3](https://huggingface.co/nvidia/parakeet-tdt-0.6b-v3) ·
+[parakeet transformers doc](https://huggingface.co/docs/transformers/en/model_doc/parakeet) ·
+[MiniCPM5-1B](https://huggingface.co/openbmb/MiniCPM5-1B) · [MiniCPM5-1B-GGUF](https://huggingface.co/openbmb/MiniCPM5-1B-GGUF) ·
+[smart-turn-v3](https://huggingface.co/pipecat-ai/smart-turn-v3) · [embeddinggemma-300m](https://huggingface.co/google/embeddinggemma-300m)
+
+**Platforms:** [ZeroGPU docs](https://huggingface.co/docs/hub/spaces-zerogpu) ·
+[Introducing gradio.Server](https://huggingface.co/blog/introducing-gradio-server) · [Gradio Server Mode guide](https://www.gradio.app/guides/server-mode) ·
+[Modal GPU](https://modal.com/docs/guide/gpu) · [Modal model weights](https://modal.com/docs/guide/model-weights) · [Modal pricing](https://modal.com/pricing) ·
+[Build Small Hackathon](https://huggingface.co/build-small-hackathon)
+
+*Verify-before-ship: Nemotron-in-ZeroGPU (Day-1 spike); MiniCPM5 license on the live card; NVIDIA Quest eligibility for
+Parakeet; Smart Turn in-browser feature extraction (voice-later); llama.cpp MiniCPM5 tool-calling (pending PR).*

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 JacobLinCool
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,13 +1,62 @@
 ---
 title: Hackathon Advisor
-emoji: 🚀
-colorFrom: red
-colorTo: yellow
+emoji: "📜"
+colorFrom: yellow
+colorTo: green
 sdk: gradio
 sdk_version: 6.16.0
-python_version: '3.13'
+python_version: "3.11"
 app_file: app.py
-pinned: false
+pinned: true
+license: mit
+short_description: Originality advisor for Build Small.
+tags:
+  - gradio
+  - build-small-hackathon
+  - small-models
+  - agent
+  - originality
+  - off-the-grid
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Hackathon Advisor
+
+**Hackathon Advisor** is a text-first project advisor for the Build Small Hackathon. The user-facing experience is
+**The Unwritten Almanac**: Mothback, an archivist of unwritten project pages, compares your idea against real Spaces in
+the `build-small-hackathon` organization, finds under-explored territory, scores the idea, and drafts a practical build
+plan.
+
+The current milestone is a deployable, deterministic vertical slice:
+
+- Local snapshot of public `build-small-hackathon` Spaces.
+- Offline search over project titles, tags, models, and descriptions.
+- Jargon correction for hackathon/model terms.
+- One-turn advisor loop with overlap citations, whitespace suggestions, scoring, and plans.
+- Custom `gradio.Server` frontend with streaming API events.
+
+See [DESIGN.md](DESIGN.md) for the full product and model plan.
+
+## Run Locally
+
+```bash
+python3.11 -m venv .venv
+. .venv/bin/activate
+pip install -r requirements.txt
+python app.py
+```
+
+Then open <http://127.0.0.1:7860>.
+
+## Refresh The Project Snapshot
+
+```bash
+python scripts/crawl_hf_spaces.py --org build-small-hackathon --out data/projects.json
+```
+
+The app uses `data/projects.json` at runtime, so deployed builds remain usable without live crawl calls.
+
+## Test
+
+```bash
+pytest
+```

app.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Iterator
+
+from fastapi.responses import FileResponse, HTMLResponse, JSONResponse
+from gradio import Server
+
+from hackathon_advisor.agent import AdvisorEngine
+from hackathon_advisor.data import ProjectIndex
+
+
+ROOT = Path(__file__).parent
+STATIC_DIR = ROOT / "static"
+DATA_PATH = ROOT / "data" / "projects.json"
+
+index = ProjectIndex.from_file(DATA_PATH)
+engine = AdvisorEngine(index)
+app = Server()
+
+
+def _json_event(payload: dict) -> str:
+    return json.dumps(payload, ensure_ascii=False)
+
+
+@app.get("/", response_class=HTMLResponse)
+def home() -> FileResponse:
+    return FileResponse(STATIC_DIR / "index.html")
+
+
+@app.get("/static/{path:path}")
+def static_file(path: str) -> FileResponse:
+    target = (STATIC_DIR / path).resolve()
+    if not str(target).startswith(str(STATIC_DIR.resolve())) or not target.is_file():
+        return JSONResponse({"error": "not found"}, status_code=404)
+    return FileResponse(target)
+
+
+@app.get("/health")
+def health() -> dict:
+    return {
+        "ok": True,
+        "projects": len(index.projects),
+        "snapshot_generated_at": index.generated_at,
+    }
+
+
+@app.get("/api/bootstrap")
+def bootstrap() -> dict:
+    return {
+        "project_count": len(index.projects),
+        "snapshot_generated_at": index.generated_at,
+        "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)],
+    }
+
+
+@app.api(name="agent_turn", concurrency_limit=4, stream_every=0.04)
+def agent_turn(message: str, session_json: str = "{}") -> Iterator[str]:
+    try:
+        session = json.loads(session_json or "{}")
+    except json.JSONDecodeError:
+        session = {}
+
+    result = engine.turn(message, session)
+    yield _json_event(
+        {
+            "type": "start",
+            "corrections": [correction.to_dict() for correction in result.corrections],
+            "normalized_text": result.normalized_text,
+            "tool_events": [event.to_dict() for event in result.tool_events],
+        }
+    )
+
+    for chunk in result.stream_chunks():
+        yield _json_event({"type": "token", "text": chunk})
+
+    yield _json_event(
+        {
+            "type": "done",
+            "state": result.state,
+            "response": result.response,
+            "projects": [project.to_public_dict() for project in result.projects],
+            "whitespace": [item.to_dict() for item in result.whitespace],
+            "score": result.score.to_dict() if result.score else None,
+            "plan": result.plan,
+            "artifact": result.artifact,
+        }
+    )
+
+
+if __name__ == "__main__":
+    app.launch(
+        server_name=os.environ.get("GRADIO_SERVER_NAME", "0.0.0.0"),
+        server_port=int(os.environ.get("GRADIO_SERVER_PORT", "7860")),
+        show_error=True,
+    )

data/projects.json

@@ -0,0 +1,2116 @@
+{
+  "generated_at": "2026-06-06T19:20:47+00:00",
+  "source": "https://huggingface.co/api/spaces?author=build-small-hackathon&limit=100",
+  "projects": [
+    {
+      "id": "build-small-hackathon/Advent_of_a_World_of_Flowering_Trees",
+      "title": "Advent Of A World Of Flowering Trees",
+      "summary": "This space is for Huggingface build small hackathon",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "CohereLabs/tiny-aya-global-GGUF"
+      ],
+      "datasets": [],
+      "likes": 1,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-06-05T12:21:42.000Z",
+      "last_modified": "2026-06-05T19:53:45.000Z",
+      "host": "https://build-small-hackathon-advent-of-a-world-of-flowe-468ebe3.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/Advent_of_a_World_of_Flowering_Trees"
+    },
+    {
+      "id": "build-small-hackathon/agent-swarm-workbench",
+      "title": "Backyard Demo Builder",
+      "summary": "Build tiny real-person demos before scaling custom software.",
+      "tags": [
+        "agents",
+        "ai-agents",
+        "backyard-ai",
+        "build-small-hackathon",
+        "demo-builder",
+        "gradio",
+        "real-estate",
+        "small-language-model"
+      ],
+      "models": [
+        "unsloth/gemma-4-12B-it-qat-GGUF",
+        "Qwen/Qwen2.5-7B-Instruct",
+        "nvidia/Nemotron-3.5-Content-Safety"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "",
+      "created_at": "2026-06-03T07:06:14.000Z",
+      "last_modified": "2026-06-06T13:57:48.000Z",
+      "host": "https://build-small-hackathon-agent-swarm-workbench.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/agent-swarm-workbench"
+    },
+    {
+      "id": "build-small-hackathon/AI-agent-Evaluation-pipeline",
+      "title": "ai agent evaluation pipeline",
+      "summary": "Evaluate AI agents at Session, Trace & Span levels",
+      "tags": [
+        "agents",
+        "evaluation",
+        "gradio",
+        "llm",
+        "observability"
+      ],
+      "models": [
+        "nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16",
+        "Qwen/Qwen3.6-27B",
+        "Qwen/QwQ-32B"
+      ],
+      "datasets": [
+        "build-small-hackathon/agent-eval-golden-dataset"
+      ],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-06-05T13:27:06.000Z",
+      "last_modified": "2026-06-06T16:22:19.000Z",
+      "host": "https://build-small-hackathon-ai-agent-evaluation-pipeline.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/AI-agent-Evaluation-pipeline"
+    },
+    {
+      "id": "build-small-hackathon/AI-Puppet-Theater",
+      "title": "AI Puppet Theater",
+      "summary": "",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "openai/gpt-oss-20b"
+      ],
+      "datasets": [],
+      "likes": 1,
+      "sdk": "gradio",
+      "license": "",
+      "created_at": "2026-06-05T17:19:57.000Z",
+      "last_modified": "2026-06-05T17:19:58.000Z",
+      "host": "https://build-small-hackathon-ai-puppet-theater.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/AI-Puppet-Theater"
+    },
+    {
+      "id": "build-small-hackathon/ai-study-buddy",
+      "title": "Ai Study Buddy",
+      "summary": "AI Study Buddy — your smart learning companion 📚 ",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "meta-llama/Llama-3.1-8B-Instruct"
+      ],
+      "datasets": [],
+      "likes": 1,
+      "sdk": "gradio",
+      "license": "apache-2.0",
+      "created_at": "2026-06-01T13:45:43.000Z",
+      "last_modified": "2026-06-05T13:42:30.000Z",
+      "host": "https://build-small-hackathon-ai-study-buddy.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/ai-study-buddy"
+    },
+    {
+      "id": "build-small-hackathon/amnesiac",
+      "title": "AMNESIAC",
+      "summary": "Reverse-Turing webcam interrogation game.",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "openbmb/MiniCPM-o-4_5"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "apache-2.0",
+      "created_at": "2026-06-05T09:51:49.000Z",
+      "last_modified": "2026-06-05T13:44:41.000Z",
+      "host": "https://build-small-hackathon-amnesiac.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/amnesiac"
+    },
+    {
+      "id": "build-small-hackathon/attention-firewall",
+      "title": "Attention Firewall",
+      "summary": "",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "",
+      "created_at": "2026-06-05T23:02:34.000Z",
+      "last_modified": "2026-06-05T23:04:42.000Z",
+      "host": "https://build-small-hackathon-attention-firewall.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/attention-firewall"
+    },
+    {
+      "id": "build-small-hackathon/awaaz",
+      "title": "Apni Awaaz",
+      "summary": "",
+      "tags": [
+        "backyard-ai",
+        "dubbing",
+        "hindi",
+        "translation",
+        "tts"
+      ],
+      "models": [
+        "openai/whisper-medium",
+        "Qwen/Qwen2.5-7B-Instruct"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-06-06T13:16:20.000Z",
+      "last_modified": "2026-06-06T14:14:31.000Z",
+      "host": "https://build-small-hackathon-awaaz.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/awaaz"
+    },
+    {
+      "id": "build-small-hackathon/backyard-dudu-destroyer",
+      "title": "Backyard Dudu Destroyer",
+      "summary": "A gradio interface for starting VLA and policy",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "apache-2.0",
+      "created_at": "2026-06-05T19:51:00.000Z",
+      "last_modified": "2026-06-05T19:51:00.000Z",
+      "host": "https://build-small-hackathon-backyard-dudu-destroyer.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/backyard-dudu-destroyer"
+    },
+    {
+      "id": "build-small-hackathon/backyard-raccoon-deterrent",
+      "title": "Backyard Raccoon Deterrent",
+      "summary": "Edge-AI raccoon deterrent. Tiny YOLO, fully offline.",
+      "tags": [
+        "build-small-hackathon",
+        "edge-ai",
+        "object-detection",
+        "raccoon",
+        "yolov8"
+      ],
+      "models": [],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-06-05T19:17:40.000Z",
+      "last_modified": "2026-06-06T14:06:45.000Z",
+      "host": "https://build-small-hackathon-backyard-raccoon-deterrent.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/backyard-raccoon-deterrent"
+    },
+    {
+      "id": "build-small-hackathon/borderless",
+      "title": "Borderless",
+      "summary": "",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "Qwen/Qwen3.6-27B"
+      ],
+      "datasets": [],
+      "likes": 1,
+      "sdk": "gradio",
+      "license": "",
+      "created_at": "2026-06-05T05:26:45.000Z",
+      "last_modified": "2026-06-06T07:32:19.000Z",
+      "host": "https://build-small-hackathon-borderless.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/borderless"
+    },
+    {
+      "id": "build-small-hackathon/bridge-troll",
+      "title": "Bridge Troll",
+      "summary": "Talk your way past a fine-tuned troll, if your argument is ",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "10Pratibh/gorm-lora",
+        "Qwen/Qwen2.5-7B-Instruct"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-06-05T06:01:32.000Z",
+      "last_modified": "2026-06-06T10:11:58.000Z",
+      "host": "https://build-small-hackathon-bridge-troll.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/bridge-troll"
+    },
+    {
+      "id": "build-small-hackathon/briefing-32",
+      "title": "briefing-32",
+      "summary": "A 32B-class AI-news briefing the maker runs every 2 hours.",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "Qwen/Qwen3-32B"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "apache-2.0",
+      "created_at": "2026-05-18T19:55:29.000Z",
+      "last_modified": "2026-05-18T20:10:19.000Z",
+      "host": "https://build-small-hackathon-briefing-32.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/briefing-32"
+    },
+    {
+      "id": "build-small-hackathon/business-order-assistant",
+      "title": "Business Order Assistant",
+      "summary": "AI that gets order  in any format and creates an  invoice",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [],
+      "datasets": [],
+      "likes": 1,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-06-05T08:14:41.000Z",
+      "last_modified": "2026-06-05T21:16:24.000Z",
+      "host": "https://build-small-hackathon-business-order-assistant.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/business-order-assistant"
+    },
+    {
+      "id": "build-small-hackathon/Case-Lantern",
+      "title": "Case Lantern",
+      "summary": "",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "lastmass/Qwen3.5-Medical-GSPO"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "apache-2.0",
+      "created_at": "2026-06-04T04:28:14.000Z",
+      "last_modified": "2026-06-04T07:51:49.000Z",
+      "host": "https://build-small-hackathon-case-lantern.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/Case-Lantern"
+    },
+    {
+      "id": "build-small-hackathon/chorus",
+      "title": "Chorus",
+      "summary": "Discover the signal without having to read the noise",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-06-06T14:29:28.000Z",
+      "last_modified": "2026-06-06T15:25:57.000Z",
+      "host": "https://build-small-hackathon-chorus.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/chorus"
+    },
+    {
+      "id": "build-small-hackathon/CodeFlow",
+      "title": "CodeFlow",
+      "summary": "Turn Python code into a readable Mermaid.js flowchart 📊",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "unsloth/Qwen3-Coder-30B-A3B-Instruct-GGUF"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-06-05T14:31:59.000Z",
+      "last_modified": "2026-06-06T19:12:05.000Z",
+      "host": "https://build-small-hackathon-codeflow.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/CodeFlow"
+    },
+    {
+      "id": "build-small-hackathon/come-and-compare",
+      "title": "Come And Compare",
+      "summary": "Real-time price comparison across Amazon, Flipkart & Myntra",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "Qwen/Qwen2.5-7B-Instruct"
+      ],
+      "datasets": [],
+      "likes": 1,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-05-27T07:54:43.000Z",
+      "last_modified": "2026-06-06T12:22:50.000Z",
+      "host": "https://build-small-hackathon-come-and-compare.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/come-and-compare"
+    },
+    {
+      "id": "build-small-hackathon/compliment-forest",
+      "title": "The Compliment Forest",
+      "summary": "Walk through a watercolor path of grounded encouragement.",
+      "tags": [
+        "build-small-hackathon",
+        "gradio",
+        "llama.cpp",
+        "local-first",
+        "watercolor"
+      ],
+      "models": [
+        "build-small-hackathon/compliment-forest-minicpm5-1b",
+        "build-small-hackathon/compliment-forest-flux-lora"
+      ],
+      "datasets": [
+        "build-small-hackathon/compliment-forest-sft",
+        "build-small-hackathon/compliment-forest-watercolor",
+        "build-small-hackathon/compliment-forest-traces"
+      ],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "",
+      "created_at": "2026-06-06T09:06:20.000Z",
+      "last_modified": "2026-06-06T09:16:04.000Z",
+      "host": "https://build-small-hackathon-compliment-forest.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/compliment-forest"
+    },
+    {
+      "id": "build-small-hackathon/Council-of-Tiny-Minds",
+      "title": "Council Of Tiny Minds",
+      "summary": "A faux chatroom where one user message wakes up a handful of",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "Qwen/Qwen3.5-9B"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-06-04T14:39:09.000Z",
+      "last_modified": "2026-06-04T14:45:24.000Z",
+      "host": "https://build-small-hackathon-council-of-tiny-minds.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/Council-of-Tiny-Minds"
+    },
+    {
+      "id": "build-small-hackathon/Darwin-35B-A3B-Opus",
+      "title": "Darwin 35B A3B Opus",
+      "summary": "The child surpassed both parents — that is evolution",
+      "tags": [
+        "gradio",
+        "mcp-server",
+        "region:us"
+      ],
+      "models": [
+        "FINAL-Bench/Darwin-35B-A3B-Opus",
+        "huggingface/documentation-images"
+      ],
+      "datasets": [
+        "FINAL-Bench/ALL-Bench-Leaderboard",
+        "huggingface/documentation-images"
+      ],
+      "likes": 2,
+      "sdk": "gradio",
+      "license": "apache-2.0",
+      "created_at": "2026-05-19T21:57:08.000Z",
+      "last_modified": "2026-06-03T13:18:48.000Z",
+      "host": "https://build-small-hackathon-darwin-35b-a3b-opus.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/Darwin-35B-A3B-Opus"
+    },
+    {
+      "id": "build-small-hackathon/dental-soap",
+      "title": "Dental SOAP",
+      "summary": "A small-model dental handoff for real patient stories.",
+      "tags": [
+        "agents",
+        "bilingual",
+        "healthcare",
+        "zero-gpu"
+      ],
+      "models": [
+        "Qwen/Qwen3-4B-Instruct-2507"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "apache-2.0",
+      "created_at": "2026-06-05T08:34:32.000Z",
+      "last_modified": "2026-06-06T16:00:40.000Z",
+      "host": "https://build-small-hackathon-dental-soap.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/dental-soap"
+    },
+    {
+      "id": "build-small-hackathon/dm-order-desk",
+      "title": "Dm Order Desk",
+      "summary": "Turn messy DMs into clean orders.",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "Qwen/Qwen2.5-1.5B-Instruct"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-06-06T08:52:31.000Z",
+      "last_modified": "2026-06-06T11:49:44.000Z",
+      "host": "https://build-small-hackathon-dm-order-desk.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/dm-order-desk"
+    },
+    {
+      "id": "build-small-hackathon/dream-customs",
+      "title": "Dream Customs",
+      "summary": "Turn dream declarations into a playful next-day pact.",
+      "tags": [
+        "build-small-hackathon",
+        "dream-journal",
+        "gradio",
+        "minicpm"
+      ],
+      "models": [
+        "openbmb/MiniCPM5-1B",
+        "openbmb/MiniCPM-V-4.6"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-06-05T04:17:23.000Z",
+      "last_modified": "2026-06-06T09:27:58.000Z",
+      "host": "https://build-small-hackathon-dream-customs.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/dream-customs"
+    },
+    {
+      "id": "build-small-hackathon/dream-museum",
+      "title": "Dream Museum",
+      "summary": "Draw a dream · Describe it · Watch it materialize",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "stabilityai/stable-diffusion-xl-base-1.0",
+        "xinsir/controlnet-scribble-sdxl-1.0"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-06-06T11:56:15.000Z",
+      "last_modified": "2026-06-06T18:11:57.000Z",
+      "host": "https://build-small-hackathon-dream-museum.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/dream-museum"
+    },
+    {
+      "id": "build-small-hackathon/dreamwall-mc",
+      "title": "DreamWall MC",
+      "summary": "",
+      "tags": [
+        "agent-trace",
+        "art",
+        "codex",
+        "game",
+        "gradio",
+        "minecraft",
+        "small-models"
+      ],
+      "models": [],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "apache-2.0",
+      "created_at": "2026-06-05T10:11:24.000Z",
+      "last_modified": "2026-06-06T15:19:12.000Z",
+      "host": "https://build-small-hackathon-dreamwall-mc.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/dreamwall-mc"
+    },
+    {
+      "id": "build-small-hackathon/ducks-happen",
+      "title": "Ducks Happen",
+      "summary": "Rubber ducks materialize here.",
+      "tags": [
+        "art",
+        "flux",
+        "fun",
+        "generative-art",
+        "rubber-duck"
+      ],
+      "models": [
+        "black-forest-labs/FLUX.1-schnell"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-06-06T09:29:26.000Z",
+      "last_modified": "2026-06-06T13:27:27.000Z",
+      "host": "https://build-small-hackathon-ducks-happen.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/ducks-happen"
+    },
+    {
+      "id": "build-small-hackathon/espressocheese-chess-demo",
+      "title": "Espressocheese Chess Demo",
+      "summary": "",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "",
+      "created_at": "2026-06-05T18:02:39.000Z",
+      "last_modified": "2026-06-05T18:02:39.000Z",
+      "host": "https://build-small-hackathon-espressocheese-chess-demo.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/espressocheese-chess-demo"
+    },
+    {
+      "id": "build-small-hackathon/exam-panic-rescue",
+      "title": "Exam Panic Rescue",
+      "summary": "",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "nvidia/Nemotron-Mini-4B-Instruct",
+        "openbmb/MiniCPM4.1-8B",
+        "openbmb/MiniCPM4.1-8B-GGUF"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-06-05T10:07:01.000Z",
+      "last_modified": "2026-06-06T18:14:13.000Z",
+      "host": "https://build-small-hackathon-exam-panic-rescue.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/exam-panic-rescue"
+    },
+    {
+      "id": "build-small-hackathon/Family-Bill-Assistant",
+      "title": "Family Bill Assistant",
+      "summary": "Smart AI Agent that simplifies and categorizes family bills",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "nvidia/NVIDIA-Nemotron-Parse-v1.2",
+        "openbmb/MiniCPM-V-4.6",
+        "openbmb/MiniCPM4.1-8B"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-06-06T10:19:08.000Z",
+      "last_modified": "2026-06-06T19:16:30.000Z",
+      "host": "https://build-small-hackathon-family-bill-assistant.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/Family-Bill-Assistant"
+    },
+    {
+      "id": "build-small-hackathon/First-Principle-AI",
+      "title": "First-Principle AI",
+      "summary": "Phase-3 Q8 GGUF lab console with llama.cpp.",
+      "tags": [
+        "build-small-hackathon",
+        "chatbot",
+        "gguf",
+        "gradio",
+        "llama-cpp",
+        "model-lab",
+        "zerogpu"
+      ],
+      "models": [
+        "build-small-hackathon/phase-3-gguf"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-06-04T21:54:27.000Z",
+      "last_modified": "2026-06-06T04:54:02.000Z",
+      "host": "https://build-small-hackathon-first-principle-ai.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/First-Principle-AI"
+    },
+    {
+      "id": "build-small-hackathon/gemma-task-agent-trace",
+      "title": "Gemma Task Agent Trace",
+      "summary": "A lightweight task agent prototype with visual reasoning tra",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "",
+      "created_at": "2026-06-02T09:07:39.000Z",
+      "last_modified": "2026-06-02T09:11:42.000Z",
+      "host": "https://build-small-hackathon-gemma-task-agent-trace.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/gemma-task-agent-trace"
+    },
+    {
+      "id": "build-small-hackathon/gemma4chat",
+      "title": "Gemma4chat",
+      "summary": "",
+      "tags": [
+        "docker",
+        "region:us"
+      ],
+      "models": [],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "docker",
+      "license": "",
+      "created_at": "2026-06-06T09:09:50.000Z",
+      "last_modified": "2026-06-06T09:11:50.000Z",
+      "host": "https://build-small-hackathon-gemma4chat.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/gemma4chat"
+    },
+    {
+      "id": "build-small-hackathon/gitopadesh",
+      "title": "Gitopadesh",
+      "summary": "The Bhagavad Gita as a living advisor powered by AI",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "Qwen/Qwen2.5-7B-Instruct",
+        "sentence-transformers/all-MiniLM-L6-v2"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-06-05T03:38:32.000Z",
+      "last_modified": "2026-06-06T09:23:11.000Z",
+      "host": "https://build-small-hackathon-gitopadesh.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/gitopadesh"
+    },
+    {
+      "id": "build-small-hackathon/GRM-2.6-Opus",
+      "title": "GRM-2.6-Opus",
+      "summary": "",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "OrionLLM/GRM-2.6-Opus"
+      ],
+      "datasets": [],
+      "likes": 1,
+      "sdk": "gradio",
+      "license": "",
+      "created_at": "2026-05-19T22:04:00.000Z",
+      "last_modified": "2026-05-14T15:48:55.000Z",
+      "host": "https://build-small-hackathon-grm-2-6-opus.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/GRM-2.6-Opus"
+    },
+    {
+      "id": "build-small-hackathon/GTROX",
+      "title": "GTROX",
+      "summary": "",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "openai/gpt-oss-20b"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "",
+      "created_at": "2026-06-04T19:08:30.000Z",
+      "last_modified": "2026-06-04T19:08:31.000Z",
+      "host": "https://build-small-hackathon-gtrox.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/GTROX"
+    },
+    {
+      "id": "build-small-hackathon/guitar-singalong",
+      "title": "Guitar Singalong Generator",
+      "summary": "",
+      "tags": [
+        "accompaniment",
+        "audio",
+        "demucs",
+        "guitar",
+        "music",
+        "musicgen"
+      ],
+      "models": [
+        "facebook/musicgen-melody"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-06-05T16:48:57.000Z",
+      "last_modified": "2026-06-05T23:31:38.000Z",
+      "host": "https://build-small-hackathon-guitar-singalong.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/guitar-singalong"
+    },
+    {
+      "id": "build-small-hackathon/her",
+      "title": "Her · हेर",
+      "summary": "A detective for your Claude Code sessions",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "nvidia/Nemotron-Mini-4B-Instruct"
+      ],
+      "datasets": [],
+      "likes": 2,
+      "sdk": "gradio",
+      "license": "",
+      "created_at": "2026-06-06T14:39:33.000Z",
+      "last_modified": "2026-06-06T14:39:39.000Z",
+      "host": "https://build-small-hackathon-her.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/her"
+    },
+    {
+      "id": "build-small-hackathon/InContext",
+      "title": "InContext",
+      "summary": "Learn reusable English expressions from real-world content.",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "Qwen/Qwen2.5-0.5B-Instruct"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-06-06T00:37:36.000Z",
+      "last_modified": "2026-06-06T02:50:47.000Z",
+      "host": "https://build-small-hackathon-incontext.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/InContext"
+    },
+    {
+      "id": "build-small-hackathon/innerspace",
+      "title": "InnerSpace",
+      "summary": "Privacy-first offline cognitive journal & reflection coach",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "build-small-hackathon/inner-space-1b-sft-cbt",
+        "openbmb/MiniCPM5-1B-SFT"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "",
+      "created_at": "2026-06-06T08:39:42.000Z",
+      "last_modified": "2026-06-06T16:56:17.000Z",
+      "host": "https://build-small-hackathon-innerspace.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/innerspace"
+    },
+    {
+      "id": "build-small-hackathon/investigative-news-agent",
+      "title": "Investigative News Agent",
+      "summary": "Traceable news analysis assistant for independent journalist",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-06-03T23:27:21.000Z",
+      "last_modified": "2026-06-03T23:27:21.000Z",
+      "host": "https://build-small-hackathon-investigative-news-agent.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/investigative-news-agent"
+    },
+    {
+      "id": "build-small-hackathon/jackailocal",
+      "title": "Jackailocal",
+      "summary": "",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "",
+      "created_at": "2026-06-04T18:38:48.000Z",
+      "last_modified": "2026-06-04T18:38:48.000Z",
+      "host": "https://build-small-hackathon-jackailocal.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/jackailocal"
+    },
+    {
+      "id": "build-small-hackathon/job-search-assistant",
+      "title": "Job Searcher",
+      "summary": "Drop your resume. Get matches with reasoning.",
+      "tags": [
+        "distillation",
+        "gguf",
+        "jobs",
+        "llama-cpp",
+        "lora",
+        "qwen3",
+        "resume"
+      ],
+      "models": [
+        "emrekuruu/job-searcher-qwen3-8B",
+        "emrekuruu/job-searcher-qwen3-8B-gguf"
+      ],
+      "datasets": [
+        "emrekuruu/job-search-distill"
+      ],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "",
+      "created_at": "2026-06-06T15:20:53.000Z",
+      "last_modified": "2026-06-06T14:14:51.000Z",
+      "host": "https://build-small-hackathon-job-search-assistant.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/job-search-assistant"
+    },
+    {
+      "id": "build-small-hackathon/karim-lab",
+      "title": "Karim Lab",
+      "summary": "Small-model legal workflow assistant prototype.",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-06-04T22:20:12.000Z",
+      "last_modified": "2026-06-04T22:26:21.000Z",
+      "host": "https://build-small-hackathon-karim-lab.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/karim-lab"
+    },
+    {
+      "id": "build-small-hackathon/Kasualdad_LFED",
+      "title": "Kasualdad LFED",
+      "summary": "Local First Education Data Analytics for school admins",
+      "tags": [
+        "duckdb",
+        "education",
+        "gguf",
+        "gradio",
+        "llama-cpp",
+        "local-first",
+        "text-to-sql"
+      ],
+      "models": [
+        "mradermacher/Qwen2.5-Coder-7B-Instruct-GGUF",
+        "unsloth/Qwen2.5-Coder-7B-Instruct"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "",
+      "created_at": "2026-06-06T01:32:03.000Z",
+      "last_modified": "2026-06-06T16:36:54.000Z",
+      "host": "https://build-small-hackathon-kasualdad-lfed.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/Kasualdad_LFED"
+    },
+    {
+      "id": "build-small-hackathon/Kintsugi-Garden",
+      "title": "The Kintsugi Garden",
+      "summary": "",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "microsoft/Phi-4-mini-instruct",
+        "Qwen/Qwen3-8B"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-06-04T13:02:44.000Z",
+      "last_modified": "2026-06-06T15:16:43.000Z",
+      "host": "https://build-small-hackathon-kintsugi-garden.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/Kintsugi-Garden"
+    },
+    {
+      "id": "build-small-hackathon/legawa",
+      "title": "Legawa",
+      "summary": "",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "Qwen/Qwen3.5-27B",
+        "Qwen/Qwen3.5-9B"
+      ],
+      "datasets": [],
+      "likes": 1,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-05-29T11:56:15.000Z",
+      "last_modified": "2026-05-29T12:41:46.000Z",
+      "host": "https://build-small-hackathon-legawa.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/legawa"
+    },
+    {
+      "id": "build-small-hackathon/LocalDuo",
+      "title": "LocalDuo",
+      "summary": "🇰🇷✨ LocalDuo - Learn Korean from Documents",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "Qwen/Qwen3.5-2B",
+        "Qwen/Qwen3.5-9B"
+      ],
+      "datasets": [],
+      "likes": 1,
+      "sdk": "gradio",
+      "license": "",
+      "created_at": "2026-06-06T08:23:40.000Z",
+      "last_modified": "2026-06-06T12:29:55.000Z",
+      "host": "https://build-small-hackathon-localduo.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/LocalDuo"
+    },
+    {
+      "id": "build-small-hackathon/lolaby",
+      "title": "Lolaby",
+      "summary": "AI-powered lullabies.",
+      "tags": [
+        "agentic",
+        "backyard-ai",
+        "build-small-hackathon",
+        "children",
+        "fine-tuned",
+        "gradio",
+        "llama-cpp",
+        "lullaby",
+        "on-device",
+        "small-models",
+        "text-to-audio"
+      ],
+      "models": [
+        "build-small-hackathon/lolaby-llama-3b",
+        "openbmb/MiniCPM-V-4_6",
+        "hexgrad/Kokoro-82M"
+      ],
+      "datasets": [
+        "build-small-hackathon/lolaby-traces"
+      ],
+      "likes": 2,
+      "sdk": "gradio",
+      "license": "llama3.2",
+      "created_at": "2026-06-05T16:18:44.000Z",
+      "last_modified": "2026-06-06T09:59:58.000Z",
+      "host": "https://build-small-hackathon-lolaby.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/lolaby"
+    },
+    {
+      "id": "build-small-hackathon/lore-lens",
+      "title": "Local in 30s — Lore Lens",
+      "summary": "Snap anything abroad. Get what locals actually know.",
+      "tags": [
+        "culture",
+        "minicpm",
+        "multimodal",
+        "travel",
+        "tts"
+      ],
+      "models": [
+        "openbmb/MiniCPM-V-4.6",
+        "openbmb/VoxCPM2"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-06-06T16:45:47.000Z",
+      "last_modified": "2026-06-06T17:31:59.000Z",
+      "host": "https://build-small-hackathon-lore-lens.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/lore-lens"
+    },
+    {
+      "id": "build-small-hackathon/lovegpt",
+      "title": "loveGPT",
+      "summary": "",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "microsoft/Phi-4-mini-instruct"
+      ],
+      "datasets": [],
+      "likes": 3,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-06-05T11:55:29.000Z",
+      "last_modified": "2026-06-06T19:13:02.000Z",
+      "host": "https://build-small-hackathon-lovegpt.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/lovegpt"
+    },
+    {
+      "id": "build-small-hackathon/Mediassist",
+      "title": "Mediassist",
+      "summary": "Medical Reasoning Assistant for Underserved Communities",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "TinyLlama/TinyLlama-1.1B-Chat-v1.0"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-06-05T12:33:40.000Z",
+      "last_modified": "2026-06-05T13:53:13.000Z",
+      "host": "https://build-small-hackathon-mediassist.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/Mediassist"
+    },
+    {
+      "id": "build-small-hackathon/metabolic-forensics",
+      "title": "Metabolic Forensics",
+      "summary": "N-of-1 biosignal evidence engine. Forensics, not coaching.",
+      "tags": [
+        "backyard-ai",
+        "build-small-hackathon"
+      ],
+      "models": [],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-06-04T21:48:56.000Z",
+      "last_modified": "2026-06-04T21:49:01.000Z",
+      "host": "https://build-small-hackathon-metabolic-forensics.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/metabolic-forensics"
+    },
+    {
+      "id": "build-small-hackathon/my-build-small-hackathon",
+      "title": "My Build Small Hackathon",
+      "summary": "This is my submission for the  build-small-hackathon",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "apache-2.0",
+      "created_at": "2026-06-05T07:32:13.000Z",
+      "last_modified": "2026-06-05T07:50:03.000Z",
+      "host": "https://build-small-hackathon-my-build-small-hackathon.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/my-build-small-hackathon"
+    },
+    {
+      "id": "build-small-hackathon/mycelium",
+      "title": "Mycelium",
+      "summary": "Local-first personal knowledge agent",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "nvidia/Nemotron-Mini-4B-Instruct",
+        "Qwen/Qwen2.5-VL-7B-Instruct",
+        "sentence-transformers/all-MiniLM-L6-v2"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-06-06T04:29:40.000Z",
+      "last_modified": "2026-06-06T05:36:51.000Z",
+      "host": "https://build-small-hackathon-mycelium.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/mycelium"
+    },
+    {
+      "id": "build-small-hackathon/Myspace",
+      "title": "Myspace",
+      "summary": "Todo",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "openai/gpt-oss-20b"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-06-04T20:20:12.000Z",
+      "last_modified": "2026-06-04T20:20:13.000Z",
+      "host": "https://build-small-hackathon-myspace.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/Myspace"
+    },
+    {
+      "id": "build-small-hackathon/mythograph-atelier",
+      "title": "Mythograph Atelier",
+      "summary": "AI abstract art with personal meaning",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "black-forest-labs/FLUX.2-klein-4B",
+        "lmstudio-community/Qwen3.5-0.8B-GGUF"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "",
+      "created_at": "2026-06-06T09:28:40.000Z",
+      "last_modified": "2026-06-06T18:49:06.000Z",
+      "host": "https://build-small-hackathon-mythograph-atelier.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/mythograph-atelier"
+    },
+    {
+      "id": "build-small-hackathon/neighbourhood-guide",
+      "title": "Neighbourhood Guide",
+      "summary": "",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "CohereLabs/tiny-aya-global",
+        "CohereLabs/cohere-transcribe-03-2026",
+        "nvidia/magpie_tts_multilingual_357m"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "apache-2.0",
+      "created_at": "2026-06-06T04:15:44.000Z",
+      "last_modified": "2026-06-06T18:36:24.000Z",
+      "host": "https://build-small-hackathon-neighbourhood-guide.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/neighbourhood-guide"
+    },
+    {
+      "id": "build-small-hackathon/neilA",
+      "title": "First Contact",
+      "summary": "Teach an alien that knows words but has never lived a life.",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "Qwen/Qwen2.5-7B-Instruct"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-06-05T15:41:30.000Z",
+      "last_modified": "2026-06-05T21:55:20.000Z",
+      "host": "https://build-small-hackathon-neila.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/neilA"
+    },
+    {
+      "id": "build-small-hackathon/NextClue",
+      "title": "NextClue",
+      "summary": "Research assistant to help design the next-best experiments ",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "",
+      "created_at": "2026-06-04T17:44:39.000Z",
+      "last_modified": "2026-06-04T17:44:40.000Z",
+      "host": "https://build-small-hackathon-nextclue.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/NextClue"
+    },
+    {
+      "id": "build-small-hackathon/NEXUS-Visual-Weaver",
+      "title": "NEXUS Visual Weaver",
+      "summary": "hackaton project from NEXUS OS and doppleground foundation",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "black-forest-labs/FLUX.2-klein-4B"
+      ],
+      "datasets": [],
+      "likes": 1,
+      "sdk": "gradio",
+      "license": "apache-2.0",
+      "created_at": "2026-06-06T06:12:35.000Z",
+      "last_modified": "2026-06-06T08:22:34.000Z",
+      "host": "https://build-small-hackathon-nexus-visual-weaver.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/NEXUS-Visual-Weaver"
+    },
+    {
+      "id": "build-small-hackathon/Objection-Your-Honour",
+      "title": "Objection Your Honour",
+      "summary": "A whimsical game",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "openai/gpt-oss-20b"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "",
+      "created_at": "2026-06-04T06:55:49.000Z",
+      "last_modified": "2026-06-04T06:55:51.000Z",
+      "host": "https://build-small-hackathon-objection-your-honour.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/Objection-Your-Honour"
+    },
+    {
+      "id": "build-small-hackathon/octopus-ai",
+      "title": "Octopus AI — Stress Test the Octopus",
+      "summary": "Can you break a self-monitoring modular AI?",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "CognitiveEngineering/octopus-dev-checkpoints",
+        "mistralai/Mixtral-8x7B-v0.1"
+      ],
+      "datasets": [],
+      "likes": 1,
+      "sdk": "gradio",
+      "license": "apache-2.0",
+      "created_at": "2026-06-05T17:47:03.000Z",
+      "last_modified": "2026-06-06T12:09:30.000Z",
+      "host": "https://build-small-hackathon-octopus-ai.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/octopus-ai"
+    },
+    {
+      "id": "build-small-hackathon/oneiros",
+      "title": "Oneiros",
+      "summary": "Map your dreams with a small model — no ChatGPT API.",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "Qwen/Qwen2.5-7B-Instruct-GGUF"
+      ],
+      "datasets": [
+        "adindamochamad/oneiros-agent-traces"
+      ],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "",
+      "created_at": "2026-06-03T02:34:28.000Z",
+      "last_modified": "2026-06-03T13:12:12.000Z",
+      "host": "https://build-small-hackathon-oneiros.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/oneiros"
+    },
+    {
+      "id": "build-small-hackathon/oracle-ternary-flame",
+      "title": "Oracle Ternary Flame",
+      "summary": "Cryptic oracle speaking in cosmic, elemental poetry.",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "google/gemma-4-12B-it",
+        "keypa/oracle-gemma4-12b-lora"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-06-05T10:03:17.000Z",
+      "last_modified": "2026-06-05T11:03:19.000Z",
+      "host": "https://build-small-hackathon-oracle-ternary-flame.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/oracle-ternary-flame"
+    },
+    {
+      "id": "build-small-hackathon/patient-virtuel-dentiste",
+      "title": "Patient Virtuel · Hygiéniste Pro",
+      "summary": "",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "Qwen/Qwen3.6-27B"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "apache-2.0",
+      "created_at": "2026-06-04T10:23:14.000Z",
+      "last_modified": "2026-06-04T15:33:38.000Z",
+      "host": "https://build-small-hackathon-patient-virtuel-dentiste.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/patient-virtuel-dentiste"
+    },
+    {
+      "id": "build-small-hackathon/pawmap",
+      "title": "PawMap",
+      "summary": "Mapeamento colaborativo de animais de rua com IA",
+      "tags": [
+        "docker",
+        "region:us"
+      ],
+      "models": [
+        "meta-llama/Llama-3.2-11B-Vision-Instruct"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "docker",
+      "license": "mit",
+      "created_at": "2026-06-04T17:55:07.000Z",
+      "last_modified": "2026-06-06T16:37:03.000Z",
+      "host": "https://build-small-hackathon-pawmap.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/pawmap"
+    },
+    {
+      "id": "build-small-hackathon/persona-atlas",
+      "title": "Persona Atlas",
+      "summary": "Build personas of public figures and compare how they think",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "google/gemma-4-26B-A4B-it",
+        "microsoft/harrier-oss-v1-0.6b"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "",
+      "created_at": "2026-06-06T06:46:34.000Z",
+      "last_modified": "2026-06-06T11:53:48.000Z",
+      "host": "https://build-small-hackathon-persona-atlas.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/persona-atlas"
+    },
+    {
+      "id": "build-small-hackathon/planpalette",
+      "title": "PlanPalette",
+      "summary": "",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "Lykon/dreamshaper-xl-lightning"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "",
+      "created_at": "2026-06-06T12:33:33.000Z",
+      "last_modified": "2026-06-06T18:11:05.000Z",
+      "host": "https://build-small-hackathon-planpalette.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/planpalette"
+    },
+    {
+      "id": "build-small-hackathon/pocket-weather-theater",
+      "title": "Pocket Weather Theater",
+      "summary": "Tiny local weather plays from pocket props.",
+      "tags": [
+        "build-small-hackathon",
+        "gradio",
+        "local-inference",
+        "thousand-token-wood",
+        "tiny-models",
+        "transformers"
+      ],
+      "models": [
+        "HuggingFaceTB/SmolLM2-135M-Instruct",
+        "PratikBuilds/pocket-weather-theater-smollm2-135m-lora"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-06-05T20:54:06.000Z",
+      "last_modified": "2026-06-06T16:13:34.000Z",
+      "host": "https://build-small-hackathon-pocket-weather-theater.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/pocket-weather-theater"
+    },
+    {
+      "id": "build-small-hackathon/rarebirds",
+      "title": "rarebirds",
+      "summary": "Aircraft rarity classifier with live ADS-B map",
+      "tags": [
+        "ads-b",
+        "aircraft",
+        "gemma",
+        "gradio"
+      ],
+      "models": [
+        "google/gemma-3-27b-it"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "",
+      "created_at": "2026-06-04T04:50:56.000Z",
+      "last_modified": "2026-06-06T05:03:49.000Z",
+      "host": "https://build-small-hackathon-rarebirds.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/rarebirds"
+    },
+    {
+      "id": "build-small-hackathon/receipt_scanner",
+      "title": "Receipt Scanner",
+      "summary": "",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "openbmb/MiniCPM-V",
+        "openbmb/MiniCPM-V-4.6"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "",
+      "created_at": "2026-06-05T19:57:46.000Z",
+      "last_modified": "2026-06-06T14:51:10.000Z",
+      "host": "https://build-small-hackathon-receipt-scanner.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/receipt_scanner"
+    },
+    {
+      "id": "build-small-hackathon/Retail-Insight-AI",
+      "title": "Retail Insight AI Pro",
+      "summary": "",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-06-03T14:00:54.000Z",
+      "last_modified": "2026-06-05T15:12:12.000Z",
+      "host": "https://build-small-hackathon-retail-insight-ai.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/Retail-Insight-AI"
+    },
+    {
+      "id": "build-small-hackathon/roadb-other-screen",
+      "title": "Road B: The Other Screen",
+      "summary": "Talk to the self who chose differently.",
+      "tags": [
+        "build-small-hackathon",
+        "custom-frontend",
+        "gguf",
+        "gradio",
+        "gradio-server",
+        "interactive-fiction",
+        "llama-cpp",
+        "modal",
+        "qwen",
+        "small-models"
+      ],
+      "models": [
+        "unsloth/Qwen3.5-9B-GGUF"
+      ],
+      "datasets": [],
+      "likes": 1,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-05-26T00:51:52.000Z",
+      "last_modified": "2026-06-05T07:11:03.000Z",
+      "host": "https://build-small-hackathon-roadb-other-screen.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/roadb-other-screen"
+    },
+    {
+      "id": "build-small-hackathon/roast-my-repo",
+      "title": "Roast My Repo",
+      "summary": "AI-powered brutal code review for your GitHub repos",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "openbmb/MiniCPM4-8B"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-06-04T07:33:38.000Z",
+      "last_modified": "2026-06-06T11:14:59.000Z",
+      "host": "https://build-small-hackathon-roast-my-repo.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/roast-my-repo"
+    },
+    {
+      "id": "build-small-hackathon/SlideAI",
+      "title": "SlideAI",
+      "summary": "",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "Qwen/Qwen2.5-7B-Instruct"
+      ],
+      "datasets": [],
+      "likes": 1,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-06-06T10:01:57.000Z",
+      "last_modified": "2026-06-06T12:20:39.000Z",
+      "host": "https://build-small-hackathon-slideai.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/SlideAI"
+    },
+    {
+      "id": "build-small-hackathon/Spooky-From-a-Distance",
+      "title": "Spooky From A Distance",
+      "summary": "",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "apache-2.0",
+      "created_at": "2026-06-05T01:38:09.000Z",
+      "last_modified": "2026-06-05T01:38:09.000Z",
+      "host": "https://build-small-hackathon-spooky-from-a-distance.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/Spooky-From-a-Distance"
+    },
+    {
+      "id": "build-small-hackathon/storybook",
+      "title": "Storybook",
+      "summary": "",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "",
+      "created_at": "2026-06-04T21:27:20.000Z",
+      "last_modified": "2026-06-04T21:27:20.000Z",
+      "host": "https://build-small-hackathon-storybook.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/storybook"
+    },
+    {
+      "id": "build-small-hackathon/Structured-Data-Rescuer",
+      "title": "Structured Data Rescuer",
+      "summary": "Unstructured data is entered and structured data is returned",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "meta-llama/Llama-3.1-8B-Instruct"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "apache-2.0",
+      "created_at": "2026-06-05T16:51:25.000Z",
+      "last_modified": "2026-06-06T18:09:14.000Z",
+      "host": "https://build-small-hackathon-structured-data-rescuer.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/Structured-Data-Rescuer"
+    },
+    {
+      "id": "build-small-hackathon/surgical-tissue-segmentation",
+      "title": "Surgical Tissue Segmentation",
+      "summary": "",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "meta-llama/Llama-3.1-8B-Instruct",
+        "sugan04/cholec-yolo26n-seg"
+      ],
+      "datasets": [],
+      "likes": 1,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-06-03T06:44:42.000Z",
+      "last_modified": "2026-06-06T08:02:16.000Z",
+      "host": "https://build-small-hackathon-surgical-tissue-segmentation.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/surgical-tissue-segmentation"
+    },
+    {
+      "id": "build-small-hackathon/tarook",
+      "title": "Tarook",
+      "summary": "",
+      "tags": [
+        "docker",
+        "region:us"
+      ],
+      "models": [],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "docker",
+      "license": "",
+      "created_at": "2026-05-14T23:10:44.000Z",
+      "last_modified": "2026-05-14T23:11:42.000Z",
+      "host": "https://build-small-hackathon-tarook.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/tarook"
+    },
+    {
+      "id": "build-small-hackathon/team_lunch_app_v1",
+      "title": "Team Lunch App V1",
+      "summary": "Individual & Team Lunch organizer",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "Qwen/Qwen2.5-1.5B-Instruct"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "apache-2.0",
+      "created_at": "2026-06-05T08:39:39.000Z",
+      "last_modified": "2026-06-06T00:01:47.000Z",
+      "host": "https://build-small-hackathon-team-lunch-app-v1.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/team_lunch_app_v1"
+    },
+    {
+      "id": "build-small-hackathon/the-echo",
+      "title": "The Echo",
+      "summary": "an agentic tree of the lives you didn't live",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "Qwen/Qwen2.5-3B-Instruct"
+      ],
+      "datasets": [],
+      "likes": 1,
+      "sdk": "gradio",
+      "license": "",
+      "created_at": "2026-06-05T21:02:40.000Z",
+      "last_modified": "2026-06-05T23:29:29.000Z",
+      "host": "https://build-small-hackathon-the-echo.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/the-echo"
+    },
+    {
+      "id": "build-small-hackathon/the-i3-ghost-matrix-v5",
+      "title": "The i3 Ghost Matrix v5.2",
+      "summary": "A delightfully weird off-the-grid i3 ghost agent.",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "apache-2.0",
+      "created_at": "2026-06-05T15:39:16.000Z",
+      "last_modified": "2026-06-06T13:40:59.000Z",
+      "host": "https://build-small-hackathon-the-i3-ghost-matrix-v5.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/the-i3-ghost-matrix-v5"
+    },
+    {
+      "id": "build-small-hackathon/the-pixelforge-klein",
+      "title": "The Pixelforge Klein",
+      "summary": "A tiny retro pixel-art game asset generator tool.",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "apache-2.0",
+      "created_at": "2026-06-06T05:50:56.000Z",
+      "last_modified": "2026-06-06T08:36:42.000Z",
+      "host": "https://build-small-hackathon-the-pixelforge-klein.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/the-pixelforge-klein"
+    },
+    {
+      "id": "build-small-hackathon/The-Shrine",
+      "title": "The Shrine",
+      "summary": "",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "",
+      "created_at": "2026-06-03T04:50:34.000Z",
+      "last_modified": "2026-06-03T09:58:20.000Z",
+      "host": "https://build-small-hackathon-the-shrine.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/The-Shrine"
+    },
+    {
+      "id": "build-small-hackathon/thousand-token-wood",
+      "title": "Thousand Token Wood",
+      "summary": "",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "",
+      "created_at": "2026-06-05T19:18:01.000Z",
+      "last_modified": "2026-06-05T19:27:14.000Z",
+      "host": "https://build-small-hackathon-thousand-token-wood.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/thousand-token-wood"
+    },
+    {
+      "id": "build-small-hackathon/thousand-token-wood-sim",
+      "title": "Thousand Token Wood",
+      "summary": "",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "AdmiralTaco/ttw-trader-0.5b",
+        "nvidia/Nemotron-Mini-4B-Instruct",
+        "openai/gpt-oss-20b",
+        "openbmb/MiniCPM3-4B",
+        "Qwen/Qwen2.5-0.5B-Instruct",
+        "Qwen/Qwen2.5-1.5B-Instruct",
+        "Qwen/Qwen2.5-3B-Instruct",
+        "Qwen/Qwen2.5-7B-Instruct"
+      ],
+      "datasets": [
+        "build-small-hackathon/thousand-token-wood-traces"
+      ],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-06-05T21:47:45.000Z",
+      "last_modified": "2026-06-06T17:03:53.000Z",
+      "host": "https://build-small-hackathon-thousand-token-wood-sim.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/thousand-token-wood-sim"
+    },
+    {
+      "id": "build-small-hackathon/tiny-army",
+      "title": "Tiny Army",
+      "summary": "Tiny Army — fighters write their own true legends",
+      "tags": [
+        "docker",
+        "region:us"
+      ],
+      "models": [
+        "black-forest-labs/FLUX.1-dev",
+        "black-forest-labs/FLUX.1-schnell",
+        "black-forest-labs/FLUX.2-klein-4B",
+        "prism-ml/bonsai-image-binary-4B-mlx-1bit",
+        "prism-ml/bonsai-image-ternary-4B-mlx-2bit",
+        "Qwen/Qwen2.5-0.5B-Instruct-GGUF",
+        "Qwen/Qwen3-TTS-12Hz-1.7B-Base",
+        "Qwen/Qwen3-TTS-12Hz-1.7B-VoiceDesign",
+        "Tongyi-MAI/Z-Image-Turbo"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "docker",
+      "license": "mit",
+      "created_at": "2026-06-03T15:28:19.000Z",
+      "last_modified": "2026-06-06T19:20:04.000Z",
+      "host": "https://build-small-hackathon-tiny-army.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/tiny-army"
+    },
+    {
+      "id": "build-small-hackathon/tiny-dispatch-coach",
+      "title": "Tiny Dispatch Coach",
+      "summary": "Small-model route coach",
+      "tags": [
+        "gradio",
+        "hackathon",
+        "logistics",
+        "operations-research",
+        "small-models"
+      ],
+      "models": [],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-06-02T02:04:10.000Z",
+      "last_modified": "2026-06-02T02:17:05.000Z",
+      "host": "https://build-small-hackathon-tiny-dispatch-coach.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/tiny-dispatch-coach"
+    },
+    {
+      "id": "build-small-hackathon/tricket",
+      "title": "Tricket",
+      "summary": "",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "openai/gpt-oss-20b"
+      ],
+      "datasets": [],
+      "likes": 1,
+      "sdk": "gradio",
+      "license": "",
+      "created_at": "2026-06-04T02:53:12.000Z",
+      "last_modified": "2026-06-04T02:53:13.000Z",
+      "host": "https://build-small-hackathon-tricket.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/tricket"
+    },
+    {
+      "id": "build-small-hackathon/Trollsona",
+      "title": "Trollsona",
+      "summary": "",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "Qwen/Qwen2.5-0.5B-Instruct",
+        "RthItalia/nano_compact_3b_qkvfp16"
+      ],
+      "datasets": [],
+      "likes": 1,
+      "sdk": "gradio",
+      "license": "",
+      "created_at": "2026-06-05T19:08:56.000Z",
+      "last_modified": "2026-06-05T19:37:07.000Z",
+      "host": "https://build-small-hackathon-trollsona.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/Trollsona"
+    },
+    {
+      "id": "build-small-hackathon/ux-crime-scene",
+      "title": "UX Crime Scene",
+      "summary": "A noir detective investigates your UI as a crime scene.",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-06-06T15:02:25.000Z",
+      "last_modified": "2026-06-06T15:35:57.000Z",
+      "host": "https://build-small-hackathon-ux-crime-scene.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/ux-crime-scene"
+    },
+    {
+      "id": "build-small-hackathon/voice-sales-logger",
+      "title": "Voice Sales Logger",
+      "summary": "",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "nvidia/nemotron-3.5-asr-streaming-0.6b",
+        "Qwen/Qwen2.5-1.5B-Instruct"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "",
+      "created_at": "2026-06-06T02:11:31.000Z",
+      "last_modified": "2026-06-06T04:16:09.000Z",
+      "host": "https://build-small-hackathon-voice-sales-logger.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/voice-sales-logger"
+    },
+    {
+      "id": "build-small-hackathon/VoiceGate",
+      "title": "VoiceGate",
+      "summary": "Multilingual dubbing with subtitles and ambience.",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "Kijai/MelBandRoFormer_comfy",
+        "openbmb/VoxCPM2",
+        "Qwen/Qwen3-ASR-1.7B",
+        "Qwen/Qwen3-ForcedAligner-0.6B"
+      ],
+      "datasets": [],
+      "likes": 1,
+      "sdk": "gradio",
+      "license": "",
+      "created_at": "2026-06-04T22:15:11.000Z",
+      "last_modified": "2026-06-06T07:36:54.000Z",
+      "host": "https://build-small-hackathon-voicegate.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/VoiceGate"
+    },
+    {
+      "id": "build-small-hackathon/wan2-2-fp8da-aoti-14B-fast",
+      "title": "Wan2.2 14B Fast Preview",
+      "summary": "generate a video from an image with a text prompt",
+      "tags": [
+        "gradio",
+        "mcp-server",
+        "region:us"
+      ],
+      "models": [
+        "cbensimon/WanTransformer3DModel-sm120-cu130-raa",
+        "r3gm/RIFE",
+        "TestOrganizationPleaseIgnore/wamu-tools",
+        "Wan-AI/Wan2.2-I2V-A14B-Diffusers"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "",
+      "created_at": "2026-06-04T11:21:36.000Z",
+      "last_modified": "2026-05-16T22:14:21.000Z",
+      "host": "https://build-small-hackathon-wan2-2-fp8da-aoti-14b-fast.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/wan2-2-fp8da-aoti-14B-fast"
+    },
+    {
+      "id": "build-small-hackathon/WitGym",
+      "title": "WitGym",
+      "summary": "",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "BAAI/bge-small-en-v1.5",
+        "cross-encoder/ettin-reranker-32m-v1",
+        "Qwen/Qwen3.5-9B"
+      ],
+      "datasets": [
+        "jxm/the_office_lines"
+      ],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "apache-2.0",
+      "created_at": "2026-06-04T10:53:06.000Z",
+      "last_modified": "2026-06-05T11:12:44.000Z",
+      "host": "https://build-small-hackathon-witgym.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/WitGym"
+    },
+    {
+      "id": "build-small-hackathon/wonderland",
+      "title": "wonderland",
+      "summary": "A text adventure with a 1000 token model guiding you.",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16",
+        "nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16",
+        "nvidia/NVIDIA-Nemotron-3-Nano-4B-FP8",
+        "nvidia/NVIDIA-Nemotron-3-Nano-4B-GGUF"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-06-05T18:46:14.000Z",
+      "last_modified": "2026-06-06T05:37:37.000Z",
+      "host": "https://build-small-hackathon-wonderland.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/wonderland"
+    },
+    {
+      "id": "build-small-hackathon/wpl-discovery",
+      "title": "Wpl Discovery",
+      "summary": "Discover what your library actually offers",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-06-06T14:50:27.000Z",
+      "last_modified": "2026-06-06T14:50:27.000Z",
+      "host": "https://build-small-hackathon-wpl-discovery.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/wpl-discovery"
+    },
+    {
+      "id": "build-small-hackathon/Yui-Home-Assisstant",
+      "title": "Yui Home Assisstant",
+      "summary": "Local voice assistant configured for home asssitant",
+      "tags": [
+        "gradio",
+        "region:us"
+      ],
+      "models": [
+        "openai/gpt-oss-20b"
+      ],
+      "datasets": [],
+      "likes": 0,
+      "sdk": "gradio",
+      "license": "mit",
+      "created_at": "2026-06-06T08:54:43.000Z",
+      "last_modified": "2026-06-06T08:54:44.000Z",
+      "host": "https://build-small-hackathon-yui-home-assisstant.hf.space",
+      "url": "https://huggingface.co/spaces/build-small-hackathon/Yui-Home-Assisstant"
+    }
+  ]
+}

hackathon_advisor/__init__.py

@@ -0,0 +1,5 @@
+"""Build Small Hackathon Advisor."""
+
+__all__ = ["__version__"]
+
+__version__ = "0.1.0"

hackathon_advisor/agent.py

@@ -0,0 +1,238 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+import re
+
+from hackathon_advisor.aliases import Correction, normalize_text
+from hackathon_advisor.data import Project, ProjectIndex, WhitespaceItem
+from hackathon_advisor.scoring import ScoreCard
+from hackathon_advisor.tools import AdvisorTools, Idea, ToolEvent, idea_from_text
+
+
+PLAN_RE = re.compile(r"\b(plan|build order|roadmap|next step|milestone)\b", re.IGNORECASE)
+COMPARE_RE = re.compile(r"\b(compare|choose|rank)\b", re.IGNORECASE)
+WHITESPACE_RE = re.compile(r"\b(whitespace|original|new|bolder|unwritten|gap)\b", re.IGNORECASE)
+SEARCH_RE = re.compile(r"\b(search|similar|already|existing|overlap|echo)\b", re.IGNORECASE)
+
+
+@dataclass
+class TurnResult:
+    normalized_text: str
+    corrections: list[Correction]
+    response: str
+    state: dict[str, Any]
+    tool_events: list[ToolEvent]
+    projects: list[Project]
+    whitespace: list[WhitespaceItem]
+    score: ScoreCard | None
+    plan: list[str]
+    artifact: dict[str, Any]
+
+    def stream_chunks(self) -> list[str]:
+        words = self.response.split(" ")
+        chunks: list[str] = []
+        current: list[str] = []
+        for word in words:
+            current.append(word)
+            if len(" ".join(current)) >= 28:
+                chunks.append(" ".join(current) + " ")
+                current = []
+        if current:
+            chunks.append(" ".join(current))
+        return chunks
+
+
+class AdvisorEngine:
+    def __init__(self, index: ProjectIndex) -> None:
+        self.index = index
+        self.tools = AdvisorTools(index)
+
+    def turn(self, message: str, state: dict[str, Any] | None = None) -> TurnResult:
+        state = dict(state or {})
+        state.setdefault("ideas", [])
+        normalized, corrections = normalize_text(message)
+        tool_events: list[ToolEvent] = []
+        projects: list[Project] = []
+        whitespace: list[WhitespaceItem] = []
+        score: ScoreCard | None = None
+        plan: list[str] = []
+
+        if not normalized.strip():
+            projects, event = self.tools.list_projects(limit=6)
+            tool_events.append(event)
+            response = self._opening_response(projects)
+            return self._result(normalized, corrections, response, state, tool_events, projects, [], None, [], {})
+
+        if COMPARE_RE.search(normalized) and state.get("ideas"):
+            response = self._compare_response(state)
+            tool_events.append(ToolEvent("compare_ideas", "Compared the current idea board."))
+            return self._result(normalized, corrections, response, state, tool_events, [], [], None, [], {})
+
+        title, pitch = idea_from_text(normalized)
+        idea, event = self.tools.save_idea(state, title, pitch)
+        tool_events.append(event)
+
+        if PLAN_RE.search(normalized):
+            score, event = self.tools.score_idea(idea)
+            self._store_idea(state, idea)
+            tool_events.append(event)
+            plan, event = self.tools.make_plan(idea)
+            tool_events.append(event)
+            response = self._plan_response(idea, score, plan)
+            artifact = self._artifact(idea, score)
+            return self._result(normalized, corrections, response, state, tool_events, [], [], score, plan, artifact)
+
+        if WHITESPACE_RE.search(normalized):
+            whitespace, event = self.tools.find_whitespace(limit=4)
+            tool_events.append(event)
+            if whitespace:
+                idea.title = whitespace[0].label
+                idea.pitch = whitespace[0].pitch
+                state["ideas"] = [
+                    idea.to_dict() if item.get("id") == idea.id else item for item in state.get("ideas", [])
+                ]
+            score, event = self.tools.score_idea(idea)
+            self._store_idea(state, idea)
+            tool_events.append(event)
+            response = self._whitespace_response(idea, whitespace, score)
+            artifact = self._artifact(idea, score)
+            return self._result(
+                normalized,
+                corrections,
+                response,
+                state,
+                tool_events,
+                [],
+                whitespace,
+                score,
+                [],
+                artifact,
+            )
+
+        hits = self.index.search(normalized, limit=5)
+        projects = [hit.project for hit in hits]
+        tool_events.append(ToolEvent("search_projects", f"Checked {len(projects)} closest project echoes."))
+        score, event = self.tools.score_idea(idea)
+        self._store_idea(state, idea)
+        tool_events.append(event)
+
+        if SEARCH_RE.search(normalized) or projects:
+            response = self._overlap_response(idea, projects, score)
+        else:
+            whitespace, event = self.tools.find_whitespace(limit=3)
+            tool_events.append(event)
+            response = self._whitespace_response(idea, whitespace, score)
+
+        artifact = self._artifact(idea, score)
+        return self._result(
+            normalized,
+            corrections,
+            response,
+            state,
+            tool_events,
+            projects,
+            whitespace,
+            score,
+            plan,
+            artifact,
+        )
+
+    def _result(
+        self,
+        normalized_text: str,
+        corrections: list[Correction],
+        response: str,
+        state: dict[str, Any],
+        tool_events: list[ToolEvent],
+        projects: list[Project],
+        whitespace: list[WhitespaceItem],
+        score: ScoreCard | None,
+        plan: list[str],
+        artifact: dict[str, Any],
+    ) -> TurnResult:
+        return TurnResult(
+            normalized_text=normalized_text,
+            corrections=corrections,
+            response=response,
+            state=state,
+            tool_events=tool_events,
+            projects=projects,
+            whitespace=whitespace,
+            score=score,
+            plan=plan,
+            artifact=artifact,
+        )
+
+    def _store_idea(self, state: dict[str, Any], idea: Idea) -> None:
+        state["ideas"] = [
+            idea.to_dict() if item.get("id") == idea.id else item for item in state.get("ideas", [])
+        ]
+
+    def _opening_response(self, projects: list[Project]) -> str:
+        names = ", ".join(project.title for project in projects[:4])
+        return (
+            "Mothback opens the Almanac. The Wood is already inked with "
+            f"{len(self.index.projects)} project pages; the brightest current echoes include {names}. "
+            "Give me one project instinct and I will test whether it bleeds red or blooms gold."
+        )
+
+    def _overlap_response(self, idea: Idea, projects: list[Project], score: ScoreCard) -> str:
+        if score.verdict.startswith("UNWRITTEN"):
+            nearby = ", ".join(project.title for project in projects[:2]) or "no close pages"
+            return (
+                f"The page for {idea.title} does not bleed much. I found {nearby}, but the seal reads "
+                f"{score.verdict} at {score.overall}/10. Push the AI necessity harder: make the model decide, rank, "
+                "or personalize something a static app cannot."
+            )
+        citations = "; ".join(f"page {idx + 1}: {project.title}" for idx, project in enumerate(projects[:3]))
+        return (
+            f"The ink bleeds around {idea.title}. Closest echoes: {citations}. The seal reads "
+            f"{score.verdict} at {score.overall}/10. Keep the audience, but change the mechanism or artifact so the "
+            "demo proves a gap instead of joining a cluster."
+        )
+
+    def _whitespace_response(
+        self,
+        idea: Idea,
+        whitespace: list[WhitespaceItem],
+        score: ScoreCard,
+    ) -> str:
+        if not whitespace:
+            return (
+                f"The page for {idea.title} stays pale: I could not find a strong whitespace candidate in the "
+                "snapshot. Narrow the user and the moment, then ask again."
+            )
+        lead = whitespace[0]
+        return (
+            f"Gold gathers on {lead.label}. {lead.pitch} {lead.evidence} The seal reads "
+            f"{score.verdict} at {score.overall}/10. The next move is to make one concrete before/after scene and "
+            "cite the two weakest nearby echoes in the margin."
+        )
+
+    def _plan_response(self, idea: Idea, score: ScoreCard, plan: list[str]) -> str:
+        steps = " ".join(f"{idx + 1}. {step}" for idx, step in enumerate(plan))
+        return (
+            f"Mothback presses the wax for {idea.title}: {score.overall}/10, {score.verdict}. "
+            f"The build path is: {steps}"
+        )
+
+    def _compare_response(self, state: dict[str, Any]) -> str:
+        ideas = state.get("ideas", [])
+        if not ideas:
+            return "There are no written pages on the board yet."
+        scored = sorted(
+            ideas,
+            key=lambda item: ((item.get("score") or {}).get("overall") or 0, item.get("title") or ""),
+            reverse=True,
+        )
+        names = ", ".join(item.get("title", "Untitled") for item in scored[:3])
+        return f"The board tilts toward {names}. Keep the top page only if its artifact can be understood in ten seconds."
+
+    def _artifact(self, idea: Idea, score: ScoreCard) -> dict[str, Any]:
+        return {
+            "title": idea.title,
+            "verdict": score.verdict,
+            "caption": f"Mothback inked my Build Small fate page: {idea.title} - {score.verdict}.",
+            "seal": score.to_dict(),
+        }

hackathon_advisor/aliases.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from difflib import SequenceMatcher
+import re
+
+
+@dataclass(frozen=True)
+class Correction:
+    original: str
+    canonical: str
+    confidence: float
+
+    def to_dict(self) -> dict:
+        return {
+            "original": self.original,
+            "canonical": self.canonical,
+            "confidence": round(self.confidence, 3),
+        }
+
+
+ALIASES: dict[str, tuple[str, ...]] = {
+    "Nemotron": ("nemotron", "nemo tron", "neutron", "nemotran", "nemo-tron"),
+    "MiniCPM5": ("minicpm5", "mini cpm5", "mini cpm", "open cpm", "opencpm5", "cpm five"),
+    "EmbeddingGemma": ("embedding gemma", "embeddinggemma", "gemma embedding", "embedded gemma"),
+    "ZeroGPU": ("zero gpu", "zerogpu", "zero-gpu", "zero g p u"),
+    "Gradio Server": ("gradio server", "gradio.server", "server mode"),
+    "Build Small Hackathon": ("build small", "build-small", "small hackathon"),
+    "Off the Grid": ("off the grid", "off-grid", "offline badge"),
+    "Well-Tuned": ("well tuned", "well-tuned", "fine tune", "finetune", "lora"),
+    "Tiny Titan": ("tiny titan", "tiny tight end", "tiny-titan"),
+    "Llama Champion": ("llama champion", "llama.cpp", "llama cpp", "llama badge"),
+}
+
+_TOKEN_RE = re.compile(r"[a-z0-9]+(?:[.-][a-z0-9]+)?", re.IGNORECASE)
+
+
+def normalize_text(text: str) -> tuple[str, list[Correction]]:
+    normalized = text
+    corrections: list[Correction] = []
+    spans = _candidate_spans(text)
+    used: set[str] = set()
+
+    for canonical, aliases in ALIASES.items():
+        best: tuple[str, float] | None = None
+        for alias in aliases:
+            for span in spans:
+                confidence = _similarity(alias, span)
+                if confidence >= 0.88 and (best is None or confidence > best[1]):
+                    best = (span, confidence)
+        if not best:
+            continue
+
+        original, confidence = best
+        if original.lower() in used or original == canonical:
+            continue
+        used.add(original.lower())
+        normalized = re.sub(re.escape(original), canonical, normalized, count=1, flags=re.IGNORECASE)
+        corrections.append(Correction(original=original, canonical=canonical, confidence=confidence))
+
+    return normalized, corrections
+
+
+def _candidate_spans(text: str) -> list[str]:
+    tokens = _TOKEN_RE.findall(text.lower())
+    spans = set(tokens)
+    for size in (2, 3):
+        for index in range(max(0, len(tokens) - size + 1)):
+            spans.add(" ".join(tokens[index : index + size]))
+    return sorted(spans, key=len, reverse=True)
+
+
+def _similarity(left: str, right: str) -> float:
+    compact_left = re.sub(r"[^a-z0-9]", "", left.lower())
+    compact_right = re.sub(r"[^a-z0-9]", "", right.lower())
+    if not compact_left or not compact_right:
+        return 0.0
+    if compact_left == compact_right:
+        return 1.0
+    return SequenceMatcher(None, compact_left, compact_right).ratio()

hackathon_advisor/data.py

@@ -0,0 +1,245 @@
+from __future__ import annotations
+
+from collections import Counter
+from dataclasses import dataclass
+import json
+import math
+from pathlib import Path
+import re
+
+
+TOKEN_RE = re.compile(r"[a-z0-9][a-z0-9.+_-]*", re.IGNORECASE)
+
+
+@dataclass(frozen=True)
+class Project:
+    id: str
+    title: str
+    summary: str
+    tags: tuple[str, ...]
+    models: tuple[str, ...]
+    datasets: tuple[str, ...]
+    likes: int
+    sdk: str
+    license: str
+    created_at: str
+    last_modified: str
+    host: str
+    url: str
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Project":
+        return cls(
+            id=str(data["id"]),
+            title=str(data.get("title") or data["id"].rsplit("/", 1)[-1]),
+            summary=str(data.get("summary") or ""),
+            tags=tuple(data.get("tags") or ()),
+            models=tuple(data.get("models") or ()),
+            datasets=tuple(data.get("datasets") or ()),
+            likes=int(data.get("likes") or 0),
+            sdk=str(data.get("sdk") or ""),
+            license=str(data.get("license") or ""),
+            created_at=str(data.get("created_at") or ""),
+            last_modified=str(data.get("last_modified") or ""),
+            host=str(data.get("host") or ""),
+            url=str(data.get("url") or f"https://huggingface.co/spaces/{data['id']}"),
+        )
+
+    @property
+    def slug(self) -> str:
+        return self.id.rsplit("/", 1)[-1]
+
+    @property
+    def searchable_text(self) -> str:
+        return " ".join(
+            [
+                self.title,
+                self.slug.replace("-", " ").replace("_", " "),
+                self.summary,
+                " ".join(self.tags),
+                " ".join(self.models),
+                " ".join(self.datasets),
+            ]
+        )
+
+    def to_public_dict(self) -> dict:
+        return {
+            "id": self.id,
+            "title": self.title,
+            "summary": self.summary,
+            "tags": list(self.tags),
+            "models": list(self.models),
+            "datasets": list(self.datasets),
+            "likes": self.likes,
+            "sdk": self.sdk,
+            "license": self.license,
+            "created_at": self.created_at,
+            "last_modified": self.last_modified,
+            "host": self.host,
+            "url": self.url,
+        }
+
+
+@dataclass(frozen=True)
+class SearchHit:
+    project: Project
+    score: float
+    matched_terms: tuple[str, ...]
+
+
+@dataclass(frozen=True)
+class WhitespaceItem:
+    label: str
+    pitch: str
+    evidence: str
+    score: float
+    nearby_projects: tuple[Project, ...]
+
+    def to_dict(self) -> dict:
+        return {
+            "label": self.label,
+            "pitch": self.pitch,
+            "evidence": self.evidence,
+            "score": round(self.score, 3),
+            "nearby_projects": [project.to_public_dict() for project in self.nearby_projects],
+        }
+
+
+@dataclass(frozen=True)
+class WhitespaceSeed:
+    label: str
+    query: str
+    pitch: str
+
+
+WHITESPACE_SEEDS: tuple[WhitespaceSeed, ...] = (
+    WhitespaceSeed(
+        "Tiny civic repair desk",
+        "local government forms benefits tenant aid accessibility paperwork",
+        "A small agent that turns intimidating public-service forms into one-page action plans.",
+    ),
+    WhitespaceSeed(
+        "Hands-on science coach",
+        "kitchen science experiment kids sensor notebook classroom",
+        "A lab-notebook companion that designs safe experiments from household materials.",
+    ),
+    WhitespaceSeed(
+        "Offline field translator",
+        "offline translation field guide travel emergency low connectivity",
+        "A local-first phrase and intent helper for stressful travel or field-work moments.",
+    ),
+    WhitespaceSeed(
+        "Personal archive cartographer",
+        "photos notes memories archive timeline family history scrapbook",
+        "A tiny model that maps a private archive into stories without sending it to cloud APIs.",
+    ),
+    WhitespaceSeed(
+        "Small-team incident scribe",
+        "incident retrospective logs on call debugging timeline root cause",
+        "A local incident historian that turns messy notes into a calm timeline and next actions.",
+    ),
+    WhitespaceSeed(
+        "Accessibility rehearsal room",
+        "accessibility captions alt text screen reader rehearsal inclusive design",
+        "A practice space that lets makers rehearse their demo for captions, contrast, and clarity.",
+    ),
+    WhitespaceSeed(
+        "Neighborhood seed library",
+        "garden plants seed library neighborhood seasons climate local exchange",
+        "An advisor for hyperlocal seed swaps, planting plans, and community garden knowledge.",
+    ),
+)
+
+
+class ProjectIndex:
+    def __init__(self, projects: list[Project], generated_at: str, source: str) -> None:
+        if not projects:
+            raise ValueError("project index requires at least one project")
+        self.projects = projects
+        self.generated_at = generated_at
+        self.source = source
+        self._documents = [Counter(tokenize(project.searchable_text)) for project in projects]
+        self._df = Counter(term for doc in self._documents for term in doc)
+        self._idf = {
+            term: math.log((1 + len(self._documents)) / (1 + freq)) + 1.0
+            for term, freq in self._df.items()
+        }
+        self._norms = [self._norm(doc) for doc in self._documents]
+
+    @classmethod
+    def from_file(cls, path: Path) -> "ProjectIndex":
+        data = json.loads(path.read_text(encoding="utf-8"))
+        projects = [Project.from_dict(item) for item in data["projects"]]
+        return cls(
+            projects=projects,
+            generated_at=str(data.get("generated_at") or ""),
+            source=str(data.get("source") or ""),
+        )
+
+    def top_projects(self, limit: int = 8) -> list[Project]:
+        return sorted(
+            self.projects,
+            key=lambda project: (project.likes, project.last_modified, project.title.lower()),
+            reverse=True,
+        )[:limit]
+
+    def search(self, query: str, limit: int = 5) -> list[SearchHit]:
+        query_terms = tokenize(query)
+        if not query_terms:
+            return []
+        query_doc = Counter(query_terms)
+        query_norm = self._norm(query_doc)
+        hits: list[SearchHit] = []
+        for project, doc, doc_norm in zip(self.projects, self._documents, self._norms, strict=True):
+            if doc_norm == 0.0 or query_norm == 0.0:
+                continue
+            raw = 0.0
+            matched: list[str] = []
+            for term, count in query_doc.items():
+                if term not in doc:
+                    continue
+                raw += count * doc[term] * self._idf.get(term, 1.0) ** 2
+                matched.append(term)
+            if not matched:
+                continue
+            title_bonus = sum(0.08 for term in matched if term in tokenize(project.title))
+            tag_bonus = sum(0.05 for term in matched if term in tokenize(" ".join(project.tags)))
+            score = raw / (query_norm * doc_norm) + title_bonus + tag_bonus
+            hits.append(SearchHit(project=project, score=score, matched_terms=tuple(sorted(matched))))
+        hits.sort(key=lambda hit: (hit.score, hit.project.likes), reverse=True)
+        return hits[:limit]
+
+    def get(self, project_id: str) -> Project | None:
+        for project in self.projects:
+            if project.id == project_id or project.slug == project_id:
+                return project
+        return None
+
+    def find_whitespace(self, limit: int = 5) -> list[WhitespaceItem]:
+        items: list[WhitespaceItem] = []
+        for seed in WHITESPACE_SEEDS:
+            hits = self.search(seed.query, limit=3)
+            saturation = sum(hit.score for hit in hits) / max(len(hits), 1)
+            score = max(0.0, 1.0 - min(saturation, 0.95))
+            if hits:
+                evidence = f"Nearest echoes are weak: {', '.join(hit.project.title for hit in hits[:2])}."
+            else:
+                evidence = "No close project echoes in the current snapshot."
+            items.append(
+                WhitespaceItem(
+                    label=seed.label,
+                    pitch=seed.pitch,
+                    evidence=evidence,
+                    score=score,
+                    nearby_projects=tuple(hit.project for hit in hits),
+                )
+            )
+        items.sort(key=lambda item: item.score, reverse=True)
+        return items[:limit]
+
+    def _norm(self, doc: Counter[str]) -> float:
+        return math.sqrt(sum((count * self._idf.get(term, 1.0)) ** 2 for term, count in doc.items()))
+
+
+def tokenize(text: str) -> list[str]:
+    return [token.lower().strip("._-+") for token in TOKEN_RE.findall(text) if len(token.strip("._-+")) > 1]

hackathon_advisor/scoring.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from hackathon_advisor.data import ProjectIndex, SearchHit, tokenize
+
+
+@dataclass(frozen=True)
+class ScoreCard:
+    originality: int
+    delight: int
+    ai_necessity: int
+    feasibility: int
+    prize_fit: int
+    verdict: str
+    echoes: tuple[SearchHit, ...]
+
+    @property
+    def overall(self) -> float:
+        return round(
+            (
+                self.originality * 0.30
+                + self.delight * 0.20
+                + self.ai_necessity * 0.20
+                + self.feasibility * 0.15
+                + self.prize_fit * 0.15
+            ),
+            1,
+        )
+
+    def to_dict(self) -> dict:
+        return {
+            "originality": self.originality,
+            "delight": self.delight,
+            "ai_necessity": self.ai_necessity,
+            "feasibility": self.feasibility,
+            "prize_fit": self.prize_fit,
+            "overall": self.overall,
+            "verdict": self.verdict,
+            "echoes": [
+                {
+                    "score": round(hit.score, 3),
+                    "matched_terms": list(hit.matched_terms),
+                    "project": hit.project.to_public_dict(),
+                }
+                for hit in self.echoes
+            ],
+        }
+
+
+def score_idea(index: ProjectIndex, title: str, pitch: str, targets: list[str] | None = None) -> ScoreCard:
+    text = f"{title} {pitch}".strip()
+    hits = index.search(text, limit=4)
+    top_overlap = hits[0].score if hits else 0.0
+    tokens = set(tokenize(text))
+    targets = targets or []
+
+    originality = clamp_score(10 - round(top_overlap * 18))
+    delight = clamp_score(4 + _keyword_count(tokens, {"story", "visual", "game", "ritual", "share", "voice"}) * 2)
+    ai_necessity = clamp_score(
+        3
+        + _keyword_count(tokens, {"agent", "model", "embed", "search", "personal", "speech", "local"}) * 2
+    )
+    complexity_penalty = _keyword_count(tokens, {"realtime", "video", "multiplayer", "payments", "social"})
+    feasibility = clamp_score(8 - complexity_penalty)
+    prize_fit = clamp_score(
+        4
+        + _keyword_count(tokens, {"local", "offline", "small", "llama", "fine", "trace", "gradio"}) * 2
+        + min(len(targets), 3)
+    )
+    verdict = "UNWRITTEN" if top_overlap < 0.16 else f"ECHO x{sum(1 for hit in hits if hit.score >= 0.12)}"
+    return ScoreCard(
+        originality=originality,
+        delight=delight,
+        ai_necessity=ai_necessity,
+        feasibility=feasibility,
+        prize_fit=prize_fit,
+        verdict=verdict,
+        echoes=tuple(hits),
+    )
+
+
+def clamp_score(value: int) -> int:
+    return max(1, min(10, value))
+
+
+def _keyword_count(tokens: set[str], keywords: set[str]) -> int:
+    return sum(1 for keyword in keywords if any(token.startswith(keyword) for token in tokens))

hackathon_advisor/tools.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+import uuid
+
+from hackathon_advisor.data import Project, ProjectIndex, WhitespaceItem
+from hackathon_advisor.scoring import ScoreCard, score_idea
+
+
+TARGETS = [
+    "Off the Grid",
+    "Well-Tuned",
+    "Off-Brand",
+    "Llama Champion",
+    "Sharing is Caring",
+    "Field Notes",
+]
+
+
+@dataclass
+class Idea:
+    id: str
+    title: str
+    pitch: str
+    targets: list[str] = field(default_factory=lambda: TARGETS[:3])
+    score: dict | None = None
+
+    def to_dict(self) -> dict:
+        return {
+            "id": self.id,
+            "title": self.title,
+            "pitch": self.pitch,
+            "targets": self.targets,
+            "score": self.score,
+        }
+
+
+@dataclass(frozen=True)
+class ToolEvent:
+    name: str
+    summary: str
+
+    def to_dict(self) -> dict:
+        return {"name": self.name, "summary": self.summary}
+
+
+class AdvisorTools:
+    def __init__(self, index: ProjectIndex) -> None:
+        self.index = index
+
+    def list_projects(self, limit: int = 8) -> tuple[list[Project], ToolEvent]:
+        projects = self.index.top_projects(limit=limit)
+        return projects, ToolEvent("list_projects", f"Read {len(projects)} prominent Space cards.")
+
+    def search_projects(self, query: str, limit: int = 5) -> tuple[list[Project], ToolEvent]:
+        hits = self.index.search(query, limit=limit)
+        projects = [hit.project for hit in hits]
+        return projects, ToolEvent("search_projects", f"Found {len(projects)} nearby Space echoes.")
+
+    def find_whitespace(self, limit: int = 5) -> tuple[list[WhitespaceItem], ToolEvent]:
+        items = self.index.find_whitespace(limit=limit)
+        return items, ToolEvent("find_whitespace", f"Ranked {len(items)} under-explored regions.")
+
+    def save_idea(self, state: dict[str, Any], title: str, pitch: str) -> tuple[Idea, ToolEvent]:
+        ideas = [Idea(**item) for item in state.get("ideas", [])]
+        current_id = state.get("current_idea_id")
+        idea = next((item for item in ideas if item.id == current_id), None)
+        if idea is None:
+            idea = Idea(id=uuid.uuid4().hex[:8], title=title, pitch=pitch)
+            ideas.append(idea)
+        else:
+            idea.title = title
+            idea.pitch = pitch
+        state["ideas"] = [item.to_dict() for item in ideas]
+        state["current_idea_id"] = idea.id
+        return idea, ToolEvent("save_idea", f"Wrote idea page '{idea.title}'.")
+
+    def score_idea(self, idea: Idea) -> tuple[ScoreCard, ToolEvent]:
+        score = score_idea(self.index, idea.title, idea.pitch, idea.targets)
+        idea.score = score.to_dict()
+        return score, ToolEvent("score_idea", f"Pressed a five-quadrant seal: {score.overall}/10.")
+
+    def make_plan(self, idea: Idea) -> tuple[list[str], ToolEvent]:
+        plan = [
+            "Lock a one-sentence promise and one demo input that proves originality.",
+            "Refresh the Space snapshot, then tune the bleed threshold against the closest echoes.",
+            "Build the smallest happy path: input, citations, score seal, and shareable artifact.",
+            "Add one prize hook only after the core loop is smooth enough to demo without narration.",
+            "Record the trace and write Field Notes from the exact build decisions.",
+        ]
+        if any("Well" in target for target in idea.targets):
+            plan.insert(4, "Prepare a tiny LoRA dataset from successful advisor turns before training.")
+        return plan, ToolEvent("make_plan", f"Drafted {len(plan)} build steps.")
+
+
+def idea_from_text(text: str) -> tuple[str, str]:
+    cleaned = " ".join(text.strip().split())
+    if not cleaned:
+        return "Blank Page", "A project direction waiting for one concrete user and one concrete tension."
+    title = cleaned
+    for prefix in ("i want to build", "build", "make", "my idea is", "idea:"):
+        if cleaned.lower().startswith(prefix):
+            title = cleaned[len(prefix) :].strip(" :-")
+            break
+    title = title[:64].strip(" .") or "Unwritten Page"
+    if len(title) < len(cleaned):
+        title = f"{title[:58].strip()}..."
+    return _display_title(title), cleaned
+
+
+def _display_title(title: str) -> str:
+    if not title:
+        return "Unwritten Page"
+    if any(char.isupper() or char.isdigit() for char in title):
+        return title[0].upper() + title[1:]
+    return title.capitalize()

pyproject.toml

@@ -0,0 +1,24 @@
+[project]
+name = "hackathon-advisor"
+version = "0.1.0"
+description = "Text-first originality advisor for the Build Small Hackathon."
+readme = "README.md"
+requires-python = ">=3.11,<3.13"
+license = { text = "MIT" }
+authors = [{ name = "Jacob LinCool" }]
+dependencies = [
+  "gradio>=6.16.0,<7",
+]
+
+[project.optional-dependencies]
+dev = [
+  "pytest>=8.0,<9",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["."]
+
+[tool.ruff]
+line-length = 100
+target-version = "py311"

requirements.txt

@@ -0,0 +1 @@
+gradio>=6.16.0,<7

scripts/crawl_hf_spaces.py

@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+from datetime import datetime, timezone
+import json
+from pathlib import Path
+import time
+from typing import Any
+from urllib.error import HTTPError
+from urllib.parse import quote
+from urllib.request import Request, urlopen
+
+
+API = "https://huggingface.co/api"
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Snapshot public Spaces in a Hugging Face org.")
+    parser.add_argument("--org", default="build-small-hackathon")
+    parser.add_argument("--out", default="data/projects.json")
+    parser.add_argument("--limit", type=int, default=100)
+    args = parser.parse_args()
+
+    spaces = fetch_json(f"{API}/spaces?author={quote(args.org)}&limit={args.limit}")
+    projects = []
+    for item in spaces:
+        space_id = item["id"]
+        detail = fetch_json(f"{API}/spaces/{quote(space_id, safe='/')}")
+        projects.append(project_from_detail(detail))
+        time.sleep(0.05)
+
+    payload = {
+        "generated_at": datetime.now(timezone.utc).isoformat(timespec="seconds"),
+        "source": f"{API}/spaces?author={args.org}&limit={args.limit}",
+        "projects": sorted(projects, key=lambda project: project["id"].lower()),
+    }
+    output = Path(args.out)
+    output.parent.mkdir(parents=True, exist_ok=True)
+    output.write_text(json.dumps(payload, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+    print(f"wrote {len(projects)} projects to {output}")
+
+
+def fetch_json(url: str) -> Any:
+    request = Request(url, headers={"User-Agent": "hackathon-advisor-crawler/0.1"})
+    try:
+        with urlopen(request, timeout=30) as response:
+            return json.loads(response.read().decode("utf-8"))
+    except HTTPError as error:
+        raise RuntimeError(f"failed to fetch {url}: {error.code}") from error
+
+
+def project_from_detail(detail: dict[str, Any]) -> dict[str, Any]:
+    card = detail.get("cardData") or {}
+    space_id = str(detail["id"])
+    title = str(card.get("title") or humanize_slug(space_id.rsplit("/", 1)[-1]))
+    summary = str(card.get("short_description") or card.get("description") or "")
+    tags = sorted(set(str(tag) for tag in (card.get("tags") or detail.get("tags") or [])))
+    return {
+        "id": space_id,
+        "title": title,
+        "summary": summary,
+        "tags": tags,
+        "models": [str(model) for model in detail.get("models") or card.get("models") or []],
+        "datasets": [str(dataset) for dataset in detail.get("datasets") or card.get("datasets") or []],
+        "likes": int(detail.get("likes") or 0),
+        "sdk": str(card.get("sdk") or detail.get("sdk") or ""),
+        "license": str(card.get("license") or ""),
+        "created_at": str(detail.get("createdAt") or ""),
+        "last_modified": str(detail.get("lastModified") or ""),
+        "host": str(detail.get("host") or ""),
+        "url": f"https://huggingface.co/spaces/{space_id}",
+    }
+
+
+def humanize_slug(slug: str) -> str:
+    return " ".join(part for part in slug.replace("_", "-").split("-") if part).title()
+
+
+if __name__ == "__main__":
+    main()

scripts/make_assets.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import random
+import struct
+import zlib
+from pathlib import Path
+
+
+def main() -> None:
+    out = Path("static/assets/parchment.png")
+    out.parent.mkdir(parents=True, exist_ok=True)
+    write_png(out, 1280, 760)
+    print(f"wrote {out}")
+
+
+def write_png(path: Path, width: int, height: int) -> None:
+    random.seed(47)
+    rows = []
+    for y in range(height):
+        row = bytearray([0])
+        for x in range(width):
+            dx = abs(x / width - 0.5)
+            dy = abs(y / height - 0.5)
+            vignette = int((dx + dy) * 58)
+            grain = random.randint(-12, 12)
+            wave = int(8 * random.random() + 6 * ((x * y) % 17 == 0))
+            r = clamp(217 - vignette + grain + wave)
+            g = clamp(190 - vignette + grain)
+            b = clamp(137 - vignette + grain // 2)
+            row.extend([r, g, b, 255])
+        rows.append(bytes(row))
+    raw = b"".join(rows)
+    png = b"\x89PNG\r\n\x1a\n"
+    png += chunk(b"IHDR", struct.pack(">IIBBBBB", width, height, 8, 6, 0, 0, 0))
+    png += chunk(b"IDAT", zlib.compress(raw, 9))
+    png += chunk(b"IEND", b"")
+    path.write_bytes(png)
+
+
+def chunk(kind: bytes, data: bytes) -> bytes:
+    return struct.pack(">I", len(data)) + kind + data + struct.pack(">I", zlib.crc32(kind + data) & 0xFFFFFFFF)
+
+
+def clamp(value: int) -> int:
+    return max(0, min(255, value))
+
+
+if __name__ == "__main__":
+    main()

static/app.js

@@ -0,0 +1,130 @@
+import { Client } from "https://cdn.jsdelivr.net/npm/@gradio/client/dist/index.min.js";
+
+const form = document.querySelector("#turn-form");
+const input = document.querySelector("#message");
+const submit = document.querySelector("#submit");
+const ink = document.querySelector("#ink");
+const corrections = document.querySelector("#corrections");
+const projectsEl = document.querySelector("#projects");
+const whitespaceEl = document.querySelector("#whitespace");
+const verdictEl = document.querySelector("#verdict");
+const overallEl = document.querySelector("#overall");
+
+let session = {};
+let clientPromise = Client.connect(window.location.origin);
+
+bootstrap();
+
+form.addEventListener("submit", async (event) => {
+  event.preventDefault();
+  const message = input.value.trim();
+  if (!message) return;
+  input.value = "";
+  submit.disabled = true;
+  ink.textContent = "";
+  ink.classList.remove("bleed", "gold");
+  corrections.textContent = "";
+
+  try {
+    const client = await clientPromise;
+    const submission = client.submit("/agent_turn", {
+      message,
+      session_json: JSON.stringify(session),
+    });
+
+    for await (const event of submission) {
+      if (event.type !== "data") continue;
+      const payloads = Array.isArray(event.data) ? event.data : [event.data];
+      for (const raw of payloads) {
+        handleEvent(JSON.parse(raw));
+      }
+    }
+  } catch (error) {
+    ink.textContent = `The page tore before it could answer: ${error.message}`;
+    ink.classList.add("bleed");
+  } finally {
+    submit.disabled = false;
+    input.focus();
+  }
+});
+
+async function bootstrap() {
+  const response = await fetch("/api/bootstrap");
+  const data = await response.json();
+  renderProjects(data.top_projects || []);
+  renderWhitespace(data.whitespace || []);
+}
+
+function handleEvent(event) {
+  if (event.type === "start") {
+    if (event.corrections?.length) {
+      corrections.textContent = event.corrections
+        .map((item) => `heard: ${item.original} -> ${item.canonical}`)
+        .join("   ");
+    }
+    return;
+  }
+
+  if (event.type === "token") {
+    ink.textContent += event.text;
+    return;
+  }
+
+  if (event.type === "done") {
+    session = event.state || {};
+    if (event.projects?.length) renderProjects(event.projects);
+    if (event.whitespace?.length) renderWhitespace(event.whitespace);
+    if (event.score) {
+      verdictEl.textContent = event.score.verdict;
+      overallEl.textContent = Number(event.score.overall).toFixed(1);
+      ink.classList.toggle("bleed", event.score.verdict.startsWith("ECHO"));
+      ink.classList.toggle("gold", event.score.verdict.startsWith("UNWRITTEN"));
+    }
+  }
+}
+
+function renderProjects(projects) {
+  projectsEl.innerHTML = "";
+  if (!projects.length) {
+    projectsEl.innerHTML = `<div class="empty">No red ink yet.</div>`;
+    return;
+  }
+  for (const project of projects.slice(0, 5)) {
+    const item = document.createElement("a");
+    item.className = "project";
+    item.href = project.url;
+    item.target = "_blank";
+    item.rel = "noreferrer";
+    item.innerHTML = `
+      <strong>${escapeHtml(project.title)}</strong>
+      <p>${escapeHtml(project.summary || project.id)}</p>
+    `;
+    projectsEl.append(item);
+  }
+}
+
+function renderWhitespace(items) {
+  whitespaceEl.innerHTML = "";
+  if (!items.length) {
+    whitespaceEl.innerHTML = `<div class="empty">Gold has not gathered.</div>`;
+    return;
+  }
+  for (const item of items.slice(0, 4)) {
+    const gap = document.createElement("div");
+    gap.className = "gap";
+    gap.innerHTML = `
+      <strong>${escapeHtml(item.label)}</strong>
+      <p>${escapeHtml(item.pitch)}</p>
+    `;
+    whitespaceEl.append(gap);
+  }
+}
+
+function escapeHtml(value) {
+  return String(value)
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&#039;");
+}

static/index.html

@@ -0,0 +1,53 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>The Unwritten Almanac</title>
+    <link rel="stylesheet" href="/static/styles.css" />
+  </head>
+  <body>
+    <main class="shell">
+      <section class="stage" aria-label="The Unwritten Almanac">
+        <div class="canopy"></div>
+        <div class="book">
+          <section class="page page-left">
+            <div class="kicker">The Unwritten Almanac</div>
+            <h1>Mothback</h1>
+            <p id="ink" class="ink">
+              The book is open. The next page waits for its first line.
+            </p>
+            <form id="turn-form" class="prompt-row">
+              <input
+                id="message"
+                name="message"
+                autocomplete="off"
+                placeholder="A local-first agent for..."
+              />
+              <button id="submit" type="submit" title="Ink the page">Ink</button>
+            </form>
+            <div id="corrections" class="corrections" aria-live="polite"></div>
+          </section>
+
+          <section class="page page-right">
+            <div class="seal" id="seal">
+              <span id="verdict">UNWRITTEN</span>
+              <strong id="overall">0.0</strong>
+            </div>
+            <div class="panels">
+              <article>
+                <h2>Echoes</h2>
+                <div id="projects" class="project-list"></div>
+              </article>
+              <article>
+                <h2>Gold Margins</h2>
+                <div id="whitespace" class="whitespace-list"></div>
+              </article>
+            </div>
+          </section>
+        </div>
+      </section>
+    </main>
+    <script type="module" src="/static/app.js"></script>
+  </body>
+</html>

static/styles.css

@@ -0,0 +1,271 @@
+:root {
+  color-scheme: dark;
+  --ink: #24160e;
+  --muted-ink: #6b4e35;
+  --paper: #d9bd83;
+  --paper-deep: #b48a4b;
+  --gold: #e6bd3f;
+  --red: #8d2d26;
+  --leaf: #2f7a49;
+  --night: #121612;
+}
+
+* {
+  box-sizing: border-box;
+}
+
+html,
+body {
+  margin: 0;
+  min-height: 100%;
+  background: radial-gradient(circle at 50% 16%, #33442c 0, #182117 42%, #080b08 100%);
+  color: #f5ead2;
+  font-family:
+    Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+}
+
+button,
+input {
+  font: inherit;
+}
+
+.shell {
+  min-height: 100vh;
+  display: grid;
+  place-items: center;
+  padding: clamp(16px, 3vw, 42px);
+}
+
+.stage {
+  position: relative;
+  width: min(1180px, 100%);
+  min-height: min(760px, calc(100vh - 40px));
+  display: grid;
+  place-items: center;
+}
+
+.canopy {
+  position: absolute;
+  inset: 0;
+  background:
+    linear-gradient(90deg, rgba(0, 0, 0, 0.5), transparent 24%, transparent 76%, rgba(0, 0, 0, 0.55)),
+    radial-gradient(circle at 50% 0, rgba(231, 191, 71, 0.18), transparent 42%);
+  border-radius: 8px;
+}
+
+.book {
+  position: relative;
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) minmax(0, 1fr);
+  width: min(1100px, 100%);
+  min-height: 680px;
+  background:
+    linear-gradient(90deg, rgba(71, 42, 23, 0.55), transparent 49%, rgba(62, 34, 20, 0.7) 50%, transparent 51%),
+    url("/static/assets/parchment.png");
+  background-size: cover;
+  color: var(--ink);
+  border: 1px solid rgba(255, 232, 169, 0.28);
+  border-radius: 8px;
+  box-shadow:
+    0 30px 80px rgba(0, 0, 0, 0.62),
+    inset 0 0 80px rgba(93, 48, 16, 0.38);
+  overflow: hidden;
+}
+
+.page {
+  min-width: 0;
+  padding: clamp(22px, 4vw, 56px);
+}
+
+.page-left {
+  display: flex;
+  flex-direction: column;
+}
+
+.kicker {
+  color: var(--muted-ink);
+  font-size: 0.78rem;
+  font-weight: 800;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+}
+
+h1 {
+  margin: 10px 0 22px;
+  font-family: Georgia, "Times New Roman", serif;
+  font-size: clamp(3rem, 8vw, 6.4rem);
+  line-height: 0.9;
+  font-weight: 700;
+  letter-spacing: 0;
+}
+
+h2 {
+  margin: 0 0 10px;
+  color: var(--muted-ink);
+  font-size: 0.78rem;
+  line-height: 1.2;
+  font-weight: 900;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+}
+
+.ink {
+  min-height: 214px;
+  margin: 0;
+  color: #2a170d;
+  font-family: Georgia, "Times New Roman", serif;
+  font-size: clamp(1.1rem, 1.9vw, 1.55rem);
+  line-height: 1.48;
+}
+
+.ink.bleed {
+  color: var(--red);
+}
+
+.ink.gold {
+  color: #6a4b00;
+  text-shadow: 0 0 18px rgba(230, 189, 63, 0.42);
+}
+
+.prompt-row {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) 84px;
+  gap: 10px;
+  margin-top: auto;
+}
+
+.prompt-row input {
+  min-width: 0;
+  height: 48px;
+  border: 1px solid rgba(80, 47, 22, 0.38);
+  border-radius: 8px;
+  padding: 0 14px;
+  background: rgba(255, 243, 203, 0.55);
+  color: var(--ink);
+  outline: none;
+}
+
+.prompt-row input:focus {
+  border-color: rgba(141, 45, 38, 0.72);
+  box-shadow: 0 0 0 3px rgba(141, 45, 38, 0.15);
+}
+
+.prompt-row button {
+  height: 48px;
+  border: 0;
+  border-radius: 8px;
+  background: #51311d;
+  color: #fff3cc;
+  font-weight: 800;
+  cursor: pointer;
+}
+
+.prompt-row button:disabled {
+  opacity: 0.58;
+  cursor: wait;
+}
+
+.corrections {
+  min-height: 30px;
+  padding-top: 10px;
+  color: var(--muted-ink);
+  font-size: 0.88rem;
+}
+
+.seal {
+  width: min(220px, 52vw);
+  aspect-ratio: 1;
+  margin: 0 auto 28px;
+  display: grid;
+  place-items: center;
+  align-content: center;
+  gap: 3px;
+  border-radius: 50%;
+  background:
+    radial-gradient(circle at 36% 30%, rgba(255, 226, 134, 0.72), transparent 26%),
+    radial-gradient(circle, #9b2f27 0 58%, #6e211f 59% 100%);
+  color: #ffe9a0;
+  box-shadow:
+    0 14px 30px rgba(91, 22, 16, 0.35),
+    inset 0 0 24px rgba(53, 11, 7, 0.45);
+  transform: rotate(-4deg);
+}
+
+.seal span {
+  max-width: 150px;
+  text-align: center;
+  font-size: 0.82rem;
+  font-weight: 900;
+  letter-spacing: 0.08em;
+}
+
+.seal strong {
+  font-family: Georgia, "Times New Roman", serif;
+  font-size: 3.4rem;
+  line-height: 1;
+}
+
+.panels {
+  display: grid;
+  gap: 18px;
+}
+
+.project-list,
+.whitespace-list {
+  display: grid;
+  gap: 10px;
+}
+
+.project,
+.gap {
+  border-left: 3px solid rgba(80, 47, 22, 0.48);
+  padding: 8px 10px;
+  background: rgba(255, 241, 196, 0.34);
+  border-radius: 0 8px 8px 0;
+}
+
+.project strong,
+.gap strong {
+  display: block;
+  color: #2a170d;
+  font-size: 0.98rem;
+  line-height: 1.25;
+}
+
+.project p,
+.gap p {
+  margin: 4px 0 0;
+  color: var(--muted-ink);
+  font-size: 0.86rem;
+  line-height: 1.35;
+}
+
+.empty {
+  color: var(--muted-ink);
+  font-size: 0.95rem;
+}
+
+@media (max-width: 820px) {
+  .shell {
+    display: block;
+    padding: 0;
+  }
+
+  .stage {
+    min-height: 100vh;
+  }
+
+  .book {
+    min-height: 100vh;
+    grid-template-columns: 1fr;
+    border-radius: 0;
+  }
+
+  .page {
+    padding: 24px;
+  }
+
+  .ink {
+    min-height: 168px;
+  }
+}

tests/test_agent.py

@@ -0,0 +1,37 @@
+from pathlib import Path
+
+from hackathon_advisor.agent import AdvisorEngine
+from hackathon_advisor.data import ProjectIndex
+
+
+def test_agent_scores_and_persists_idea() -> None:
+    index = ProjectIndex.from_file(Path("data/projects.json"))
+    engine = AdvisorEngine(index)
+
+    result = engine.turn("A local-first archive cartographer for family photos", {})
+
+    assert result.score is not None
+    assert result.state["ideas"]
+    assert result.state["ideas"][0]["score"] is not None
+    assert result.response
+
+
+def test_agent_finds_whitespace() -> None:
+    index = ProjectIndex.from_file(Path("data/projects.json"))
+    engine = AdvisorEngine(index)
+
+    result = engine.turn("write bolder and find whitespace", {})
+
+    assert result.whitespace
+    assert result.score is not None
+    assert result.artifact["verdict"]
+
+
+def test_agent_preserves_canonical_jargon_case() -> None:
+    index = ProjectIndex.from_file(Path("data/projects.json"))
+    engine = AdvisorEngine(index)
+
+    result = engine.turn("use neutron and mini cpm on zero gpu", {})
+
+    assert "MiniCPM5" in result.artifact["title"]
+    assert "ZeroGPU" in result.artifact["title"]

tests/test_aliases.py

@@ -0,0 +1,10 @@
+from hackathon_advisor.aliases import normalize_text
+
+
+def test_normalize_jargon_alias() -> None:
+    text, corrections = normalize_text("use neutron with mini cpm on zero gpu")
+
+    assert "Nemotron" in text
+    assert "MiniCPM5" in text
+    assert "ZeroGPU" in text
+    assert {item.canonical for item in corrections} >= {"Nemotron", "MiniCPM5", "ZeroGPU"}

tests/test_data.py

@@ -0,0 +1,21 @@
+from pathlib import Path
+
+from hackathon_advisor.data import ProjectIndex
+
+
+def test_project_index_searches_snapshot() -> None:
+    index = ProjectIndex.from_file(Path("data/projects.json"))
+
+    hits = index.search("lullaby children audio", limit=3)
+
+    assert hits
+    assert hits[0].project.id.startswith("build-small-hackathon/")
+
+
+def test_project_index_whitespace() -> None:
+    index = ProjectIndex.from_file(Path("data/projects.json"))
+
+    items = index.find_whitespace(limit=3)
+
+    assert len(items) == 3
+    assert all(item.label for item in items)