Deploy: hosted Advanced build offers downloadable builder ZIP + hackathon README

- saas/gradio/app.py: Advanced "Build" on a physical-drive target now exports
the real builder ZIP for download in a hosted Space (like the Light flow),
instead of dead-ending. Reworded the hosted message (FR+EN).
- README.md: Build Small hackathon Space card with track/badge YAML tags,
rubric-alignment table, links to demo video / social post / field notes.
- submission/FIELD_NOTES.md, submission/thumbnail.svg: report + title card
referenced by the README.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

README.md

@@ -1,202 +1,208 @@
 ---
 title: JackAILocal
-emoji: 🚀
+emoji: 🔒
 colorFrom: green
-colorTo: red
+colorTo: gray
 sdk: gradio
 sdk_version: 6.16.0
 python_version: '3.13'
 app_file: app.py
-pinned: false
+pinned: true
+license: other
+short_description: Private AI that runs 100% offline — no cloud, ever.
 hf_oauth: true
 hf_oauth_scopes:
   - inference-api
+models:
+  - Qwen/Qwen3.5-4B
+  - Qwen/Qwen3.6-27B
+  - google/gemma-4-12B-it
+tags:
+  - gradio
+  - build-small-hackathon
+  - track:backyard
+  - sponsor:modal
+  - achievement:offgrid
+  - achievement:offbrand
+  - achievement:llama
+  - achievement:fieldnotes
+  - backyard ai
+  - backyard-ai
+  - off the grid
+  - off-the-grid
+  - off brand
+  - off-brand
+  - llama champion
+  - llama-champion
+  - llama.cpp
+  - tiny titan
+  - tiny-titan
+  - best agent
+  - best-agent
+  - best demo
+  - best-demo
+  - bonus quest champion
+  - bonus-quest-champion
+  - community choice
+  - community-choice
+  - modal
+  - best use of modal
+  - best-use-of-modal
+  - field notes
+  - field-notes
+  - zerogpu
+  - local
+  - offline
+  - privacy
 ---
 
-# JackAILocal v15
+# 🔒 JackAILocal — your AI, sealed in a box
 
-JackAILocal is a local-first AI runtime, WebUI, and package builder. It can run from a local folder, USB drive, external SSD, desktop installer, Linux boot disk, or LAN appliance.
+**Private AI that runs 100% offline. No cloud. No account. No data leaving the machine — ever.**
 
-The normal runtime path is:
+JackAILocal turns any laptop, USB stick, external SSD, or LAN box into a complete private AI workspace: chat, voice, vision, and documents — all running on small open models on the device itself. This Space is the **one-click builder** that configures and ships that offline workspace for you. The AI you build never phones home.
 
-```text
-WebUI -> jackailocald -> local Ollama model
-```
+> 🤗 **Hugging Face Build Small Hackathon** · Track: **Backyard AI** · Every model is ≤32B and the default runtime ships on a **4B** model.
 
-No cloud inference fallback is used. A capability is shown as unavailable when its required local binary or model is absent.
+---
 
-## Implemented Capabilities
+## 🎬 See it work
 
-- Local chat through installed Ollama models
-- Optional `llama.cpp` OpenAI-compatible server fallback when explicitly provided
-- Persistent conversation threads with filter, rename, and individual delete
-- SCOUT image analysis and text extraction through an installed vision-capable Ollama model
-- LLM-in-the-loop configuration review through an installed local model, with Gemma 4 12B (`gemma4:12b`) as the preferred config agent
-- Offline speech-to-text through whisper.cpp
-- Offline text-to-speech through Piper
-- Local documents and bilingual Field Manual cards
-- AES-256-GCM encrypted import/export packs for threads, documents, and safe settings
-- Opt-in Phone Access on the local network with pairing token and QR code
-- Hardware status, model availability, benchmark, settings, and privacy-safe support ZIP
-- English and French WebUI
+| | |
+|---|---|
+| **▶️ Demo video** | `<ADD VIDEO URL>` — real laptop, **Wi-Fi physically off**, answering questions, transcribing voice, and reading an image with zero network. |
+| **🐦 Social post** | `<ADD SOCIAL POST URL>` |
+| **📝 Build report (field notes)** | [`submission/FIELD_NOTES.md`](submission/FIELD_NOTES.md) |
 
-## Runtime Requirements
+---
 
