E2B experiment: Tiny Titan Space on ZeroGPU with Gemma 4 E2B

- New patient-virtuel-e2b/ directory with simplified 3-phase prompt
- ffmpeg audio decode, no Whisper, native E2B audio via Gemma4Processor
- 'sdpa' attention to avoid flash-attn dependency on ZeroGPU
- trace.jsonl: 18-step curated build trace for HF Dataset
- LINKEDIN_POST.md, VIDEO_SCRIPT.md: rewritten first-person, no em dashes
- README.md: HF Dataset + experiment Space links
- server_app.py: title changed to 'Field Notes: Patient Virtuel'

README.md

@@ -8,6 +8,16 @@ sdk_version: 6.16.0
 app_file: server_app.py
 pinned: false
 license: apache-2.0
+tags:
+  - hackathon
+  - build-small-hackathon
+  - voice-ai
+  - french-learning
+  - dental
+  - gradio
+  - modal
+  - llama-cpp
+  - gemma
 ---
 
 # Patient Virtuel · Français en médecine dentaire
@@ -25,6 +35,8 @@ Uses `gradio.Server` with a custom HTML/CSS/JS frontend (Off-Brand Award entry).
 See [`space_README.md`](space_README.md) for the full description.
 
 📖 [Field Notes](FIELD_NOTES.md) — architecture decisions, lessons learned, and the story behind the app.
