Upload folder using huggingface_hub

report/.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

report/COMPARISON.md

@@ -0,0 +1,75 @@
+# `local_final` vs `remote_final` — head-to-head
+
+Two WAVE-session LoRA fine-tunes of `unsloth/gemma-4-E2B-it`, trained against the **same** source dataset (`models/datasets/lora-wave-session-expanded.jsonl`) with the **same** stratification seed (`7`). Test-split `example_id`s are byte-identical (428 examples, same 144/147/137 surface counts; the only file-level diff is CRLF vs LF in the JSONLs).
+
+The two runs differ in hardware and a few hyperparameters. This file is the head-to-head; for the full per-run details see:
+
+- [`local_final/REPORT.md`](./local_final/REPORT.md) — RTX 5080, r=16, 3 epochs
+- [`remote_final/REPORT.md`](./remote_final/REPORT.md) — A100 80 GB, r=32, 1 epoch (§10 of that doc is the source of this file)
+
+---
+
+## Recipes
+
+| | `local_final` | `remote_final` |
+|---|---|---|
+| Hardware | RTX 5080 (Windows, local) | A100 80 GB SXM4 (Linux, Thunder Compute) |
+| LoRA rank | 16 | **32** |
+| LoRA alpha | 32 | 32 |
+| Epochs | **3** (1,152 steps) | 1 (428 steps) |
+| Warmup | 64 steps | 21 steps |
+| LR / schedule / batch / accum / wd / grad-norm | same: 2e-4 cosine, 1×8, 0.001, 0.3 | same |
+
+---
+
+## Quantitative — full 428-row held-out test split
+
+| | `local_final` | `remote_final` |
+|---|---|---|
+| LoRA completion NLL | 4.7149 | **4.5576** |
+| LoRA perplexity | 111.59 | **95.35** |
+| Paired wins vs base | 386 / 428 (90.2%) | **428 / 428 (100%)** |
+| Mean NLL Δ vs base | 0.327 nats | **0.508 nats** |
+| Sign-test p-value | 9.5 × 10⁻⁷¹ | **2.9 × 10⁻¹²⁹** |
+
+**`remote_final` is stronger on every probability metric.** Higher rank captured the WAVE distribution more decisively in fewer steps; the effect size is 55% larger and the win rate is perfect (no test prompt was worse than base) vs ~10% losses for the local run.
+
+---
+
+## Generation eval — apples-to-apples on the 6 overlapping `example_id`s
+
+`local_final` only ran an 8-example smoke; `remote_final` ran 60. Overlap = 6.
+
+| ID | Surface | Local | Remote | Notes |
+|---|---|---|---|---|
+| `15f8662e` | check_in | ✓ json+schema+safety, F1=1.000 | ✓ json+schema+safety, F1=1.000 | **Identical** reply to reference — only whitespace differs |
+| `2bf8ec4f` | check_in | ✓ F1=1.000 | ✓ F1=1.000 | Both identical to reference |
+| `2510fd56` | phase | ✓ F1=0.483 | ✓ F1=**0.512** | Remote slightly closer to reference |
+| `30b744c4` | phase | ✓ json+schema+safety, **183 tok** | ✗ json fail, 160 tok (**truncated by cap**) | Local won by having a bigger token budget at gen time, not a model difference |
+| `afedb9b7` | reflection | ✓ F1=**0.429** | ✓ F1=0.355 | Local slightly closer to reference |
+| `ec718a0e` | reflection | ✓ F1=0.423 | ✓ F1=0.416, ROUGE-L=**0.315** | Tie on F1; remote slightly better ROUGE-L |
+
+Pass rates on overlap: local **6/6**, remote **5/6** (the one miss is a 160-token cap artifact — when we raised the cap to 384 for the phase rerun, remote cleared most of the phase failures too).
+
+---
+
+## Verdict
+
+- **Both models are clinically equivalent** on identical prompts. Word choice differs but pose, safety, structure, and JSON shape are the same.
+- **`remote_final` is the better adapter for the WAVE distribution** — stronger NLL evidence, perfect paired-win rate, smaller p-value, and a more recent (post-`local_final`) eval/repair pipeline.
+- Recommend shipping `remote_final/adapter/` (or its merged/GGUF derivatives) with `--phase-max-new-tokens ≥ 256` plus the JSON-repair post-process described in `remote_final/REPORT.md §9.2` to close the residual phase-close defect.
+
+---
+
+## Artifact layout (mirrors are byte-exact within each run)
+
+| | `local_final/` | `remote_final/` |
+|---|---|---|
+| `adapter/adapter_model.safetensors` | 202,775,888 B (r=16) | 202,775,888 B (r=32, different content) |
+| `merged-16bit/model.safetensors` | 10,246,621,886 B | 10,246,621,886 B |
+| `gguf/gemma-4-e2b-it.Q4_K_M.gguf` | 3,427,878,240 B | 3,427,878,240 B |
+| `gguf/gemma-4-e2b-it.BF16-mmproj.gguf` | 986,833,280 B | 986,833,280 B |
+| `train.jsonl` / `validation.jsonl` / `test.jsonl` | same example_ids | same example_ids |
+| `REPORT.md` | full run report | full run report |
+
+(File **sizes** are identical for the merged/GGUF/mmproj because both are the same base + tokenizer at the same quantization; the **content** differs because the embedded adapter is different.)

report/MORNING_REPORT.md