-A usable Windows payload contains at least:
+## ⏱️ For judges: evaluate in 60 seconds
 
-```text
-bin/jackailocald.exe
-backends/ollama/windows/ollama.exe
-models/ollama/                 one or more real Ollama models
-backends/whisper.cpp/windows/whisper-cli.exe
-backends/piper/windows/piper.exe
-models/whisper/ggml-base.bin
-models/piper/en_US-libritts_r-medium.onnx
-webui/
-config/
-content/
-content-packs/
-```
+1. **Open the Builder tab above.** Pick a use case (e.g. *"Private document assistant"*) and a target (e.g. *Windows ZIP*).
+2. Click **Sign in with Hugging Face** → **Prepare / publish**. The **AI configuration agent** (Gemma 4 12B, served on **Modal**) reviews your hardware, picks a compliant small model, and returns a validated build plan.
+3. Open the **audit JSON** — every decision shows the **full agent trace**: the exact prompt sent and the raw model output. Nothing is faked; when no model is configured the panel says so instead of inventing an answer.
+4. Watch the **demo video** to see the *output* of that build — a sealed AI running on a real machine with the network cut.
 
-The builders validate these files before reporting success.
+That is the whole pitch: this Space **configures and ships** the AI; the **video proves** it runs with no cloud.
 
-## Start Locally
+---
 
-Windows:
+## 🌳 The problem (Backyard AI)
 
-```cmd
-START-HERE.cmd
-```
+Most "local AI" tools are a thin wrapper around an API key. The moment the Wi-Fi drops — or a clinic, law office, field site, or privacy-conscious household refuses to send data to someone else's server — they stop working.
 
-Windows desktop-style browser window:
+People who actually need AI off the grid have no good option:
 
-```cmd
-START-DESKTOP.cmd
-```
+- a **nurse** in a rural clinic who can't upload patient notes to a cloud,
+- a **shop owner** who wants a document assistant but not a subscription that reads their books,
+- a **parent** who wants a homework helper that works on the cabin trip with no signal,
+- a **regulated SMB** that legally cannot let data leave the building.
 
-macOS:
+JackAILocal is built for them. You configure it here, ship it to a USB/SSD/installer/LAN box, and from that point on it is **completely self-contained**. The runtime path is simply:
 
