fix: restore missing comma in Activity BarPlot (boot SyntaxError)

FIELD_NOTES.md

@@ -24,7 +24,7 @@ only place the messages exist in a queryable form is a Mac, where they sync to
 The biggest adoption lesson came later: requiring a Mac collector + Full Disk
 Access is a wall for a non-technical user. The fix was to make **paste-from-phone**
 the hero path (the collector is now strictly optional) — no install, no DB, no
-permissions. Most of that capability already existed in the Schedule tab; it was just
+permissions. Most of that capability already existed in the Review tab; it was just
 framed as secondary.
 
 ## 2. `attributedBody` is the iMessage parsing trap
@@ -87,30 +87,16 @@ exporting them, so the metric tracks value taken, not previews shown.
 QLoRA on a 31B needs an 80GB GPU. [`training/modal_train.py`](./training/modal_train.py)
 wraps the existing `train_qlora.py` + `export_gguf.sh` to run on a serverless
 A100/H100 and publish the GGUF to HF — roughly **$5–15 per run**, so ~$250 of credit
-is 15–40 iterations. The "Well-Tuned" track went the distance: the eval-gated **E4B** fine-tune is
-published and is what production serves —
-[`build-small-hackathon/gemma-4-cal-gguf`](https://huggingface.co/build-small-hackathon/gemma-4-cal-gguf)
-— after clearing the gate over six runs at zero quality cost vs. stock E4B. (Re-running the pipeline
-still spends your own Modal credits; the turnkey path is there whenever you want to retrain.)
+is 15–40 iterations. The "Well-Tuned" track is genuinely *prepped* (pipeline +
+expanded seed dataset + a turnkey publish path) but **not finished**: the actual run
+spends the user's credits, so the repo is honest that the Space still ships on a
+community GGUF until you run it.
 
 A small rule that paid off: training-data generation can use *any* offline tooling —
 the "no cloud AI API" rule applies only to the **running app's inference**, not to
 dataset prep.
 
-## 7. Two models, not one — a 1B planner over the same tools
-
-What shipped is two small local models, not one. The fine-tuned **gemma-cal E4B** does the
-*reading* (thread → validated `ActionPlan`); a 1B **OpenBMB MiniCPM** does the *orchestrating*.
-Clicking **Run the agents** hands the job to MiniCPM, which drives the Space's own MCP tools —
-`extract_events → check_conflicts → make_ics` — as a visible multi-step agent
-([`server/orchestrator.py`](./server/orchestrator.py)), consuming the *public* tool contract
-instead of calling internals. Two things I'd underline: keep the planner **optional** (a
-deterministic scripted plan is the fallback, so the agentic path never hard-depends on a second
-model load), and don't let "agent" become a separate destination — the same **Run the agents**
-action drives both the home workflow and the orchestrated trace, so it stays one engine, not a
-second UI to keep in sync.
-
-## 8. The Off-the-Grid tension
+## 7. The Off-the-Grid tension
 
 "No cloud AI APIs" and "serve a 31B" pull against each other: a Q4 31B GGUF is
 ~18–20GB and needs a GPU. Keeping inference **in the Space via `llama.cpp`** preserves
@@ -123,7 +109,7 @@ The same principle drove the trace-sharing design (below): the hosted Space hold
 HF token** — it only offers a **local download**, and a separate local CLI does the
 upload with your own auth.
 
-## 9. What I'd do next
+## 8. What I'd do next
 
 - **Durable trace/metrics store.** The activity bus is an 800-entry in-memory ring
   buffer ([`server/events.py`](./server/events.py)) — runs are lost on restart, so only

PLAN.md

@@ -14,7 +14,7 @@ the point; the app must deliver value with no GPU (stub agent) first.
 You want an agent that reads iMessage-style threads, understands the conversation, and turns them
 into calendar events/reminders — exposed through a custom Gradio UI deployed as a Hugging Face Space.
 Two local models share the work: our fine-tuned Gemma does the *reading* (thread → validated
-ActionPlan), and an **OpenBMB MiniCPM** planner does the *orchestrating* — the brain behind **Run the agents**,
+ActionPlan), and an **OpenBMB MiniCPM** planner does the *orchestrating* — the Agent tab's brain,
 driving the Space's own MCP tools (`extract_events → check_conflicts → make_ics`) as a visible
 multi-step agent. The build competes in the **Backyard AI** track (general and OpenBMB prizes are
 awarded per track) and satisfies the quests secondary to the user story above: **Off the Grid** (no
@@ -37,7 +37,7 @@ Confirmed decisions:
 - **Calendar output:** local `.ics` files first (strictly off-grid), with an *optional* Google
   Calendar push toggle as a bonus.
 - **Extraction model:** fine-tune Gemma, serve as GGUF via llama.cpp (production serves the
-  **E4B** edge fine-tune, `build-small-hackathon/gemma-4-cal-gguf`).
+  **E4B** edge fine-tune, `ParetoOptimal/gemma-4-cal-gguf`).
 - **Agent planner:** **OpenBMB MiniCPM** (`openbmb/MiniCPM4.1-8B-GGUF`, Q4; the 1B variant is a
   config switch) on a second llama-server — it plans, the MCP tools execute, every step visible.
 
@@ -63,7 +63,7 @@ Confirmed decisions:
 Flow: messages → extraction prompt → model emits structured JSON of candidate events →
 validated → shown in UI for review → user approves → `.ics` generated (and/or pushed to GCal).
 