@@ -0,0 +1,116 @@
+# Overnight WAVE LoRA — Morning Report
+
+**Run:** `runs/lora-wave-session/overnight-primary-r32-a32-lr2e-4-1epoch`
+**Adapter:** `runs/.../adapter/adapter_model.safetensors` (~194 MB)
+**Date:** 2026-05-11
+
+## TL;DR
+
+- Adapter trained successfully on full WAVE combined dataset (4,277 examples).
+- **Completion eval (n=428 held-out):** LoRA NLL **4.558** vs base **4.931** → **31.98% paired delta**, **428/428 win rate**, sign test p ≈ 2.9e-129. Strong, statistically significant improvement on every test example.
+- **Generation eval (n=60 balanced, LoRA-only, 4bit):** JSON validity **75.0%**, schema **71.7%**, style **100%**, safety **73.3%**. Overall gate `pass=false`, but the failure mode is concentrated in one surface and one root cause.
+- **Per surface:**
+  - **reflection:** 100% across every gate. Ship-ready.
+  - **check_in:** 100% JSON valid; 90% schema; 95% safety; 90% turn-sequence. Strong.
+  - **phase_narration:** **25%** JSON valid → cascade to schema/safety/6-line at 25%. **Root cause: outputs are being truncated at the 160-token cap before the JSON closes**, not poor clinical content. Style pass is still 100% on the truncated rows.
+- Latency on A100 4bit: mean **52s/example**, p95 **78s**.
+
+## Training Run
+
+- Model: `unsloth/gemma-4-E2B-it`, 4-bit QLoRA via Unsloth `FastModel`
+- Dataset: `models/datasets/lora-wave-session-expanded.jsonl` (4277 rows: 1534 check_in, 1553 phase_narration, 1190 reflection)
+- Split (seed 7, stratified): 3421 train / 428 val / 428 test
+- LoRA: r=32, alpha=32, dropout=0.0, all language + attention + MLP layers
+- Epochs: 1.0 (428 steps), batch 1 × grad_accum 8 = 16 effective
+- LR: 2e-4 cosine, warmup 21 steps, weight decay 0.001, max grad norm 0.3
+- max_seq_length: 4096; preflight max-row tokens: 2227 (no truncation needed)
+- Chat template: `gemma-4` (Unsloth); response-only training via `train_on_responses_only`
+- Wall clock: ~2h 26m on A100 80GB SXM4
+- Final `train_loss`: **0.241**
+
+## Quantitative — Completion NLL (whole frozen test split, n=428)
+
+| Metric | Base Gemma | LoRA | Delta |
+|---|---|---|---|
+| Completion NLL | 4.9312 | **4.5576** | **−0.374** |
+| Perplexity | 138.55 | **95.35** | **−43.2** |
+| Paired wins | — | **428 / 428** | **100%** |
+| Mean NLL delta | — | **0.508** | 95% bootstrap CI [0.477, 0.537] |
+| Sign-test p-value | — | **2.89e-129** | overwhelmingly significant |
+
+Bookmark this table — it is the strongest claim: on the same frozen held-out prompts, the LoRA assigns higher probability to the reference WAVE-style JSON completion than base Gemma on **every** test example, with effect size **≈ 0.5 nats / example** and tight CI.
+
+## Quality — Generation gates (LoRA-only, 60 examples, balanced 20/20/20, 4bit Unsloth inference)
+
+Overall gate `pass=false` driven by phase_narration truncation only.
+
+| Metric | All 60 | check_in (n=20) | phase_narration (n=20) | reflection (n=20) |
+|---|---|---|---|---|
+| JSON validity | 75.0% | **100%** | **25%** | **100%** |
+| Schema pass | 71.7% | 90% | 25% | **100%** |
+| Style pass | 100% | 100% | 100% | 100% |
+| Safety pass | 73.3% | 95% | 25% | **100%** |
+| Patient-facing | 85.0% | — | — | — |
+| No analysis voice | 100% | — | — | — |
+| No markdown | 100% | — | — | — |
+| Medical directive | 100% | — | — | — |
+| Phase 6-line | 75% | — | 25% | n/a |
+| Reflection next-step | 100% | n/a | n/a | 100% |
+| Check-in turn seq | 96.7% | 90% | n/a | n/a |
+| Token F1 (vs ref) | 0.434 | 0.490 | 0.382 | 0.429 |
+| ROUGE-L F1 | 0.303 | 0.456 | 0.171 | 0.282 |
+| Mean latency | 52.0s | 32.3s | 70.7s | 53.2s |
+| p95 latency | 77.8s | 51.6s | 118.8s | 66.0s |
+| Mean gen tokens | 120 | 77 | **159** | 123 |
+
+## Failure root cause
+
+All 15 `phase_narration` JSON-invalid rows show the same pattern: the model writes well-formed clinical content but never reaches the closing `]}` because generation is stopped at the **160 token cap** (run flag `--phase-max-new-tokens=160`). Style pass is 100% on the truncated rows — the prose is fine, the wrapper just doesn't close. Almost every phase row used the full 160 tokens (mean = 159).
+
+Example (truncation visible):
+
+```
+gen: {
+"lines": [
+"Let's bring our attention to sound right now. You don't need to find a perfect sound. Just notice what is present in this moment.",
+"Maybe there is a steady hum from the refrigerator, a    ← cut off here
+```
+
+The two `check_in` schema failures are different: the LoRA wrote `endConversation: null` instead of the structured object the reference expects on session-end turns. Real-world rare; fixable with one more pass of synthetic end-of-session data.
+
+The reflection surface is genuinely clean (100% across every gate, sensible 6-line / next-step structure).
+
+## Files (on VM under `~/wave-work/Wave/models/runs/lora-wave-session/overnight-primary-r32-a32-lr2e-4-1epoch/`)
+
+- `adapter/adapter_model.safetensors` — trained LoRA
+- `adapter/adapter_config.json` — PEFT config
+- `run-config.json` — full hyperparameters + dataset counts
+- `train.jsonl`, `validation.jsonl`, `test.jsonl` — frozen splits (seed 7)
+- `token-length-report.json` — preflight evidence (max=2227, no truncation)
+- `validation-eval.json` — validation completion metrics
+- `tuning-summary.json` — full per-candidate validation log
+- `eval.json` — full base-vs-LoRA completion comparison (the headline numbers above)
+- `generation-eval.json` — generation gate aggregate (this report's quality section)
+- `generation-eval-progress.jsonl` — 60 per-example generated outputs + checks
+- `MORNING_REPORT.md` — this file
+- `README.md` — short auto summary written at training end
+
+## What to show judges
+
+1. **Headline:** "LoRA wins on 428/428 held-out prompts vs base Gemma 4 E2B, p ≈ 1e-129, NLL −0.37."
+2. **Quality:** reflection 100% / check_in ~90–100% on every behavior gate (JSON, schema, safety, style, turn sequence).
+3. **Per-example artifact:** `generation-eval-progress.jsonl` has prompt → generated → reference → gate results for 60 outputs.
+
+## Honest caveats
+
+- Generation gate `pass=false` overall. Disclose this — drives quality engineering choices.
+- Phase narration outputs are clinically good but **truncated** because of an inference-time token budget set conservatively; not a model failure. A rerun with `--phase-max-new-tokens=384` would almost certainly clear most of the phase_narration JSON failures. Cheap fix.
+- Two check-in schema misses involve missing `endConversation` object on end-of-session turns.
+- Base-vs-LoRA *generation* (not completion) comparison was skipped to save time; completion eval already proved the win. Could be added if judges ask.
+- 4bit Unsloth inference is slow (mean 52s/example, p95 78s). For deployment to E2B on-device, expect much faster after export/optimization.
+
+## Recommended next action
+
+1. **Cheapest:** rerun generation eval on phase_narration only with `--phase-max-new-tokens=384` (≈ 20 min, costs little). Expected: phase_narration JSON validity / schema / 6-line jumps from 25% → 80–95%. Almost certainly enough to flip overall gate to `pass=true`.
+2. **If retraining:** the conservative LR=2e-5 / 3-epoch fallback is still available, but the completion-side metrics already look strong; no obvious reason to redo training tonight.
+3. **For deployment:** the adapter is in `adapter/`. Merge + export (GGUF / safetensors) when ready.

report/README.md

@@ -0,0 +1,51 @@
+---
+license: gemma
+tags:
+- gemma
+- gemma-4
+- lora
+- report
+- documentation
+- clinical
+- wellness
+language:
+- en
+datasets:
+- Maelstrome/lora-wave-session-dataset
+---
+
+# lora-wave-session-r32 — training report
+
+Documentation-only repo. Contains the full training/eval write-up for the **rank-32 / 1-epoch A100** WAVE fine-tune of Gemma 4 E2B Instruct, plus the head-to-head comparison against its rank-16 sibling.
+
+## Documents
+
+| File | What's in it |
+|---|---|
+| [`REPORT.md`](./REPORT.md) | Full run report — dataset, training, quantitative eval (NLL/PPL/paired-wins/p-value), generation gates, phase-rerun + reproducibility check, artifact manifest, reproducibility commands, export commands, caveats, recommendations. ~28 KB / 451 lines. |
+| [`COMPARISON.md`](./COMPARISON.md) | Head-to-head vs the rank-16 / 3-epoch sibling run (`lora-wave-session`). Same dataset, same seed, same test split. r32 wins on every probability metric. |
+| [`MORNING_REPORT.md`](./MORNING_REPORT.md) | First-pass overnight summary written immediately after training completed. Preserved for history; superseded by `REPORT.md`. |
+
+## Linked artifacts
+
+- 🦥 **Adapter:** [`Maelstrome/lora-wave-session-r32`](https://huggingface.co/Maelstrome/lora-wave-session-r32) — PEFT adapter (~194 MB)
+- 🛻 **Merged bf16:** [`Maelstrome/lora-wave-session-r32-merged`](https://huggingface.co/Maelstrome/lora-wave-session-r32-merged) — drop-in for `transformers`/vLLM (~10 GB)
+- 🧊 **GGUF Q4_K_M:** [`Maelstrome/lora-wave-session-r32-gguf`](https://huggingface.co/Maelstrome/lora-wave-session-r32-gguf) — llama.cpp / Ollama / wllama (~4 GB)
+- 📚 **Dataset:** [`Maelstrome/lora-wave-session-dataset`](https://huggingface.co/datasets/Maelstrome/lora-wave-session-dataset) — 4,277 examples, frozen splits (seed `7`)
+- 🌊 **Sibling run (rank-16):** [`Maelstrome/lora-wave-session`](https://huggingface.co/Maelstrome/lora-wave-session) — same dataset, different recipe
+
+## Headline numbers
+
+On the same frozen 428-row held-out test split:
+
+| | rank-16 sibling | **rank-32 (this report)** |
+|---|---|---|
+| LoRA completion NLL | 4.7149 | **4.5576** |
+| LoRA perplexity | 111.59 | **95.35** |
+| Paired wins vs base | 386 / 428 (90.2%) | **428 / 428 (100%)** |
+| Mean NLL Δ vs base | 0.327 nats | **0.508 nats** |
+| Sign-test p-value | 9.5 × 10⁻⁷¹ | **2.9 × 10⁻¹²⁹** |
+
+## License
+
+Gemma Terms of Use. See [https://ai.google.dev/gemma/terms](https://ai.google.dev/gemma/terms).

report/REPORT.md

@@ -0,0 +1,451 @@
+# WAVE LoRA — Remote A100 Final Run Report
+
+**Run ID:** `overnight-primary-r32-a32-lr2e-4-1epoch`
+**Hardware:** Thunder Compute, NVIDIA A100-SXM4-80GB, Ubuntu 22.04, 8 vCPU, 64 GB RAM
+**Date trained:** 2026-05-11 (≈ 2h 26m wall clock)
+**Date evaluated:** 2026-05-11 (completion eval + 60-sample generation eval + phase-rerun)
+**Adapter:** `runs/lora-wave-session/overnight-primary-r32-a32-lr2e-4-1epoch/adapter/adapter_model.safetensors` (~194 MB, 25.3 M trainable params)
+
+---
+
+## 0. TL;DR
+
+- **Completion eval on the full frozen test split (n=428):** LoRA beats base Gemma 4 E2B on **428/428** examples, mean NLL Δ **+0.508 nats** (perplexity 138.5 → 95.4), sign-test p ≈ **2.9 × 10⁻¹²⁹**.
+- **Generation quality (n=60 balanced):** style 100%, medical-directive 100%, no-markdown 100%, no-analysis-voice 100%, JSON 75 → **~92%** after a token-budget fix on phase.
+- **Reflection:** 100% across every behavior gate. **Check-in:** 90–100%. **Phase-narration:** 25 → 80–85% after raising `--phase-max-new-tokens` from 160 to 384.
+- Adapter is production-quality for reflection and check-in. Phase-narration has 4/20 (20%) JSON-close bug — **confirmed reproducible** via byte-identical regeneration (8/8 reruns matched the originals exactly), so it is a real model defect that needs either an inference-time JSON-repair pass or a small targeted retraining set, not a sampling glitch.
+
+---
+
+## 1. Dataset
+
+### 1.1 Source files
+The combined training corpus comes from seven per-surface clinician/synthetic datasets under `models/datasets/clinician-seeds/` (plus the unified `lora-wave-session-expanded.jsonl` built from them):
+
+| Surface | Source file | Purpose |
+|---|---|---|
+| Check-in 1 | `datasets/clinician-seeds/lora-check-in-1-clinician.jsonl` | First check-in after grounding |
+| Check-in 2 | `datasets/clinician-seeds/lora-check-in-2-clinician.jsonl` | After body-scan |
+| Check-in 3 | `datasets/clinician-seeds/lora-check-in-3-clinician.jsonl` | After sound/visualization anchor |
+| Check-in 4 | `datasets/clinician-seeds/lora-check-in-4-clinician.jsonl` | Late-session check |
+| Check-in 5 | `datasets/clinician-seeds/lora-check-in-5-clinician.jsonl` | Final session check |
+| Phase narration | `datasets/clinician-seeds/lora-phase-narration-expanded.jsonl` | 6-line clinician narration per phase |
+| Reflection | `datasets/clinician-seeds/lora-reflection-clinician.jsonl` | End-of-session insight + journaling prompt |
+
+### 1.2 Combined dataset
+- `models/datasets/lora-wave-session-expanded.jsonl` is the unified training file used by the trainer.
+- **4,277 examples total** — 1,534 check_in, 1,553 phase_narration, 1,190 reflection.
+- Each row carries: `loraId`, `surface`, `prompt`, `output` (target JSON), `metadata`, `messages` (system / user / assistant chat turns), `splitKey`.
+- The clinician-written core is augmented with `synthetic_draft` rows expanding patient context (MAT type, medication status, scenario ID, prior chunk summaries) to cover the long tail.
+- Status mix in the training portion: 1,260 draft / 45 ready / 2,116 synthetic_draft.
+
+### 1.3 Data validation
+Before training, the dataset was validated against the trainer's own loader and schema checks:
+- All 4,277 rows have `system`/`user`/`assistant` messages.
+- All assistant messages parse as strict JSON.
+- No empty prompts; no assistant/output mismatches.
+- Cross-checked structure against a Hugging Face Gemma example (`mlabonne/FineTome-100k`); WAVE follows the same ShareGPT→ChatML→`gemma-4` template pipeline expected by Unsloth.
+
+### 1.4 Splits (frozen, reproducible)
+- Stratified by `splitKey` (320 unique session contexts) and by `surface`.
+- Seed `7`.
+- 3,421 train / 428 validation / 428 test → `train.jsonl`, `validation.jsonl`, `test.jsonl` saved into the run dir.
+
+### 1.5 Token-length preflight
+- Renderer applies the `gemma-4` chat template and counts tokens per row.
+- Max row token length: **2,227** (well under `max_seq_length=4096`).
+- No row was truncated.
+
+---
+
+## 2. Training process
+
+### 2.1 Pipeline
+1. **Sync trainer + dataset to VM.** Local trainer hash matched VM trainer hash after sync.
+2. **Schema + split dry-run** → 4,277 examples, 3,421/428/428 split confirmed.
+3. **Token-length preflight** → max 2,227 tokens, no truncation.
+4. **Full training** → 1 epoch × 428 optimizer steps, completion-only final eval.
+5. **Generation quality eval** → 60 balanced samples from the frozen test split with `--generation-eval-load-mode 4bit` and per-surface token caps.
+6. **Phase-only rerun** → 20 held-out phase examples with `--phase-max-new-tokens 384` (the original 160 cap was truncating the JSON close).
+
+### 2.2 Model + adapter
+- **Base model:** `unsloth/gemma-4-E2B-it` (4-bit QLoRA via Unsloth `FastModel`)
+- **LoRA targets:** all language layers + attention modules + MLP modules
+- **LoRA hyperparameters:** `r=32`, `alpha=32`, `dropout=0.0`
+- **Trainable LoRA parameters:** 25.3 M
+- **Chat template:** `gemma-4` (applied via `get_chat_template`)
+- **Loss mode:** **response-only**, via `train_on_responses_only` — model only learns assistant turns, not its own prompts
+- **BOS handling:** training text strips the leading `<bos>` so the processor doesn't double-insert one
+
+### 2.3 Trainer hyperparameters
+| Knob | Value | Source |
+|---|---|---|
+| Epochs | 1.0 | Plan modification: smaller, safer first big run |
+| Steps | 428 (from 3,421/8) | Auto-derived |
+| Batch size | 1 | Memory-friendly with QLoRA |
+| Gradient accumulation | 8 | Effective batch size 8 |
+| Learning rate | 2e-4 | Unsloth notebook default for short runs |
+| LR schedule | cosine | Standard |
+| Warmup | 21 steps (≈ 5%) | Conservative |
+| Weight decay | 0.001 | Unsloth recommendation |
+| Max grad norm | 0.3 | Stability cap |
+| Max seq length | 4096 | Preflight max only 2,227 |
+| Optimizer | adamw_8bit | bitsandbytes 8-bit Adam |
+| Seed | 7 | Same as split seed |
+
+### 2.4 Hardware + environment
+- Thunder Compute A100-80GB instance
+- Python 3.11.15 inside `models/.venv` (uv-managed)
+- Torch 2.11.0 + CUDA 13.0, Triton 3.6
+- Unsloth 2026.5.2, TRL 0.24, Datasets 3.6
+- xformers 0.0.35, flash-attn 2.8.3 (FA2 is detected but Gemma 4's 512-dim head exceeds FA2's 256 cap → Unsloth falls back to SDPA on this model)
+
+### 2.5 Wall clock
+- Training only: **~2 h 26 m**
+- Completion eval (base + LoRA, full 428-row test): rolled into training run
+- Generation eval (60 samples, LoRA-only, 4bit): **~52 min**
+- Phase-only rerun (20 samples, 4bit, 384 max-new): **~23 min**
+
+---
+
+## 3. Quantitative results — Completion NLL
+
+Same prompts, same tokenization, base vs LoRA on the **full** 428-row held-out test set.
+
+| Metric | Base Gemma 4 E2B | WAVE LoRA | Delta |
+|---|---|---|---|
+| Completion NLL | 4.9312 | **4.5576** | **−0.374** |
+| Completion perplexity | 138.55 | **95.35** | **−43.20** |
+| Paired wins (LoRA assigned higher prob to the reference) | — | **428 / 428** | **100% win rate** |
+| Mean per-example NLL Δ | — | **0.508** nats | 95% bootstrap CI [0.477, 0.537] |
+| Median per-example NLL Δ | — | 0.454 nats | — |
+| Sign-test p-value | — | **2.89 × 10⁻¹²⁹** | overwhelming |
+| Final training loss (last step) | — | 0.241 | — |
+
+This is the strongest single claim from the run: on every single held-out prompt — without exception — the LoRA assigns higher probability to the reference WAVE-style JSON completion than base Gemma 4 E2B, with a tight bootstrap confidence interval and a sign-test p-value far below any reasonable bar.
+
+---
+
+## 4. Quality results — Generation gates
+
+Generation eval reloads the saved adapter in 4-bit inference mode (`FastModel.for_inference`), enables KV cache, disables gradient checkpointing, and generates the assistant turn with surface-specific token budgets. Each generated string is then run through the WAVE behavior gates: JSON parse, schema match, style rules, safety lexicon, medical-directive lexicon, no-analysis-voice, no-markdown, plus per-surface checks (check-in turn sequence, phase 6-line, reflection next-step).
+
+### 4.1 First run (60 balanced examples, 20 per surface)
+
+| Metric | All 60 | check_in (n=20) | phase_narration (n=20) | reflection (n=20) |
+|---|---|---|---|---|
+| JSON validity | 75.0% | **100%** | 25% | **100%** |
+| Schema pass | 71.7% | 90% | 25% | **100%** |
+| Style pass | 100% | 100% | 100% | 100% |
+| Safety pass | 73.3% | 95% | 25% | **100%** |
+| Medical directive | 100% | — | — | — |
+| Patient-facing | 85.0% | — | — | — |
+| No analysis voice | 100% | — | — | — |
+| No markdown | 100% | — | — | — |
+| Phase 6-line | 75% | n/a | 25% | n/a |
+| Reflection next-step | 100% | n/a | n/a | 100% |
+| Check-in turn-seq | 96.7% | 90% | n/a | n/a |
+| Token F1 vs reference | 0.434 | 0.490 | 0.382 | 0.429 |
+| ROUGE-L F1 vs reference | 0.303 | 0.456 | 0.171 | 0.282 |
+| Mean latency (A100, 4bit) | 52.0 s | 32.3 s | 70.7 s | 53.2 s |
+| p95 latency | 77.8 s | 51.6 s | 118.8 s | 66.0 s |
+| Mean generated tokens | 120 | 77 | **159** | 123 |
+
+**Root cause of overall fail:** every phase row was using essentially the full 160-token budget (mean 159/160). The model was writing valid clinical content but never reaching the closing `]}` — JSON parser fails → cascades to schema/safety/6-line.
+
+### 4.2 Phase rerun (20 phase examples, `--phase-max-new-tokens 384`)
+
+| Metric | 160-token cap | 384-token cap | Δ |
+|---|---|---|---|
+| JSON validity | 25% | **85%** | **+60 pp** |
+| Schema pass | 25% | **80%** | **+55 pp** |
+| Safety pass | 25% | **85%** | **+60 pp** |
+| Phase 6-line | 25% | **80%** | **+55 pp** |
+| Style pass | 100% | 100% | flat |
+| Patient-facing | — | 100% | — |
+| Mean generated tokens | 159 | 182 | +23 |
+| Mean latency | 70.7 s | 70.6 s | flat |
+
+### 4.3 Combined post-fix picture (weighting per-surface results from the right run)
+
+| Metric | check_in | phase_narration (384) | reflection | Weighted (60 mix) |
+|---|---|---|---|---|
+| JSON validity | 100% | 85% | 100% | **~95%** |
+| Schema pass | 90% | 80% | 100% | **~90%** |
+| Safety pass | 95% | 85% | 100% | **~93%** |
+| Style pass | 100% | 100% | 100% | **100%** |
+
+### 4.4 Remaining phase failures (4/20 even at 384 tokens) — different root cause
+
+After raising the cap, the remaining 4 phase-narration failures are **not** truncation. The model is writing the closing `"` and `}` but skipping the `]` that closes the `lines` array:
+
+```
+gen tail (id=2c658c71): ..."}    ← missing ]
+gen tail (id=eb8174f3): ..."\n}  ← missing ]
+gen tail (id=86152852): ..."\n}  ← missing ]
+```
+
+Token counts on these rows (182, 246, 163) are well within the 384-token budget. One additional failure (`3871f876`) does close JSON properly (`"]}`) but schema fails because the model wrote a different number of lines than the reference's 6.
+
+### 4.5 Reproducibility check — confirmed deterministic model defect
+
+We re-ran all 4 failing IDs twice each (8 generations total) against the same saved adapter at the same `--phase-max-new-tokens 384`. Result: **8/8 generations reproduced the original failures byte-for-byte**, including identical token counts:
+
+| Example ID | Original tokens | Re-run 1 | Re-run 2 | Generated tail (both repeats) |
+|---|---|---|---|---|
+| `2c658c71…` | 182 | 182 | 182 | `…watching it move through you."}` |
+| `3871f876…` | 228 | 228 | 228 | `…one sound at a time."]}` (json valid, schema fail) |
+| `86152852…` | 163 | 163 | 163 | `…Just notice it."\n}` |
+| `eb8174f3…` | 246 | 246 | 246 | `…steady moment of noticing."\n}` |
+
+Both repeats produce **identical** strings. This means:
+1. Inference is effectively deterministic on this code path (regardless of the documented `temperature=1.0` defaults — the trained adapter's distribution is peaked tight enough that the same continuation wins every time on these prompts).
+2. The failures are **not sampling noise** that more sampling would fix.
+3. These prompts will fail in production 100% of the time with this adapter — they need either data/retrain remediation or a deterministic post-process.
+
+Saved artifact: `runs/.../phase-regen-check.json` + `runs/.../phase-regen-check/generation-eval-progress.jsonl`.
+
+### 4.6 Diagnosis
+
+The model has learned the surface format correctly (style/safety/voice all 100%) but has memorized a wrong stop pattern for a subset of phase-narration prompts: it emits the final string and then jumps directly to the wrapping `}` without first emitting the `]` that closes the `lines` array. This is consistent with the synthetic-draft share of the dataset (62%) introducing a small pattern where the array-close token was occasionally followed by a different bracket sequence — the adapter overfit to that minority pattern on the specific prompt shapes that trigger it.
+
+The fix is straightforward:
+- **Cheapest:** add a deterministic JSON-repair pass at inference time. If the assistant emits `"…"}` while the `lines` array is unclosed, insert the missing `]`. This is safe and immediately recovers the 3/4 truncated-close failures.
+- **Cleanest:** add ~50 targeted phase-narration examples that explicitly drill the `"]}` close sequence and retrain for 1 more epoch.
+- **Best long-term:** both — repair pass for safety net, plus the data fix to eliminate the underlying defect.
+
+### 4.5 Representative passing sample
+
+**reflection** (`ec718a0e`, exact-behavior match to reference style):
+- Generated: `{"insight":"You started at an intensity of 8 and finished at a 7 after 360 seconds. That shows the urge was very strong and you stayed with it long enough to notice a shift, even if the peak intensity didn't drop significantly. Staying present during intense urges builds tolerance for them.","journalPromptQuestion":...}`
+- Reference: `{"insight": "You moved from an 8 to a 7 in about six minutes. The urge stayed relatively high, but you kept returning attention instead of acting on it. Not every session will show a big drop; showing up still matters.", "journalPromptQuestion":...}`
+
+Same clinical pose, same structure, valid JSON, calm second-person voice.
+
+---
+
+## 5. Artifacts (local mirror at `models/successful_runs/remote_final/`)
+
+All 101 VM run-dir files were SCP'd to local byte-exact (verified by manifest diff). One extra local file: `REPORT.md` (this document). Total size ~16.1 GB.
+
+### Training run artifacts
+| Path | Bytes | Purpose |
+|---|---|---|
+| `adapter/adapter_model.safetensors` | 202,775,888 | Trained LoRA weights (~194 MB, 25.3M trainable params) |
+| `adapter/adapter_config.json` | 1,640 | PEFT config (r=32, alpha=32, target layers) |
+| `adapter/tokenizer.json` + `tokenizer_config.json` | 32 MB + 6.7 KB | Gemma 4 tokenizer for inference |
+| `adapter/chat_template.jinja` | 2,375 | Gemma 4 chat template baked in |
+| `adapter/training_args.bin` | 5,777 | Frozen `SFTConfig` for reproducibility |
+| `adapter/processor_config.json` | 1,688 | Processor config |
+| `adapter/README.md` | 5,254 | Auto-generated PEFT card |
+| `run-config.json` | 3,276 | Full hyperparameters, dataset counts, split seed |
+| `train.jsonl` | 27.5 MB | Frozen train split (3,421 examples) |
+| `validation.jsonl` | 3.6 MB | Frozen validation split (428 examples) |
+| `test.jsonl` | 3.4 MB | Frozen test split (428 examples) |
+| `normalized.jsonl` | 34.7 MB | Full normalized dataset (4,277 examples) |
+| `token-length-report.json` | 3,978 | Preflight evidence (max=2,227, no truncation) |
+| `checkpoints/` (5 dirs) | 1.6 GB | TRL checkpoints at steps 250/300/350/400/428 — full state (adapter + optimizer + scheduler + rng + trainer_state) |
+| `validation-eval.json` | 129,849 | Validation completion metrics |
+| `tuning-summary.json` | 87,482 | Per-candidate validation log |
+
+### Evaluation artifacts
+| Path | Bytes | Purpose |
+|---|---|---|
+| `eval.json` | 430,049 | **Headline:** full base-vs-LoRA completion comparison on the 428-row test split |
+| `generation-eval.json` | 307,075 | 60-sample generation gate aggregate (LoRA-only, 4bit) |
+| `generation-eval-progress.jsonl` | 269,963 | 60 per-example generated outputs + gate results |
+| `generation-eval-phase-384.json` | 90,532 | Phase rerun aggregate (`max_new_tokens=384`) |
+| `phase-rerun-384/generation-eval-progress.jsonl` | 76,144 | 20 per-example phase outputs at 384-token cap |
+| `phase-regen-check.json` | 40,948 | Reproducibility re-run (4 failing IDs × 2 repeats) |
+| `phase-regen-check/generation-eval-progress.jsonl` | 28,245 | 8 per-example outputs proving determinism |
+
+### Export artifacts (post-training, produced on the VM and SCP'd back)
+| Path | Bytes | Purpose |
+|---|---|---|
+| `merged-16bit/model.safetensors` | 10,246,621,886 | Base Gemma 4 E2B + LoRA merged in bf16, single safetensors (~9.6 GB) — drop-in for `transformers` / vLLM |
+| `merged-16bit/merge-manifest.json` | 350 | Merge provenance (base model, adapter path, save method) |
+| `merged-16bit/config.json` + `chat_template.jinja` + `processor_config.json` + tokenizer files | ~32 MB | Everything needed to load the merged model directly |
+| `gguf/gemma-4-e2b-it.Q4_K_M.gguf` | 3,427,878,240 | Q4_K_M quantization of the merged model for llama.cpp / Ollama / Unsloth (~3.2 GB) |
+| `gguf/gemma-4-e2b-it.BF16-mmproj.gguf` | 986,833,280 | BF16 multimodal projection (Gemma 4 vision/audio) — required alongside the text GGUF for full multimodal use (~941 MB) |
+| `gguf/Modelfile` | 205 | Ollama Modelfile (`ollama create wave-lora -f gguf/Modelfile`) |
+| `gguf/config.json` + tokenizer + chat template + processor_config | ~32 MB | Reference configs paired with the GGUF |
+
+### Documentation
+| Path | Purpose |
+|---|---|
+| `REPORT.md` (this file) | Comprehensive run report — single source of truth |
+| `MORNING_REPORT.md` | First-pass morning report (kept for history) |
+| `README.md` | Auto-summary written at training end. ⚠ Its "gates skipped" line was true for the original completion-only eval; gates were added later — see §4 of this REPORT for the full quality numbers. |
+| `checkpoints/README.md` | Auto-generated TRL checkpoint card |
+| `adapter/README.md` | Auto-generated PEFT card |
+
+### Verified byte-exact transfer
+SCP'd from `ubuntu@216.81.200.233:/home/ubuntu/wave-work/Wave/models/runs/lora-wave-session/overnight-primary-r32-a32-lr2e-4-1epoch/` on 2026-05-11. After transfer, file-size diff against the VM showed:
+- `Missing locally (vs VM): 0` files
+- `Extras locally (vs VM): 1` file (`REPORT.md`)
+- `Matching files: 101 / 101`
+
+Spot checks on the heaviest binaries:
+
+| File | VM bytes | Local bytes | Match |
+|---|---|---|---|
+| `adapter/adapter_model.safetensors` | 202,775,888 | 202,775,888 | ✓ |
+| `merged-16bit/model.safetensors` | 10,246,621,886 | 10,246,621,886 | ✓ |
+| `gguf/gemma-4-e2b-it.Q4_K_M.gguf` | 3,427,878,240 | 3,427,878,240 | ✓ |
+| `gguf/gemma-4-e2b-it.BF16-mmproj.gguf` | 986,833,280 | 986,833,280 | ✓ |
+
+---
+
+## 6. Reproducibility
+
+### 6.1 Training command (the actual command that ran)
+```bash
+.venv/bin/python -u train_wave_session_lora.py \
+  --data datasets/lora-wave-session-expanded.jsonl \
+  --model-id unsloth/gemma-4-E2B-it \
+  --seed 7 \
+  --validation-size 0.1 --test-size 0.1 \
+  --max-seq-length 4096 \
+  --lora-r 32 --lora-alpha 32 --lora-dropout 0.0 \
+  --epochs 1.0 \
+  --batch-size 1 --gradient-accumulation 8 \
+  --learning-rate 2e-4 --lr-scheduler-type cosine --warmup-ratio 0.03 \
+  --weight-decay 0.001 --max-grad-norm 0.3 \
+  --save-strategy steps --save-steps 50 --save-total-limit 5 \
+  --final-eval-mode completion \
+  --output-dir runs/lora-wave-session/overnight-primary-r32-a32-lr2e-4-1epoch
+```
+
+### 6.2 Generation quality eval (initial 60-sample)
+```bash
+.venv/bin/python -u run_generation_eval_from_adapter.py \
+  --run-dir runs/lora-wave-session/overnight-primary-r32-a32-lr2e-4-1epoch \
+  --limit 60 --load-mode 4bit --max-seq-length 4096 \
+  --check-in-max-new-tokens 96 \
+  --phase-max-new-tokens 160 \
+  --reflection-max-new-tokens 192 \
+  --out generation-eval.json
+```
+
+### 6.3 Phase rerun (after raising the cap)
+```bash
+.venv/bin/python -u run_generation_eval_phase_only.py \
+  --run-dir runs/lora-wave-session/overnight-primary-r32-a32-lr2e-4-1epoch \
+  --limit 20 --load-mode 4bit \
+  --phase-max-new-tokens 384 \
+  --out generation-eval-phase-384.json
+```
+
+### 6.4 Reproducibility regen check (deterministic-defect proof)
+```bash
+.venv/bin/python -u regen_phase_failures.py \
+  --run-dir runs/lora-wave-session/overnight-primary-r32-a32-lr2e-4-1epoch \
+  --example-ids 2c658c71-d966-51a4-8f7e-80481dbd22df,\
+eb8174f3-9547-53cd-9e6c-b131fbd77157,\
+3871f876-4f69-5f03-a0af-2624564e57e9,\
+86152852-23a1-5cde-a148-e94fe1eca2cd \
+  --repeats 2 --load-mode 4bit --phase-max-new-tokens 384
+```
+
+### 6.5 Merged-16bit export
+```bash
+.venv/bin/python -u merge_lora_adapter.py \
+  --adapter-dir runs/lora-wave-session/overnight-primary-r32-a32-lr2e-4-1epoch/adapter \
+  --out-dir runs/lora-wave-session/overnight-primary-r32-a32-lr2e-4-1epoch/merged-16bit \
+  --max-seq-length 4096
+```
+
+### 6.6 GGUF export (Q4_K_M + BF16 mmproj for Gemma 4 multimodal)
+Pre-install build deps once, then run with `yes` piped to stdin so Unsloth's package-prompt accepts cleanly under `nohup`:
+```bash
+sudo apt-get install -y cmake libcurl4-openssl-dev pkg-config ccache
+yes "" | .venv/bin/python -u export_gguf.py \
+  --adapter-dir runs/lora-wave-session/overnight-primary-r32-a32-lr2e-4-1epoch/adapter \
+  --out-dir runs/lora-wave-session/overnight-primary-r32-a32-lr2e-4-1epoch/gguf \
+  --quant q4_k_m --max-seq-length 4096
+# Then consolidate Unsloth's `gguf_gguf/` outputs into `gguf/` and drop the
+# intermediate `gguf/model.safetensors` (Unsloth re-merges before quantizing).
+```
+
+### 6.7 Frozen seed
+- Split seed: `7`
+- LoRA random state: `3407`
+- HuggingFace cache: default (`~/.cache/huggingface`)
+
+---
+
+## 7. Honest caveats
+
+1. **Generation gate `pass=false` in the headline aggregate.** Disclose this. The cause is the JSON-close defect on phase, not bad clinical content. The behavior gates (style, medical-directive, no-markdown, no-analysis-voice) are at 100%.
+2. **Two check-in schema misses** involve missing the structured `endConversation` object on session-end turns (the LoRA emitted `endConversation: null` instead). Easily addressable with more session-end synthetic data.
+3. **Phase narration JSON close.** Even with the 384-token cap, 4/20 phase rows emit `"}` (missing `]`) instead of `"]}`. This is a model defect, not a runtime issue. It can be fixed via: (a) one more epoch focused on phase, (b) an inference-time JSON-repair pass, or (c) a structured-decoding constraint at generation time.
+4. **Base-vs-LoRA *generation* comparison** was deliberately skipped — the completion eval already proves the win on the full 428 prompts, and generating with base would have roughly doubled the eval time. Available on demand.
+5. **A100 4-bit inference is slow** (mean 52 s/example, p95 78 s). This is fine for offline eval. The deployment target is on-device E2B with a faster runtime — and we now have those exports ready: `merged-16bit/` for `transformers`/vLLM, and `gguf/gemma-4-e2b-it.Q4_K_M.gguf` (+ `BF16-mmproj.gguf`) for llama.cpp / Ollama / Unsloth. Expect ~10× improvement after deployment on faster inference backends.
+6. **Synthetic data share.** 62% of the training rows are `synthetic_draft` and 37% are `draft` (clinician-written but unfinalized). Only 45 rows (1%) are `ready` (clinician-approved final). The strong NLL win shows the model learned the structure; for end-user readiness, a clinician QA pass on the `synthetic_draft` rows is the most impactful data improvement.
+
+---
+
+## 8. What to show judges
+
+1. **Headline statistic:** "The LoRA adapter beats base Gemma 4 E2B on **all 428** frozen held-out prompts. Mean improvement **0.508 nats / example**, sign-test p ≈ **1e-129**. Perplexity dropped from **138.5** to **95.4**."
+2. **Behavior gates:** WAVE style, medical-directive, no-markdown, no-analysis-voice all **100%**. Reflection surface **100%** across every gate. Check-in surface **90–100%**.
+3. **Per-example evidence:** `generation-eval-progress.jsonl` + `phase-rerun-384/generation-eval-progress.jsonl` contain prompt → generated → reference → gate results for every evaluated example.
+4. **Reproducibility:** frozen `train/validation/test.jsonl`, deterministic seed, exact training command, run-config + adapter weights all saved alongside the eval JSON.
+
+---
+
+## 9. Recommended next steps (in cost order)
+
+1. **Cheapest / first** — small data pass: add ~50 hand-tuned end-of-session check-in examples (covering the structured `endConversation` object) and ~50 phase-narration examples that explicitly model the `"]}` close. Retrain 1 epoch with same hyperparameters. Expected: JSON validity → 95%+, schema → 95%+ on phase.
+2. **Cheap engineering** — wrap inference with a tiny JSON-repair pass that, if `lines` is open and the next char would be `}`, inserts the missing `]`. This is a safe, deterministic fix for the remaining 4/20 phase failures.
+3. **If retraining time available** — try a 2-epoch run at LR 1e-4 (between the current 2e-4 and the conservative 2e-5 fallback). Same r=32/alpha=32. Reuse the same split/seed for a clean A/B.
+4. **Deployment** — exports already in place:
+   - **Hosted (server-side, full quality):** load `merged-16bit/` directly with `transformers` or vLLM.
+   - **On-device / edge (Ollama):** `ollama create wave-lora -f gguf/Modelfile` then `ollama run wave-lora` — uses the Q4_K_M (text) + BF16-mmproj (vision/audio) pair.
+   - **On-device (llama.cpp/Unsloth):** load `gguf/gemma-4-e2b-it.Q4_K_M.gguf` with `--mmproj gguf/gemma-4-e2b-it.BF16-mmproj.gguf`.
+
+---
+
+## 10. Comparison vs `local_final` (sibling run)
+
+Both runs fine-tuned the same base (`unsloth/gemma-4-E2B-it`) on the same source dataset with the same seed=7. Test-split example_ids are byte-identical (428 examples, same 144/147/137 surface counts); the only file-level difference is CRLF vs LF in the JSONL splits.
+
+### Recipes
+| | `local_final` | `remote_final` (this run) |
+|---|---|---|
+| Hardware | RTX 5080 (Windows, local) | A100 80 GB SXM4 (Linux, Thunder Compute) |
+| LoRA rank | 16 | **32** |
+| LoRA alpha | 32 | 32 |
+| Epochs | **3** (1,152 steps) | 1 (428 steps) |
+| Warmup | 64 steps | 21 steps |
+| LR / schedule / batch / accum / wd / grad-norm | same: 2e-4 cosine, 1×8, 0.001, 0.3 | same |
+
+### Quantitative (full 428 test split)
+| | `local_final` | `remote_final` |
+|---|---|---|
+| LoRA completion NLL | 4.7149 | **4.5576** |
+| LoRA perplexity | 111.59 | **95.35** |
+| Paired wins vs base | 386 / 428 (90.2%) | **428 / 428 (100%)** |
+| Mean NLL Δ vs base | 0.327 nats | **0.508 nats** |
+| Sign-test p-value | 9.5 × 10⁻⁷¹ | **2.9 × 10⁻¹²⁹** |
+
+**`remote_final` is measurably stronger on every probability metric** — higher rank captured the WAVE distribution more decisively in fewer steps. Effect size 55% larger; perfect win rate (no losses on any prompt) vs ~10% losses for local.
+
+### Generation eval — apples-to-apples on the 6 overlapping example_ids
+(`local_final` only ran an 8-example smoke; `remote_final` ran 60; overlap = 6.)
+
+| ID | Surface | Local | Remote | Notes |
+|---|---|---|---|---|
+| `15f8662e` | check_in | ✓ json+schema+safety, F1=1.000 | ✓ json+schema+safety, F1=1.000 | **Identical** reply to reference — only whitespace differs |
+| `2bf8ec4f` | check_in | ✓ F1=1.000 | ✓ F1=1.000 | Both identical to reference |
+| `2510fd56` | phase | ✓ F1=0.483 | ✓ F1=**0.512** | Remote slightly closer to reference |
+| `30b744c4` | phase | ✓ json+schema+safety, **183 tok** | ✗ json fail, 160 tok (**truncated by cap**) | Local won by having a bigger token budget at gen time, not a model difference |
+| `afedb9b7` | reflection | ✓ F1=**0.429** | ✓ F1=0.355 | Local slightly closer to reference |
+| `ec718a0e` | reflection | ✓ F1=0.423 | ✓ F1=0.416, ROUGE-L=**0.315** | Tie on F1; remote slightly better ROUGE-L |
+
+Pass rates on overlap: local **6/6**, remote **5/6** (the one miss is a 160-token cap artifact — when we raised the cap to 384 for the phase rerun, remote cleared most phase failures too).
+
+### Verdict
+- **Both models are clinically equivalent** on identical prompts. Word choice differs but pose, safety, structure, and JSON shape are the same.
+- **`remote_final` is the better adapter for the WAVE distribution** — stronger NLL evidence, perfect paired-win rate, smaller p-value, and more recent (post-`local_final`) eval/repair pipeline.
+- Recommend shipping `remote_final/adapter/` (or its merged/GGUF derivatives) and applying a token-budget bump (`--phase-max-new-tokens ≥ 256`) plus the JSON-repair post-process from §9.2 to close the residual phase-close defect.