+📡 [Agent Trace](https://huggingface.co/datasets/build-small-hackathon/patient-virtuel-trace) — curated build log on HF Hub (Sharing is Caring badge).
+🐜 [Tiny Titan Experiment](https://huggingface.co/spaces/build-small-hackathon/patient-virtuel-e2b) — Patient Virtuel on Gemma 4 E2B via ZeroGPU (2.3B params).
 
 ## Architecture
 

patient-virtuel-e2b/README.md

@@ -0,0 +1,53 @@
+---
+title: Patient Virtuel E2B · Tiny Titan
+emoji: 🦷
+colorFrom: red
+colorTo: gray
+sdk: gradio
+sdk_version: 6.16.0
+python_version: "3.12"
+app_file: server_app.py
+pinned: false
+license: apache-2.0
+short_description: Voice dental patient on Gemma 4 E2B (2.3B params)
+tags:
+  - hackathon
+  - tiny-titan
+  - gemma
+  - zerogpu
+---
+# Patient Virtuel E2B · Tiny Titan Experiment
+
+A voice-based AI dental patient running on **Gemma 4 E2B** (2.3B effective params) via **ZeroGPU**. This is an experiment to claim the Tiny Titan award (≤4B parameter app).
+
+Uses `gradio.Server` with a custom HTML/CSS/JS frontend.
+
+## How it differs from the main app
+
+| Feature | Main app | This app |
+|---|---|---|
+| Model | Gemma 4 26B A4B (Modal L4) | Gemma 4 E2B (ZeroGPU) |
+| STT | faster-whisper (Modal T4) | Built into E2B (native audio) |
+| Infrastructure | Modal + HF Space | ZeroGPU only |
+| Qualifies for | Llama Champion, Off the Grid | Tiny Titan |
+
+## Architecture
+
+The app uses Gemma 4 E2B's native audio encoder to process speech directly, eliminating the need for a separate STT model:
+
+```
+Microphone → ffmpeg decode → Gemma 4 E2B (ZeroGPU) → text → piper-tts (CPU)
+```
+
+No cloud APIs, no separate ASR model. Everything runs on a single model.
+
+## Badges
+
+- Tiny Titan — app built on a ≤4B model (Gemma 4 E2B at 2.3B effective)
+- Shares the custom frontend (Off-Brand) and piped TTS (Off the Grid) badges
+
+## Links
+
+- **Main app**: https://huggingface.co/spaces/build-small-hackathon/patient-virtuel-dentiste
+- **Field Notes**: https://huggingface.co/spaces/build-small-hackathon/patient-virtuel-dentiste/field-notes
+- **Agent Trace**: https://huggingface.co/datasets/build-small-hackathon/patient-virtuel-trace

patient-virtuel-e2b/core.py

@@ -0,0 +1,286 @@
+import io
+import logging
+import os
+import re
+import subprocess
+import tempfile
+import time
+import wave
+
+import numpy as np
+
+log = logging.getLogger(__name__)
+
+try:
+    from spaces import GPU
+except ImportError:
+    GPU = lambda **kw: lambda fn: fn
+
+from prompts_e2b import SYSTEM_PROMPT, PHASE_SWITCH_REMINDER
+from parse_feedback import parse_feedback, render_feedback_table, strip_markdown
+from tts_engine import synthesize
+
+TERMINATE_RE = re.compile(
+    r"(fin\s+de\s+(la\s+)?séance|session\s+terminée|on\s+a\s+terminé|c'est\s+fini)",
+    re.IGNORECASE,
+)
+
+_MODEL = None
+_PROCESSOR = None
+
+
+def load_model():
+    global _MODEL, _PROCESSOR
+    if _MODEL is not None:
+        return _MODEL, _PROCESSOR
+    import torch
+    from transformers import AutoModelForMultimodalLM, AutoProcessor
+    model_id = "google/gemma-4-E2B-it"
+    log.info("Loading %s on ZeroGPU...", model_id)
+    _PROCESSOR = AutoProcessor.from_pretrained(model_id)
+    _MODEL = AutoModelForMultimodalLM.from_pretrained(
+        model_id,
+        torch_dtype=torch.bfloat16,
+        device_map="cuda",
+        attn_implementation="sdpa",
+    )
+    _MODEL.eval()
+    log.info("Model loaded")
+    return _MODEL, _PROCESSOR
+
+
+@GPU(duration=60)
+def e2b_generate(audio_array: np.ndarray, sampling_rate: int, history_text: str) -> str:
+    model, processor = load_model()
+    import torch
+
+    audio_array = audio_array.astype(np.float32)
+    if audio_array.ndim == 1:
+        audio_array = audio_array[np.newaxis, :]
+
+    messages = [
+        {"role": "system", "content": SYSTEM_PROMPT},
+        {"role": "user", "content": [
+            {"type": "text", "text": history_text},
+            {"type": "audio", "audio": audio_array},
+        ]},
+    ]
+
+    inputs = processor(
+        text=messages,
+        padding=True,
+        return_tensors="pt",
+    )
+    inputs = {k: v.to("cuda") if hasattr(v, "to") else v for k, v in inputs.items()}
+
+    with torch.no_grad():
+        output_ids = model.generate(
+            **inputs,
+            max_new_tokens=256,
+            temperature=0.8,
+            top_p=0.9,
+            do_sample=True,
+        )
+
+    input_len = inputs["input_ids"].shape[1]
+    response = processor.decode(output_ids[0, input_len:], skip_special_tokens=True)
+    return response.strip()
+
+
+@GPU(duration=60)
+def e2b_generate_text(user_message: str) -> str:
+    model, processor = load_model()
+    import torch
+
+    messages = [
+        {"role": "system", "content": SYSTEM_PROMPT},
+        {"role": "user", "content": user_message},
+    ]
+
+    inputs = processor(
+        text=messages,
+        padding=True,
+        return_tensors="pt",
+    )
+    inputs = {k: v.to("cuda") if hasattr(v, "to") else v for k, v in inputs.items()}
+
+    with torch.no_grad():
+        output_ids = model.generate(
+            **inputs,
+            max_new_tokens=512,
+            temperature=0.7,
+            top_p=0.9,
+            do_sample=True,
+        )
+
+    input_len = inputs["input_ids"].shape[1]
+    response = processor.decode(output_ids[0, input_len:], skip_special_tokens=True)
+    return response.strip()
+
+
+def decode_audio(file_path: str, target_sr: int = 16000) -> tuple:
+    result = subprocess.run(
+        ["ffmpeg", "-i", file_path, "-f", "wav", "-acodec", "pcm_s16le",
+         "-ar", str(target_sr), "-ac", "1", "pipe:1"],
+        capture_output=True, timeout=30,
+    )
+    result.check_returncode()
+    with wave.open(io.BytesIO(result.stdout)) as wf:
+        frames = wf.readframes(wf.getnframes())
+        array = np.frombuffer(frames, dtype=np.int16).astype(np.float32) / 32768.0
+    return array, target_sr
+
+
+def _build_history_text(messages: list) -> str:
+    lines = []
+    for msg in messages:
+        role = msg.get("role", "")
+        content = msg.get("content", "")
+        if role == "system":
+            continue
+        if isinstance(content, list):
+            content = ""
+        if role == "user":
+            lines.append(f"Hygienist: {content}")
+        elif role == "assistant":
+            lines.append(f"Patient: {content}")
+    return "\n".join(lines)
+
+
+def make_initial_state():
+    messages = [{"role": "system", "content": SYSTEM_PROMPT}]
+    return {"messages": messages, "phase": 1, "turn_count": 0}
+
+
+def _chat_val(state):
+    return [m for m in state["messages"] if m.get("content") != PHASE_SWITCH_REMINDER]
+
+
+def _make_audio(audio_bytes):
+    if not audio_bytes:
+        return None
+    f = tempfile.NamedTemporaryFile(suffix=".wav", delete=False, dir=tempfile.gettempdir())
+    f.write(audio_bytes)
+    f.close()
+    return os.path.basename(f.name)
+
+
+def _default_feedback():
+    return {
+        "feedback_intro": "",
+        "feedback_points_forts": [],
+        "feedback_table": [],
+        "feedback_vocabulaire": [],
+        "feedback_priorite": [],
+        "feedback_bilan": {},
+        "feedback_open": False,
+    }
+
+
+def process_turn(audio_path, state):
+    state = dict(state)
+    result = {
+        "chat": _chat_val(state),
+        "audio_file": None,
+        "state": state,
+        **_default_feedback(),
+        "status": "",
+    }
+
+    if not audio_path:
+        return result
+
+    result["status"] = "Decoding audio..."
+    _t0 = time.monotonic()
+    try:
+        audio_array, sr = decode_audio(audio_path)
+        _t1 = time.monotonic()
+    except Exception as e:
+        result["status"] = f"Audio error: {e}"
+        return result
+
+    if len(audio_array) < sr * 0.5:
+        result["status"] = "Please speak longer."
+        return result
+
+    result["status"] = "Patient thinking..."
+    history_text = _build_history_text(state["messages"])
+    response = e2b_generate(audio_array, sr, history_text)
+    _t2 = time.monotonic()
+
+    if not response:
+        result["status"] = "Model error. Try again."
+        return result
+
+    response = re.sub(r"^(assistant|model)\s*", "", response).strip()
+
+    if TERMINATE_RE.search(response):
+        state["messages"].append({"role": "assistant", "content": response})
+        return _end_session(state)
+
+    state["messages"].append({"role": "user", "content": "(audio input)"})
+    state["messages"].append({"role": "assistant", "content": response})
+
+    result["status"] = "Synthesizing speech..."
+    clean = strip_markdown(response)
+    audio_bytes = synthesize(clean)
+    _t3 = time.monotonic()
+    result["audio_file"] = _make_audio(audio_bytes)
+    log.info("TIMING audio=%.1fs inference=%.1fs tts=%.1fs total=%.1fs",
+             _t1 - _t0, _t2 - _t1, _t3 - _t2, _t3 - _t0)
+    result["chat"] = _chat_val(state)
+    result["status"] = ""
+    return result
+
+
+def _end_session(state):
+    state["messages"].append({"role": "user", "content": PHASE_SWITCH_REMINDER})
+
+    result = {
+        "chat": _chat_val(state),
+        "audio_file": None,
+        "state": state,
+        **_default_feedback(),
+        "status": "Generating recap...",
+    }
+
+    history_text = _build_history_text(state["messages"])
+    response = e2b_generate_text(history_text + "\n\nGenerate the structured feedback now.")
+    _t0 = time.monotonic()
+
+    if not response:
+        result["status"] = "Error generating recap."
+        return result
+
+    clean = strip_markdown(response)
+    state["phase"] = 2
+
+    fb = parse_feedback(clean)
+    table = render_feedback_table(fb["erreurs"]) if fb["erreurs"] else []
+    intro = fb.get("intro") or clean
+
+    state["messages"].append({"role": "assistant", "content": intro})
+
+    audio_bytes = synthesize(intro)
+    _t1 = time.monotonic()
+
+    result["chat"] = _chat_val(state)
+    result["audio_file"] = _make_audio(audio_bytes)
+    log.info("TIMING llm=%.1fs tts=%.1fs", _t1 - _t0, result["audio_file"])
+    result["feedback_intro"] = intro
+    result["feedback_points_forts"] = fb["points_forts"]
+    result["feedback_table"] = table
+    result["feedback_vocabulaire"] = fb["vocabulaire"]
+    result["feedback_priorite"] = fb["priorite"]
+    result["feedback_bilan"] = fb["bilan"]
+    result["feedback_open"] = True
+    result["status"] = ""
+    return result
+
+
+def end_session_click(state):
+    return _end_session(dict(state))
+
+
+def reset_session():
+    return make_initial_state()

patient-virtuel-e2b/custom_index.html

@@ -0,0 +1,982 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>Patient Virtuel E2B · Tiny Titan</title>
+<link rel="preconnect" href="https://fonts.googleapis.com">
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+<link href="https://fonts.googleapis.com/css2?family=EB+Garamond:ital,wght@0,400;0,500;1,400;1,500&family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
+<style>
+*, *::before, *::after { margin: 0; box-sizing: border-box; }
+
+:root {
+  --bg: #19120c;
+  --accent: #ff5719;
+  --accent-dim: rgba(255, 87, 25, 0.15);
+  --glass: rgba(255, 87, 25, 0.06);
+  --glass-border: rgba(255, 200, 150, 0.1);
+  --text: #efe0d4;
+  --text-dim: #e6beb2;
+  --surface-low: #221a13;
+  --surface-high: #312821;
+  --outline: #ac897e;
+  --outline-variant: #5c4037;
+  --serif: "EB Garamond", Georgia, serif;
+  --sans: "Inter", ui-sans-serif, system-ui, sans-serif;
+}
+
+html, body {
+  height: 100%;
+  background: var(--bg);
+  color: var(--text);
+  font-family: var(--sans);
+  -webkit-font-smoothing: antialiased;
+  overflow-x: hidden;
+}
+
+body {
+  background-image:
+    radial-gradient(60rem 50rem at 0% 100%, color-mix(in srgb, var(--accent) 18%, transparent), transparent 60%),
+    radial-gradient(50rem 40rem at 100% 0%, color-mix(in srgb, var(--accent) 8%, transparent), transparent 60%);
+  background-attachment: fixed;
+}
+
+.glass {
+  background: var(--glass);
+  backdrop-filter: blur(40px);
+  -webkit-backdrop-filter: blur(40px);
+  border: 1px solid var(--glass-border);
+  box-shadow: 0 20px 50px rgba(0,0,0,0.3);
+  border-radius: 16px;
+}
+
+.app {
+  position: relative;
+  z-index: 1;
+  min-height: 100vh;
+  display: flex;
+  flex-direction: column;
+  max-width: 1280px;
+  margin: 0 auto;
+  padding: 28px 32px;
+}
+
+.header {
+  display: flex;
+  align-items: center;
+  gap: 14px;
+  margin-bottom: 36px;
+  flex-shrink: 0;
+  align-self: center;
+}
+.header-icon {
+  width: 44px; height: 44px;
+  border-radius: 50%;
+  background: var(--accent);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  box-shadow: 0 4px 20px rgba(255, 87, 25, 0.3);
+  flex-shrink: 0;
+}
+.header-icon svg { width: 24px; height: 24px; color: #fff; }
+.header-title {
+  font-family: var(--serif);
+  font-size: 32px;
+  font-weight: 400;
+  letter-spacing: 0.01em;
+}
+.header-sub {
+  font-size: 14px;
+  text-transform: uppercase;
+  letter-spacing: 0.2em;
+  color: var(--accent);
+  font-weight: 600;
+}
+
+.main-grid {
+  display: grid;
+  grid-template-columns: 5fr 7fr;
+  gap: 32px;
+  flex: 1;
+  min-height: 0;
+}
+
+.left-col {
+  display: flex;
+  flex-direction: column;
+  gap: 28px;
+}
+
+.desc h2 {
+  font-family: var(--serif);
+  font-size: 56px;
+  font-weight: 400;
+  line-height: 1.15;
+  letter-spacing: -0.01em;
+}
+.desc h2 em {
+  font-style: italic;
+  color: var(--accent);
+}
+.desc p {
+  color: var(--text-dim);
+  font-size: 14px;
+  line-height: 1.6;
+  margin-top: 16px;
+}
+
+.howto {
+  padding: 24px;
+  background: rgba(255,255,255,0.03);
+  border: 1px solid rgba(255,255,255,0.08);
+  border-radius: 12px;
+  backdrop-filter: blur(10px);
+}
+.howto .howto-title {
+  font-size: 10px;
+  text-transform: uppercase;
+  letter-spacing: 0.15em;
+  color: var(--accent);
+  font-weight: 700;
+}
+.howto ol {
+  list-style: none;
+  margin: 16px 0 0;
+  padding: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+}
+.howto li {
+  display: flex;
+  gap: 12px;
+  font-size: 13px;
+  color: var(--text-dim);
+  line-height: 1.6;
+}
+.howto li .num {
+  flex-shrink: 0;
+  width: 20px; height: 20px;
+  border-radius: 50%;
+  display: grid;
+  place-items: center;
+  border: 1px solid rgba(255,255,255,0.15);
+  font-size: 10px;
+  font-weight: 600;
+  color: var(--accent);
+  margin-top: 2px;
+}
+.howto li strong { color: var(--text); }
+
+.mic-area {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 20px;
+  padding: 12px 0;
+}
+.mic-btn {
+  width: 136px; height: 136px;
+  border-radius: 50%;
+  border: 2px solid var(--glass-border);
+  background: var(--glass);
+  backdrop-filter: blur(30px);
+  cursor: pointer;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  transition: all 0.3s ease;
+  position: relative;
+}
+.mic-btn:hover {
+  border-color: var(--accent);
+  box-shadow: 0 0 40px rgba(255,87,25,0.2);
+}
+.mic-btn:disabled {
+  opacity: 0.4;
+  cursor: not-allowed;
+}
+.mic-btn.recording {
+  border-color: var(--accent);
+  background: var(--accent-dim);
+  animation: mic-pulse 1.8s ease-in-out infinite;
+}
+@keyframes mic-pulse {
+  0%, 100% {
+    box-shadow:
+      0 0 0 0 color-mix(in srgb, var(--accent) 55%, transparent),
+      0 0 60px 10px color-mix(in srgb, var(--accent) 35%, transparent);
+  }
+  50% {
+    box-shadow:
+      0 0 0 24px color-mix(in srgb, var(--accent) 0%, transparent),
+      0 0 90px 24px color-mix(in srgb, var(--accent) 45%, transparent);
+  }
+}
+.mic-btn svg { width: 42px; height: 42px; color: var(--text); transition: color 0.3s; }
+.mic-btn.recording svg { color: var(--accent); }
+
+.mic-label {
+  font-size: 10px;
+  text-transform: uppercase;
+  letter-spacing: 0.18em;
+  color: var(--text-dim);
+  padding: 6px 16px;
+  border-radius: 20px;
+  background: var(--surface-low);
+  backdrop-filter: blur(10px);
+  border: 1px solid var(--glass-border);
+  font-weight: 600;
+}
+.mic-label.active {
+  color: var(--accent);
+  border-color: var(--accent);
+  background: var(--accent-dim);
+}
+
+.controls {
+  display: flex;
+  gap: 12px;
+}
+.btn {
+  flex: 1;
+  padding: 11px 20px;
+  border-radius: 10px;
+  border: 1px solid var(--glass-border);
+  background: var(--glass);
+  color: var(--text);
+  font-size: 13px;
+  font-weight: 600;
+  font-family: var(--sans);
+  cursor: pointer;
+  transition: all 0.2s;
+}
+.btn:hover { border-color: var(--accent); background: var(--accent-dim); }
+.btn-stop {
+  background: rgba(139, 0, 0, 0.35);
+  border-color: rgba(139, 0, 0, 0.5);
+  color: #ffb4ab;
+}
+.btn-stop:hover { background: rgba(139, 0, 0, 0.6); }
+.btn:disabled { opacity: 0.35; cursor: not-allowed; }
+
+#status {
+  text-align: center;
+  font-size: 13px;
+  color: var(--accent);
+  font-weight: 500;
+  min-height: 20px;
+  transition: opacity 0.2s;
+}
+
+.right-col {
+  display: flex;
+  flex-direction: column;
+  gap: 20px;
+  min-height: 0;
+}
+
+.chat-wrap {
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  border: 1px solid var(--glass-border);
+  border-radius: 16px;
+  background: var(--glass);
+  backdrop-filter: blur(40px);
+  overflow: hidden;
+  min-height: 0;
+}
+.chat-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 14px 18px;
+  border-bottom: 1px solid var(--glass-border);
+}
+.chat-header-label {
+  font-size: 10px;
+  text-transform: uppercase;
+  letter-spacing: 0.18em;
+  color: var(--accent);
+  font-weight: 600;
+}
+.chat-header-live {
+  font-size: 10px;
+  text-transform: uppercase;
+  letter-spacing: 0.12em;
+  color: var(--text-dim);
+}
+#chat {
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+  padding: 16px 18px;
+  overflow-y: auto;
+  min-height: 120px;
+  max-height: 50vh;
+}
+#chat::-webkit-scrollbar { width: 6px; }
+#chat::-webkit-scrollbar-thumb { background: var(--outline-variant); border-radius: 3px; }
+#chat::-webkit-scrollbar-track { background: transparent; }
+
+.msg {
+  padding: 12px 16px;
+  border-radius: 12px;
+  font-size: 14px;
+  line-height: 1.6;
+  max-width: 88%;
+  animation: fadeIn 0.3s ease;
+}
+@keyframes fadeIn { from { opacity: 0; transform: translateY(8px); } to { opacity: 1; transform: translateY(0); } }
+.msg-user {
+  align-self: flex-end;
+  background: var(--accent-dim);
+  border: 1px solid var(--glass-border);
+  color: var(--text);
+  border-top-right-radius: 4px;
+}
+.msg-patient {
+  align-self: flex-start;
+  background: var(--surface-high);
+  border: 1px solid rgba(255,255,255,0.06);
+  color: var(--text);
+  border-top-left-radius: 4px;
+}
+.msg-role {
+  font-size: 10px;
+  text-transform: uppercase;
+  letter-spacing: 0.1em;
+  color: var(--text-dim);
+  margin-bottom: 4px;
+  font-weight: 600;
+}
+.msg-patient .msg-role { color: var(--accent); }
+.no-audio { cursor: help; font-size: 1.1em; }
+
+.feedback {
+  border: 1px solid var(--glass-border);
+  border-radius: 16px;
+  background: var(--glass);
+  backdrop-filter: blur(40px);
+  overflow: hidden;
+}
+.feedback-header {
+  padding: 14px 18px;
+  cursor: pointer;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  border-bottom: 1px solid var(--glass-border);
+}
+.feedback-header h3 {
+  font-family: var(--serif);
+  font-size: 18px;
+  font-weight: 400;
+}
+.feedback-badge {
+  font-size: 10px;
+  text-transform: uppercase;
+  letter-spacing: 0.1em;
+  padding: 2px 10px;
+  border-radius: 20px;
+  border: 1px solid var(--glass-border);
+  color: var(--text-dim);
+  font-weight: 600;
+}
+.feedback-header .arrow {
+  transition: transform 0.3s;
+  color: var(--text-dim);
+  font-size: 14px;
+}
+.feedback.open .feedback-header .arrow { transform: rotate(180deg); }
+.feedback-body {
+  padding: 18px;
+  transition: max-height 0.3s ease, opacity 0.25s ease;
+  max-height: 500px;
+  opacity: 1;
+  overflow-y: auto;
+}
+.feedback:not(.open) .feedback-body {
+  max-height: 0;
+  padding: 0 18px;
+  opacity: 0;
+}
+.feedback-intro {
+  font-size: 13px;
+  color: var(--text-dim);
+  line-height: 1.6;
+  margin-bottom: 14px;
+  white-space: pre-wrap;
+}
+.feedback-empty {
+  font-size: 13px;
+  color: var(--text-dim);
+  font-style: italic;
+}
+.feedback-table {
+  width: 100%;
+  border-collapse: collapse;
+  font-size: 12px;
+}
+.feedback-table th {
+  text-align: left;
+  padding: 8px 10px;
+  font-size: 10px;
+  text-transform: uppercase;
+  letter-spacing: 0.1em;
+  color: var(--accent);
+  border-bottom: 1px solid var(--glass-border);
+  font-weight: 600;
+}
+.feedback-table td {
+  padding: 8px 10px;
+  border-bottom: 1px solid var(--glass-border);
+  color: var(--text);
+  line-height: 1.5;
+  font-size: 12px;
+}
+
+.feedback-section { margin-bottom: 14px; }
+.feedback-section-title {
+  font-family: var(--serif);
+  font-size: 14px;
+  font-weight: 600;
+  margin-bottom: 6px;
+  color: var(--accent);
+}
+.feedback-list {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+}
+.feedback-list li {
+  font-size: 12px;
+  line-height: 1.6;
+  padding: 2px 0;
+  color: var(--text);
+}
+.feedback-list li::before {
+  content: "\2022";
+  color: var(--accent);
+  margin-right: 6px;
+}
+
+.bilan-row {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  margin-bottom: 8px;
+}
+.bilan-label {
+  font-size: 11px;
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+  color: var(--text-dim);
+  width: 140px;
+  flex-shrink: 0;
+}
+.bilan-bar {
+  flex: 1;
+  height: 8px;
+  background: rgba(255,255,255,0.08);
+  border-radius: 4px;
+  overflow: hidden;
+}
+.bilan-fill {
+  height: 100%;
+  background: var(--accent);
+  border-radius: 4px;
+  transition: width 0.5s ease;
+}
+.bilan-score {
+  font-size: 11px;
+  color: var(--text-dim);
+  width: 30px;
+  text-align: right;
+}
+
+.footer {
+  text-align: center;
+  font-size: 10px;
+  color: var(--text-dim);
+  padding-top: 20px;
+  margin-top: 28px;
+  border-top: 1px solid rgba(255,255,255,0.04);
+  flex-shrink: 0;
+}
+
+#audio-player { display: none; }
+
+.dots::after {
+  content: '';
+  animation: dots 1.5s steps(4, end) infinite;
+}
+@keyframes dots {
+  0% { content: ''; }
+  25% { content: '.'; }
+  50% { content: '..'; }
+  75% { content: '...'; }
+}
+
+@media (max-width: 860px) {
+  .main-grid {
+    grid-template-columns: 1fr;
+  }
+  .app { padding: 20px 16px; }
+  .desc h2 { font-size: 38px; }
+  #chat { max-height: 40vh; }
+}
+</style>
+</head>
+<body>
+
+<div class="app">
+  <div class="header">
+    <div class="header-icon">
+      <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+        <path d="M4.8 2.3A.3.3 0 1 0 5 2H4a2 2 0 0 0-2 2v5a6 6 0 0 0 6 6v0a6 6 0 0 0 6-6V4a2 2 0 0 0-2-2h-1a.2.2 0 1 0 .3.3"/>
+        <path d="M8 15v1a6 6 0 0 0 6 6v0a6 6 0 0 0 6-6v-4"/>
+        <circle cx="20" cy="10" r="2"/>
+      </svg>
+    </div>
+    <div>
+      <div class="header-title">Patient Virtuel · E2B</div>
+      <div class="header-sub">Gemma 4 E2B sur ZeroGPU · Tiny Titan</div>
+    </div>
+  </div>
+
+  <div class="main-grid">
+    <div class="left-col">
+      <div class="desc">
+        <h2>Pratiquez votre <em>Français Dentaire</em></h2>
+        <p>
+          Un patient virtuel qui vous r&eacute;pond &agrave; voix haute. Entra&icirc;nez-vous aux conversations
+          de soins dentaires en fran&ccedil;ais, puis recevez un bilan structur&eacute; de votre vocabulaire
+          et de votre grammaire.
+        </p>
+      </div>
+
+      <div class="mic-area">
+        <button class="mic-btn" id="mic-btn" onclick="toggleRecording()">
+          <svg id="mic-icon" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+            <path d="M12 2a3 3 0 0 0-3 3v7a3 3 0 0 0 6 0V5a3 3 0 0 0-3-3Z"/>
+            <path d="M19 10v2a7 7 0 0 1-14 0v-2"/>
+            <line x1="12" x2="12" y1="19" y2="22"/>
+          </svg>
+          <svg id="stop-icon" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="currentColor" style="display:none">
+            <rect x="6" y="6" width="12" height="12" rx="2"/>
+          </svg>
+        </button>
+        <div class="mic-label" id="mic-label">Appuyez pour parler</div>
+      </div>
+
+      <div class="howto">
+        <div class="howto-title">Comment utiliser</div>
+        <ol>
+          <li><span class="num">1</span><span>Appuyez sur le bouton micro pour commencer &agrave; enregistrer.</span></li>
+          <li><span class="num">2</span><span>Parlez en fran&ccedil;ais — saluez le patient, posez des questions, expliquez les soins.</span></li>
+          <li><span class="num">3</span><span>Appuyez &agrave; nouveau pour arr&ecirc;ter — le patient vous r&eacute;pond &agrave; voix haute.</span></li>
+          <li><span class="num">4</span><span>Dites <strong>&laquo; Fin de la s&eacute;ance &raquo;</strong> ou appuyez sur <strong>Terminer</strong> pour obtenir votre bilan.</span></li>
+        </ol>
+      </div>
+
+      <div class="controls">
+        <button class="btn btn-stop" id="btn-end" onclick="endSession()">Terminer la s&eacute;ance</button>
+        <button class="btn" id="btn-reset" onclick="resetSession()">Nouvelle s&eacute;ance</button>
+      </div>
+
+      <div id="status"></div>
+    </div>
+
+    <div class="right-col">
+      <div class="chat-wrap">
+        <div class="chat-header">
+          <span class="chat-header-label">Transcription</span>
+          <span class="chat-header-live">En direct</span>
+        </div>
+        <div id="chat"></div>
+      </div>
+
+      <div class="feedback open" id="feedback">
+        <div class="feedback-header" onclick="toggleFeedback()">
+          <div style="display:flex;align-items:center;gap:10px">
+            <h3>Bilan de la s&eacute;ance</h3>
+            <span class="feedback-badge" id="feedback-count">0 notes</span>
+          </div>
+          <span class="arrow">&#9662;</span>
+        </div>
+        <div class="feedback-body">
+          <div class="feedback-intro" id="feedback-intro"></div>
+          <div class="feedback-empty" id="feedback-empty">Le bilan se construira au fil de la conversation.</div>
+
+          <div id="feedback-points-forts" class="feedback-section" style="display:none">
+            <div class="feedback-section-title">Points forts</div>
+            <ul class="feedback-list" id="feedback-points-list"></ul>
+          </div>
+
+          <table class="feedback-table" id="feedback-table" style="display:none">
+            <thead><tr><th>Citation</th><th>Correction</th><th>Pourquoi</th></tr></thead>
+            <tbody id="feedback-tbody"></tbody>
+          </table>
+
+          <div id="feedback-vocab" class="feedback-section" style="display:none">
+            <div class="feedback-section-title">Vocabulaire dentaire utile</div>
+            <ul class="feedback-list" id="feedback-vocab-list"></ul>
+          </div>
+
+          <div id="feedback-priorite" class="feedback-section" style="display:none">
+            <div class="feedback-section-title">Priorit&eacute; pour la prochaine s&eacute;ance</div>
+            <ul class="feedback-list" id="feedback-priorite-list"></ul>
+          </div>
+
+          <div id="feedback-bilan" class="feedback-section" style="display:none">
+            <div class="feedback-section-title">Bilan</div>
+            <div id="feedback-bilan-rows"></div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </div>
+
+  <div class="footer">
+    Mod&egrave;le: Gemma 4 E2B (ZeroGPU) &middot; STT int&eacute;gr&eacute;e &middot; TTS: piper-tts<br>
+    <a href="https://huggingface.co/spaces/build-small-hackathon/patient-virtuel-dentiste" style="color:#ff5719;text-decoration:none;">&#8592; Version principale (Gemma 4 26B)</a>
+  </div>
+</div>
+
+<audio id="audio-player" autoplay></audio>
+
+<script type="module">
+import { Client } from "https://cdn.jsdelivr.net/npm/@gradio/client@2.2.1/dist/browser.js";
+
+let client = null;
+let sessionState = null;
+let mediaRecorder = null;
+let audioChunks = [];
+let isRecording = false;
+let isProcessing = false;
+
+const micBtn = document.getElementById("mic-btn");
+const micIcon = document.getElementById("mic-icon");
+const stopIcon = document.getElementById("stop-icon");
+const micLabel = document.getElementById("mic-label");
+const statusEl = document.getElementById("status");
+const chatEl = document.getElementById("chat");
+const feedbackEl = document.getElementById("feedback");
+const feedbackIntro = document.getElementById("feedback-intro");
+const feedbackTbody = document.getElementById("feedback-tbody");
+const feedbackTable = document.getElementById("feedback-table");
+const feedbackEmpty = document.getElementById("feedback-empty");
+const feedbackCount = document.getElementById("feedback-count");
+const feedbackPointsForts = document.getElementById("feedback-points-forts");
+const feedbackPointsList = document.getElementById("feedback-points-list");
+const feedbackVocab = document.getElementById("feedback-vocab");
+const feedbackVocabList = document.getElementById("feedback-vocab-list");
+const feedbackPriorite = document.getElementById("feedback-priorite");
+const feedbackPrioriteList = document.getElementById("feedback-priorite-list");
+const feedbackBilan = document.getElementById("feedback-bilan");
+const feedbackBilanRows = document.getElementById("feedback-bilan-rows");
+const audioPlayer = document.getElementById("audio-player");
+const btnEnd = document.getElementById("btn-end");
+const btnReset = document.getElementById("btn-reset");
+
+async function initClient() {
+  try {
+    client = await Client.connect(window.location.origin);
+    const result = await client.predict("/reset_session", {});
+    sessionState = result.data[0].state;
+    console.log("Connected to backend");
+  } catch (err) {
+    console.error("Failed to connect:", err);
+    setStatus("Failed to connect to server.");
+  }
+}
+
+async function toggleRecording() {
+  if (isProcessing) return;
+  if (isRecording) {
+    stopRecording();
+  } else {
+    startRecording();
+  }
+}
+
+async function startRecording() {
+  try {
+    const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+    audioChunks = [];
+    mediaRecorder = new MediaRecorder(stream, { mimeType: "audio/webm;codecs=opus" });
+    mediaRecorder.ondataavailable = (e) => { if (e.data.size > 0) audioChunks.push(e.data); };
+    mediaRecorder.onstop = () => {
+      stream.getTracks().forEach(t => t.stop());
+      const blob = new Blob(audioChunks, { type: "audio/webm" });
+      processAudio(blob);
+    };
+    mediaRecorder.start();
+    isRecording = true;
+    micBtn.classList.add("recording");
+    micIcon.style.display = "none";
+    stopIcon.style.display = "block";
+    micLabel.textContent = "Recording...";
+    micLabel.classList.add("active");
+    setStatus("");
+  } catch (err) {
+    setStatus("Microphone unavailable.");
+  }
+}
+
+function stopRecording() {
+  if (mediaRecorder && mediaRecorder.state === "recording") {
+    mediaRecorder.stop();
+  }
+  isRecording = false;
+  micBtn.classList.remove("recording");
+  micIcon.style.display = "block";
+  stopIcon.style.display = "none";
+  micLabel.textContent = "Tap to speak";
+  micLabel.classList.remove("active");
+}
+
+async function processAudio(blob) {
+  if (!client) return;
+
+  isProcessing = true;
+  micBtn.disabled = true;
+  btnEnd.disabled = true;
+  setStatus("Decoding audio...");
+
+  try {
+    const audioFile = new File([blob], "recording.webm", { type: blob.type || "audio/webm" });
+    setStatus("Patient thinking...");
+    const result = await client.predict("/process_turn", {
+      audio: audioFile,
+      state: sessionState,
+    });
+
+    const d = result.data[0];
+    sessionState = d.state;
+
+    renderChat(d.chat);
+
+    if (d.audio_url) {
+      setStatus("Synthesizing speech...");
+      await playAudio(d.audio_url);
+    } else {
+      const bubbles = chatEl.querySelectorAll(".msg-patient");
+      const last = bubbles[bubbles.length - 1];
+      if (last) last.innerHTML += ' <span class="no-audio">&#128263;</span>';
+    }
+
+    if (d.feedback_open) {
+      showFeedback(d.feedback_intro, d.feedback_table, d.feedback_points_forts, d.feedback_vocabulaire, d.feedback_priorite, d.feedback_bilan);
+    }
+
+    setStatus(d.status || "");
+  } catch (err) {
+    console.error("Process error:", err);
+    setStatus("Error. Please retry.");
+  } finally {
+    isProcessing = false;
+    micBtn.disabled = false;
+    btnEnd.disabled = false;
+  }
+}
+
+async function endSession() {
+  if (!client || isProcessing) return;
+  isProcessing = true;
+  micBtn.disabled = true;
+  btnEnd.disabled = true;
+  setStatus("Generating recap...");
+
+  try {
+    const result = await client.predict("/end_session", { state: sessionState });
+    const d = result.data[0];
+    sessionState = d.state;
+
+    renderChat(d.chat);
+    if (d.audio_url) {
+      setStatus("Synthesizing speech...");
+      await playAudio(d.audio_url);
+    }
+    if (d.feedback_open) {
+      showFeedback(d.feedback_intro, d.feedback_table, d.feedback_points_forts, d.feedback_vocabulaire, d.feedback_priorite, d.feedback_bilan);
+    }
+    setStatus("");
+  } catch (err) {
+    console.error("End session error:", err);
+    setStatus("Error generating recap.");
+  } finally {
+    isProcessing = false;
+    micBtn.disabled = false;
+    btnEnd.disabled = false;
+  }
+}
+
+async function resetSession() {
+  if (!client || isProcessing) return;
+  try {
+    const result = await client.predict("/reset_session", {});
+    sessionState = result.data[0].state;
+    chatEl.innerHTML = "";
+    feedbackEl.classList.add("open");
+    feedbackIntro.textContent = "";
+    feedbackTbody.innerHTML = "";
+    feedbackTable.style.display = "none";
+    feedbackEmpty.style.display = "";
+    feedbackPointsForts.style.display = "none";
+    feedbackPointsList.innerHTML = "";
+    feedbackVocab.style.display = "none";
+    feedbackVocabList.innerHTML = "";
+    feedbackPriorite.style.display = "none";
+    feedbackPrioriteList.innerHTML = "";
+    feedbackBilan.style.display = "none";
+    feedbackBilanRows.innerHTML = "";
+    feedbackCount.textContent = "0 notes";
+    setStatus("");
+    audioPlayer.pause();
+    audioPlayer.src = "";
+  } catch (err) {
+    console.error("Reset error:", err);
+  }
+}
+
+function renderChat(messages) {
+  chatEl.innerHTML = "";
+  for (const msg of messages) {
+    if (msg.role === "system") continue;
+    const div = document.createElement("div");
+    div.className = `msg ${msg.role === "user" ? "msg-user" : "msg-patient"}`;
+    const roleLabel = msg.role === "user" ? "Vous" : "Patient";
+    div.innerHTML = `<div class="msg-role">${roleLabel}</div>${escapeHtml(msg.content)}`;
+    chatEl.appendChild(div);
+  }
+  chatEl.scrollTop = chatEl.scrollHeight;
+}
+
+function showFeedback(intro, table, pointsForts, vocabulaire, priorite, bilan) {
+  feedbackIntro.textContent = intro;
+  feedbackTbody.innerHTML = "";
+
+  if (pointsForts && pointsForts.length) {
+    feedbackPointsForts.style.display = "";
+    feedbackPointsList.innerHTML = "";
+    for (const item of pointsForts) {
+      const li = document.createElement("li");
+      li.textContent = item;
+      feedbackPointsList.appendChild(li);
+    }
+  } else {
+    feedbackPointsForts.style.display = "none";
+  }
+
+  if (table && table.length) {
+    feedbackTable.style.display = "";
+    feedbackEmpty.style.display = "none";
+    feedbackCount.textContent = table.length + (table.length > 1 ? " notes" : " note");
+    for (const row of table) {
+      const tr = document.createElement("tr");
+      const cells = Array.isArray(row) ? row : [row["citation"], row["correction"], row["pourquoi"]];
+      for (const cell of cells) {
+        const td = document.createElement("td");
+        td.textContent = cell || "";
+        tr.appendChild(td);
+      }
+      feedbackTbody.appendChild(tr);
+    }
+  } else {
+    feedbackTable.style.display = "none";
+  }
+
+  if (vocabulaire && vocabulaire.length) {
+    feedbackVocab.style.display = "";
+    feedbackVocabList.innerHTML = "";
+    for (const item of vocabulaire) {
+      const li = document.createElement("li");
+      li.textContent = item;
+      feedbackVocabList.appendChild(li);
+    }
+  } else {
+    feedbackVocab.style.display = "none";
+  }
+
+  if (priorite && priorite.length) {
+    feedbackPriorite.style.display = "";
+    feedbackPrioriteList.innerHTML = "";
+    for (const item of priorite) {
+      const li = document.createElement("li");
+      li.textContent = item;
+      feedbackPrioriteList.appendChild(li);
+    }
+  } else {
+    feedbackPriorite.style.display = "none";
+  }
+
+  if (bilan && Object.keys(bilan).length) {
+    feedbackBilan.style.display = "";
+    feedbackBilanRows.innerHTML = "";
+    const labels = {
+      grammaire: "Grammaire",
+      fluidite: "Fluidite",
+      vocabulaire_dentaire: "Vocabulaire dentaire",
+    };
+    for (const [key, label] of Object.entries(labels)) {
+      const val = bilan[key];
+      if (val == null) continue;
+      const pct = Math.max(10, (val / 5) * 100);
+      const row = document.createElement("div");
+      row.className = "bilan-row";
+      row.innerHTML =
+        `<span class="bilan-label">${label}</span>` +
+        `<div class="bilan-bar"><div class="bilan-fill" style="width:${pct}%"></div></div>` +
+        `<span class="bilan-score">${val}/5</span>`;
+      feedbackBilanRows.appendChild(row);
+    }
+  } else {
+    feedbackBilan.style.display = "none";
+  }
+
+  if (!table || !table.length) {
+    feedbackEmpty.style.display = "none";
+    feedbackCount.textContent = "";
+  }
+
+  feedbackEl.classList.add("open");
+}
+
+function toggleFeedback() {
+  feedbackEl.classList.toggle("open");
+}
+
+function playAudio(url) {
+  return new Promise((resolve) => {
+    audioPlayer.onended = resolve;
+    audioPlayer.onerror = resolve;
+    audioPlayer.src = url;
+    audioPlayer.play().catch(resolve);
+  });
+}
+
+function setStatus(text) {
+  statusEl.textContent = text;
+}
+
+function escapeHtml(text) {
+  const div = document.createElement("div");
+  div.textContent = text;
+  return div.innerHTML;
+}
+
+initClient();
+
+window.toggleRecording = toggleRecording;
+window.endSession = endSession;
+window.resetSession = resetSession;
+window.toggleFeedback = toggleFeedback;
+</script>
+</body>
+</html>