-**Run the agents** runs the same flow agentically: an **OpenBMB MiniCPM** planner (second local
+The **Agent tab** runs the same flow agentically: an **OpenBMB MiniCPM** planner (second local
 llama-server, OpenAI-compatible) consumes the Space's own **MCP tool surface** —
 `extract_events → check_conflicts → make_ics` — through smolagents, so the pipeline above is
 demonstrated as multi-step tool use over the public tool contract, with the planner's trace on
@@ -87,8 +87,8 @@ screen (`server/orchestrator.py`). Stub/CI falls back to a scripted planner so t
 - **Docker SDK Space** (`README.md` frontmatter: `sdk: docker`, `app_port: 7860`).
 - **llama.cpp** loads the fine-tuned GGUF and serves chat completions — satisfies
   *Llama Champion*; no external AI call satisfies *Off the Grid*.
-- **Agent orchestrator** (`server/orchestrator.py`): the **OpenBMB MiniCPM** planner behind
-  **Run the agents** (its own llama-server) drives the Space's MCP tools as a multi-step agent — the OpenBMB
+- **Agent orchestrator** (`server/orchestrator.py`): the Agent tab's **OpenBMB MiniCPM** planner
+  (its own llama-server) drives the Space's MCP tools as a multi-step agent — the OpenBMB
   per-track prize case, and the same extraction pipeline exercised through the public tool
   contract rather than private imports.
 - `/ingest` (FastAPI, mounted alongside Gradio) receives messages, runs the extraction prompt,
@@ -174,9 +174,6 @@ screen (`server/orchestrator.py`). Stub/CI falls back to a scripted planner so t
   the headline, E4B as the safety net for a reliable live demo.
 - **`chat.db` schema / `attributedBody`.** Mitigated by using `imessage-exporter`/`imessage_reader`.
 - **Full Disk Access** must be granted to the collector's process or reads return empty.
-- **Privacy:** the autonomous Mac-collector path sends messages to the Space (token-gated); the
-  hero phone-paste path keeps data client-side (calendar tokens live in the browser, nothing
-  persists server-side). The Space now lives in the public **`build-small-hackathon`** submission
-  org, so the *source* is public — but user data still never lands on the server.
+- **Privacy:** messages leave the Mac for the Space — keep the Space **private** and token-gated.
 - **Relative-date accuracy** is the main quality risk — pass the current datetime into the prompt
   and weight the dataset toward relative-date examples.

README.md

@@ -24,26 +24,15 @@ models:
 demo_video:
   - https://youtu.be/m-o0u9X3tI4
 social_posts:
-  - https://x.com/nate_mauer/status/2065973341651882386
   - https://x.com/nate_mauer/status/2064920352845709419
   - https://x.com/nate_mauer/status/2065661878441750916
-  - https://www.linkedin.com/feed/update/urn:li:ugcPost:7471440639969132545
-blog_post:
-  - https://huggingface.co/blog/build-small-hackathon/offgridschedula
 made_by:
   - ParetoOptimal - a.k.a., Nate Mauer
 ---
 
-# 🗓️ Message Scheduling Agent
+# 🗓️ iMessage Scheduling Agent
 
- **OffGridSchedula turns a pasted chat (or a flyer screenshot) into calendar events, catches conflicts, and drafts the reply — right from your phone, no app, no account,
-no setup. iOS allows neither background iMessage access nor a persistent on-device LLM server, so there's no autonomous on-device agent to install; instead, 
-a foreground Shortcut ([docs/automations.md](./docs/automations.md)) hands a thread or screenshot to the agent in two taps (optionally using a remote model via `INFERENCE_BASE_URL`).**
-
-The model runs on **your own server or even on the phone itself** and not on a cloud AI service. Your chats aren't shipped off to a third-party AI to be read; agent reads your snippet in memory and
-discards it after replying. The run trace you can optionally share is a redacted, sent to the agent you control that turns it into ready-to-add calendar events.
-
-**Hardware-aware.** With under-powered hardware, the app warns users with an upgrade banner rather than hanging, the real model needs a tiny GPU.
+**Turn a class group chat into calendar events — from your phone, no setup.**
 
 ## Build Small submission — the idea & the tech
 
@@ -52,7 +41,7 @@ class chat, the practice that moved, the party flyer. OffGridSchedula turns thos
 events: paste the chat (or snap the flyer) from a phone browser, review the extracted events, the
 conflicts against your own `.ics`, and a drafted reply — then add to Apple/Google Calendar in a tap.
 
-**The tech.** Two small local models do the work. Extraction is [`gemma-cal` E4B](https://huggingface.co/build-small-hackathon/gemma-4-cal-gguf)
+**The tech.** One small model does everything: [`gemma-cal` E4B](https://huggingface.co/ParetoOptimal/gemma-4-cal-gguf)
 (~4B effective params), our QLoRA fine-tune of Gemma-4 E4B that emits a single validated
 **ActionPlan** (events · conflicts · reply · clarifying question), served with **vision** through
 the official **llama.cpp** server inside this Docker Gradio Space — no cloud AI APIs. The
@@ -60,7 +49,7 @@ fine-tune + its 60-example task eval ran entirely on **Modal** serverless GPUs,
 eval gate that rejected eight regressed models before this one shipped. Conflict math is
 deterministic Python, the UI is fully custom, the agent doubles as an **MCP tool server**, and
 redacted run traces are public on the [Hub](https://huggingface.co/datasets/ParetoOptimal/offgridschedula-traces).
-Click **Run the agents** and a local **OpenBMB MiniCPM** planner (a second local llama-server)
+The **Agent tab** closes the loop: an **OpenBMB MiniCPM** planner (second local llama-server)
 drives this same Space's MCP tools as a multi-step agent — extract → check conflicts → render
 `.ics` — with every step visible. Still zero cloud AI; every model under 32B.
 
@@ -81,9 +70,8 @@ captured, conflicts caught, and time saved; a per-device **Memory** (localStorag
 samples) feeds names and preferences back into extraction.
 
 **Submission links:** [requirement-by-requirement mapping](./docs/build-small-submission.md) ·
-[demo video](https://youtu.be/m-o0u9X3tI4) ·
-social posts [1](https://x.com/nate_mauer/status/2064920352845709419) ·
-[2](https://x.com/nate_mauer/status/2065661878441750916)
+demo video *(recording — https://youtu.be/m-o0u9X3tI4)* ·
+social post *(queued — https://x.com/nate_mauer/status/2064920352845709419 and https://x.com/nate_mauer/status/2065661878441750916)*
 
 ## Who this is for
 
@@ -101,7 +89,7 @@ with no GPU (see *Accuracy upgrade* below).
 ## The model: `gemma-cal` E4B — one calendar-native LLM, built for exactly this
 
 What makes this platform different isn't a prompt wrapped around a generic chatbot — it's
-**[`gemma-cal` E4B](https://huggingface.co/build-small-hackathon/gemma-4-cal-gguf), our own fine-tune of
+**[`gemma-cal` E4B](https://huggingface.co/ParetoOptimal/gemma-4-cal-gguf), our own fine-tune of
 Gemma-4 E4B purpose-built for one job: turning messy human conversation into calendar-ready
 structure.** The model doesn't chat. It reads a thread (or a flyer photo) and emits a single
 validated **ActionPlan** — events with exact ISO datetimes, conflicts, proposed alternatives, a
@@ -205,7 +193,7 @@ Two caveats:
 app.py                 # Gradio + FastAPI entrypoint (the Space)
 server/
   agent.py             # thread (+images) -> validated ActionPlan
-  orchestrator.py      # Run the agents: MiniCPM planner driving our own MCP tools
+  orchestrator.py      # Agent tab: MiniCPM planner driving our own MCP tools
   schema.py            # Event / Conflict / ActionPlan pydantic models
   model.py             # llama.cpp load: GGUF + vision mmproj, constrained JSON
   imageutil.py         # image -> base64 data URI
@@ -263,7 +251,7 @@ config works anywhere llama.cpp runs:
 
 ```bash
 export USE_STUB_EXTRACTOR=0
-export MODEL_HF_REPO="build-small-hackathon/gemma-4-cal-gguf"
+export MODEL_HF_REPO="ParetoOptimal/gemma-4-cal-gguf"
 export MODEL_FILE="gemma-cal-e4b-Q4_K_M.gguf"     # ~5 GB edge fine-tune (what the Space serves)
 export MMPROJ_REPO="unsloth/gemma-4-E4B-it-GGUF"  # the E4B's own vision projector
 export MMPROJ_FILE="mmproj-F16.gguf"              # enables screenshot/vision input
@@ -321,7 +309,7 @@ parent whose family calendar is buried in a noisy class group chat.
 | Award | Why this submission qualifies |
 |---|---|
 | 🟢 **Modal Awards** (best Modal-powered apps) | **Modal powered the development of the platform's model end-to-end** — required note, gladly given: [`training/modal_train.py`](./training/modal_train.py) (QLoRA fine-tune on serverless A100/H100s, Volumes caching weights), [`training/modal_eval.py`](./training/modal_eval.py) + [`modal_quant_eval.py`](./training/modal_quant_eval.py) (the task eval served on llama.cpp inside Modal, incl. an f16/Q8_0/Q4_K_M quantization study and the regex/text/vision A/B harness), and [`training/gated_retrain.py`](./training/gated_retrain.py) (train → staging → eval → promote *only past the gate* — eight regressed models rejected, every run a Modal job). |
-| 🌱 **OpenBMB Awards** (standout MiniCPM builds, per track) | The **agent is planned by OpenBMB MiniCPM** (`openbmb/MiniCPM4.1-8B-GGUF`, Q4; the 1B variant is a config switch) on a second local llama-server, driving this Space's own MCP tools (`extract_events → check_conflicts → make_ics`) as a visible multi-step agent ([`server/orchestrator.py`](./server/orchestrator.py)). MiniCPM is the agent's brain, not a garnish. |
+| 🌱 **OpenBMB Awards** (standout MiniCPM builds, per track) | The **Agent tab is planned by OpenBMB MiniCPM** (`openbmb/MiniCPM4.1-8B-GGUF`, Q4; the 1B variant is a config switch) on a second local llama-server, driving this Space's own MCP tools (`extract_events → check_conflicts → make_ics`) as a visible multi-step agent ([`server/orchestrator.py`](./server/orchestrator.py)). MiniCPM is the agent's brain, not a garnish. |
 
 *(Not claimed: the OpenAI Track — no Codex-attributed commits — and the NVIDIA Nemotron Quest —
 different model family. We'd rather be honest than eligible.)*
@@ -334,7 +322,7 @@ different model family. We'd rather be honest than eligible.)*
 | 🎨 **Off-Brand Award** | Custom landing page, hero + carousel, grouped nav, bespoke results cards and Activity dashboard — [`ui/blocks.py`](./ui/blocks.py) + [`static/app.css`](./static/app.css), far past the stock Gradio look. |
 | 🐜 **Tiny Titan** | The platform's one and only model is **Gemma E4B — ~4B *effective* parameters** (~5 GB at Q4, serves on a 16 GB T4 or a laptop), and a 1B MiniCPM planner variant is a config switch. Honest framing: E4B is a MatFormer "effective-4B" — judges' call whether that's tiny enough. |
 | 🎬 **Best Demo** | App + demo video + social post as one package — storyboard with every quest named on-camera in [`docs/demo-script.md`](./docs/demo-script.md). |
-| 🤖 **Best Agent** | The MiniCPM-planned, MCP-tool-driven agent above — real multi-step tool use, every model under the 32B cap. |
+| 🤖 **Best Agent** | The MiniCPM-planned, MCP-tool-driven Agent tab above — real multi-step tool use, every model under the 32B cap. |
 | 🃏 **Judges' Wildcard** | No entry needed — but if "eval-gated fine-tuning with a public failure post-mortem" fits no category, we know where to find you. |
 
 ### Collectable quests — all six claimed
@@ -342,11 +330,11 @@ different model family. We'd rather be honest than eligible.)*
 | Quest | Evidence |
 |---|---|
 | 🔌 **Off the Grid** (local-first, no cloud APIs) | All inference is llama.cpp inside the Space; the only optional outbound call is the user's own Google Calendar push. |
-| 🎯 **Well-Tuned** (published fine-tune) | [`gemma-cal` E4B](https://huggingface.co/build-small-hackathon/gemma-4-cal-gguf) — our QLoRA fine-tune **is the model production serves**, shipped through the eval gate with the [honest scorecard public](./docs/eval-roadmap.md). |
+| 🎯 **Well-Tuned** (published fine-tune) | [`gemma-cal` E4B](https://huggingface.co/ParetoOptimal/gemma-4-cal-gguf) — our QLoRA fine-tune **is the model production serves**, shipped through the eval gate with the [honest scorecard public](./docs/eval-roadmap.md). |
 | 🎨 **Off-Brand** (custom UI) | See the Off-Brand Award case above. |
 | 🦙 **Llama Champion** (llama.cpp runtime) | The official `ghcr.io/ggml-org/llama.cpp` server image runs the GGUF + vision mmproj ([`Dockerfile`](./Dockerfile), [`scripts/start_space.sh`](./scripts/start_space.sh)). |
 | 📡 **Sharing is Caring** (open trace on the Hub) | Redacted agent traces published to [`ParetoOptimal/offgridschedula-traces`](https://huggingface.co/datasets/ParetoOptimal/offgridschedula-traces) — one click from the Activity tab. |
-| 📓 **Field Notes** (write-up) | [`FIELD_NOTES.md`](./FIELD_NOTES.md) + the [eval-gated fine-tuning post-mortem](./docs/blog-eval-gated-finetuning.md) + [project blog](https://huggingface.co/blog/build-small-hackathon/offgridschedula). |
+| 📓 **Field Notes** (write-up) | [`FIELD_NOTES.md`](./FIELD_NOTES.md) + the [eval-gated fine-tuning post-mortem](./docs/blog-eval-gated-finetuning.md) + [project blog](./docs/blog-offgridschedula.md). |
 
 ## Fine-tune on Modal (GPU)
 
@@ -433,3 +421,5 @@ gh variable set SPACE_HEALTH_URL -b "https://<owner>-<space>.hf.space/health"
 CI installs `requirements-ci.txt` (excludes `llama-cpp-python` and the Google libs — both are
 imported lazily and not needed for the stub-mode tests). A weekly Claude `/schedule` routine handles
 the judgment work (grow `training/data/dataset.jsonl` → PR, triage CI failures).
+
+See **[PLAN.md](./PLAN.md)** for the full design, phases, and verification steps.

app.py

@@ -11,7 +11,7 @@ from fastapi import BackgroundTasks, FastAPI, Header, HTTPException, Request
 from fastapi.responses import HTMLResponse, JSONResponse, RedirectResponse
 from pydantic import BaseModel
 
-from server import dedup, events, health, threads
+from server import dedup, events, threads
 from server.pipeline import AgentRequest, AgentResponse, run_pipeline
 from ui.blocks import CAROUSEL_JS, CSS, THEME, build_demo
 
@@ -134,10 +134,8 @@ def ingest(batch: IngestBatch, background_tasks: BackgroundTasks,
 
 
 @app.get("/health")
-def health_route():
-    # Liveness + hardware-adequacy (device/model/degraded/reason). The on-page
-    # status banner and the maintenance monitor both read this.
-    return health.health_status()
+def health():
+    return {"ok": True}
 
 
 # --- Per-user Google Calendar OAuth (web flow) ----------------------------- #
@@ -254,19 +252,6 @@ if SERVE == "uvicorn":
     from starlette.responses import Response as _Response
 
     _CAROUSEL_INLINE = f'<script id="cz-inline-js">({CAROUSEL_JS})();</script>'
-    # Status banner: fetch /health on load and reveal #status-banner if degraded
-    # (e.g. real model on CPU-only hardware). Same inline-script pattern as the
-    # carousel, since js= is unreliable on a mounted app; it polls for the element
-    # because Gradio renders it client-side after </body>.
-    _BANNER_JS = (
-        "(function(){fetch('/health').then(function(r){return r.json();})"
-        ".then(function(h){if(!h||!h.degraded){return;}(function s(){"
-        "var b=document.getElementById('status-banner');"
-        "if(!b){return setTimeout(s,400);}"
-        "b.textContent='\\u26a0\\ufe0f '+(h.reason||'This Space needs a GPU.')+' \\u26a0\\ufe0f';"
-        "b.style.display='block';})();}).catch(function(){});})();"
-    )
-    _BANNER_INLINE = f'<script id="cz-banner-js">{_BANNER_JS}</script>'
 
     @app.middleware("http")
     async def _inject_carousel_js(request, call_next):  # noqa: ANN001
@@ -276,7 +261,7 @@ if SERVE == "uvicorn":
         body = b"".join([chunk async for chunk in resp.body_iterator])
         html = body.decode("utf-8", "ignore")
         if "cz-inline-js" not in html and "</body>" in html:
-            html = html.replace("</body>", _CAROUSEL_INLINE + _BANNER_INLINE + "</body>", 1)
+            html = html.replace("</body>", _CAROUSEL_INLINE + "</body>", 1)
         headers = dict(resp.headers)
         headers.pop("content-length", None)  # body length changed; let Starlette recompute
         return _Response(content=html, status_code=resp.status_code,

docs/blog-offgridschedula.md

@@ -0,0 +1,181 @@
+---
+title: "Off the Grid, On Schedule: a local-first, fine-tuned agent that turns group chats into calendar events"
+thumbnail: /blog/assets/offgridschedula/thumbnail.png
+authors:
+- user: ParetoOptimal
+---
+
+# Off the Grid, On Schedule
+
+> **TL;DR**
+> - **OffGridSchedula** turns a pasted group chat — or a screenshot of a flyer or invite — into calendar events, with conflicts caught and a reply drafted, then a local `.ics` you own.
+> - It runs a **fine-tuned Gemma 4** through **llama.cpp**, **in the Space**. No cloud AI APIs, no account, no app to install.
+> - We built a full **QLoRA → GGUF** fine-tuning pipeline with an **eval gate** that refuses to publish a model that doesn't clear the bar — and used it to ship an own edge model at parity with the base.
+> - It's also an **MCP server**: any MCP-aware agent can call `extract_events` / `make_ics` / `check_conflicts` as tools.
+> - 👉 Try it: [**ParetoOptimal/OffGridSchedula**](https://huggingface.co/spaces/ParetoOptimal/OffGridSchedula) · Model: [**gemma-4-cal-gguf**](https://huggingface.co/ParetoOptimal/gemma-4-cal-gguf) · Traces: [**offgridschedula-traces**](https://huggingface.co/datasets/ParetoOptimal/offgridschedula-traces)
+
+## Contents
+- [The problem](#the-problem)
+- [What we built](#what-we-built)
+- [Architecture](#architecture)
+- [Fine-tuning Gemma 4 for calendars](#fine-tuning-gemma-4-for-calendars)
+- [Off the grid: llama.cpp in a Space](#off-the-grid-llamacpp-in-a-space)
+- [From app to agent: MCP, memory, and shared traces](#from-app-to-agent-mcp-memory-and-shared-traces)
+- [Lessons learned](#lessons-learned)
+- [What's next](#whats-next)
+- [Get started](#get-started)
+- [Acknowledgements & citation](#acknowledgements--citation)
+
+## The problem
+
+Every parent knows this chat. The class group thread scrolls past: *"Picture day is Thursday at 9am, wear the green shirt."* *"Practice moves to Tuesday 5pm this week."* *"RSVP by Friday for the party."* You read it once, mean to add it later, and miss it.
+
+That's the person we built for — not "users" in the abstract, but one busy parent whose kid's school and activity events are buried in noise. It's an honest fit for a small, local model: the input is a handful of recent messages or a screenshot, the output is a few calendar events, and the whole thing should work from a phone browser with nothing to install.
+
+![The dark hero of the OffGridSchedula landing page: "Schedule your invite before it slips away."](assets/offgridschedula/hero.png)
+*The landing page. Paste a chat or a screenshot; get events back.*
+
+## What we built
+
+Paste the chat (or attach a screenshot of a flyer/invite). The agent returns:
+
+1. **The events** — title, start/end, location, a sensible default reminder.
+2. **A conflict check** against a calendar you upload (`.ics`), with clashes flagged.
+3. **A ready-to-send reply** ("Got it — adding both, thanks!").
+
+Everything is **surfaced for review before anything is saved**. The output is a local `.ics` file you can import into any calendar, with an optional one-click Google Calendar push. No inbox access, no auto-reading — it reads only what you choose to paste.
+
+## Architecture
+
+The app is a single **Gradio 6** Blocks UI mounted alongside a **FastAPI** app on one port, so the same Space serves the UI, a `/agent` endpoint, and an MCP server.
+
+The model never decides *whether two events clash* — it decides **what** the events are; deterministic interval math decides **when they conflict**. The model emits a single constrained JSON object (a pydantic `ActionPlan`), grammar-constrained so it's always valid:
+
+```python
+class Event(BaseModel):
+    title: str
+    start: str            # ISO 8601
+    end: str | None = None
+    location: str | None = None
+    reminder_minutes: int | None = 30
+
+class ActionPlan(BaseModel):
+    reasoning: str
+    events: list[Event] = []
+    conflicts: list[Conflict] = []
+    proposed_times: list[str] = []
+    reply_draft: str = ""
+    needs_clarification: bool = False
+```
+
+Inference sits behind one seam — an `INFERENCE_BASE_URL` env var. Unset, the Space loads a GGUF and runs it in-process via llama.cpp. Set, it points at any OpenAI-compatible `llama-server` (e.g. one running on your own machine). Same app, two deployment shapes.
+
+A nice consequence: a **stub extractor** (`USE_STUB_EXTRACTOR=1`, a tiny regex heuristic) lets the entire app, the test suite, and the demo run with **no GPU at all**. The expensive dependency is optional from day one — which means the cheap path doubles as the CI harness and the free-tier preview.
+
+## Fine-tuning Gemma 4 for calendars
+
+The fun part. We fine-tuned **Gemma 4** to read messy chats into the `ActionPlan` schema, and — just as importantly — built the **machinery to know whether a fine-tune is actually any good**.
+
+**The pipeline.** QLoRA via Unsloth (4-bit, r=16) → merge → `convert_hf_to_gguf.py` → `llama-quantize Q4_K_M` → published as [`ParetoOptimal/gemma-4-cal-gguf`](https://huggingface.co/ParetoOptimal/gemma-4-cal-gguf). Training data is hand-authored examples plus a **SMCalFlow** importer (Microsoft Semantic Machines, CC BY-SA 4.0) that resolves LISP "dataflow" calendar programs into concrete, self-consistent datetimes — directly training the relative-date skill ("next Thursday", "the 14th") against a spread of 2026 reference dates.
+
+**The real win: an eval gate.** Generic benchmarks (MMLU, etc.) don't apply to a narrow extraction task, so we wrote a task-specific scorer (`training/eval.py`) over a held-out set, and made it the **publishing process** (`training/gated_retrain.py`):
+
+> Retrain → upload to a **staging** filename → score on the held-out eval → **gate**
+> (`schema_validity ≥ 0.95`, `event_f1 ≥ 0.81`, `start-exact recall ≥ 0.773`) →
+> **PASS** promotes staging to production (a free server-side copy); **FAIL** deletes staging, production untouched.
+
+No retrain reaches users unless it beats the current best. That gate has already earned its keep — it caught regressions on bigger retrains and refused to ship them, so production was never degraded by an experiment.
+
+Here's the fine-tune's scorecard (Q4_K_M, n=28), with the base model as context:
+
+| Metric | Fine-tune `gemma-4-cal` | Base Gemma 4 (context) |
+| --- | --- | --- |
+| schema validity | 1.00 | 1.00 |
+| no-event accuracy | 1.00 | 1.00 |
+| **clarification recall** | **1.00** | 0.75 |
+| end-time exact | 1.00 | 1.00 |
+| event precision | 0.85 | 1.00 |
+| start-exact recall | 0.77 | 0.955 |
+| event F1 | 0.81 | 0.977 |
+
+The standout is **clarification discipline** — the fine-tune reliably asks when a thread is "date TBD" instead of guessing, where the base model sometimes plows ahead. The base model is genuinely strong on this narrow task, so rather than argue about it, **we let the eval decide what production serves** — and we keep the published fine-tune as our Well-Tuned artifact.
+
+**Where fine-tuning shines: the edge model.** We re-aimed the effort at a **Gemma 4 E4B (~4B)** model that runs on the **free CPU tier** — no paid GPU. Six gated runs, each fixing a diagnosed miss, with schema validity holding at **1.0 the entire time**. On an expanded 60-example eval, our fine-tuned E4B landed at **F1 0.97 / recall 0.96 / clarification 1.0** — an exact statistical tie with stock E4B (identical 48/1/2 true/false/missed), at **zero quality cost** and on a model small enough to run on a laptop. An own, local, parity fine-tune is exactly the "small + well-tuned" sweet spot the constraint rewards.
+
+Two honest notes the eval forced us to write down:
+- **Quantization was exonerated.** We tested the same weights at f16 / Q8 / Q4 — precision wasn't the bottleneck. Good to know before chasing a fix that wouldn't have helped.
+- **Both the base and the fine-tune are ≤ 32B** (31B and ~4B), satisfying the size constraint, and the "no cloud AI" rule applies to the *running app* — dataset prep can use any offline tooling.
+
+## Off the grid: llama.cpp in a Space
+
+"Local-first" meant: inference runs **in the Space**, not via a hosted LLM API. We started on ZeroGPU but pivoted to a **Docker Space** built on the official `ggml-org/llama.cpp` image — `llama-server` is always warm, and (crucially) we don't pay a multi-minute build cost compiling llama.cpp from source on the free builders. The big 31B GGUF wants a GPU; the **E4B variant runs on the free CPU tier**, which is the honest "runs on a laptop" story.
+
+The whole point: your messages never touch a third-party AI service. The default output is a file you own.
+
+## From app to agent: MCP, memory, and shared traces
+
+**It's an MCP server.** Gradio's `mcp_server=True` turns typed functions into tools any MCP-aware client (Claude Desktop, Cursor, …) can call — so a larger agent can use scheduling as an **off-grid skill**:
+
+```python
+def extract_events(thread: str, images: list[str] | None = None) -> dict:
+    """Extract calendar events from a chat thread (and optional screenshots).
+
+    Args:
+        thread: the conversation text to scan for events.
+        images: optional base64 data-URIs of screenshots.
+    Returns: an ActionPlan (events, conflicts, proposed_times, reply_draft).
+    """
+```
+
+…plus `make_ics(events)` and `check_conflicts(events, ics_base64)`. The MCP schema is generated straight from the type hints and docstrings.
+
+**Memory that grows with you, on *your* device.** Facts like *"Dana is the soccer coach"* or *"you decline Mondays"* personalize every extraction. They live in your browser's **localStorage** — per-user by default, never on a server — and are injected into the prompt at run time. You can seed them with a 10-second onboarding, or import contacts (`.vcf`/CSV) and a calendar (`.ics`), parsed locally.
+
+**Sharing is Caring.** One click publishes a **redacted** run trace to a public dataset, [`offgridschedula-traces`](https://huggingface.co/datasets/ParetoOptimal/offgridschedula-traces), for others to learn from. The trace is structural by design — counts and stage names, never your chat text — and redaction is forced for anything public.
+
+## Lessons learned
+
+A field-notes dump of things that cost us time so they don't cost you yours:
+
+> **Gradio 6 ignores `css=`/`js=` set on `gr.Blocks` when it's mounted under FastAPI.** Custom styling silently doesn't apply. The fix that stuck: inject the CSS at mount time and the JS as a real inline `<script>` before `</body>` via middleware, so it always executes:
+> ```python
+> html = html.replace("</body>", f"<script>({CAROUSEL_JS})()</script></body>")
+> ```
+
+> **`display:none` ≠ "responsive."** Gradio's tab strip needed explicit CSS to hide on narrow screens; our nav buttons click the *real* hidden Gradio tabs underneath. A `MutationObserver` re-wires everything after each Gradio swap so dynamic updates don't break it.
+
+> **Make the expensive dependency optional on day one.** The stub extractor + lazy imports meant the same codebase is our test harness, our offline demo, and our free tier — all at once.
+
+> **The HF MCP badge is Gradio-SDK only.** A pure FastAPI app or a bare `llama-server` won't advertise MCP; you need Gradio's `mcp_server=True` and typed, docstringed tool functions.
+
+> **Traces are redacted by construction, not after the fact.** The activity bus only ever emits counts and short status strings; the one free-text field (a chat name) is stripped. An allowlist beats a denylist when the cost of a leak is someone's private calendar.
+
+> **Be honest about "off the grid."** A 31B GGUF (~18–20 GB) wants a GPU — and "your own cloud GPU" is easy to conflate with "a cloud AI API." We kept the headline model honest and shipped the E4B edge variant as the truly-local path.
+
+And the meta-lesson: **an eval that gates publishing changes how you work.** Once "does it beat the bar?" is automated, you stop arguing about vibes and start shipping only what's measurably better — or, as happened here, you learn that a strong prompt on a capable base is sometimes the right answer, and you keep your fine-tune for where it actually wins.
+
+## What's next
+
+- Polish the optional Mac collector (reading `~/Library/Messages/chat.db`, including the `attributedBody` blobs modern Messages uses).
+- Grow the on-device memory beyond contacts and preferences.
+- Push the E4B edge model further so the fully-local path matches the 31B headline on the hardest relative-date cases.
+
+## Get started
+
+- **Try it (30 seconds, no install):** open the [Space](https://huggingface.co/spaces/ParetoOptimal/OffGridSchedula), tap **Try a sample**, and watch a chat become events + a conflict check + a reply.
+- **The model:** [`ParetoOptimal/gemma-4-cal-gguf`](https://huggingface.co/ParetoOptimal/gemma-4-cal-gguf) (QLoRA fine-tune of Gemma 4, GGUF for llama.cpp).
+- **The traces dataset:** [`ParetoOptimal/offgridschedula-traces`](https://huggingface.co/datasets/ParetoOptimal/offgridschedula-traces).
+- **Use it as a tool:** add the Space as an MCP server and call `extract_events` from your own agent.
+
+## Acknowledgements & citation
+
+Built on the shoulders of [Gemma 4](https://huggingface.co/google), [llama.cpp / ggml](https://github.com/ggml-org/llama.cpp), [Gradio](https://www.gradio.app/), and [Unsloth](https://github.com/unslothai/unsloth). Training data uses **SMCalFlow** (Semantic Machines et al., *"Task-Oriented Dialogue as Dataflow Synthesis,"* TACL 2020; CC BY-SA 4.0).
+
+```bibtex
+@misc{offgridschedula2026,
+  title  = {OffGridSchedula: a local-first, fine-tuned scheduling agent},
+  author = {ParetoOptimal},
+  year   = {2026},
+  howpublished = {\url{https://huggingface.co/spaces/ParetoOptimal/OffGridSchedula}}
+}
+```

docs/build-small-submission.md

@@ -10,12 +10,12 @@ Tags claimed in the README frontmatter use the field guide's namespaced taxonomy
 
 | # | Rule | Status | Evidence |
 |---|------|--------|----------|
-| 1 | Every model under 32B parameters | ✅ | Two local models, both far under the cap: extraction is [`gemma-cal` E4B](https://huggingface.co/build-small-hackathon/gemma-4-cal-gguf) (~4B effective params, ~5 GB GGUF at Q4) and planning is [`openbmb/MiniCPM5-1B`](https://huggingface.co/openbmb/MiniCPM5-1B-GGUF) (1B). |
-| 2 | Gradio app, hosted as an HF Space (Docker OK) | ✅ | [`app.py`](../app.py) is a Gradio Blocks app served from a Docker SDK Space running llama.cpp, now hosted in the hackathon org: [`build-small-hackathon/OffGridSchedula`](https://huggingface.co/spaces/build-small-hackathon/OffGridSchedula). |
-| 3 | Demo video | ✅ | Recorded and linked from the README: [youtu.be/m-o0u9X3tI4](https://youtu.be/m-o0u9X3tI4) (storyboard in [`docs/demo-script.md`](./demo-script.md)). |
-| 4 | Social media post, linked from the README | ✅ | Published and linked from the README: [X (1)](https://x.com/nate_mauer/status/2064920352845709419), [X (2)](https://x.com/nate_mauer/status/2065661878441750916), and [LinkedIn](https://www.linkedin.com/feed/update/urn:li:ugcPost:7471440639969132545) (drafts in [`docs/social-post.md`](./social-post.md)). |
+| 1 | Every model under 32B parameters | ✅ | The platform's one and only model is [`gemma-cal` E4B](https://huggingface.co/ParetoOptimal/gemma-4-cal-gguf) (~4B effective parameters, ~5 GB GGUF at Q4) — far under the cap. |
+| 2 | Gradio app, hosted as an HF Space (Docker OK) | ✅ / ⚠️ | [`app.py`](../app.py) is a Gradio Blocks app served from a Docker SDK Space running llama.cpp. ⚠️ Still to do: upload the Space **inside the `build-small-hackathon` org** (it currently lives in `ParetoOptimal`). |
+| 3 | Demo video | ⚠️ to record | Script/storyboard ready in [`docs/demo-script.md`](./demo-script.md); video link goes in the README once recorded. |
+| 4 | Social media post, linked from the README | ⚠️ to post | Drafts ready in [`docs/social-post.md`](./social-post.md); link goes in the README once published. |
 | 5 | ≤ 10 ZeroGPU apps per user | ✅ n/a | Runs on cpu-basic (stub preview) or a dedicated T4 — no ZeroGPU dependency. |
-| 6 | README frontmatter tags + short write-up of idea & tech | ✅ | Namespaced tags + the idea-and-tech write-up are in [`README.md`](../README.md). |
+| 6 | README frontmatter tags + short write-up of idea & tech | ✅ | Tags + write-up added to [`README.md`](../README.md) (this change). |
 
 ## Track — `track:backyard` (Backyard AI)
 
@@ -36,33 +36,30 @@ Modal powered the **development** of the platform's model end-to-end:
 
 ## Sponsor prize — `sponsor:openbmb` (Best MiniCPM Build)
 
-Clicking **Run the agents** invokes **OpenBMB MiniCPM** as the planner (`openbmb/MiniCPM5-1B-GGUF`;
-the larger `MiniCPM4.1-8B` variant is a config switch) on a second local llama.cpp instance. It
-drives this Space's own MCP tools (`extract_events` → `check_conflicts` → `make_ics`) as a visible
+The **Agent tab** is planned by **OpenBMB MiniCPM** (`openbmb/MiniCPM4.1-8B-GGUF`, Q4; the ≤4B
+`MiniCPM5-1B` variant is a config switch) served by a second local llama.cpp instance. It drives
+this Space's own MCP tools (`extract_events` → `check_conflicts` → `make_ics`) as a visible
 multi-step agent ([`server/orchestrator.py`](../server/orchestrator.py)) — MiniCPM is core to the
-agent experience, not a garnish (a deterministic scripted plan is the fallback when the planner
-isn't configured). Also the natural evidence for the judged **Best Agent** award.
+agent experience, not a garnish. Also the natural evidence for the judged **Best Agent** award.
 
 ## Achievement badges (self-declared, all claimed)
 
 | Tag | Badge | Evidence |
 |-----|-------|----------|
 | `achievement:offgrid` | Off the Grid | All inference runs inside the Space via llama.cpp — no cloud AI APIs. The only optional outbound call is the user's own Google Calendar push. |
-| `achievement:welltuned` | Well-Tuned | [`build-small-hackathon/gemma-4-cal-gguf`](https://huggingface.co/build-small-hackathon/gemma-4-cal-gguf) — our published QLoRA fine-tune of Gemma-4 E4B **is the model production serves**, shipped through the eval gate with the [honest scorecard public](./eval-roadmap.md). |
+| `achievement:welltuned` | Well-Tuned | [`ParetoOptimal/gemma-4-cal-gguf`](https://huggingface.co/ParetoOptimal/gemma-4-cal-gguf) — our published QLoRA fine-tune of Gemma-4 E4B **is the model production serves**, shipped through the eval gate with the [honest scorecard public](./eval-roadmap.md). |
 | `achievement:offbrand` | Off-Brand | Custom landing page, grouped nav, dark hero + carousel, elevated tool card, bespoke CSS/JS ([`ui/blocks.py`](../ui/blocks.py), [`static/app.css`](../static/app.css)) — far past the stock Gradio look. |
 | `achievement:llama` | Llama Champion | The official `ghcr.io/ggml-org/llama.cpp` server image runs the GGUF + vision mmproj ([`Dockerfile`](../Dockerfile), [`scripts/start_space.sh`](../scripts/start_space.sh)). |
 | `achievement:sharing` | Sharing is Caring | Redacted agent traces published to the public dataset [`ParetoOptimal/offgridschedula-traces`](https://huggingface.co/datasets/ParetoOptimal/offgridschedula-traces) — one-click from the Activity tab, or [`training/share_trace.py`](../training/share_trace.py). |
-| `achievement:fieldnotes` | Field Notes | [`FIELD_NOTES.md`](../FIELD_NOTES.md) (build retrospective) + [`docs/blog-eval-gated-finetuning.md`](./blog-eval-gated-finetuning.md) (fine-tuning post-mortem) + the [published project blog](https://huggingface.co/blog/build-small-hackathon/offgridschedula) ([source](./blog-offgridschedula.md)). |
+| `achievement:fieldnotes` | Field Notes | [`FIELD_NOTES.md`](../FIELD_NOTES.md) (build retrospective) + [`docs/blog-eval-gated-finetuning.md`](./blog-eval-gated-finetuning.md) (fine-tuning post-mortem) + [`docs/blog-offgridschedula.md`](./blog-offgridschedula.md). |
 
-Sponsor prizes **not** claimed: OpenAI Codex (no Codex-attributed commits) and NVIDIA Nemotron
-(different model family). The cash bonus badges (Off Brand, Tiny Titan, Best Demo, Best Agent,
-Bonus Quest Champion, Judges' Wildcard) are judged across all submissions and take no tags.
+Sponsor prizes **not** claimed: OpenAI Codex (no Codex-attributed commits), OpenBMB MiniCPM and
+NVIDIA Nemotron (different model family). The cash bonus badges (Off Brand, Tiny Titan, Best
+Demo, Best Agent, Bonus Quest Champion, Judges' Wildcard) are judged across all submissions and
+take no tags.
 
-## Status
+## Remaining before the June 15 deadline
 
-All six hard rules are met — nothing outstanding:
-
-- The Space is live in the hackathon org: [`build-small-hackathon/OffGridSchedula`](https://huggingface.co/spaces/build-small-hackathon/OffGridSchedula).
-- The model is published at [`build-small-hackathon/gemma-4-cal-gguf`](https://huggingface.co/build-small-hackathon/gemma-4-cal-gguf) (the planner is [`openbmb/MiniCPM5-1B-GGUF`](https://huggingface.co/openbmb/MiniCPM5-1B-GGUF)).
-- The [demo video](https://youtu.be/m-o0u9X3tI4) and the social posts (X + LinkedIn) are published and linked from the README.
-- The write-up is live as a Hugging Face blog post: [build-small-hackathon/offgridschedula](https://huggingface.co/blog/build-small-hackathon/offgridschedula).
+1. **Upload the Space into the `build-small-hackathon` org** (hard rule #2 — the ParetoOptimal Space doesn't count as a submission).
+2. Record the demo video (script in [`docs/demo-script.md`](./demo-script.md)), host it publicly, link it from the README.
+3. Publish the social post (drafts in [`docs/social-post.md`](./social-post.md)), link it from the README.

docs/demo-script.md

@@ -0,0 +1,34 @@
+# OffGridSchedula — 95-second demo video script & storyboard
+
+**Goal:** show a real busy parent turn a messy group chat into calendar events — locally, on a small
+model — and name every claimed bonus quest out loud at its evidence moment. "Show, tell the judges."
+
+> Recording it? The full operator's runbook — environment prep, demo-calendar
+> setup, the talk track and the reasoning behind each line —
+> is in **[demo-walkthrough.md](./demo-walkthrough.md)**.
+
+**Model:** `ParetoOptimal/gemma-4-cal-gguf` — our fine-tune of **Gemma E4B** (~4B effective
+params, far under the 32B cap), run via llama.cpp. (The 31B gguf in the repo is a legacy
+artifact; the platform serves the E4B.)
+
+**Bonus quests called out on camera** (field-guide names, verbatim): **Off the Grid** ·
+**Well-Tuned** · **Llama Champion** · **Sharing is Caring** · **Off-Brand**. The sixth claimed
+quest, **Field Notes**, lives on the end card + README (it's a write-up, not a screen).
+
+| # | Time | Shot (visual) | Voiceover / on-screen text |
+|---|------|---------------|----------------------------|
+| 1 | 0:00–0:08 | Phone screen: a noisy class group chat scrolling ("Picture day Thursday 9am", "practice moved to Tuesday", "RSVP by Friday"). | "Every parent knows this chat. The dates are in here — and they're easy to miss." |
+| 2 | 0:08–0:20 | Open the Space in a phone browser. Hero: *Catch every invite before it slips away.* Zoom the 🔒 badge. | "OffGridSchedula. No app, no account — a small model runs right in the Space. No cloud APIs anywhere: that's the **Off the Grid** quest — the whole thing runs on the model in front of you." |
+| 3 | 0:20–0:34 | Paste the chat → tap **Find the events**. The "thinking" panel streams; flash the HF model card. | "Paste the chat. The model reading it is **Well-Tuned** — our own fine-tune of Gemma, published on Hugging Face with its eval scorecard — running through the llama.cpp runtime: **Llama Champion**." |
+| 4 | 0:34–0:48 | Results: event cards (Picture Day · Thu 9:00, Practice · Tue 5:00), a ⚠️ conflict badge, free-time chips. | "It pulls out the events, checks them against your calendar, and catches the clash — before anything is saved." |
+| 5 | 0:48–0:58 | Screenshot/flyer upload → an event appears from the image. | "A flyer or screenshot works too — the same local model reads the date, time and place from the picture." |
+| 6 | 0:58–1:10 | Copy the ready-to-send reply; tap **Download .ics**; event drops into the calendar. | "It even drafts the reply. Then the events drop into your calendar — Google, Apple, anything that takes a .ics." |
+| 7 | 1:10–1:22 | Activity tab: live pipeline → click **share trace** → the public Hub dataset page. | "Every agent run is observable — and one click publishes a redacted trace to a public dataset for anyone to learn from. **Sharing is Caring**: the open-trace quest." |
+| 8 | 1:22–1:35 | Slow pan over the custom landing page → **🏆 Submission** tab scorecard (all six quests green) → end card with Space URL. | "And everything you've watched is a custom frontend pushed far past the default Gradio look — **Off-Brand**. Local-first, fine-tuned, llama.cpp, open traces, custom UI — built small, by the rules. Try it free — link below." |
+
+**B-roll / cutaways:** the rotating use-case cards (carpool, appointments, parties); the Activity tab's
+"time saved this week" tiles.
+
+**Capture tips:** record the phone browser at 1080×1920; keep the cursor visible on desktop shots; show
+the network panel offline once to prove no cloud calls; pre-load the traces dataset page in a tab
+for shot 7.

docs/demo-walkthrough.md

@@ -0,0 +1,127 @@
+# Demo video — recording walkthrough & talk track
+
+The end-to-end runbook for recording the public demo video: environment prep,
+the shot-by-shot walkthrough with the exact talk track, and *why each line is
+worded the way it is*. The compact storyboard lives in
+[demo-script.md](./demo-script.md); this document is the operator's guide for
+actually producing it for a general-public audience (the hackathon
+Submission-tab finale is replaced with a public closer).
+
+## Decisions baked into this walkthrough
+
+- **Backend: the live GPU Space.** Record against the real model — streaming
+  output, real extraction, working vision. Never record stub mode
+  (`USE_STUB_EXTRACTOR=1` output is visibly fake and vision is disabled).
+- **Calendar: a brand-new demo Google account** (e.g. `offgridschedula.demo@`),
+  not a personal calendar. Zero PII can appear on camera — no real events, no
+  real email in the OAuth chrome — and the calendar is seeded with exactly the
+  event that produces the on-screen conflict.
+- **The on-camera "event lands in the calendar" moment uses .ics import**, not
+  a server-side OAuth push. `credentials.json`/`token.json` must never live on
+  the public Space; importing the downloaded .ics into the demo account's
+  Google Calendar shows the same payoff with zero server credentials. (An
+  optional locally-recorded one-click-push splice is described at the end.)
+
+## Part A — Prep (before recording day)
+
+### A1. Demo Google account
+1. Create the account; set a neutral profile name ("OffGrid Demo").
+2. In its Google Calendar (local timezone), seed **one clashing event**:
+   `Dentist — Tuesday 5:00 PM`. It collides with "practice moved to Tuesday
+   5pm" in the UI's built-in sample thread, which is what makes the ⚠️ conflict
+   badge fire on camera. Add 1–2 filler events so the calendar looks lived-in.
+3. Export the calendar (Settings → Import & export → Export) and save the
+   unzipped file as `demo-existing-calendar.ics` — this gets uploaded in the UI.
+
+### A2. Assets
+- **Flyer image** for the vision shot: a simple school-event flyer (title,
+  date, time, place) as PNG/JPEG — *not HEIC* (the vision pipeline can't decode
+  it), under 4 MB.
+- **Staged iMessage chat** for the opening phone shot: stage a group chat with
+  demo contacts containing the storyboard lines ("Picture day Thursday 9am",
+  "practice moved to Tuesday 5", "RSVP by Friday") and screen-record it
+  scrolling. Never show a real chat.
+
+### A3. Space
+1. Put the Docker Space on a GPU tier (T4 is enough for E4B) and **restart
+   it** — restarting also clears `/tmp`, so no previously-ingested feed data is
+   visible anywhere in the UI.
+2. Confirm `USE_STUB_EXTRACTOR` is unset and `MMPROJ_FILE` is set (vision).
+3. Dry-run after llama-server health is green: sample thread → real streamed
+   output; upload `demo-existing-calendar.ics` → conflict badge; flyer → event
+   from image.
+4. Relative dates resolve from the **server clock (UTC)** — check the dry-run
+   dates land on the expected weekdays and adjust the seeded Dentist event if
+   needed.
+
+### A4. Recording
+- 1080p+ screen capture (QuickTime / OBS) in a **clean browser profile** logged
+  into the demo Google account only.
+- Record the voiceover separately after screen capture — cleaner than
+  narrating live, and the talk track below is written to be read.
+
+## Part B — Shot list with talk track
+
+| # | Time | Screen | Action | Talk track |
+|---|------|--------|--------|------------|
+| 1 | 0:00–0:08 | iPhone clip | Staged class group chat scrolls past | "Every parent knows this chat. The dates are in here — and they're easy to miss." |
+| 2 | 0:08–0:20 | Browser | Open the Space; hero + badges visible; zoom the 🔒 badge | "OffGridSchedula. No app, no account — a small model runs right in the Space. No cloud APIs anywhere: that's the **Off the Grid** quest — local-first, the whole thing runs on the model in front of you." |
+| 3 | 0:20–0:34 | Schedule flow | Upload `demo-existing-calendar.ics` first, then tap **Try a sample**; thinking panel streams; flash the model card link | "Paste the chat. The model reading it is **Well-Tuned** — our own fine-tune of Gemma, published on Hugging Face with its eval scorecard — and it runs through the llama.cpp runtime: **Llama Champion**." |
+| 4 | 0:34–0:48 | Results | Event cards appear; ⚠️ conflict vs Dentist; free-slot chips | "It pulls out the events, checks your calendar, and catches the clash — before anything is saved." |
+| 5 | 0:48–0:58 | Vision | Start over → drop in the flyer PNG → event extracted from the image | "A flyer or screenshot works too — the same local model reads the date, time and place right off the picture." |
+| 6 | 0:58–1:10 | Export | Copy the drafted reply; **Download .ics**; switch tabs and import it into the demo Google Calendar — events appear on the grid | "It drafts the reply, and the events drop straight into your calendar — Google, Apple, anything that takes a .ics." |
+| 7 | 1:10–1:22 | Activity | Activity tab's live pipeline; click **share trace**; the public dataset page flashes | "Every agent run is observable — and one click publishes a redacted trace to a public Hub dataset for anyone to learn from. That's **Sharing is Caring**: the open trace quest." |
+| 8 | 1:22–1:35 | Closer | Slow pan over the custom landing page → end card with the Space URL | "And everything you've watched — the hero, the cards, that dashboard — is a custom frontend pushed far past the default Gradio look: **Off-Brand**. Open source, runs locally, your messages never leave the machine. Try it free — link below." |
+
+Tip for shot 6: pre-open the demo calendar's import dialog in a second tab so
+the on-camera import is two clicks. Tip for shot 7: have the
+`ParetoOptimal/offgridschedula-traces` dataset page pre-loaded in a tab so the
+"published" beat is one cut, not a page load.
+
+## Why the talk track is worded this way
+
+- **Shot 1 names the pain before the product.** "Every parent knows this chat"
+  earns the next 60 seconds from a general audience that has never heard of
+  local LLMs — the hook is the missed pickup, not the model.
+- **The bonus quests are named out loud, verbatim, at their evidence moments.**
+  This track serves two audiences at once: the public hook stays in shots 1
+  and 4–6, while the field guide's quest names — **Off the Grid** (local-first,
+  no cloud APIs), **Well-Tuned** (published fine-tune), **Llama Champion**
+  (llama.cpp runtime), **Sharing is Caring** (open trace on the Hub), and
+  **Off-Brand** (custom UI past stock Gradio) — are each spoken exactly when
+  the screen shows the proof. Judges score the video against those names;
+  making them explicit means no claimed quest can be missed on a single watch.
+  (The sixth claimed quest, **Field Notes**, is print, not screen — it lives on
+  the end card and in the README, not the voiceover.)
+- **Shot 2 still kills the two adoption objections immediately** ("no app, no
+  account") before the first quest callout — the badge language is framed as a
+  plain-English promise ("the whole thing runs on the model in front of you"),
+  so the callout lands for laypeople too.
+- **Shot 4's "before anything is saved"** is the trust beat — the agent
+  proposes, the human disposes. This line pre-empts the "AI touched my
+  calendar" fear that kills scheduling tools.
+- **Shot 6 generalizes the payoff** ("Google, Apple, anything that takes a
+  .ics") so the demo doesn't read as Google-only — and the on-screen action
+  matches the off-grid story: a local file the user chooses to import.
+- **Shot 8 closes on the three-word value stack** — open source, local,
+  private — and a single call to action, with the Off-Brand callout folded
+  into the visual it describes. People remember one URL and one feeling.
+
+## Part C — Edit & publish
+
+- Assemble: phone clip → screen capture → end card. Speed-ramp model wait time
+  but keep ~2 s of genuine streaming so it reads as live.
+- Burn in captions (most social viewers watch muted). Export 1920×1080;
+  optionally a 1080×1920 vertical crop of shots 3–6 for Shorts/Reels.
+- Pair with the draft copy in [social-post.md](./social-post.md); link the
+  video from the README (Build Small hard rule #3).
+- **Pause or downgrade the GPU Space after recording** unless the closer is
+  meant to drive live traffic.
+
+## Optional: one-click Google Calendar push splice
+
+To show the actual **Add to Google Calendar** button instead of the .ics
+import: run the app locally, complete the one-time OAuth flow as the *demo*
+account to mint a local `token.json`, enable the toggle, and record just that
+click — the UI is pixel-identical and splices cleanly. Never upload
+`credentials.json`/`token.json` to the public Space.

docs/social-post.md

@@ -0,0 +1,36 @@
+# Draft social posts — OffGridSchedula (#BuildSmall)
+
+## X / Twitter (primary)
+
+> Your kid's school events are buried in the class group chat — and you miss them.
+>
+> 🗓️ OffGridSchedula turns a pasted chat (or a flyer screenshot) into calendar events,
+> catches conflicts, and drafts the reply.
+>
+> 🔒 100% local · 🦙 llama.cpp · 🎯 fine-tuned Gemma 4 (≤32B) · no cloud, no account
+>
+> Built for #BuildSmall 👇
+> https://huggingface.co/spaces/ParetoOptimal/OffGridSchedula
+
+## LinkedIn (longer)
+
+> **The dates are always in the group chat. The misses happen anyway.**
+>
+> For the Build-Small hackathon I built **OffGridSchedula** — a tiny, local scheduling agent for one
+> very specific person: a busy parent drowning in a noisy class group chat.
+>
+> Paste the chat (or a screenshot of a flyer/invite) and it returns the events, a conflict check
+> against your calendar, and a ready-to-send reply — all reviewed before anything is saved. Output is a
+> local `.ics`, with optional Google Calendar push.
+>
+> The honest part: it's a *small* model doing a *small* job well. Gemma 4 (31B, ≤32B — fine-tuned with
+> QLoRA and published on the Hub), run through **llama.cpp**, **100% local — no cloud AI APIs**. Custom
+> Gradio UI, agent traces shared as a dataset, full field notes in the repo.
+>
+> Try it (phone browser, no install): https://huggingface.co/spaces/ParetoOptimal/OffGridSchedula
+>
+> #BuildSmall #Gradio #HuggingFace #llamacpp #LocalAI #Gemma
+
+## Alt text for the demo clip
+A phone browser pasting a school group chat into OffGridSchedula; it extracts "Picture Day, Thu 9am"
+and "Practice, Tue 5pm", flags a conflict, and offers a Download .ics button — all running locally.

server/health.py

@@ -1,54 +0,0 @@
-"""Liveness + a hardware-adequacy signal for the UI banner and external monitors.
-
-`health_status()` powers both `GET /health` and the on-page status banner. It
-reports `degraded: true` when the *real* model would run on CPU-only hardware
-(where extraction can be slow or time out). `FORCE_DEGRADED=1` forces it on so
-the banner can be exercised without actually changing the Space's hardware.
-"""
-from __future__ import annotations
-
-import os
-
-
-def gpu_available() -> bool:
-    """Best-effort GPU probe. This app serves via llama.cpp (no torch), so we
-    can't rely on torch.cuda — check for an NVIDIA device or `nvidia-smi`."""
-    import glob
-    import shutil
-    import subprocess
-
-    if glob.glob("/dev/nvidia[0-9]*"):
-        return True
-    if shutil.which("nvidia-smi"):
-        try:
-            return subprocess.run(["nvidia-smi"], capture_output=True, timeout=5).returncode == 0
-        except Exception:  # noqa: BLE001  any probe failure -> treat as no GPU
-            return False
-    return False
-
-
-def health_status() -> dict:
-    """Return liveness + the degraded/device/model signal (read at call time)."""
-    if os.environ.get("FORCE_DEGRADED") == "1":
-        return {
-            "ok": True, "device": "cpu", "model": "real", "degraded": True,
-            "reason": "Running the model on CPU-only hardware. Extraction may be slow "
-                      "or time out. Upgrade to a GPU.",
-        }
-    # Stub mode is a deliberate, fast, free preview — not a degraded state.
-    if os.environ.get("USE_STUB_EXTRACTOR") == "1":
-        return {"ok": True, "device": "cpu", "model": "stub", "degraded": False, "reason": ""}
-
-    # Real model. On the Space, INFERENCE_BASE_URL points at the *local* llama-server,
-    # so local inference still depends on this host having a GPU. A non-localhost URL
-    # means inference runs elsewhere, so this host's hardware is irrelevant.
-    base = os.environ.get("INFERENCE_BASE_URL", "")
-    local = (not base) or ("127.0.0.1" in base) or ("localhost" in base)
-    gpu = gpu_available()
-    degraded = local and not gpu
-    device = "cuda" if (local and gpu) else ("cpu" if local else "remote")
-    reason = (
-        "Running the model on CPU-only hardware. Extraction may be slow or time out. "
-        "Upgrade to a GPU." if degraded else ""
-    )
-    return {"ok": True, "device": device, "model": "real", "degraded": degraded, "reason": reason}

static/app.css

@@ -378,25 +378,15 @@ html { overflow-x: hidden; scroll-behavior: smooth; }
 
 /* Hide the default Gradio tab strip — the banner is the only navigation now.
    IMPORTANT: don't use display:none / width:0 — Gradio 6's tab bar is responsive
-   (measures its width and overflows tabs that don't fit into a "more" menu as a
-   non-interactive clone the nav JS can't click). Collapsing it while keeping its
-   NATURAL width broke on mobile: a ~390px phone viewport can't fit 7 tabs, so the
-   later ones (Memory/Feed/Submission, index >= 3) overflowed into that dead clone
-   and their banner links did nothing — while desktop's ~1100px fit them all.
-   Fix: park the strip far off-screen at a FIXED LARGE width so the responsive
-   measurement always sees room for every tab on one row, no overflow menu is
-   ever built, and all tab buttons stay real and programmatically clickable. */
+   (measures clientWidth and overflows tabs into a "more" menu), and zero width
+   pushes tabs into a non-interactive clone so the nav JS can't click them.
+   Instead collapse it vertically while KEEPING its width, so measurement works,
+   all tab buttons stay in the real container, and programmatic .click() switches. */
 .gradio-container .tab-wrapper,
 .gradio-container .tab-nav {
   height: 0 !important; min-height: 0 !important; overflow: hidden !important;
   opacity: 0 !important; margin: 0 !important; padding: 0 !important; border: 0 !important;
   pointer-events: none;
-  /* KEEP the strip from ever overflowing tabs into the dead "more" clone:
-     force its measured width far past the tab count and forbid wrapping, so on
-     a phone all 7 tabs still "fit" and stay real, clickable buttons. height:0 +
-     overflow:hidden keeps it invisible; html{overflow-x:hidden} clips the
-     oversized width so it can't add a horizontal scrollbar. */
-  min-width: 1600px !important; max-width: none !important; flex-wrap: nowrap !important;
 }
 
 /* ---- hero (full-bleed DARK band, split: copy + example-card grid) ---- */
@@ -926,13 +916,10 @@ a.footer-cta:hover { transform: translateY(-2px); filter: brightness(1.07); }
   #site-nav .nav-inner { flex-direction: column; align-items: stretch;
     justify-content: flex-start; gap: 6px; padding: 8px 14px; }
   .nav-brand { justify-content: flex-start; font-size: .98rem; }
-  /* WRAP, don't scroll: a horizontal overflow-x:auto strip swallowed taps on a
-     phone (a touch with any micro-movement reads as a scroll, and links past the
-     fold needed scrolling first) — which left Submission/Memory/Feed feeling
-     dead. Wrapping keeps every link fully on-screen and plainly tappable. */
-  .nav-links { width: 100%; gap: 10px 16px; flex-wrap: wrap; }
-  .nav-solo { flex: 0 0 auto; white-space: nowrap; padding: 8px 6px;
-    touch-action: manipulation; }
+  .nav-links { width: 100%; gap: 16px; flex-wrap: nowrap; overflow-x: auto;
+    -webkit-overflow-scrolling: touch; scrollbar-width: none; padding-bottom: 2px; }
+  .nav-links::-webkit-scrollbar { display: none; }
+  .nav-solo { flex: 0 0 auto; white-space: nowrap; }
 }
 
 /* Activity "Activity by stage" chart shares a 2-col row with the timeline, so on
@@ -946,16 +933,3 @@ a.footer-cta:hover { transform: translateY(-2px); filter: brightness(1.07); }
 /* Footer: keep "on Hugging Face" (its own <a> in .footer-meta) on one line
    instead of breaking as "on Hugging" / "Face". */
 .footer-meta a { white-space: nowrap; }
-
-/* Hardware-degraded banner — revealed by app.py's /health probe (inline JS). */
-#status-banner-host { padding: 0; margin: 0; }
-.status-banner {
-  display: none;
-  padding: 10px 16px;
-  text-align: center;
-  font-weight: 600;
-  font-size: 0.95rem;
-  line-height: 1.4;
-  background: var(--accent);
-  color: #fff;
-}