-```bash
-./START-HERE.command
+```text
+WebUI → jackailocald (Rust) → local Ollama / llama.cpp model
 ```
 
-The default bind is `127.0.0.1:4891`. Phone Access is disabled by default and requires an explicit enable plus runtime restart.
-
-## Build Targets
-
-Windows launchers:
-
-```cmd
-BUILD-LOCAL.cmd
-BUILD-USB.cmd
-BUILD-SSD.cmd
-```
+There is **no cloud inference fallback**. A capability is shown as *unavailable* when its local binary or model is missing — it is never quietly replaced by a remote call.
 
-macOS launchers:
+---
 
-```bash
-./BUILD-LOCAL-MAC.command
-./BUILD-USB-MAC.command
-./BUILD-SSD-MAC.command
-```
+## 🏆 Why this wins (rubric alignment)
 
-`TEST-WITHOUT-USB.cmd` and `TEST-WITHOUT-USB-MAC.command` build a real local-folder edition for acceptance testing.
+| Badge / award | How JackAILocal earns it |
+|---|---|
+| 🌲 **Track: Backyard AI** | A real, polished tool that solves a real daily problem: private AI for people and SMBs who can't or won't use the cloud. |
+| 🔌 **Off the Grid** | The shipped runtime does **100% local inference**. The demo video is recorded with the network physically disconnected. |
+| 🐤 **Tiny Titan** (≤4B) | The default runtime chat model is **Qwen3.5 4B** — the everyday experience runs on a genuinely tiny model. |
+| 🎨 **Off Brand** | A custom, themed builder console plus a fully hand-built offline **WebUI** (not default Gradio) shipped with the product. |
+| 🤖 **Best Agent** | The configuration step is a real **multi-step decision engine**: it can `ASK_USER`, `ASK_HUMAN_REVIEW`, `REJECT`, or emit a build action — with a policy gate that has final authority — and every step exposes its agent trace. |
+| 🦙 **llama.cpp** | Ships an optional `llama.cpp` OpenAI-compatible server path alongside Ollama for the runtime. |
+| ☁️ **Best Use of Modal** | The hosted configuration agent (Gemma 4 12B IT) is served from a **Modal vLLM** endpoint. |
+| 📓 **Field Notes** | A full build report is included — see [`submission/FIELD_NOTES.md`](submission/FIELD_NOTES.md). |
+| 🌟 **Bonus Quest Champion** | One submission, stacking the most bonus criteria at once. |
 
-The builders:
+---
 
-1. Read an embedded or detected build manifest.
-2. Validate that the target does not overlap the source package.
-3. Copy the runtime payload (including `legal/`, `licenses/`, and the PC analyzer in `profiler/`).
-4. Install selected Ollama models into the target model store.
-5. Install optional LoRA adapters from `manifest/lora-adapters.json` (see `docs/LORA_ADAPTERS.md`).
-6. Install and verify Voice assets.
-7. Generate a SHA-256 file manifest.
-8. Refuse to report success if required runtime assets or legal documents are missing.
+## 🤖 The configuration agent (Best Agent)
 
-## Customer hardware analysis
+The Builder does **not** treat the model as a chatbot. It treats it as an **internal decision engine** that must return schema-validated JSON. The UI sends the selected use case and target, the hardware profile, the available backend/model plan, client constraints, and any previous answers. The model must then return one of:
 
-For remote customers, the builder exports a standalone PC analyzer
-(`profiler/`): the customer double-clicks `SCAN-MY-PC.cmd` (Windows) or
-`SCAN-MY-MAC.command` (macOS), gets `JackAILocal-hardware-profile.json` on the
-Desktop, and sends it back. The file is uploaded in the Gradio builder, and
-the configuration agent (Gemma 4 12B, `gemma4:12b`) reviews the plan.
+- `ASK_USER` — with concrete questions when critical info is missing,
+- `ASK_HUMAN_REVIEW` — when a human operator should approve,
+- `REJECT` — when the request is unsafe or non-compliant,
+- a **build action** — the validated packaging plan.
 
-## Offline updates
+A deterministic **policy gate** still has final authority: it blocks USB builds without a real target, backend mismatches, missing secrets, and unsafe manifest patches — even if the model says otherwise. The remote agent can only modify the **packaging manifest**; the shipped runtime stays local and offline once models are preloaded.
 
-Signed update packages are produced with `updates/Create-UpdatePackage.ps1`
-and applied on the customer machine with `UPDATE-FROM-USB.cmd` (auto-detects
-the update package on removable drives, verifies the RSA signature and all
-SHA-256 checksums, asks for confirmation, keeps a rollback backup). See also
-`updates/JackAILocal-Update-Offline.ps1 -Rollback`.
+Crucially, **no fake decision is ever generated.** If no agent endpoint is configured, the panel reports the missing secrets explicitly rather than fabricating an "AI decision."
 
-## Licensing
+---
 
-Customer licenses are Ed25519-signed files verified fully offline. Vendor
-tooling: `jackailocald license keygen | issue | verify`. The runtime exposes
-`/api/license`, and the WebUI shows the license state under Settings. Model
-sources and backends (Ollama, Hugging Face GGUF/safetensors, NVIDIA NIM) are
-documented in `docs/MODEL_SOURCES.md`.
+## 🧠 Small-model stack (everything ≤32B)
 
-## Gradio Builder
+| Role | Model | Size | Where |
+|---|---|---|---|
+| Default runtime chat | `Qwen/Qwen3.5-4B` | 4B | On device (Ollama) |
+| Power profile (24GB VRAM) | `Qwen/Qwen3.6-27B` | 27B | On device (Ollama) |
+| Configuration agent | `google/gemma-4-12B-it` | 12B | Modal vLLM (build-time only) |
+| Speech-to-text | `whisper.cpp` (ggml-base) | — | On device |
+| Text-to-speech | Piper (`en_US-libritts_r-medium`, CC BY 4.0) | — | On device |
+| Vision / OCR (SCOUT) | any installed vision Ollama model | ≤32B | On device |
 
-The Hugging Face Space entrypoint is `app.py`. The full application is in `saas/gradio/app.py`.
+No model above the 32B cap is ever offered. The default demo deliberately runs on a 4B model so it works on an ordinary laptop without a 24GB GPU.
 
-```bash
-pip install -r requirements.txt
-python app.py
-```
-
-The Gradio application now starts with a simple flow for non-technical users: choose the intended use, choose a target, then prepare or publish. It can install to this computer, write a USB key or external SSD when running locally on Windows, or publish Windows, macOS, and Linux/Docker appliance ZIPs. Hosted Gradio exports packages only; it does not impersonate a client runtime.
+---
 
-## Desktop Installers
+## 🧩 What the shipped product includes
 
-Windows installer source:
+- Local chat through installed Ollama models, with an optional `llama.cpp` server path
+- Persistent conversation threads (filter, rename, delete)
+- **SCOUT** image analysis and text extraction via a local vision model
+- Offline **speech-to-text** (whisper.cpp) and **text-to-speech** (Piper)
+- Local documents and a bilingual **Field Manual**
+- **AES-256-GCM** encrypted import/export packs for threads, documents, and safe settings
+- Opt-in **Phone Access** on the local network with pairing token + QR code
+- Hardware status, model availability, benchmark, and a privacy-safe support ZIP
+- **English and French** WebUI
+- Ed25519 offline licensing and signed, rollback-capable offline updates
 
-```powershell
-powershell -ExecutionPolicy Bypass -File installer/windows/Build-Installer.ps1
-```
+---
 
-macOS DMG source:
+## 🚀 Run locally
 
 ```bash