patient-virtuel-e2b/parse_feedback.py

@@ -0,0 +1,130 @@
+import re
+
+SECTION_HEADERS = [
+    "Points forts",
+    "À corriger",
+    "Vocabulaire dentaire utile",
+    "Priorité pour la prochaine séance",
+    "Bilan",
+]
+
+NEXT_HEADER_PATTERN = re.compile(
+    rf"(?:^|\n)\s*(?:{'|'.join(re.escape(h) for h in SECTION_HEADERS)})\s*:\s*",
+    re.IGNORECASE | re.MULTILINE,
+)
+
+CITATION_RE = re.compile(
+    r'Citation:\s*["\u00ab](.+?)["\u00bb]\s*Correction:\s*(.+?)\s*Pourquoi:\s*(.+?)(?=\s*(?:Citation:|[A-Z\u00c0-\u017f][^\n:]*:)|\s*$)',
+    re.DOTALL | re.IGNORECASE,
+)
+
+
+def _extract_section(text: str, header: str) -> str:
+    """Return content between *header*: and the next section header or EOF."""
+    m = re.search(
+        rf"(?:^|\n)\s*{re.escape(header)}\s*:\s*",
+        text, re.IGNORECASE | re.MULTILINE,
+    )
+    if not m:
+        return ""
+    start = m.end()
+    # Find next section header
+    nm = NEXT_HEADER_PATTERN.search(text, start)
+    end = nm.start() if nm else len(text)
+    return text[start:end].strip()
+
+
+def _parse_bullets(text: str) -> list[str]:
+    """Extract lines prefixed with - or • from a section block."""
+    if not text:
+        return []
+    items = []
+    for line in text.split("\n"):
+        line = line.strip()
+        if re.match(r"^[-•]\s", line):
+            items.append(re.sub(r"^[-•]\s*", "", line).strip())
+    return items
+
+
+def _parse_bilan(text: str) -> dict:
+    """Extract Bilan scores as {key: int}."""
+    section = _extract_section(text, "Bilan")
+    if not section:
+        return {}
+    scores = {}
+    for line in section.split("\n"):
+        m = re.match(
+            r"[-•]?\s*(Grammaire|Fluidité|Vocabulaire dentaire|Communication clinique)\s*:\s*(\d+)\s*/\s*\d+",
+            line.strip(), re.IGNORECASE,
+        )
+        if m:
+            key = m.group(1).lower().replace(" ", "_")
+            scores[key] = int(m.group(2))
+    return scores
+
+
+def parse_feedback(text: str) -> dict:
+    """Parse full feedback into a structured dict.
+
+    Returns:
+        intro -- spoken part (before delimiter)
+        points_forts -- list[str]
+        erreurs -- list[dict] with keys: citation, correction, pourquoi
+        vocabulaire -- list[str]
+        priorite -- list[str]
+        bilan -- dict {grammaire: int, fluidite: int, ...}
+    """
+    result = {
+        "intro": "",
+        "points_forts": [],
+        "erreurs": [],
+        "vocabulaire": [],
+        "priorite": [],
+        "bilan": {},
+    }
+
+    # Split on delimiter
+    if "---" in text:
+        parts = text.split("---", 1)
+        result["intro"] = parts[0].strip()
+        rest = parts[1].strip()
+    elif "Points forts:" in text:
+        parts = text.split("Points forts:", 1)
+        result["intro"] = parts[0].strip()
+        rest = "Points forts: " + parts[1].strip()
+    else:
+        result["intro"] = text.strip()
+        return result
+
+    result["points_forts"] = _parse_bullets(_extract_section(rest, "Points forts"))
+
+    corriger = _extract_section(rest, "À corriger")
+    for m in CITATION_RE.finditer(corriger):
+        result["erreurs"].append({
+            "citation": m.group(1).strip(),
+            "correction": m.group(2).strip(),
+            "pourquoi": m.group(3).strip(),
+        })
+
+    result["vocabulaire"] = _parse_bullets(_extract_section(rest, "Vocabulaire dentaire utile"))
+    result["priorite"] = _parse_bullets(_extract_section(rest, "Priorité pour la prochaine séance"))
+    result["bilan"] = _parse_bilan(rest)
+
+    return result
+
+
+def render_feedback_table(entries: list[dict]) -> list[list[str]]:
+    """Convert error entries to table rows for the frontend."""
+    return [[e["citation"], e["correction"], e["pourquoi"]] for e in entries]
+
+
+def strip_markdown(text: str) -> str:
+    text = re.sub(r"\*\*(.+?)\*\*", r"\1", text)
+    text = re.sub(r"\*(.+?)\*", r"\1", text)
+    text = re.sub(r"`(.+?)`", r"\1", text)
+    text = re.sub(r"#{1,6}\s*", "", text)
+    text = re.sub(r"^[-*]\s", "", text, flags=re.MULTILINE)
+    text = re.sub(r"!?\[.*?\]\(.*?\)", "", text)
+    text = text.replace("\u258c", "")
+    text = text.replace("\U0001f916", "")
+    return text.strip()

