Remove dead chat code and obsolete planning docs.

Drop unwired results chat, hosted API extractor, experimental medreason script, and stale markdown. Trim interpretation rendering to patterns_html only and make model path tests cache-independent.
Co-authored-by: Codex <chatgpt-codex-connector[bot]@users.noreply.github.com>

DEPLOYMENT_LOG.md

@@ -1,149 +0,0 @@
-# Deployment Log
-
-## 2026-06-13 — Opt-in llama.cpp vision + doc refresh
-
-Decision: keep **Transformers** as the default extraction backend; make llama.cpp an explicit,
-opt-in lane controlled by environment variables.
-
-Why:
-- PDF/image uploads always go through the vision document pipeline in `src/document_processing.py`.
-- The previous docs described `auto` falling back to CPU llama.cpp, but `AutoExtractor` now always
-  selects Transformers.
-- The hackathon **Llama Champion** badge still needs a GGUF path through `llama-cpp-python`.
-- Fine-tuned deployment may swap in a GGUF repo without changing the Gradio app.
-
-How to enable llama.cpp vision:
-
-```bash
-EXTRACTOR_BACKEND=llamacpp-gpu
-LLAMACPP_VISION=1
-LLAMACPP_GGUF_REPO=openbmb/MiniCPM-V-4.6-gguf
-LLAMACPP_MODEL_FILE=MiniCPM-V-4_6-Q4_K_M.gguf
-LLAMACPP_MMPROJ_FILE=mmproj-model-f16.gguf
-```
-
-Default production Space variables remain:
-
-```bash
-EXTRACTOR_BACKEND=transformers
-ZEROGPU_MODEL_ID=openbmb/MiniCPM-V-4.6
-```
-
-Docs updated: `README.md`, `RUNBOOK.md`, `DEPLOY.md`.
-
-## 2026-06-13 — Route ZeroGPU to Transformers, CPU to llama.cpp
-
-> **Superseded** by the opt-in llama.cpp lane above. `auto` no longer auto-selects llama.cpp on
-> CPU; use `EXTRACTOR_BACKEND=llamacpp-gpu` explicitly when the GGUF lane is needed.
-
-Decision: keep `EXTRACTOR_BACKEND=auto`, but make ZeroGPU select the official OpenBMB
-Transformers backend instead of relying on app-level CUDA visibility.
-
-Why:
-- On ZeroGPU, CUDA is allocated only inside a `@spaces.GPU` worker, so
-  `torch.cuda.is_available()` can be false in normal Gradio app code.
-- The app was therefore selecting the CPU llama.cpp fallback even while the Space hardware was
-  configured as ZeroGPU.
-- The intended runtime behavior is now explicit: `ACCELERATOR=zero-a10g`, `ZERO_GPU=TRUE`, or
-  visible CUDA selects Transformers; CPU-only runtime selects llama.cpp.
-
-Space variables:
-
-```bash
-EXTRACTOR_BACKEND=auto
-ZEROGPU_MODEL_ID=openbmb/MiniCPM-V-4.6
-```
-
-CPU fallback after a Transformers failure is now opt-in with:
-
-```bash
-AUTO_FALLBACK_TO_LLAMACPP=1
-```
-
-Follow-up fix: MiniCPM-V 4.6 declares `model_type: minicpmv4_6` and its official model card
-requires `transformers[torch]>=5.7.0`. The Space was still pinned to `transformers==4.57.3`, which
-caused the ZeroGPU worker to fail with:
-
-```text
-Transformers does not recognize this architecture
-```
-
-The runtime now pins:
-
-```text
-transformers[torch]==5.7.0
-```
-
-## 2026-06-10 — Switch from Docker Space to Gradio ZeroGPU
-
-Decision: use **Gradio ZeroGPU** as the active Hugging Face Space architecture.
-
-Why:
-
-- The Docker Space build failed on free CPU hardware with `OOMKilled`.
-- Hugging Face ZeroGPU is available only for Gradio SDK Spaces, not Docker Spaces.
-- The project needs a free dynamic GPU path for demoability.
-
-What changed:
-
-- `README.md` metadata changed from `sdk: docker` to `sdk: gradio`.
-- `DEPLOY.md` and `RUNBOOK.md` now describe Gradio + ZeroGPU + Transformers as the active path.
-- `src/extraction/zerogpu_transformers.py` adds the official OpenBMB MiniCPM-V Transformers backend.
-- `src/extraction/factory.py` initially resolved `auto` to the ZeroGPU Transformers backend.
-- Docker-only files (`Dockerfile`, `start.sh`, `.dockerignore`) were removed from the active deployment.
-
-Current model:
-
-```bash
-ZEROGPU_MODEL_ID=openbmb/MiniCPM-V-4.6
-```
-
-Future fine-tuned model:
-
-Only change this variable:
-
-```bash
-ZEROGPU_MODEL_ID=<owner>/<fine-tuned-minicpm-v-model>
-```
-
-Do not reintroduce Docker or `llama-server` while the project is targeting ZeroGPU. Do not commit model files to the Space repository.
-
-## 2026-06-11 — Add llama.cpp badge path on ZeroGPU
-
-Decision: keep the Space as **Gradio ZeroGPU**, but target the hackathon llama.cpp badge with the
-`auto` / `llamacpp-gpu` backend.
-
-Why:
-
-- ZeroGPU requires Gradio SDK, so Docker is still not the right deployment surface.
-- The llama.cpp badge can still be targeted from a Gradio Space if inference runs through
-  `llama-cpp-python` over GGUF inside `@spaces.GPU`.
-- The official OpenBMB GGUF repo stays outside the Space git repo and is downloaded through the
-  Hugging Face cache at runtime.
-
-Current badge-target defaults:
-
-```bash
-EXTRACTOR_BACKEND=auto
-LLAMACPP_GGUF_REPO=openbmb/MiniCPM-V-4.6-gguf
-LLAMACPP_MODEL_FILE=MiniCPM-V-4_6-Q4_K_M.gguf
-LLAMACPP_MMPROJ_FILE=mmproj-model-f16.gguf
-```
-
-Fallback if `llama-cpp-python` is incompatible with MiniCPM-V 4.6 on ZeroGPU:
-
-```bash
-EXTRACTOR_BACKEND=zerogpu
-ZEROGPU_MODEL_ID=openbmb/MiniCPM-V-4.6
-```
-
-Future fine-tuned model:
-
-Only change the `LLAMACPP_*` variables to point at the fine-tuned GGUF repo/files.
-
-The app now also surfaces backend load errors directly in the UI and falls back to the
-Transformers ZeroGPU backend when the llama.cpp GGUF load path fails, so a runtime mismatch does
-not collapse the whole extraction flow.
-
-We also upgraded the llama-cpp-python binding to a MiniCPM-V 4.6-capable build, which is the
-actual fix for the earlier `Failed to load model from file` failure.