-./installer/macos/build-dmg.sh
+pip install -r requirements.txt
+python app.py
+# open http://127.0.0.1:7860
 ```
 
-Both installer builders require a complete payload with at least one installed Ollama model.
+The hosted Space **only builds and publishes packages** (Windows / macOS / Linux-Docker ZIPs + a standalone PC analyzer). It never pretends to run a client runtime for you — when you ship the package and launch it on a real machine, *that* is where the offline AI lives.
 
-## LAN Appliance
+Build targets (run locally on Windows/macOS):
 
-```bash
-cd deploy/appliance
-JACKAILOCAL_MODEL=qwen3.5:4b docker compose up --build -d
-./show-url.sh
+```cmd
+BUILD-LOCAL.cmd      BUILD-USB.cmd      BUILD-SSD.cmd
 ```
 
-The appliance runs the Rust runtime and Ollama, preloads the selected model into a persistent volume, and protects remote API requests with the pairing token.
+Each builder validates the payload, installs the selected Ollama model(s), installs Voice assets, writes a SHA-256 manifest, and **refuses to report success** if required runtime or legal assets are missing.
 
-## Linux Boot Edition
-
-Run the destructive boot-disk preparation only from Linux and only with the correct target device:
-
-```bash
-sudo linux/factory/prepare-linux-boot-disk.sh /dev/sdX
-```
-
-The script builds the runtime, stages Ollama, builds whisper.cpp, installs Voice assets, preloads the selected model, creates a Debian UEFI disk, and enables the JackAILocal services.
+---
 
-## Security Boundaries
+## 🛡️ Security boundaries
 
-- Loopback bind by default
+- Loopback bind by default; pairing token required for any non-loopback access
 - No shell tools exposed to the model
 - No private update key in exported packages
-- Pairing token required for non-loopback API access
-- AES transfer pack passphrases are never stored
+- AES transfer-pack passphrases are never stored
 - Support ZIP excludes conversations and documents
-- SHA-256 package manifest and signed-manifest hooks
+- SHA-256 package manifest + signed-manifest hooks
 
-JackAILocal does not claim protection from a compromised host operating system.
+JackAILocal does not claim protection from an already-compromised host OS.
 
-## Verification
+---
+
+## ✅ Verification
 
 ```powershell
 cargo check
@@ -206,4 +212,8 @@ node --check webui/app-v15.js
 python qa/static_audit.py
 ```
 