patient-virtuel-e2b/prompts_e2b.py

@@ -0,0 +1,47 @@
+SYSTEM_PROMPT = """You are a virtual dental patient in a Swiss dental clinic. The user is a dental hygienist practicing professional French.
+
+Stay in character at all times. Speak only French. Use plain text. Keep responses short (1-2 sentences).
+
+PATIENT PROFILE
+Create one hidden profile per session: age, dental habits, one mild concern. Be consistent. You have moderate dental anxiety.
+
+APPOINTMENT
+React naturally to the hygienist's questions and instructions across these phases:
+
+1. EXAM (bilan): Answer questions about your health and oral care. Mention sensitivity on your left molars.
+
+2. TREATMENT (soins): Respond to vibrations, water spray, and instruments. If something hurts, say so briefly.
+
+3. ADVICE (conseils): Ask 1-2 questions about home care. Say you forget to floss sometimes.
+
+TUTOR MODE
+When the user says "fin de la seance" or "on a termine", switch to French coach mode.
+
+First say 2 short sentences: one encouraging, one priority for improvement.
+Then output --- on its own line.
+Then give a short recap:
+
+Points forts:
+- ...
+
+A corriger:
+Citation: "..."
+Correction: ...
+Pourquoi: ...
+
+Vocabulaire dentaire utile:
+- ...
+
+Priorite pour la prochaine seance:
+- ...
+
+Bilan:
+- Grammaire: x/5
+- Fluidity: x/5
+- Vocabulaire dentaire: x/5
+
+Only correct real errors the user made. If unsure about transcription, say so. Avoid inventing mistakes.
+
+DO NOT use markdown, emojis, or bullets in roleplay replies."""
+
+PHASE_SWITCH_REMINDER = """Reminder: you are now a French coach. Stop roleplay. Say 2 spoken sentences (encouragement + priority), then ---, then written recap with Points forts, A corriger, Vocabulaire dentaire utile, Priorite, and Bilan scores. Plain text only."""