PLAN.md

@@ -1,116 +0,0 @@
-# Blood Test Explainer ("Pulse") — Plan, revised against current repo
-
-> Grounded in the actual code as of 2026-06-09. Two developers, parallel.
-> Target prizes: **OpenAI + OpenBMB + Modal** + all badges.
-> ⚠️ Confirm the real submission deadline first — teams are already final-submitting.
-
-> 2026-06-10 deployment update: the active HF Space path is now **Gradio ZeroGPU + official
-> OpenBMB Transformers model**. The Docker/llama.cpp serving plan was replaced because ZeroGPU is
-> Gradio-only and the Docker build was OOM-killed on free CPU hardware. For the fine-tuned model,
-> keep this ZeroGPU architecture and replace only `ZEROGPU_MODEL_ID`.
-
----
-
-## 1. Where we are (DONE — solid foundation)
-
-- **Polished Gradio app** (`app.py`): light clinical theme, animated "formation" hero,
-  loading/empty states, report cards with status pills, tabs (Report / Values / JSON / Raw),
-  responsive. This is genuinely good and is a real head start on the "premium document" wow.
-- **Extraction works** (`src/openbmb_client.py`, `src/document_processing.py`): OpenBMB
-  **MiniCPM-V-4.6** (vision) via OpenAI-compatible API. PDF→images (PyMuPDF), images, and
-  text files supported; base64 image payloads; robust JSON-repair parsing.
-- **Schema:** `{marker, value, unit, reference_range, status, source_text, confidence}` + notes.
-- **Env/secret handling** ready (`.env` local, Space secret). Codex is contributing.
-- Extraction prompt is deliberately **extraction-only** ("do not diagnose/interpret").
-
-## 2. Blunt gap analysis — what's missing and which prize it unblocks
-
-The current app is a beautiful **extractor that calls an external API**. As-is it does not win.
-
-| Missing piece | Why it matters | Unblocks |
-|---|---|---|
-| **Interpretation + cross-marker reasoning** | Right now MiniCPM looks like OCR/plumbing. The model must *reason* (e.g. "ALT+AST+GGT all high → liver-enzyme pattern") to be visibly central. | **OpenBMB** "central model" + req #5 |
-| **Cited knowledge base (~40 markers)** | Reliable reference ranges + "what it measures" + "questions for your doctor", grounded not hallucinated. | medical credibility |
-| **Run the model LOCALLY (llama.cpp)** | The current external API call **fails off-grid / "fully offline."** | **off-grid badge** + offline requirement |
-| **Fine-tune + GGUF on Modal** | No fine-tune yet. Needed for the badge + the OpenBMB before/after story. | **fine-tune + quantization badges, Modal prize** |
-| **Agent trace** | Single API call now; needs a visible multi-step pipeline. | req #5 |
-| **Eval harness + before/after** | No metrics yet. | **OpenBMB** proof |
-| **Traces dataset + model card + multi-repo** | Top teams (compliment-forest) do this. | competitiveness |
-| **Video (local run) + social + README lines** | Required submission artifacts. | **general pool** |
-
-## 3. The biggest technical fork: getting OFF the external API
-
-Off-grid + "fully offline" require the model to **run inside the Space**, no external calls.
-The README already flags this ("API-backed extractor is temporary"). Options:
-
-- **Recommended (hybrid):** keep MiniCPM-V for extraction but run it **locally in the Space**
-  (MiniCPM-V GGUF via llama.cpp multimodal, or via transformers on **ZeroGPU**), and **fine-tune
-  a small MiniCPM *text* model** for the **interpretation + cross-marker reasoning** layer (easier
-  to fine-tune, this is the "model is the star" part, runs offline via llama.cpp). Earns off-grid
-  + fine-tune + quantization together.
-- **Simpler fallback:** drop vision; do **local OCR/text extraction** (PyMuPDF text + tesseract)
-  → one fine-tuned MiniCPM text model does structuring **and** interpretation. Fully offline,
-  easiest fine-tune; weaker on scans/photos.
-- **Decide in Phase B.** Main technical risk = running MiniCPM-V locally; the fallback de-risks it.
-
-## 4. Parallel plan from here (2 devs, shared stack, contract-first)
-
-**Shared contract to agree first (extend the existing dataclass):** add `Interpretation`
-(`marker, plain, meaning, questions[], citation`) and a `cross_marker: list[str]` + `summary`
-to the result object. Both tracks build against it; Track B can use a fixture until Track A ships.
-
-**Module ownership (avoid collisions):**
-- **Track A (model/data):** `src/openbmb_client.py` (+ interpretation), new `src/kb/`,
-  `src/reasoning/`, `train/`, `eval/`. Owns: extraction-offline, fine-tune, KB, reasoning, eval.
-- **Track B (product/UI):** `app.py`, report rendering, **interpretation cards**, **cross-marker
-  insight section**, **doctor-questions**, **agent-trace panel**, `.html` download, sample report, deploy.
-- **Co-owned:** the result dataclass (the contract).
-
-### Phase A — DONE ✓ (extraction MVP + UI shell)
-
-### Phase B — Interpretation + KB + reasoning (the win-maker)
-- **Track A:** build the **cited KB** (~40 markers: CBC, metabolic, lipid, thyroid, key vitamins);
-  add an **interpretation pass** (grounded in KB + the user's value) and the **cross-marker
-  reasoning** (W1). Decide the offline path (��3).
-- **Track B:** extend the report to render interpretation per marker + a **cross-marker insights**
-  block + **"questions for your doctor"**; add the **agent-trace** panel (Ingest → extract →
-  normalize → KB lookup → reason → render) streaming via generator `yield`.
-- **Milestone:** real report → extracted + explained + reasoned document.
-
-### Phase C — Offline + fine-tune (the badges)
-- **Track A:** synthetic data (Claude) for extraction/interpretation; **LoRA fine-tune on Modal**
-  → merge → **GGUF Q4_K_M**; wire local **llama.cpp** inference; **before/after chart**.
-- **Track B:** deploy to the **org Space** with the local model; verify **zero external calls**;
-  graceful failure; downloadable `.html`; bundle a **sample report**.
-- **Milestone:** runs fully offline on a stranger's report; fine-tune metrics in hand.
-
-### Phase D — Robustness + artifacts
-- International units (mg/dL↔mmol/L), messy formats, unknown markers.
-- Publish **agent traces as a HF dataset** + **model card with GGUF/eval metrics**; multi-repo.
-
-### Phase E — Submission
-- Record **2-min video locally** (so "nothing left my laptop" is literally true); **social post**;
-  README with every eligibility line; flip repo public if needed; final eval numbers. Freeze + submit.
-
-## 5. The two weaknesses we engineer around
-- **W1 — model must be the star:** cross-marker reasoning is a first-class component, not an add-on.
-- **W2 — medical credibility:** every fact from a **cited KB**; "questions for your doctor," never
-  diagnosis (the current prompt's restraint is the right instinct — keep it).
-- Privacy is only honest run locally → record the **video locally**; the Space ships a sample report.
-
-## 6. Submission checklist
-- [ ] Gradio app, HF Space under the **org**.
-- [ ] All models <32B; the model <4B; **fine-tuned MiniCPM declared central**.
-- [ ] **Runs fully offline** (no external API — the current OpenBMB call must be replaced) under **llama.cpp** (GGUF).
-- [ ] **Demo video** (local) + **social post** linked in README.
-- [ ] **Public repo** + dense **Codex-attributed commits**.
-- [ ] README states: MiniCPM central, **Modal for fine-tuning**, off-grid, fine-tuned, quantized.
-- [ ] Before/after chart + **traces dataset** + **model card** published.
-- [ ] Space runs without our hardware (sample report bundled).
-
-## 7. Prize map (one line each)
-- **OpenAI $10K** — build via Codex (already a contributor); public repo.
-- **OpenBMB $10K** — MiniCPM central (extraction **+ reasoning**); before/after chart.
-- **Modal $20K credits** — LoRA fine-tune (+ eval/data-gen) on Modal.
-- **General pool** — Gradio Space + premium document + video + post.
-- **Badges** — off-grid (local model, no API), fine-tune (LoRA), quantization (GGUF Q4_K_M).

eval/data/real/README.md

@@ -33,14 +33,14 @@ The extractor reads PDFs directly (it renders pages to images), so `image` point
 
 ```bash
 # 1) draft labels with the current extractor, then hand-correct into gold
-EXTRACTOR_BACKEND=api OPENBMB_API_KEY=... python eval/run_eval.py \
-    --labels eval/data/real/labels.jsonl --run    # prints metrics for labeled rows
+EXTRACTOR_BACKEND=transformers python eval/run_eval.py \
+    --labels eval/data/real/labels.jsonl --run
 ```
 To add a report: run the extractor on it, copy the predicted `tests` into a new `labels.jsonl`
 row, and correct any mistakes against the PDF. Faster and more accurate than typing from scratch.
 
 ## Run the eval
 ```bash
-python eval/run_eval.py --labels eval/data/real/labels.jsonl --run     # needs a model/API
+python eval/run_eval.py --labels eval/data/real/labels.jsonl --run
 ```
 Use it twice (base vs fine-tuned GGUF) for the before/after.

src/extraction/auto.py

@@ -31,7 +31,3 @@ class AutoExtractor:
             self._selected = ZeroGPUTransformersExtractor(model_id=self.model_id)
         return self._selected
 
-
-def runtime_target() -> str:
-    """Local app always runs through Transformers."""
-    return "transformers"

src/extraction/factory.py

@@ -21,7 +21,6 @@ from src.extraction.auto import AutoExtractor
 from src.extraction.llamacpp_gpu import LlamaCppGPUExtractor
 from src.extraction.local_minicpmv import LocalMiniCPMVExtractor
 from src.extraction.local_server import LocalServerExtractor
-from src.extraction.zerogpu_transformers import ZeroGPUTransformersExtractor
 
 _DEFAULT_BACKEND = "transformers"
 _DISABLED_BACKENDS = {"api", "openbmb", "hosted"}

src/extraction/llamacpp_gpu.py

@@ -248,55 +248,6 @@ def _run_llamacpp_generation(
         raise _raise_generation_error(exc, vision=False) from exc
 
 
-@spaces.GPU(duration=120)
-def _run_llamacpp_chat(
-    messages: list[dict[str, str]],
-    repo: str,
-    model_file: str,
-    max_tokens: int,
-    n_ctx: int,
-    n_gpu_layers: int,
-    *,
-    vision_enabled: bool = False,
-    mmproj_file: str = DEFAULT_MMPROJ_FILE,
-    chat_handler: str = DEFAULT_CHAT_HANDLER,
-) -> str:
-    try:
-        model_path = download_hf_file(repo, model_file)
-        if vision_enabled:
-            mmproj_path = download_hf_file(repo, mmproj_file)
-    except Exception as exc:
-        raise RuntimeError(
-            "llama.cpp download failed while preparing the GGUF model: "
-            f"{type(exc).__name__}: {exc}"
-        ) from exc
-
-    try:
-        if vision_enabled:
-            llm = load_vision_llama(model_path, mmproj_path, n_ctx, n_gpu_layers, chat_handler)
-        else:
-            llm = _load_text(model_path, n_ctx, n_gpu_layers)
-    except Exception as exc:
-        label = "vision GGUF model for chat" if vision_enabled else "text-only GGUF model for chat"
-        raise RuntimeError(
-            f"The llama.cpp backend could not load the {label}. "
-            f"Inner error: {type(exc).__name__}: {exc}"
-        ) from exc
-
-    try:
-        response = llm.create_chat_completion(
-            messages=messages,
-            temperature=0.2,
-            max_tokens=max_tokens,
-        )
-        return str(response["choices"][0]["message"].get("content") or "").strip()
-    except Exception as exc:
-        raise RuntimeError(
-            "llama.cpp chat generation failed. "
-            f"Inner error: {type(exc).__name__}: {exc}"
-        ) from exc
-
-
 def _compose_prompt(parts: list[dict[str, Any]]) -> str:
     text_parts: list[str] = [EXTRACTION_PROMPT]
     image_count = 0

src/extraction/text_generation.py

@@ -1,63 +0,0 @@
-"""Shared text-generation helpers for chat (mirrors EXTRACTOR_BACKEND)."""
-
-from __future__ import annotations
-
-import os
-
-from src.extraction.llamacpp_gpu import DEFAULT_GGUF_REPO, DEFAULT_MODEL_FILE
-from src.extraction.llamacpp_vision import DEFAULT_CHAT_HANDLER, DEFAULT_MMPROJ_FILE, llamacpp_vision_enabled
-from src.local_env import load_local_env
-
-load_local_env()
-
-
-def generate_text_chat(messages: list[dict[str, str]], max_tokens: int | None = None) -> str:
-    """Run a text-only chat completion using the configured extraction backend family."""
-    backend = os.getenv("EXTRACTOR_BACKEND", "transformers").strip().lower()
-    token_limit = max_tokens or int(os.getenv("CHAT_MAX_TOKENS", "1024"))
-
-    if backend in {"api", "openbmb", "hosted"}:
-        raise RuntimeError(
-            "Chat via the hosted OpenBMB API is disabled. Use EXTRACTOR_BACKEND=transformers."
-        )
-    if backend in {"auto", "zerogpu", "zero-gpu", "transformers"}:
-        return _transformers_chat(messages, token_limit)
-    if backend in {"llamacpp-gpu", "gpu-llamacpp", "llama-champion", "llamacpp"}:
-        return _llamacpp_chat(messages, token_limit)
-
-    raise RuntimeError(f"Chat is not configured for EXTRACTOR_BACKEND={backend!r}.")
-
-
-def _transformers_chat(messages: list[dict[str, str]], max_tokens: int) -> str:
-    from src.extraction.zerogpu_transformers import _run_zerogpu_generation
-    from src.model_paths import resolve_transformers_model_source
-
-    model_source = resolve_transformers_model_source(os.getenv("ZEROGPU_MODEL_ID"))
-    downsample_mode = (os.getenv("ZEROGPU_DOWNSAMPLE_MODE") or "16x").strip()
-    structured = [{"role": m["role"], "content": m["content"]} for m in messages]
-    return _run_zerogpu_generation(
-        messages=structured,
-        model_source=model_source,
-        max_new_tokens=max_tokens,
-        downsample_mode=downsample_mode,
-    )
-
-
-def _llamacpp_chat(messages: list[dict[str, str]], max_tokens: int) -> str:
-    from src.extraction.llamacpp_gpu import _run_llamacpp_chat
-
-    repo = os.getenv("LLAMACPP_GGUF_REPO", DEFAULT_GGUF_REPO).strip()
-    model_file = os.getenv("LLAMACPP_MODEL_FILE", DEFAULT_MODEL_FILE).strip()
-    n_ctx = int(os.getenv("LLAMACPP_N_CTX", "8192"))
-    n_gpu_layers = int(os.getenv("LLAMACPP_N_GPU_LAYERS", "0"))
-    return _run_llamacpp_chat(
-        messages=messages,
-        repo=repo,
-        model_file=model_file,
-        max_tokens=max_tokens,
-        n_ctx=n_ctx,
-        n_gpu_layers=n_gpu_layers,
-        vision_enabled=llamacpp_vision_enabled(),
-        mmproj_file=os.getenv("LLAMACPP_MMPROJ_FILE", DEFAULT_MMPROJ_FILE).strip(),
-        chat_handler=os.getenv("LLAMACPP_CHAT_HANDLER", DEFAULT_CHAT_HANDLER).strip(),
-    )

src/interpretation_render.py

@@ -1,28 +1,10 @@
-"""Render the grounded Interpretation into display-ready Markdown / HTML (Phase 3.5).
-
-Pure presentation — every fact comes from src/interpretation.py (which comes from the KB), nothing
-is invented here. Framework-agnostic so the app can drop `interpretation_html(tests)` into a
-`gr.HTML` (styled cards) or `interpretation_markdown(tests)` into a `gr.Markdown`.
-"""
+"""Render cross-marker interpretation patterns for the health report UI."""
 
 from __future__ import annotations
 
 import html
 
-from src.interpretation import Interpretation, build_interpretation
-
-_STATUS_LABEL = {"low": "Low", "high": "High"}
-_STATUS_COLOR = {"low": "#b06b00", "high": "#b22222"}
-
-
-def interpretation_markdown(tests: list[dict]) -> str:
-    """tests (extracted) -> markdown for a gr.Markdown component."""
-    return render_markdown(build_interpretation(tests))
-
-
-def interpretation_html(tests: list[dict]) -> str:
-    """tests (extracted) -> styled HTML cards for a gr.HTML component."""
-    return render_html(build_interpretation(tests))
+from src.interpretation import build_interpretation
 
 
 def patterns_html(tests: list[dict]) -> str:
@@ -55,76 +37,3 @@ def patterns_html(tests: list[dict]) -> str:
         f'<div style="color:#9ca3af;font-size:11px;margin-top:4px;">{esc(interp.disclaimer)}</div>'
         "</div>"
     )
-
-
-def render_markdown(interp: Interpretation) -> str:
-    out = ["### What your results may mean", "_Educational information, not a diagnosis._", ""]
-    if not interp.has_findings:
-        out.append(f"All {interp.normal_count} recognized markers are within their reference ranges.")
-        out += ["", f"> {interp.disclaimer}"]
-        return "\n".join(out)
-
-    for c in interp.flagged:
-        unit = f" {c.unit}" if c.unit else ""
-        status = _STATUS_LABEL.get(c.status, c.status)
-        out.append(f"**{c.marker} — {c.value}{unit}  ({status}, ref {c.reference_range})**")
-        if c.note:
-            out.append(c.note)
-        if c.questions:
-            out.append("Questions for your doctor: " + " ".join(f"_{q}_" for q in c.questions))
-        out.append("")
-
-    if interp.patterns:
-        out.append("#### Patterns across markers")
-        out += [f"- **{p.name}** — {p.note}" for p in interp.patterns]
-        out.append("")
-
-    out.append(f"{interp.normal_count} other recognized markers were within range.")
-    out += ["", f"> {interp.disclaimer}"]
-    return "\n".join(out)
-
-
-def render_html(interp: Interpretation) -> str:
-    def esc(value: object) -> str:
-        return html.escape(str(value))
-
-    parts = ['<div style="font-family:system-ui,-apple-system,sans-serif;max-width:760px;">']
-    parts.append('<h3 style="margin:0 0 2px;">What your results may mean</h3>')
-    parts.append('<div style="color:#6b7280;font-size:13px;margin-bottom:14px;">'
-                 'Educational information, not a diagnosis.</div>')
-
-    if not interp.has_findings:
-        parts.append(f'<div style="padding:12px;border-radius:10px;background:#f0fdf4;color:#166534;">'
-                     f'All {interp.normal_count} recognized markers are within their reference ranges.</div>')
-    else:
-        for c in interp.flagged:
-            color = _STATUS_COLOR.get(c.status, "#374151")
-            unit = f" {esc(c.unit)}" if c.unit else ""
-            status = _STATUS_LABEL.get(c.status, esc(c.status))
-            parts.append(
-                f'<div style="border:1px solid #e5e7eb;border-left:4px solid {color};border-radius:10px;'
-                f'padding:12px 14px;margin-bottom:10px;">'
-                f'<div style="font-weight:600;">{esc(c.marker)} '
-                f'<span style="color:{color};">{esc(c.value)}{unit} ({status})</span> '
-                f'<span style="color:#9ca3af;font-weight:400;font-size:12px;">ref {esc(c.reference_range)}</span></div>'
-            )
-            if c.note:
-                parts.append(f'<div style="color:#374151;margin-top:4px;font-size:14px;">{esc(c.note)}</div>')
-            if c.questions:
-                items = "".join(f"<li>{esc(q)}</li>" for q in c.questions)
-                parts.append('<div style="margin-top:6px;font-size:13px;color:#6b7280;">'
-                             f'Questions for your doctor:<ul style="margin:4px 0 0;padding-left:18px;">{items}</ul></div>')
-            parts.append("</div>")
-
-        if interp.patterns:
-            parts.append('<h4 style="margin:14px 0 6px;">Patterns across markers</h4>')
-            for p in interp.patterns:
-                parts.append('<div style="background:#eff6ff;border-radius:8px;padding:10px 12px;margin-bottom:8px;'
-                             f'font-size:14px;"><b>{esc(p.name)}</b> — {esc(p.note)}</div>')
-        parts.append(f'<div style="color:#6b7280;font-size:13px;margin-top:6px;">'
-                     f'{interp.normal_count} other recognized markers were within range.</div>')
-
-    parts.append(f'<div style="margin-top:14px;padding-top:10px;border-top:1px solid #eee;'
-                 f'color:#9ca3af;font-size:12px;">{esc(interp.disclaimer)}</div>')
-    parts.append("</div>")
-    return "".join(parts)

src/openbmb_client.py

@@ -1,26 +1,17 @@
 from __future__ import annotations
 
 import json
-import os
 import re
-import time
 from dataclasses import dataclass, field
 from typing import Any
 
-import requests
 from json_repair import loads as repair_json_loads
-from requests import HTTPError
 
-from src.document_processing import document_intake_metadata, document_to_payload_parts
 from src.local_env import load_local_env
 
 
 load_local_env()
 
-DEFAULT_API_URL = "http://35.203.155.71:8003/v1/chat/completions"
-DEFAULT_MODEL = "MiniCPM-V-4.6"
-
-
 EXTRACTION_PROMPT = """
 You are extracting laboratory test results from a medical document.
 
@@ -68,89 +59,6 @@ class ExtractionResult:
     patient: dict[str, Any] = field(default_factory=dict)
 
 
-class OpenBMBExtractor:
-    def __init__(
-        self,
-        api_url: str | None = None,
-        model: str | None = None,
-        api_key: str | None = None,
-        timeout_seconds: int = 90,
-    ) -> None:
-        self.api_url = (api_url or os.getenv("OPENBMB_API_URL") or DEFAULT_API_URL).strip()
-        self.model = (model or os.getenv("OPENBMB_MODEL") or DEFAULT_MODEL).strip()
-        self.api_key = _normalize_api_key(api_key or os.getenv("OPENBMB_API_KEY"))
-        self.timeout_seconds = timeout_seconds
-
-    @property
-    def is_configured(self) -> bool:
-        return bool(self.api_key)
-
-    def extract(self, file_path: str, max_pages: int | None = None) -> ExtractionResult:
-        if not self.api_key:
-            raise RuntimeError(
-                "OpenBMB API key is not configured. Set OPENBMB_API_KEY locally or add it as a Hugging Face Space secret."
-            )
-
-        document_parts = document_to_payload_parts(file_path, max_pages=max_pages)
-        payload = {
-            "model": self.model,
-            "messages": [
-                {
-                    "role": "user",
-                    "content": [
-                        {"type": "text", "text": EXTRACTION_PROMPT},
-                        *document_parts,
-                    ],
-                }
-            ],
-            "temperature": 0,
-            "max_tokens": 2048,
-        }
-
-        started = time.perf_counter()
-        response = requests.post(
-            self.api_url,
-            headers={
-                "Authorization": f"Bearer {self.api_key}",
-                "Content-Type": "application/json",
-            },
-            json=payload,
-            timeout=self.timeout_seconds,
-        )
-        duration_ms = int((time.perf_counter() - started) * 1000)
-        try:
-            response.raise_for_status()
-        except HTTPError as error:
-            if response.status_code == 401:
-                raise RuntimeError(
-                    "OpenBMB rejected the API key with 401 Unauthorized. Check that the token is exact, active, and belongs to this endpoint."
-                ) from error
-            raise
-
-        raw_response = _extract_message_content(response.json())
-        parsed = _parse_json_response(raw_response)
-
-        return ExtractionResult(
-            patient=_normalize_patient(parsed.get("patient", {})),
-            tests=_normalize_tests(parsed.get("tests", [])),
-            notes=_normalize_notes(parsed.get("notes", [])),
-            raw_response=raw_response,
-            request_summary={
-                "backend": "api",
-                "api_url": self.api_url,
-                "model": self.model,
-                "document_parts": len(document_parts),
-                "pages": max_pages or "auto",
-                "extraction_prompt": EXTRACTION_PROMPT,
-                "user_message_preview": summarize_document_parts(document_parts),
-                **document_intake_metadata(file_path, document_parts),
-                "http_status": response.status_code,
-                "return_code": 0,
-                "duration_ms": duration_ms,
-            },
-        )
-
-
 def summarize_document_parts(parts: list[dict[str, Any]]) -> dict[str, int]:
     """Lightweight payload stats for pipeline traces (no base64 blobs)."""
     image_count = 0
@@ -163,34 +71,6 @@ def summarize_document_parts(parts: list[dict[str, Any]]) -> dict[str, int]:
     return {"image_count": image_count, "text_characters": text_characters}
 
 
-def _extract_message_content(payload: dict[str, Any]) -> str:
-    try:
-        message = payload["choices"][0]["message"]
-    except (KeyError, IndexError, TypeError) as error:
-        raise ValueError("OpenBMB response did not include choices[0].message.") from error
-
-    content = message.get("content", "")
-    if isinstance(content, str):
-        return content.strip()
-
-    if isinstance(content, list):
-        text_parts = [part.get("text", "") for part in content if isinstance(part, dict)]
-        return "\n".join(text_parts).strip()
-
-    raise ValueError("OpenBMB response message content was not text.")
-
-
-def _normalize_api_key(value: str | None) -> str | None:
-    if not value:
-        return None
-
-    cleaned = value.strip()
-    if cleaned.lower().startswith("bearer "):
-        cleaned = cleaned[7:].strip()
-
-    return cleaned or None
-
-
 def _parse_json_response(text: str) -> dict[str, Any]:
     cleaned = _strip_think(_strip_code_fence(text))
     parsed = _loads_model_json(cleaned)

src/pipeline_trace.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import html
 import json
-from dataclasses import asdict, dataclass, field
+from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any
 
@@ -615,77 +615,3 @@ def error_trace_html(message: str) -> str:
     body = step_to_html(failed_step, interactive=False)
     return _trace_block(body, interactive=False)
 
-
-def step_to_markdown(step: PipelineStep) -> str:
-    parts = [f"**{step.title}**", step.summary]
-    if step.prompt:
-        parts.append(
-            f"<details><summary>Full prompt</summary>\n\n```\n{step.prompt}\n```\n</details>"
-        )
-    if step.input_preview:
-        parts.append(
-            f"<details><summary>Input preview</summary>\n\n```\n{step.input_preview}\n```\n</details>"
-        )
-    if step.output_preview:
-        parts.append(
-            f"<details><summary>Output preview</summary>\n\n```\n{step.output_preview}\n```\n</details>"
-        )
-    return "\n\n".join(parts)
-
-
-def trace_to_chat_messages(steps: list[PipelineStep]) -> list[dict[str, str]]:
-    intro = (
-        "**Analysis pipeline complete.** Below are the agent steps that processed your document."
-    )
-    messages = [{"role": "assistant", "content": intro}]
-    for step in steps:
-        messages.append({"role": "assistant", "content": step_to_markdown(step)})
-    return messages
-
-
-def serialize_steps(steps: list[PipelineStep]) -> list[dict[str, Any]]:
-    return [asdict(step) for step in steps]
-
-
-def interpretation_to_dict(interpretation: Interpretation) -> dict[str, Any]:
-    return {
-        "flagged": [
-            {
-                "marker": item.marker,
-                "value": item.value,
-                "unit": item.unit,
-                "status": item.status,
-                "reference_range": item.reference_range,
-                "note": item.note,
-                "questions": list(item.questions),
-            }
-            for item in interpretation.flagged
-        ],
-        "normal_count": interpretation.normal_count,
-        "patterns": [{"name": p.name, "note": p.note} for p in interpretation.patterns],
-        "disclaimer": interpretation.disclaimer,
-    }
-
-
-def extraction_to_dict(extraction: ExtractionResult) -> dict[str, Any]:
-    return {
-        "patient": extraction.patient,
-        "tests": extraction.tests,
-        "notes": extraction.notes,
-        "raw_response": extraction.raw_response,
-        "request_summary": extraction.request_summary,
-    }
-
-
-def build_session_state(
-    extraction: ExtractionResult,
-    health_report: dict[str, Any],
-    steps: list[PipelineStep],
-) -> dict[str, Any]:
-    interpretation = build_interpretation(extraction.tests)
-    return {
-        "extraction": extraction_to_dict(extraction),
-        "health_report": health_report,
-        "interpretation": interpretation_to_dict(interpretation),
-        "trace_steps": serialize_steps(steps),
-    }

src/results_chat.py

@@ -1,156 +0,0 @@
-"""Context-aware chat about uploaded blood test results."""
-
-from __future__ import annotations
-
-import json
-from typing import Any
-
-from src.extraction.text_generation import generate_text_chat
-
-CHAT_SYSTEM_PROMPT = """
-You are an educational assistant helping a patient understand blood test results.
-
-Rules:
-- Use ONLY the patient context, extracted lab values, knowledge-graph enrichment, and grounded
-  interpretation notes provided below.
-- Do not diagnose, prescribe, or invent medical facts not present in the context.
-- Use plain language and say when a clinician should interpret a result in person.
-- If the user asks about something not in the context, say you do not have that information.
-- Keep answers concise unless the user asks for detail.
-""".strip()
-
-_MAX_CONTEXT_CHARS = 8000
-_MAX_HISTORY_TURNS = 6
-
-
-class ResultsChatAssistant:
-    def reply(
-        self,
-        user_message: str,
-        chat_history: list[dict[str, str]] | None,
-        session: dict[str, Any] | None,
-    ) -> str:
-        message = (user_message or "").strip()
-        if not message:
-            return "Please enter a question about your blood test results."
-
-        if not session or not session.get("health_report"):
-            return "Upload and analyze a lab report first, then I can answer questions about your results."
-
-        context = build_chat_context(session)
-        messages = _build_messages(context, chat_history or [], message)
-        try:
-            return generate_text_chat(messages)
-        except Exception as exc:
-            return (
-                "I couldn't generate a chat reply with the current model backend. "
-                f"Details: {exc}"
-            )
-
-
-def build_chat_context(session: dict[str, Any]) -> str:
-    health_report = session.get("health_report") or {}
-    extraction = session.get("extraction") or {}
-    interpretation = session.get("interpretation") or {}
-
-    patient = health_report.get("patient") or extraction.get("patient") or {}
-    markers = health_report.get("markers") or []
-    summary = health_report.get("summary") or {}
-
-    lines: list[str] = [
-        "=== Patient context ===",
-        json.dumps(
-            {
-                "age": patient.get("age"),
-                "age_years": patient.get("age_years"),
-                "age_group": patient.get("age_group"),
-                "sex": patient.get("sex"),
-            },
-            indent=2,
-        ),
-        "",
-        "=== Report summary ===",
-        json.dumps(summary, indent=2),
-        "",
-        "=== Extracted markers ===",
-    ]
-
-    for marker in markers[:40]:
-        lines.append(
-            json.dumps(
-                {
-                    "name": marker.get("display_name") or marker.get("raw_name"),
-                    "value": marker.get("value"),
-                    "unit": marker.get("unit"),
-                    "status": marker.get("status"),
-                    "lab_reference_range": marker.get("lab_reference_range"),
-                    "comparison_basis": (marker.get("comparison") or {}).get("basis"),
-                    "kg_description": ((marker.get("knowledge") or {}).get("description")),
-                    "kg_importance": ((marker.get("knowledge") or {}).get("why_important")),
-                },
-                ensure_ascii=False,
-            )
-        )
-
-    if interpretation.get("flagged"):
-        lines.extend(["", "=== Flagged markers (KB-grounded) ==="])
-        for item in interpretation["flagged"]:
-            lines.append(json.dumps(item, ensure_ascii=False))
-
-    if interpretation.get("patterns"):
-        lines.extend(["", "=== Cross-marker patterns ==="])
-        for item in interpretation["patterns"]:
-            lines.append(json.dumps(item, ensure_ascii=False))
-
-    if extraction.get("notes"):
-        lines.extend(["", "=== Extraction notes ===", json.dumps(extraction["notes"], indent=2)])
-
-    lines.extend(["", "=== Disclaimer ===", interpretation.get("disclaimer", "")])
-
-    context = "\n".join(lines)
-    if len(context) <= _MAX_CONTEXT_CHARS:
-        return context
-    return context[: _MAX_CONTEXT_CHARS - 3].rstrip() + "..."
-
-
-def _build_messages(
-    context: str,
-    chat_history: list[dict[str, str]],
-    user_message: str,
-) -> list[dict[str, str]]:
-    messages: list[dict[str, str]] = [
-        {"role": "system", "content": CHAT_SYSTEM_PROMPT},
-        {"role": "user", "content": f"Blood test context:\n\n{context}"},
-        {
-            "role": "assistant",
-            "content": "I have your blood test context. Ask me anything about these results.",
-        },
-    ]
-
-    recent = _recent_chat_turns(chat_history)
-    messages.extend(recent)
-    messages.append({"role": "user", "content": user_message})
-    return messages
-
-
-def _recent_chat_turns(chat_history: list[dict[str, str]]) -> list[dict[str, str]]:
-    """Keep only user follow-up turns, skipping pipeline trace assistant messages."""
-    turns: list[dict[str, str]] = []
-    for item in chat_history:
-        role = item.get("role")
-        content = str(item.get("content") or "").strip()
-        if not content or role not in {"user", "assistant"}:
-            continue
-        if role == "assistant" and content.startswith("**Step "):
-            continue
-        if role == "assistant" and content.startswith("**Analysis pipeline complete."):
-            continue
-        if role == "assistant" and content.startswith("**Pipeline running"):
-            continue
-        if role == "assistant" and content.startswith("Upload a lab report"):
-            continue
-        turns.append({"role": role, "content": content})
-
-    if len(turns) > _MAX_HISTORY_TURNS * 2:
-        turns = turns[-(_MAX_HISTORY_TURNS * 2) :]
-    return turns

tests/test_model_paths.py

@@ -7,8 +7,17 @@ sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
 from src.model_paths import is_transformers_model_dir, resolve_transformers_model_source
 
 
-def test_resolve_uses_hub_download_when_no_local_weights():
+def test_resolve_uses_hub_download_when_no_local_weights(monkeypatch):
     with tempfile.TemporaryDirectory() as tmp:
+        empty_models = Path(tmp) / "models"
+        empty_models.mkdir()
+        monkeypatch.setenv("BTE_MODELS_DIR", str(empty_models))
+        monkeypatch.setenv("HF_HOME", str(Path(tmp) / "hf"))
+        monkeypatch.setattr(
+            "src.model_paths.latest_complete_snapshot",
+            lambda repo_id, hub_cache: None,
+        )
+
         source = resolve_transformers_model_source("openbmb/MiniCPM-V-4.6")
         assert source.local_files_only is False
         assert source.origin == "hub-download"

tests/test_pipeline_trace.py

@@ -4,7 +4,7 @@ from pathlib import Path
 sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
 
 from src.openbmb_client import EXTRACTION_PROMPT, ExtractionResult
-from src.pipeline_trace import build_pipeline_trace, empty_trace_html, trace_hover_js, trace_to_html, trace_to_chat_messages
+from src.pipeline_trace import build_pipeline_trace, empty_trace_html, trace_hover_js, trace_to_html
 from src.report_pipeline import build_health_report
 
 
@@ -119,19 +119,8 @@ def test_trace_hover_js_registers_listeners_once():
     assert "<script" not in js.lower()
 
 
-def test_trace_to_chat_messages_shape():
-    extraction = _sample_extraction()
-    report = build_health_report(extraction)
-    steps = build_pipeline_trace(extraction, report)
-    messages = trace_to_chat_messages(steps)
-    assert messages[0]["role"] == "assistant"
-    assert all(msg["role"] == "assistant" for msg in messages)
-    assert len(messages) == len(steps) + 1
-
-
 if __name__ == "__main__":
     test_build_pipeline_trace_has_five_steps()
     test_extraction_step_includes_full_prompt()
     test_trace_to_html_collapsible_steps()
-    test_trace_to_chat_messages_shape()
     print("test_pipeline_trace: ok")

tests/test_results_chat.py

@@ -1,60 +0,0 @@
-import sys
-from pathlib import Path
-from unittest.mock import patch
-
-sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
-
-from src.openbmb_client import ExtractionResult
-from src.pipeline_trace import build_pipeline_trace, build_session_state
-from src.report_pipeline import build_health_report
-from src.results_chat import ResultsChatAssistant, build_chat_context
-
-
-def _session() -> dict:
-    extraction = ExtractionResult(
-        patient={"age_years": 42, "sex": "female"},
-        tests=[
-            {
-                "marker": "Hemoglobin",
-                "value": "11.2",
-                "unit": "g/dL",
-                "reference_range": "12.0-16.0",
-                "status": "low",
-                "confidence": 0.9,
-            }
-        ],
-        notes=[],
-        raw_response="{}",
-        request_summary={"backend": "test", "document_parts": 1},
-    )
-    report = build_health_report(extraction)
-    steps = build_pipeline_trace(extraction, report)
-    return build_session_state(extraction, report, steps)
-
-
-def test_build_chat_context_includes_patient_and_markers():
-    context = build_chat_context(_session())
-    assert "female" in context
-    assert "Hemoglobin" in context
-    assert "Report summary" in context
-
-
-def test_reply_requires_session():
-    assistant = ResultsChatAssistant()
-    reply = assistant.reply("What is low hemoglobin?", [], {})
-    assert "Upload and analyze" in reply
-
-
-def test_reply_uses_llm_when_session_present():
-    assistant = ResultsChatAssistant()
-    session = _session()
-    with patch("src.results_chat.generate_text_chat", return_value="Educational reply."):
-        reply = assistant.reply("Explain my hemoglobin.", [], session)
-    assert reply == "Educational reply."
-
-
-if __name__ == "__main__":
-    test_build_chat_context_includes_patient_and_markers()
-    test_reply_requires_session()
-    test_reply_uses_llm_when_session_present()
-    print("test_results_chat: ok")

train/modal_eval.py

@@ -7,7 +7,7 @@ runs directly on the Modal GPU).
 
     modal run train/modal_eval.py::compare --finetuned-id dimitriskalligaridis/blood-test-minicpmv-4_6
 
-Writes eval/before_after.json locally; render the chart with:  python eval/make_chart.py
+Writes eval/before_after.json locally with the base vs fine-tuned metrics.
 """
 
 from __future__ import annotations
@@ -117,7 +117,7 @@ def compare(
 
     out = Path("eval/before_after.json")
     out.write_text(json.dumps({"base": base, "finetuned": fine}, indent=2), encoding="utf-8")
-    print(f"\n  wrote {out}  ->  render the chart with:  python eval/make_chart.py\n")
+    print(f"\n  wrote {out}\n")
 
 
 @app.function(

train/modal_medreason.py

@@ -1,121 +0,0 @@
-"""Medical-reasoning LoRA fine-tune (Track 1) — earns Well-Tuned WITHOUT touching extraction.
-
-Roman's idea, done as LoRA (not full FT, which would catastrophically forget the vision/extraction
-ability). We freeze the vision encoder and LoRA the LLM only, on the general medical-reasoning
-dataset FreedomIntelligence/medical-o1-reasoning-SFT (TEXT, no images). The result is used as the
-*interpretation phraser* that speaks the KB-grounded facts fluently — extraction stays on base.
-
-A held-out slice is used for eval (reasoning loss). Gate A also re-runs the extraction eval on the
-merged model to confirm extraction did not regress.
-
-    modal run train/modal_medreason.py::main --n 100 --epochs 1     # cheap smoke test first
-    modal run --detach train/modal_medreason.py::main               # full run (n=4000)
-    modal run train/modal_finetune.py::merge --adapter-dir /adapters/medreason-lora --repo-id <owner>/<name>-medreason
-    modal run train/modal_eval.py::compare --finetuned-id <owner>/<name>-medreason   # Gate A: extraction unharmed?
-"""
-
-from __future__ import annotations
-
-import modal
-
-MODEL_ID = "openbmb/MiniCPM-V-4.6"
-
-app = modal.App("blood-test-medreason")
-
-image = (
-    modal.Image.debian_slim(python_version="3.11")
-    .apt_install("git")
-    .pip_install(
-        # Pin the exact ms-swift that recognizes MiniCPM-V 4.6 (the extraction run used this);
-        # an unpinned `datasets` previously dragged ms-swift down to a version that didn't. ms-swift
-        # brings a compatible `datasets`, so we don't add it ourselves.
-        "torch",
-        "transformers>=5.7.0",
-        "peft>=0.12",
-        "accelerate>=0.33",
-        "ms-swift==4.3.0",
-        "sentencepiece",
-        "timm",
-    )
-)
-
-adapters = modal.Volume.from_name("blood-test-adapters", create_if_missing=True)
-hf_cache = modal.Volume.from_name("blood-test-hf-cache", create_if_missing=True)
-
-
-@app.function(
-    image=image,
-    gpu="A100",
-    timeout=6 * 60 * 60,
-    volumes={"/adapters": adapters, "/root/.cache/huggingface": hf_cache},
-)
-def train_medreason(n: int = 4000, epochs: int = 1, lr: float = 1e-4, n_eval: int = 500, seed: int = 13) -> str:
-    import json
-    import os
-    import subprocess
-    from pathlib import Path
-
-    from datasets import load_dataset
-
-    os.environ["USE_HF"] = "1"  # pull dataset + weights from HF (fast on Modal), not ModelScope
-
-    # 1) medical-o1 reasoning data (English) -> text chat messages (Question -> CoT + Response)
-    ds = load_dataset("FreedomIntelligence/medical-o1-reasoning-SFT", "en", split="train")
-    ds = ds.shuffle(seed=seed).select(range(min(n + n_eval, len(ds))))
-
-    def to_messages(ex: dict) -> dict:
-        q = (ex.get("Question") or "").strip()
-        cot = (ex.get("Complex_CoT") or "").strip()
-        resp = (ex.get("Response") or "").strip()
-        answer = f"{cot}\n\n{resp}".strip() if cot else resp
-        return {"messages": [{"role": "user", "content": q}, {"role": "assistant", "content": answer}]}
-
-    rows = [to_messages(ex) for ex in ds]
-    val_rows, train_rows = rows[:n_eval], rows[n_eval:]
-
-    data_dir = Path("/root/data")
-    data_dir.mkdir(parents=True, exist_ok=True)
-    train_path = data_dir / "medreason_train.jsonl"
-    val_path = data_dir / "medreason_val.jsonl"
-    train_path.write_text("\n".join(json.dumps(r, ensure_ascii=False) for r in train_rows), encoding="utf-8")
-    val_path.write_text("\n".join(json.dumps(r, ensure_ascii=False) for r in val_rows), encoding="utf-8")
-    print(f"medical-o1: {len(train_rows)} train, {len(val_rows)} held-out eval examples")
-
-    # 2) LoRA the LLM only (freeze vision) on the reasoning text — keeps extraction untouched.
-    out_dir = "/adapters/medreason-lora"
-    cmd = [
-        "swift", "sft",
-        "--model", MODEL_ID,
-        "--dataset", str(train_path),
-        "--val_dataset", str(val_path),
-        "--num_train_epochs", str(epochs),
-        "--lora_rank", "16",
-        "--lora_alpha", "32",
-        "--learning_rate", str(lr),
-        "--warmup_ratio", "0.05",
-        "--per_device_train_batch_size", "2",
-        "--gradient_accumulation_steps", "8",
-        "--max_length", "4096",       # medical CoT answers are long
-        "--freeze_vit", "true",       # do not touch the vision encoder (extraction lives there)
-        "--eval_steps", "50",         # report held-out reasoning loss during training
-        "--output_dir", out_dir,
-        "--save_total_limit", "1",
-    ]
-    print("Running:", " ".join(cmd))
-    subprocess.run(cmd, check=True, env={**os.environ, "USE_HF": "1"})
-
-    adapters.commit()
-    return out_dir
-
-
-@app.local_entrypoint()
-def main(n: int = 4000, epochs: int = 1, lr: float = 1e-4) -> None:
-    # spawn() runs the job in the background on Modal and returns immediately, so it survives the
-    # local client disconnecting (.remote() + --detach can still be canceled on a dropped connection).
-    call = train_medreason.spawn(n=n, epochs=epochs, lr=lr)
-    print(f"\nLaunched medical-reasoning LoRA on Modal (call {call.object_id}) — runs in the background.")
-    print("Watch it in the Modal dashboard; it saves to the 'blood-test-adapters' volume. When done:")
-    print("  modal run train/modal_finetune.py::merge --adapter-dir /adapters/medreason-lora \\")
-    print("      --repo-id dimitriskl/blood-test-minicpmv-4_6-medreason")
-    print("  modal run train/modal_eval.py::compare --finetuned-id dimitriskl/blood-test-minicpmv-4_6-medreason")
-    print("  ^ Gate A: confirms extraction did NOT regress on the reasoning-tuned model.")