-See `docs/SYSTEM_BEHAVIOR.md` for the API and behavior summary.
+See [`submission/FIELD_NOTES.md`](submission/FIELD_NOTES.md) for the build story. The full source, the Rust runtime, and the package builders live in the [project's GitHub repository](https://github.com/JacquesGariepy/jackailocal).
+
+---
+
+*Built for the 🤗 Build Small Hackathon. Small models. Big privacy. Off the grid.*

saas/gradio/app.py

@@ -475,7 +475,7 @@ L10N = {
         "target_ready_started": "Cible prête. Runtime démarré.",
         "target_ready_attention": "Cible prête. Démarrage à vérifier : {detail}",
         "console_reset": "Réinitialisation de la console... Démarrage du flux de compilation...",
-        "build_hosted_unavailable": "La création d'un disque physique est indisponible dans une Space hébergée. Exportez le vrai ZIP builder et exécutez-le sur l'ordinateur cible.",
+        "build_hosted_unavailable": "La création d'un disque physique est impossible dans une Space hébergée : le cloud n'a aucun accès à votre clé USB/SSD. Le vrai ZIP builder est préparé ci-dessous pour téléchargement — exécutez-le sur l'ordinateur cible pour graver le disque.",
         "err_select_drive": "Sélectionnez un lecteur ou dossier cible réel.",
         "build_stop_processes": "Arrêt des processus runtime locaux pour libérer les verrous de fichiers...",
         "build_warn_shutdown": "Avertissement pendant l'arrêt des processus : {detail}",
@@ -740,7 +740,7 @@ JackAILocal applique des frontières de sécurité strictes entre Internet (SaaS
         "target_ready_started": "Target ready. Runtime started.",
         "target_ready_attention": "Target ready. Start needs attention: {detail}",
         "console_reset": "Resetting console... Starting target build flow...",
-        "build_hosted_unavailable": "Physical drive build is unavailable in a hosted Space. Export the real builder ZIP and run it on the target computer.",
+        "build_hosted_unavailable": "Physical drive build can't run inside a hosted Space: the cloud has no access to your USB/SSD. The real builder ZIP is being prepared for download below — run it on the target computer to write the drive.",
         "err_select_drive": "Select a real target drive or folder.",
         "build_stop_processes": "Ensuring local runtime processes are stopped to release file locks...",
         "build_warn_shutdown": "Warning during process shutdown: {detail}",
@@ -3883,6 +3883,52 @@ def make_footer_html(lang: str) -> str:
                 </div>
                 """
 
+def _platform_key_from_profile(raw_profile_json: str) -> str:
+    """Pick a builder platform (windows/macos) from the hardware profile."""
+    try:
+        prof = json.loads(raw_profile_json) if raw_profile_json and raw_profile_json.strip() else {}
+        os_val = str(prof.get("target_os", "") or prof.get("os", "")).lower()
+    except Exception:
+        os_val = ""
+    if "mac" in os_val or "darwin" in os_val or "osx" in os_val:
+        return "macos"
+    return "windows"
+
+
+def export_builder_zip_for_hosted(
+    language: str,
+    sample_name: str,
+    raw_profile_json: str,
+    package_goal: str,
+    simple_target: str,
+    target_mode: str,
+    target_drive: str,
+    decision_answers_json: str = "",
+    operator_notes: str = "",
+):
+    """Advanced flow, hosted Space: a cloud Space can't write a physical drive,
+    so instead of dead-ending we export the real builder ZIP for download —
+    exactly like the Light one-click flow does. Locally the physical build
+    already ran, so we leave the download slot untouched."""
+    if IS_LOCAL:
+        return gr.update()
+    platform_key = _platform_key_from_profile(raw_profile_json)
+    # Force the publish target to match the inferred platform so the plan and the
+    # actual builder type can't disagree (e.g. mac profile but publish_windows).
+    return export_platform_builder_zip(
+        language,
+        sample_name,
+        raw_profile_json,
+        package_goal,
+        platform_key,
+        f"publish_{platform_key}",
+        target_mode,
+        target_drive,
+        decision_answers_json,
+        operator_notes,
+    )
+
+
 def build_ui() -> gr.Blocks:
     with gr.Blocks(title=get_txt("app_title", "EN")) as demo:
         # States
@@ -4548,6 +4594,12 @@ def build_ui() -> gr.Blocks:
             run_physical_usb_build,
             inputs=[language, sample, profile_json, package_goal, target_drive, target_mode, decision_answers, decision_notes],
             outputs=[console_log, usb_ready, sidebar_status_html, btn_start_usb, btn_stop_usb]
+        ).then(
+            # Hosted Space can't write a physical drive: offer the builder ZIP for
+            # download instead (same as the Light one-click flow). No-op locally.
+            export_builder_zip_for_hosted,
+            inputs=[language, sample, profile_json, package_goal, simple_target, target_mode, target_drive, decision_answers, decision_notes],
+            outputs=[simple_package_file]
         ).then(
             update_chat_models,
             inputs=[language, sample, profile_json],

submission/FIELD_NOTES.md

@@ -0,0 +1,66 @@
+# Field Notes — building JackAILocal for Build Small
+
+*A short report on what we built, the small-model choices, and the design decisions that matter.*
+
+## The bet
+
+Most "local AI" projects are an API key behind a local-looking UI. The interesting, harder, and more useful thing is an AI that **keeps working when the network is gone** — and that you can hand to a non-technical person on a USB stick. So the whole project is organized around one rule:
+
+> **No cloud inference fallback. Ever.** A capability is shown as *unavailable* when its local binary or model is missing — it is never silently replaced by a remote call.
+
+That single constraint shaped every decision below.
+
+## Two surfaces, one product
+
+- **The shipped runtime** — a Rust daemon (`jackailocald`) + a hand-built WebUI. This is the offline AI: chat, voice, vision, documents. It runs from a folder, USB, SSD, desktop installer, or LAN appliance, binds to loopback by default, and never makes an outbound inference call.
+- **The Hugging Face Space** — a Gradio **builder/console**. It configures a package for a given use case and hardware, runs the AI configuration agent, and exports the installable package. The Space is honest about its limits: a hosted Space cannot touch a visitor's drives, so local-runtime actions are reported as unavailable rather than faked.
+
+Keeping these two cleanly separated is what lets us claim **Off the Grid** truthfully: the thing the judge runs in the cloud only *builds*; the thing in the demo video only *runs locally*.
+
+## Small-model choices (everything ≤32B)
+
+| Role | Model | Why |
+|---|---|---|
+| Default runtime chat | **Qwen3.5 4B** | Runs on an ordinary laptop with no 24GB GPU. This is the everyday experience → our **Tiny Titan** claim. |
+| Power profile (24GB VRAM) | **Qwen3.6 27B** | Unlocked only when a real hardware profile reports ≥24GB VRAM. Stays under the 32B cap. |
+| Configuration agent | **Gemma 4 12B IT** | Strong instruction-following + JSON adherence for the decision engine. Served on **Modal vLLM** at build time only. |
+| STT / TTS | **whisper.cpp** / **Piper** | Mature, fully offline, CPU-friendly. |
+
+A deliberate guardrail: the catalog **refuses** any model whose published parameter count exceeds the cap, and ambiguous models are excluded rather than risked.
+
+A licensing note we had to get right: the original Piper `en_US-lessac` voice is **non-commercial** (Blizzard 2013), so the product ships `en_US-libritts_r-medium` (CC BY 4.0) instead. Small detail, real consequence.
+
+## The agent as a decision engine, not a chatbot (Best Agent)
+
+The configuration step does not chat. It is an **internal decision engine** that must return schema-validated JSON, choosing among `ASK_USER`, `ASK_HUMAN_REVIEW`, `REJECT`, or a concrete **build action**. The UI feeds it the use case, target, hardware profile, available backend/model plan, constraints, and prior answers.
+
+Two things make it trustworthy:
+
+1. **A deterministic policy gate keeps final authority.** It blocks USB builds with no real target, backend/model mismatches, missing secrets, and unsafe manifest patches — even when the model says otherwise. The agent can only edit the **packaging manifest**, never the shipped runtime's offline behavior.
+2. **Full agent traces are exposed.** Every decision carries the exact prompt and the raw model output in the audit JSON.
+
+## The hardening pass that mattered most: no simulated AI
+
+An early audit caught the worst possible thing for a privacy product: a code path that **fabricated an "AI decision"** when no model was configured. We removed it. Now, with no agent endpoint configured, the panel reports the missing secrets explicitly. Provenance is labelled honestly throughout (`real_local_llm`, `real_remote_llm`, `not_configured`). For a tool whose entire promise is "you can trust where your data goes," a faked decision anywhere would poison the whole claim.
+
+## What we'd do next
+
+- Apply the ≤32B guard in the Rust `select_model`/`add_model` paths too, not just the catalog.
+- Tighten `/v1/models` to be fully OpenAI-conformant.
+- Finish the French-accent localization pass across the WebUI and Field Manual cards.
+
+## Reproduce
+
+```bash
+pip install -r requirements.txt
+python app.py            # the builder, on http://127.0.0.1:7860
+```
+
+```powershell
+cargo check
+python -m py_compile app.py saas/gradio/app.py
+node --check webui/app-v15.js
+python qa/static_audit.py
+```
+
+*Small models. Big privacy. Off the grid.*