patient-virtuel-e2b/requirements.txt

@@ -0,0 +1,9 @@
+gradio>=6.0,<7.0
+transformers>=5.10.2,<6.0
+torch>=2.8.0,<3.0
+torchvision>=0.22.0
+torchaudio>=2.8.0
+numpy
+piper-tts>=1.2,<2.0
+soundfile
+accelerate

patient-virtuel-e2b/server_app.py

@@ -0,0 +1,105 @@
+import logging
+import os
+import tempfile
+
+from gradio import Server
+from gradio.data_classes import FileData
+from fastapi.responses import HTMLResponse, FileResponse
+from fastapi.staticfiles import StaticFiles
+
+from core import process_turn, end_session_click, reset_session, make_initial_state
+
+log = logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO, force=True)
+
+app = Server()
+
+
+@app.api(name="process_turn")
+def api_process_turn(audio: FileData, state: dict) -> dict:
+    try:
+        audio_path = audio.get("path") if isinstance(audio, dict) else audio.path if hasattr(audio, "path") else str(audio)
+        log.info("process_turn audio_path=%s state_turns=%s", audio_path, state.get("turn_count"))
+        result = process_turn(audio_path, state)
+        log.info("process_turn done status=%s", result.get("status"))
+    except Exception as e:
+        log.error("process_turn error: %s", e)
+        return {
+            "chat": state.get("messages", []),
+            "audio_url": None,
+            "state": state,
+            "feedback_intro": "",
+            "feedback_points_forts": [],
+            "feedback_table": [],
+            "feedback_vocabulaire": [],
+            "feedback_priorite": [],
+            "feedback_bilan": {},
+            "feedback_open": False,
+            "status": f"Error: {e}",
+        }
+
+    audio_url = None
+    if result["audio_file"]:
+        audio_url = f"/audio/{result['audio_file']}"
+
+    return {
+        "chat": result["chat"],
+        "audio_url": audio_url,
+        "state": result["state"],
+        "feedback_intro": result["feedback_intro"],
+        "feedback_points_forts": result["feedback_points_forts"],
+        "feedback_table": result["feedback_table"],
+        "feedback_vocabulaire": result["feedback_vocabulaire"],
+        "feedback_priorite": result["feedback_priorite"],
+        "feedback_bilan": result["feedback_bilan"],
+        "feedback_open": result["feedback_open"],
+        "status": result["status"],
+    }
+
+
+@app.api(name="end_session")
+def api_end_session(state: dict) -> dict:
+    result = end_session_click(state)
+
+    audio_url = None
+    if result["audio_file"]:
+        audio_url = f"/audio/{result['audio_file']}"
+
+    return {
+        "chat": result["chat"],
+        "audio_url": audio_url,
+        "state": result["state"],
+        "feedback_intro": result["feedback_intro"],
+        "feedback_points_forts": result["feedback_points_forts"],
+        "feedback_table": result["feedback_table"],
+        "feedback_vocabulaire": result["feedback_vocabulaire"],
+        "feedback_priorite": result["feedback_priorite"],
+        "feedback_bilan": result["feedback_bilan"],
+        "feedback_open": result["feedback_open"],
+        "status": result["status"],
+    }
+
+
+@app.api(name="reset_session")
+def api_reset_session() -> dict:
+    state = reset_session()
+    return {"state": state}
+
+
+@app.get("/audio/{filename}")
+async def serve_audio(filename: str):
+    path = os.path.join(tempfile.gettempdir(), filename)
+    if not os.path.exists(path):
+        return {"error": "Audio not found"}
+    return FileResponse(path, media_type="audio/wav")
+
+
+@app.get("/", response_class=HTMLResponse)
+async def homepage():
+    html_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "custom_index.html")
+    with open(html_path, "r", encoding="utf-8") as f:
+        return f.read()
+
+
+if __name__ == "__main__":
+    app.launch()

patient-virtuel-e2b/tts_engine.py

@@ -0,0 +1,98 @@
+import io
+import logging
+import os
+import wave
+import threading
+
+import httpx
+
+log = logging.getLogger(__name__)
+
+MODEL_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "voices")
+MODEL_URL = (
+    "https://huggingface.co/rhasspy/piper-voices/resolve/main/fr/fr_FR/siwis/medium/"
+    "fr_FR-siwis-medium.onnx"
+)
+CONFIG_URL = MODEL_URL + ".json"
+MODEL_PATH = os.path.join(MODEL_DIR, "fr_FR-siwis-medium.onnx")
+CONFIG_PATH = MODEL_PATH + ".json"
+
+_voice = None
+_voice_lock = threading.Lock()
+_piper_available = False
+
+
+def _download(url, path):
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    with httpx.Client() as client:
+        resp = client.get(url, follow_redirects=True, timeout=120)
+        resp.raise_for_status()
+        with open(path, "wb") as f:
+            for chunk in resp.iter_bytes():
+                f.write(chunk)
+
+
+def _ensure_model():
+    if not os.path.exists(MODEL_PATH):
+        _download(MODEL_URL, MODEL_PATH)
+    if not os.path.exists(CONFIG_PATH):
+        _download(CONFIG_URL, CONFIG_PATH)
+
+
+def _init():
+    global _piper_available
+    try:
+        _ensure_model()
+        from piper import PiperVoice  # noqa: F401
+        _piper_available = True
+        log.info("piper-tts available, voice model at %s", MODEL_PATH)
+    except Exception as e:
+        log.warning("piper-tts unavailable: %s", e)
+
+
+_init()
+
+
+def _get_voice():
+    global _voice
+    if _voice is not None:
+        return _voice
+    with _voice_lock:
+        if _voice is not None:
+            return _voice
+        from piper import PiperVoice
+
+        _voice = PiperVoice.load(MODEL_PATH, config_path=CONFIG_PATH)
+        return _voice
+
+
+def synthesize(text: str) -> bytes | None:
+    if not text:
+        return None
+    if not _piper_available:
+        log.warning("piper-tts not available, skipping TTS")
+        return None
+    try:
+        voice = _get_voice()
+
+        sample_rate = 22050
+        sample_width = 2
+        frames = bytearray()
+        for chunk in voice.synthesize(text):
+            sample_rate = chunk.sample_rate
+            sample_width = chunk.sample_width
+            frames.extend(chunk.audio_int16_bytes)
+
+        if not frames:
+            return None
+
+        buf = io.BytesIO()
+        with wave.open(buf, "wb") as wf:
+            wf.setnchannels(1)
+            wf.setsampwidth(sample_width)
+            wf.setframerate(sample_rate)
+            wf.writeframes(bytes(frames))
+        return buf.getvalue()
+    except Exception as e:
+        log.error("TTS synthesis failed: %s", e)
+        return None

server_app.py

@@ -111,7 +111,7 @@ _FIELD_NOTES_HTML_TEMPLATE = """\
 <head>
 <meta charset="UTF-8">
 <meta name="viewport" content="width=device-width, initial-scale=1.0">
-<title>Field Notes · Patient Virtuel</title>
+<title>Field Notes: Patient Virtuel</title>
 <style>
   *, *::before, *::after { margin: 0; box-sizing: border-box; }
   body {

trace.jsonl

@@ -0,0 +1,18 @@
+{"trace_id": "patient-virtuel-01", "step": 1, "phase": "ideation", "intent": "My wife is a dentist returning to work after years at home. Her French is good, but dental hygiene French is a different language. She needed a patient to practice on.", "action": "Turned that into a concrete plan: a voice-based AI dental patient that roleplays a full hygiene session in Swiss French. It listens, responds naturally, gives feedback on the dentist's French, and guides her through each step of a real appointment.", "reasoning": "The problem came from real life. My wife couldn't practice the specific vocabulary and flow of a hygiene session in French without a patient. A voice AI could simulate that interaction and also correct her French, something a real patient can't do.", "tools": ["conversation"], "files": [], "outcome": "A clear concept: roleplay a dental hygiene session with an AI patient that also acts as a French tutor.", "lesson": "The best problems come from someone who actually needs the solution. My wife was the product manager.", "commit": null},
+{"trace_id": "patient-virtuel-02", "step": 2, "phase": "scoping", "intent": "Define what the app does and does not do. A voice interface, not a chatbot. A dental patient, not a general French tutor.", "action": "Scoped it to a single Gradio app with microphone input and audio output. One turn at a time: dentist speaks, patient answers. No real-time streaming, no video, no UI beyond a chat transcript and mic button. The dentist roleplays the appointment and at the end the patient switches to a tutor that reviews her French.", "reasoning": "A voice loop is hard to get right without a dedicated telephony stack. Turn-based keeps latency predictable and avoids the self-hearing bug that single-device voice apps struggle with. The tutor mode at the end is the differentiator that makes this more than a toy.", "tools": ["conversation"], "files": [], "outcome": "Scope: Gradio app, turn-based voice, dental roleplay + tutor feedback. No streaming, no phone deployment.", "lesson": "Start with the smallest loop that solves the core problem. Voice features can grow later.", "commit": null},
+{"trace_id": "patient-virtuel-03", "step": 3, "phase": "method", "intent": "Keep the build from sprawling. One person building while a dentist reviews, so the iteration loop had to be tight.", "action": "Used a small loop on every feature: write the prompt change, deploy to HF Space and Modal, hand the phone to my wife, watch her use it, fix what felt wrong, commit, push. The prompt was the product and it changed almost every day during the first two weeks.", "reasoning": "The app lives on her phone in a browser tab. The real test is her trying to talk to it naturally and the patient responding believably. No automated test catches that.", "tools": ["Write", "Bash", "WebFetch"], "files": [], "outcome": "A 5-minute edit-deploy-test cycle. Most prompt changes went from idea to live in under 10 minutes.", "lesson": "When the user is in the same house, the fastest feedback loop wins.", "commit": null},
+{"trace_id": "patient-virtuel-04", "step": 4, "phase": "architecture", "intent": "Settle on the smallest stack that works: STT, LLM, TTS, all no-cost or self-hosted.", "action": "Started with Gradio 5 for the shell, Modal for GPU inference, faster-whisper for speech recognition, Mistral API for the LLM, and edge-tts for voice output. Gradio handled the audio recording and playback through its built-in Audio component.", "reasoning": "Gradio lets you build a working voice app in an afternoon. Modal gives GPU access without managing servers. Whisper runs cheap on Modal T4. edge-tts was free and produced decent French voice.", "tools": ["Write", "Bash"], "files": ["app.py", "modal_app.py", "requirements.txt", "modal_requirements.txt", "core/stt_engine.py", "core/llm_engine.py", "core/tts_engine.py"], "outcome": "End-to-end voice pipeline on Gradio + Modal + edge-tts. Working prototype in one evening.", "lesson": "A full voice app needs three pieces. Gradio gives you two of them (STT input, TTS output) for free.", "commit": "4bfc264"},
+{"trace_id": "patient-virtuel-05", "step": 5, "phase": "model-selection", "intent": "Replace Mistral API with a self-hosted model to qualify for the Off the Grid badge.", "action": "Switched the LLM from Mistral API to Gemma 4 26B-A4B running on a Modal L4 via llama.cpp with flash attention. Whisper runs on a Modal T4. The total is about 27B parameters, well under the 32B limit.", "reasoning": "The Off the Grid badge requires zero cloud API calls. Self-hosting the LLM also gives control over the prompt, temperature, and repetition penalty. Gemma 4 26B fits on an L4 at Q4_K_M and produces natural French responses for roleplay.", "tools": ["Write", "Bash", "Read"], "files": ["modal_app.py", "core/llm_engine.py", "modal_requirements.txt"], "outcome": "LLM: Gemma 4 26B on Modal L4 via llama.cpp. Whisper on Modal T4. Total ~27B parameters.", "lesson": "A 26B model with decent quantization runs well on an L4. The Off the Grid badge forced a better architecture.", "commit": "9904e15"},
+{"trace_id": "patient-virtuel-06", "step": 6, "phase": "debugging", "intent": "Get llama.cpp to compile with CUDA on Modal's CUDA devel image so Gemma 4 uses the GPU.", "action": "The base Modal image did not have the CUDA toolkit headers needed by llama.cpp. Switched to a CUDA devel image, pinned g++ to GCC 11 for compatibility, and added the build flags for flash attention and Metal/CUDA.", "reasoning": "llama.cpp needs nvcc and CUDA headers at build time, even if the runtime image is lighter. The devel image is bigger but the build is cached by Modal after the first run.", "tools": ["Bash", "Write"], "files": ["modal_requirements.txt"], "outcome": "llama.cpp compiles with CUDA on the devel image. Gemma 4 runs on the L4 at full speed.", "lesson": "GPU-accelerated llama.cpp needs the CUDA toolkit at build time. Use Modal's devel image and cache the layer.", "commit": "4d0770b"},
+{"trace_id": "patient-virtuel-07", "step": 7, "phase": "debugging", "intent": "Fix edge-tts compatibility and version confusion. Then replace it entirely with piper-tts to eliminate the last cloud dependency.", "action": "edge-tts kept breaking with version mismatches and its Python 3.13 incompatibility. Replaced it with piper-tts running on the HF Space CPU. Piper generates WAV files locally with no network call. Fixed the 1.x API where synthesize returns a generator of AudioChunk objects, not subscriptable, requiring explicit iteration.", "reasoning": "edge-tts calls Microsoft's cloud API, which breaks Off the Grid. Piper runs entirely on-device with no cloud dependency. It produces acceptable French voice quality and the CPU inference is fast enough on HF Space (under 1s per response).", "tools": ["Write", "Bash", "Read"], "files": ["core/tts_engine.py", "requirements.txt"], "outcome": "TTS is now fully local piper-tts. Zero cloud API calls across the entire stack: STT, LLM, and TTS.", "lesson": "Piper on CPU is fast enough for turn-based voice and eliminates the last cloud dependency. Pre-download the voice model at import time to avoid first-turn delay.", "commit": "77dc7fb"},
+{"trace_id": "patient-virtuel-08", "step": 8, "phase": "debugging", "intent": "Load piper-tts voice model eagerly so the first turn is not delayed by model download.", "action": "Moved the voice model loading from lazy (first synthesize call) to eager (import time) so the download happens during Space startup, not during the user's first interaction. Added a graceful fallback that returns a silent WAV if the voice fails to load.", "reasoning": "First impressions matter. If the first patient response takes 10 seconds because it downloads a 200MB model, the user assumes the app is broken. Loading at startup shifts that cost to the Space cold start, which the user expects to be slow.", "tools": ["Edit"], "files": ["core/tts_engine.py"], "outcome": "First-turn TTS latency dropped from ~10s to under 1s. Fallback audio prevents crashes if the voice model fails.", "lesson": "Eager-load model files that users wait for. Cold start is the right time for heavy I/O.", "commit": "960ba51"},
+{"trace_id": "patient-virtuel-09", "step": 9, "phase": "feature", "intent": "Replace the default Gradio UI with a custom frontend for a more natural conversation feel.", "action": "Built a custom frontend with gr.Server using vanilla HTML/CSS/JS. Two-column layout with EB Garamond font and glassmorphism styling. The top panel shows the conversation transcript, the bottom has a single mic button. Audio plays inline without page reload.", "reasoning": "The default Gradio Chatbot component looks like a research notebook. A real conversation needs to feel like a messaging app. gr.Server lets you keep Gradio's API layer and server-side audio handling while writing your own HTML. The @gradio/client browser build replaced the jsdelivr version that threw Buffer is not defined in the browser.", "tools": ["Write", "Edit", "WebFetch"], "files": ["custom_index.html", "server_app.py"], "outcome": "Custom frontend with glassmorphism styling, two columns, and inline audio playback feeling like a messaging app.", "lesson": "gr.Server gives you the best of both worlds: Gradio's API layer with your own HTML. Skip the default Chatbot component.", "commit": "0213ffe"},
+{"trace_id": "patient-virtuel-10", "step": 10, "phase": "architecture", "intent": "Reduce cold start latency by warming up both the LLM and Whisper models before the user's first turn.", "action": "Added a /warmup endpoint on Modal that loads Gemma 4 into memory and runs one inference pass. The Gradio backend fires a request to /warmup on page load, rate-limited to once per 120 seconds. Added a similar warmup for faster-whisper by sending a silent 44-byte WAV through the transcription pipeline.", "reasoning": "Modal containers scale to zero after 90 seconds of idle. The first request after idle triggers a cold start that takes 30-45 seconds to load Gemma 4. Warming up proactively shifts that wait from the user's first turn to the page load, where a 5-second delay is acceptable.", "tools": ["Write", "Edit"], "files": ["modal_app.py", "core/llm_engine.py", "core/stt_engine.py", "custom_index.html"], "outcome": "First-turn latency dropped from ~45s to under 10s. Warmup fires on page load and on Nouvelle session click.", "lesson": "Shift cold start cost to moments the user tolerates waiting. Modal's scale-to-zero is great for cost but you need a strategy for it.", "commit": "bff24ec"},
+{"trace_id": "patient-virtuel-11", "step": 11, "phase": "feature", "intent": "Make the app work in Swiss French with proper dental vocabulary and appointment flow.", "action": "Wrote a detailed system prompt that defines the patient persona: a 32-year-old patient in a Swiss dental clinic with moderate dental anxiety. The prompt specifies how the patient responds to each phase of a hygiene appointment: bilan (exam), detectartrage (scaling), aeropolissage (air polishing), polissage (polishing), conseils (home care), and cloture (wrap up). Each phase has a realistic reaction and the patient follows chairside instructions naturally.", "reasoning": "The prompt is the product. Without a detailed prompt, the LLM gives generic medical chatbot responses. The appointment phases came directly from my wife's dental school scripts. The chairside instruction responses let the dentist practice commands like ouvrez grand (open wide) and crachez (spit), which are core to real sessions.", "tools": ["Write", "Edit"], "files": ["prompts.py"], "outcome": "The patient follows a real hygiene appointment flow, reacts to sensitivity, and obeys chairside instructions. The dentist can practice the entire session including giving commands.", "lesson": "A prompt written from a domain expert's scripts is worth more than any model upgrade. My wife's dental scripts were the best training data we never trained on.", "commit": "3b90454"},
+{"trace_id": "patient-virtuel-12", "step": 12, "phase": "feature", "intent": "Add structured French tutoring after the roleplay session ends.", "action": "Added a two-phase prompt system. During roleplay, the model stays in character as the patient. When the dentist says fin de la seance or session terminee, a PHASE_SWITCH_REMINDER triggers a switch to tutor mode that generates structured feedback: points forts (strengths), corrections with citations from the conversation, vocabulary to review, and scores for grammar, vocabulary, pronunciation, and fluidity.", "reasoning": "The hybrid patient-tutor role is what makes this more than a chatbot. My wife needs both the practice and the correction. The phase switch had to be reliable because early versions leaked tutor responses into roleplay or vice versa.", "tools": ["Write", "Edit"], "files": ["prompts.py", "core.py"], "outcome": "Dentist practices until she says fin de la seance, then gets structured feedback with scores and vocabulary corrections.", "lesson": "A clear phase boundary with a dedicated reminder prompt prevents the model from leaking characters between two very different roles.", "commit": "3252fe9"},
+{"trace_id": "patient-virtuel-13", "step": 13, "phase": "architecture", "intent": "Eliminate the last cloud dependency by replacing edge-tts with local piper-tts and removing all third-party API calls.", "action": "Replaced edge-tts (which calls Microsoft's cloud API) with piper-tts running on the HF Space CPU. Fixed the piper-tts 1.x API where synthesize returns a generator of AudioChunk objects. Rebuilt the TTS pipeline to iterate the generator and accumulate int16 frames. Updated the footer to credit piper-tts instead of edge-tts.", "reasoning": "The Off the Grid badge requires zero cloud API calls. Piper on CPU is fast enough for turn-based voice and produces decent French quality. The generator-based API was the main gotcha since the docs show subscript access that does not work.", "tools": ["Write", "Read"], "files": ["core/tts_engine.py", "requirements.txt"], "outcome": "Full stack is Off the Grid: Gemma 4 on Modal, faster-whisper on Modal, piper-tts on HF Space. Zero third-party cloud APIs.", "lesson": "Read the API docs carefully at runtime, not just at write time. Piper's 1.x generator caught me because I assumed it returned AudioChunk directly.", "commit": "d8c79e2"},
+{"trace_id": "patient-virtuel-14", "step": 14, "phase": "testing", "intent": "Measure and optimize latency across the full STT-LLM-TTS pipeline.", "action": "Added latency logging to process_turn and _end_session in core.py using time.monotonic(). Each turn logs STT, LLM, TTS, and total latency. Tuned llama.cpp parameters: batch size, temperature 0.85, repeat penalty 1.15, removed MTP (speculative decoding did not help with Gemma 4 on this workload).", "reasoning": "Without metrics, you optimize blind. The logs showed LLM inference at 4.2s median, STT at 1.8s, TTS at 0.6s. The total under 7s per turn is good for a voice app. Speculative decoding added complexity without speedup on a 26B model with short outputs.", "tools": ["Write", "Edit", "Bash"], "files": ["core.py", "modal_app.py"], "outcome": "Median per-turn latency: 1.8s STT + 4.2s LLM + 0.6s TTS = 6.6s total. Removed MTP for simpler code with no regression.", "lesson": "Measure before optimizing. The logs told us LLM was the bottleneck, not TTS or STT, so that is where tuning effort went.", "commit": "bdf814c"},
+{"trace_id": "patient-virtuel-15", "step": 15, "phase": "debugging", "intent": "Fix a bug where the first-turn status message fired on every turn, not just the first.", "action": "The original code showed a status message Le patient arrive au cabinet... on turn_count == 0 with a 2-second delay. But sessionState reset per turn, so the condition was always true. Removed the status message and the delay entirely.", "reasoning": "The bug made every turn start with a 2-second delay and a message that only made sense on the first turn. Removing the message simplified the UX and eliminated the delay.", "tools": ["Edit"], "files": ["custom_index.html"], "outcome": "No more spurious status messages. Turns start immediately with the patient's response.", "lesson": "When a state-dependent feature cannot work reliably because state resets, remove it rather than patch around it.", "commit": "ef4b333"},
+{"trace_id": "patient-virtuel-16", "step": 16, "phase": "hygiene", "intent": "Clean up the repo for public consumption: rename env vars, remove dead code, update documentation.", "action": "Renamed MODAL_ENDPOINT_QWEN to MODAL_ENDPOINT_LLM because the model is now Gemma 4, not Qwen. Moved orphaned modal scripts to experimental/ and legacy React code to legacy/. Added both to .gitignore. Updated space_README.md with correct SDK version (6.16.0), piper-tts info, and the new env var name. Removed the old Gradio app.py that was superseded by the custom frontend.", "reasoning": "A public repo should not have dead code, misleading env var names, or stale docs. Hackathon judges read the README first.", "tools": ["Write", "Edit", "Bash"], "files": ["core/llm_engine.py", "space_README.md", ".gitignore", "server_app.py", "requirements.txt"], "outcome": "Clean repo with accurate docs, correct env var names, and no dead code.", "lesson": "A repo is part of the submission. If it looks abandoned, the code does not matter.", "commit": "bdf814c"},
+{"trace_id": "patient-virtuel-17", "step": 17, "phase": "deploy", "intent": "Ship the app as a public HF Space with auto-deploy on push.", "action": "Pushed to huggingface.co/spaces/build-small-hackathon/patient-virtuel-dentiste via a second remote (hf) that maps the build-small-hackathon branch to main. Added a /field-notes route that renders FIELD_NOTES.md with proper markdown (tables, fenced code) using the Python markdown library. Deployed Modal app separately with modal deploy modal_app.py.", "reasoning": "HF Spaces auto-deploys when you push to the main branch. The two-remote setup (origin for GitHub, hf for Spaces) keeps the GitHub repo as the source of truth while deploying automatically. The /field-notes route makes the blog post accessible from the live app.", "tools": ["Bash", "Write"], "files": ["server_app.py", "requirements.txt"], "outcome": "Live at hf.co/spaces/build-small-hackathon/patient-virtuel-dentiste. Auto-deploys on push. Field Notes at /field-notes.", "lesson": "Two remotes let you keep a GitHub source repo and auto-deploy to Spaces. Just push to both.", "commit": "675cf71"},
+{"trace_id": "patient-virtuel-18", "step": 18, "phase": "hygiene", "intent": "Match all public text to my tone and voice: first person, direct, no em dashes, short sentences.", "action": "Rewrote FIELD_NOTES.md from third-person (we, our) to first person (I, my). Added a Modal cost control section. Cut em dashes throughout all three bonus quest files. Added a lesson about how previous llama.cpp experience on a Quadro RTX 3000 with 6 GB VRAM helped me get up to speed on Modal quickly.", "reasoning": "The hackathon submission includes FIELD_NOTES.md, LINKEDIN_POST.md, and VIDEO_SCRIPT.md. These represent me, so the voice had to be mine: direct, concise, a bit informal, no academic padding. The cost control section is useful for other builders considering Modal.", "tools": ["Write", "Edit"], "files": ["FIELD_NOTES.md", "LINKEDIN_POST.md", "VIDEO_SCRIPT.md", "server_app.py"], "outcome": "All bonus quest deliverables in first person with consistent tone. Cost section documents actual Modal spending.", "lesson": "Public writing is part of the build. Budget time to edit it like code, because it represents the project as much as the architecture.", "commit": "2f4e25b"}]