feat: expand coach summary training pipeline

configs/coach_summary_lora.default.json

@@ -1,5 +1,5 @@
 {
-  "base_model": "Qwen/Qwen2.5-7B-Instruct",
+  "base_model": "Qwen/Qwen3-14B",
   "train_file": "/Users/h/Documents/Pozify/data/sft/coach_summary_train.jsonl",
   "eval_file": "/Users/h/Documents/Pozify/data/sft/coach_summary_eval.jsonl",
   "output_dir": "/Users/h/Documents/Pozify/models/coach_summary_lora",
@@ -11,4 +11,4 @@
   "per_device_train_batch_size": 1,
   "gradient_accumulation_steps": 8,
   "max_seq_length": 4096
-}
+}

docs/coach-model-data-plan.md

@@ -0,0 +1,654 @@
+# Pozify Coach Model Data Plan
+
+## Objective
+
+Define a practical data and modeling plan for improving Pozify's coach summary and coach-style guidance using open datasets and the current codebase.
+
+This document answers:
+
+- Which public datasets are actually useful for Pozify's current problem.
+- Whether to use RAG, SFT, or both.
+- How those choices fit the current pipeline, artifacts, verifier, and UI.
+- A concrete implementation roadmap that does not break the current app architecture.
+
+## Current Codebase Fit
+
+Pozify today is not a generic fitness chatbot. It is a structured video-analysis pipeline that ends with a grounded coach summary:
+
+- `video_qc` -> `pose_landmarker` -> `exercise_classifier` -> `rep_analysis` -> `variation` -> `issue_markers` -> `coach_summary` -> `verifier`
+- The coach summary step already consumes structured evidence and retrieved knowledge cards.
+- The verifier already rejects summaries that invent issues, overcorrect valid variations, or make unsafe claims.
+
+Relevant modules:
+
+- `src/pozify/pipeline.py`
+- `src/pozify/steps/coach_summary.py`
+- `src/pozify/slm/prompting.py`
+- `src/pozify/knowledge_cards.py`
+- `src/pozify/steps/verifier.py`
+
+That means any dataset strategy must be evaluated against the real task:
+
+> Generate safe, grounded, structured coaching language from Pose/Rep/Variation/Issue JSON artifacts.
+
+This is **not** the same task as:
+
+- answering open-ended fitness questions,
+- free-form nutrition coaching,
+- broad lifestyle coaching,
+- or generic health chat.
+
+## Recommendation Summary
+
+### Best near-term strategy
+
+Use a **hybrid approach**:
+
+1. **Expand knowledge retrieval first** using a curated exercise knowledge base.
+2. **Keep coach summary grounded on structured Pozify artifacts.**
+3. **Use lightweight SFT only after you have a Pozify-native training set** built from your own analysis artifacts and target summaries.
+
+### What not to do first
+
+Do **not** directly fine-tune the current coach-summary model on broad fitness chat datasets and expect it to improve the grounded summary step.
+
+That would likely:
+
+- make the model more conversational,
+- but also make it more likely to hallucinate,
+- talk beyond the provided JSON,
+- and fight against the verifier.
+
+### Strong recommendation
+
+For the current codebase, the best order is:
+
+1. **RAG / retrieval upgrade**
+2. **Pozify-native supervised dataset creation**
+3. **LoRA / SFT on the Pozify-native task**
+4. **Optional separate chatbot mode** trained on public chat/Q&A datasets
+
+## Dataset-by-Dataset Assessment
+
+### 1. `onurSakar/GYM-Exercise`
+
+Source notes:
+
+- Hugging Face dataset page shows `1.66k` rows and a single text field formatted in Llama-style instruction format.
+- The visible examples include fitness Q&A, but also broader wellness topics such as environmental stressors, work-life balance, mental clarity, and social well-being.
+
+Fit for Pozify:
+
+- Good for **general fitness coach tone**.
+- Weak fit for **grounded rep-by-rep coach summary generation**.
+- Weak fit for **variation-vs-issue reasoning** tied to structured pose artifacts.
+
+Risks:
+
+- Topic drift beyond movement coaching.
+- May encourage generic answer patterns instead of artifact-conditioned reasoning.
+- Could increase verifier failures because the model may mention things outside `issue_markers.json`.
+
+Best use in Pozify:
+
+- Use only as **auxiliary style data**.
+- Filter to movement-technique and workout-guidance samples.
+- Do not use raw as the main SFT dataset for `coach_summary`.
+
+Verdict:
+
+- **Useful later**
+- **Not the primary dataset for the current summary pipeline**
+
+### 2. `HazSylvia/Fitness_Unformatted`
+
+Source notes:
+
+- Hugging Face page shows `928` rows.
+- Fields appear as `Human` and `Assistant`.
+- Examples are cleaner fitness Q&A than the dataset above and closer to gym onboarding and workout guidance.
+
+Fit for Pozify:
+
+- Better than `onurSakar/GYM-Exercise` for conversational coach tone.
+- Still not tightly aligned with Pozify's structured JSON-to-summary task.
+
+Risks:
+
+- Still mostly free-form Q&A, not evidence-grounded explanation.
+- Lacks explicit inputs like `rep_analysis`, `variation`, `issue_markers`.
+
+Best use in Pozify:
+
+- Use as **secondary SFT data for tone/voice**.
+- Convert to JSONL and filter for exercise technique, beginner coaching, and workout-planning responses.
+- Consider this dataset for a future `Ask Pozify` chat mode.
+
+Verdict:
+
+- **Good for coach voice**
+- **Not enough by itself for the current pipeline**
+
+### 3. `chibbss/fitness-chat-prompt-completion-dataset`
+
+Source notes:
+
+- Hugging Face page shows `245` rows.
+- Has `instruction` and `output` fields.
+- Content appears to focus on healthy habits, routines, stress, sleep, and lifestyle guidance.
+
+Fit for Pozify:
+
+- Good format for instruction tuning.
+- Too small and too broad to be the main fine-tuning source for the current task.
+
+Risks:
+
+- Small size.
+- Lifestyle-heavy answers may not improve form-review summaries.
+- Could push the model toward broad wellness advice instead of evidence-based movement coaching.
+
+Best use in Pozify:
+
+- Optional augmentation for tone.
+- Better suited to a future “habit coach” or “ask a coach” feature than to movement-summary generation.
+
+Verdict:
+
+- **Supplementary only**
+
+### 4. `hasaneyldrm/exercises-dataset`
+
+Based on your description, this is the most strategically valuable dataset for Pozify right now.
+
+Fit for Pozify:
+
+- High fit for retrieval and knowledge expansion.
+- It maps well to Pozify's current `knowledge_cards` architecture.
+- It improves factual consistency for exercise descriptions, target muscles, equipment, and execution cues.
+
+Why it fits the codebase:
+
+- Pozify already retrieves deterministic cards in `src/pozify/knowledge_cards.py`.
+- The prompt builder already injects knowledge cards into the model input.
+- The current gap is not “more chat data”; the gap is “richer, broader, more standardized exercise knowledge.”
+
+Best use in Pozify:
+
+- Use this as the basis for a **local knowledge base** first.
+- Convert exercise rows into:
+  - exercise cards,
+  - variation cards,
+  - equipment-aware cues,
+  - and optional goal-specific cue overlays.
+- Later, optionally index it in FAISS/Chroma for semantic retrieval in a separate chat flow.
+
+Verdict:
+
+- **Best immediate dataset to integrate**
+
+### 5. `strova-ai/fitness-tracker-dataset`
+
+Source notes:
+
+- Hugging Face page describes it as a synthetic wearable/activity dataset.
+- It contains tabular metrics such as age, gender, height, weight, steps, heart rate, calories, distance, and activity.
+- The page also shows dataset-viewer schema issues, which suggests ingestion may need cleanup.
+
+Fit for Pozify:
+
+- Useful for personalization experiments.
+- Weak fit for current video-form summary generation.
+
+Why it does not fit immediately:
+
+- Pozify's current app does not reason from wearable timeseries.
+- The current `UserProfile` contract is small and categorical.
+- There is no current component that transforms tabular physiology into grounded motion advice.
+
+Best use in Pozify:
+
+- Optional later-stage personalization module.
+- Useful for future “today's activity context” or “session recommendation” features.
+- Not a priority for the current coach summary pipeline.
+
+Verdict:
+
+- **Future personalization dataset, not Phase 1**
+
+## What This Means For Pozify
+
+### The current task is not generic chat SFT
+
+Pozify's core output is:
+
+- bounded by `exercise_classification.json`
+- bounded by `rep_analysis.json`
+- bounded by `variation.json`
+- bounded by `issue_markers.json`
+- conditioned by knowledge cards
+- checked by a verifier
+
+So the most valuable training examples are not public generic fitness Q&A.
+
+The most valuable examples look like this:
+
+```json
+{
+  "analysis_json": {
+    "user_profile": {},
+    "exercise_classification": {},
+    "rep_analysis": {},
+    "variation": {},
+    "issue_markers": {}
+  },
+  "retrieved_knowledge_cards": [],
+  "ideal_coach_summary": {
+    "summary": "",
+    "what_you_did": [],
+    "what_looked_good": [],
+    "what_changed_across_reps": [],
+    "valid_variation_vs_issue": [],
+    "top_fixes": [],
+    "next_session_plan": [],
+    "confidence_notes": []
+  }
+}
+```
+
+This is already much closer to the current runtime prompt contract than any public chat dataset you listed.
+
+## Recommended Strategy
+
+## Option A: Retrieval-first upgrade
+
+### Why this is the best first move
+
+It fits the current architecture with the least risk.
+
+It improves:
+
+- factual exercise guidance,
+- coaching cue coverage,
+- equipment-specific instructions,
+- and future exercise expansion,
+
+without retraining the model first.
+
+### How to use `hasaneyldrm/exercises-dataset`
+
+Convert exercise rows into a normalized internal artifact such as:
+
+```json
+{
+  "card_id": "exercise:barbell_bench_press",
+  "card_type": "exercise",
+  "labels": ["barbell_bench_press", "bench_press"],
+  "title": "Barbell Bench Press",
+  "summary": "Compound upper-body press.",
+  "target_muscles": ["chest"],
+  "secondary_muscles": ["triceps", "front_delts"],
+  "equipment": ["barbell", "bench"],
+  "instructions": [
+    "Set the shoulder blades before unracking.",
+    "Lower with control to a repeatable touch point.",
+    "Press while keeping wrists stacked."
+  ]
+}
+```
+
+### Implementation in current codebase
+
+1. Add a data ingestion script under `scripts/`:
+   - `scripts/build_exercise_knowledge_base.py`
+2. Store normalized cards under:
+   - `data/knowledge/exercises.json`
+3. Update `src/pozify/knowledge_cards.py` to:
+   - load built-in cards,
+   - merge external exercise cards,
+   - keep deterministic retrieval for current exercise/variation/issue labels.
+4. Keep the current coach-summary flow intact.
+
+### Benefits
+
+- Immediate product improvement.
+- No retraining required.
+- Low safety risk.
+- Reuses the current prompt architecture.
+
+## Option B: Pozify-native SFT for coach summary
+
+### Why this is the right SFT target
+
+If you do SFT, train on the task Pozify actually runs:
+
+- structured evidence in
+- structured grounded summary out
+
+### Recommended data source for SFT
+
+Build your own dataset from:
+
+- current artifact pipeline outputs in `runs/`
+- synthetic or hand-authored expert summaries
+- optional edits by the team
+
+Then optionally augment with:
+
+- filtered examples from `HazSylvia/Fitness_Unformatted`
+- filtered examples from `onurSakar/GYM-Exercise`
+- filtered examples from `chibbss/fitness-chat-prompt-completion-dataset`
+
+But use public datasets only for:
+
+- tone,
+- phrasing,
+- concise coaching style,
+- and generic structure.
+
+Do not use them to replace the grounded target format.
+
+### SFT training objective
+
+Input:
+
+- current prompt evidence object
+- retrieved cards
+
+Output:
+
+- the exact `CoachSummary` JSON contract
+
+### Recommended model
+
+Use the current runtime-aligned model family first:
+
+- `Qwen/Qwen3-14B`
+
+Because the app already uses this model family successfully through Hugging Face Inference.
+
+### Recommended training tools
+
+- TRL if you want closer Hugging Face-native control
+- Unsloth if you want fast LoRA iteration on a smaller GPU budget
+- Axolotl if you want a cleaner config-driven fine-tuning pipeline
+
+### Best fine-tuning style
+
+- LoRA / QLoRA
+- JSON-only target format
+- deterministic eval checks against verifier outcomes
+
+### Why not train directly on public chat sets first
+
+Because the task mismatch is too large:
+
+- public chat sets teach “fitness assistant”
+- Pozify needs “artifact-grounded explanation generator”
+
+## Option C: Separate chat / Ask-a-Coach feature
+
+This is where the public datasets are actually strongest.
+
+### Best datasets for that feature
+
+- `HazSylvia/Fitness_Unformatted`
+- `onurSakar/GYM-Exercise`
+- `chibbss/fitness-chat-prompt-completion-dataset`
+
+### Suitable user stories
+
+- “I am new to the gym, where do I start?”
+- “Can you give me a 3-day weekly plan?”
+- “What should I eat after a workout?”
+- “How do I stay consistent?”
+
+### Why keep this separate from coach summary
+
+Because:
+
+- the current summary step must stay grounded
+- broad wellness chat should not weaken form-review safety
+- the verifier logic is built for artifact-based outputs, not broad coaching conversations
+
+### Suggested architecture
+
+- Keep `coach_summary` as today, evidence-first.
+- Add a future `ask_coach` endpoint and UI tab.
+- Back that feature with:
+  - a filtered fitness Q&A dataset,
+  - optional RAG over exercise knowledge,
+  - and a different safety policy.
+
+## Recommended Final Architecture
+
+### Phase 1
+
+- Retrieval-only upgrade from exercise knowledge base
+- No SFT required
+
+### Phase 2
+
+- Build Pozify-native summary dataset
+- Fine-tune a LoRA adapter for structured summary generation
+
+### Phase 3
+
+- Add optional `Ask Pozify` chat mode
+- Use public Q&A datasets there
+
+### Phase 4
+
+- Add personalization features using wearable/tabular data
+- Use `strova-ai/fitness-tracker-dataset` only if product scope expands into recommendations
+
+## Concrete Implementation Plan
+
+## Step 1: Add external exercise knowledge ingestion
+
+Goal:
+
+- turn exercise reference data into Pozify-ready knowledge cards
+
+Work:
+
+1. Create `data/knowledge/` directory.
+2. Add `scripts/build_exercise_knowledge_base.py`.
+3. Normalize raw exercise dataset fields into a local JSON schema.
+4. Add tests for normalization and card loading.
+5. Update `src/pozify/knowledge_cards.py` to load external cards.
+
+Deliverables:
+
+- `data/knowledge/exercises.json`
+- updated knowledge card loader
+- tests
+
+## Step 2: Expand current retrieval interface
+
+Goal:
+
+- use richer exercise and equipment context without changing app UX
+
+Work:
+
+1. Keep deterministic retrieval for current labels.
+2. Add equipment-aware retrieval using `UserProfile.equipment`.
+3. Add goal-aware retrieval overlays.
+4. Add per-exercise cue prioritization for the summary prompt.
+
+Deliverables:
+
+- richer `retrieve_cards(...)`
+- no changes needed in the UI contract
+
+## Step 3: Create a Pozify-native SFT dataset builder
+
+Goal:
+
+- create training examples from the actual runtime task
+
+Work:
+
+1. Add `scripts/build_coach_summary_sft_dataset.py`.
+2. Read from:
+   - `runs/*/exercise_classification.json`
+   - `runs/*/rep_analysis.json`
+   - `runs/*/variation.json`
+   - `runs/*/issue_markers.json`
+   - retrieved knowledge cards
+3. Export JSONL rows like:
+
+```json
+{
+  "messages": [
+    {"role": "system", "content": "..."},
+    {"role": "user", "content": "...structured evidence..."},
+    {"role": "assistant", "content": "{...coach summary json...}"}
+  ]
+}
+```
+
+4. Start with hand-authored gold summaries for 100-300 samples.
+5. Add validation scripts that reject malformed outputs.
+
+Deliverables:
+
+- `data/sft/coach_summary_train.jsonl`
+- `data/sft/coach_summary_eval.jsonl`
+
+## Step 4: Use public datasets only as auxiliary style data
+
+Goal:
+
+- improve coach tone without damaging grounded reasoning
+
+Work:
+
+1. Add `scripts/prepare_public_fitness_chat_data.py`.
+2. Ingest:
+   - `onurSakar/GYM-Exercise`
+   - `HazSylvia/Fitness_Unformatted`
+   - `chibbss/fitness-chat-prompt-completion-dataset`
+3. Filter out:
+   - broad medical claims
+   - unrelated wellness topics
+   - environment/toxin/social-life content
+4. Convert only the most relevant rows into a secondary style corpus.
+5. Use this corpus with lower sampling weight than Pozify-native data.
+
+Deliverables:
+
+- `data/sft/public_fitness_style.jsonl`
+
+## Step 5: Fine-tune with LoRA
+
+Goal:
+
+- make the model better at emitting Pozify's exact summary contract
+
+Work:
+
+1. Choose one training stack:
+   - TRL
+   - Unsloth
+   - Axolotl
+2. Fine-tune `Qwen/Qwen3-14B`.
+3. Use:
+   - low temperature at inference
+   - JSON-only targets
+   - training/eval split with verifier-based metrics
+4. Track:
+   - JSON validity rate
+   - verifier pass rate
+   - unsupported-issue mention rate
+   - variation-overcorrection rate
+
+Deliverables:
+
+- LoRA adapter
+- eval report
+- deployment notes
+
+## Step 6: Add pluggable model loading for local or Hub adapters
+
+Goal:
+
+- swap between base model and fine-tuned adapter cleanly
+
+Work:
+
+1. Extend `src/pozify/slm/providers.py`.
+2. Add env-driven model selection:
+   - base model
+   - fine-tuned adapter
+   - fallback model
+3. Surface model metadata in `final_report.artifacts`.
+
+Deliverables:
+
+- deployable adapter path
+- clear model/version tracking in UI and artifacts
+
+## Step 7: Optional future RAG for free-form chat
+
+Goal:
+
+- add a broader coach chat feature without weakening grounded summaries
+
+Work:
+
+1. Add `src/pozify/chat/` module.
+2. Index exercise knowledge into:
+   - FAISS first, or
+   - ChromaDB if persistence/filtering is preferred
+3. Use RAG only for:
+   - exercise explanations
+   - equipment substitutions
+   - general programming suggestions
+4. Keep this separate from `coach_summary`.
+
+Deliverables:
+
+- `Ask Pozify` feature
+- isolated inference path
+
+## Decision Table
+
+| Dataset | Best use in Pozify | Use now? | Notes |
+|---|---|---:|---|
+| `onurSakar/GYM-Exercise` | auxiliary style SFT | No | useful tone, but too broad for summary task |
+| `HazSylvia/Fitness_Unformatted` | auxiliary style SFT / future chat | Later | cleaner coach Q&A, still task-mismatched |
+| `chibbss/fitness-chat-prompt-completion-dataset` | auxiliary style SFT / future chat | Later | small, useful for tone only |
+| `hasaneyldrm/exercises-dataset` | retrieval knowledge base | Yes | best immediate fit for current architecture |
+| `strova-ai/fitness-tracker-dataset` | future personalization | No | not aligned with current app contracts |
+
+## Final Recommendation
+
+If the goal is to improve the current Pozify product, do this:
+
+1. **Integrate `hasaneyldrm/exercises-dataset` as structured knowledge cards first.**
+2. **Build a Pozify-native coach-summary SFT dataset from real artifacts.**
+3. **Fine-tune Qwen with LoRA on the Pozify-native task.**
+4. **Use public fitness chat datasets only as secondary style data.**
+5. **Use RAG later for a separate chat feature, not to replace the current grounded summary path.**
+
+This path gives the best balance of:
+
+- safety,
+- architecture fit,
+- product usefulness,
+- and implementation risk.
+
+## Sources
+
+- Hugging Face dataset page for `onurSakar/GYM-Exercise`: https://huggingface.co/datasets/onurSakar/GYM-Exercise
+- Hugging Face dataset page for `HazSylvia/Fitness_Unformatted`: https://huggingface.co/datasets/HazSylvia/Fitness_Unformatted
+- Hugging Face dataset page for `chibbss/fitness-chat-prompt-completion-dataset`: https://huggingface.co/datasets/chibbss/fitness-chat-prompt-completion-dataset
+- Hugging Face dataset page for `strova-ai/fitness-tracker-dataset`: https://huggingface.co/datasets/strova-ai/fitness-tracker-dataset
+- Pozify runtime code:
+  - `src/pozify/pipeline.py`
+  - `src/pozify/steps/coach_summary.py`
+  - `src/pozify/slm/prompting.py`
+  - `src/pozify/knowledge_cards.py`
+  - `src/pozify/steps/verifier.py`

docs/coach-summary-modal-training.md

@@ -13,7 +13,9 @@ It follows the same stage pattern as the exercise-router Modal pipeline:
 - `prepare-data`
 - `train`
 - `evaluate`
+- `merge`
 - `publish`
+- `publish-merged`
 - `all`
 
 ## Requirements
@@ -29,9 +31,11 @@ modal setup
 
 - `HF_TOKEN`
 - optional `POZIFY_COACH_SUMMARY_HF_REPO_ID`
+- optional `POZIFY_COACH_SUMMARY_MERGED_HF_REPO_ID`
+- recommended `POZIFY_COACH_SUMMARY_MODEL`
 - optional `POZIFY_COACH_SUMMARY_HF_PRIVATE=1`
 
-The script uses `modal.Secret.from_dotenv()`, so for local `modal run ...` usage you do not need to pre-create a hosted Modal secret just to run `prepare-data` or `train`.
+The script reads your local `.env` and injects those values into a Modal secret at runtime, so for local `modal run ...` usage you do not need to pre-create a hosted Modal secret just to run `prepare-data`, `train`, or `publish`.
 
 If you prefer a hosted secret for team/shared environments, you can still create one manually in Modal and adapt the script later.
 
@@ -72,6 +76,32 @@ Publish the adapter and metadata to Hugging Face:
 modal run scripts/coach_summary_modal.py --stage publish --repo-id build-small-hackathon/pozify-coach-summary
 ```
 
+Merge the LoRA adapter into a full Transformers checkpoint:
+
+```bash
+modal run scripts/coach_summary_modal.py --stage merge
+```
+
+Publish the merged inference-ready model to Hugging Face:
+
+```bash
+modal run scripts/coach_summary_modal.py --stage publish-merged --repo-id build-small-hackathon/pozify-coach-summary
+```
+
+If your Hugging Face token does not have permission to create or write under an organization
+namespace, publish to a personal repo instead:
+
+```bash
+modal run scripts/coach_summary_modal.py --stage publish-merged --repo-id <your-username>/pozify-coach-summary
+```
+
+You can also set this once in `.env`:
+
+```bash
+POZIFY_COACH_SUMMARY_MODEL=<your-username>/pozify-coach-summary
+POZIFY_COACH_SUMMARY_MERGED_HF_REPO_ID=<your-username>/pozify-coach-summary
+```
+
 Run the full pipeline end to end:
 
 ```bash
@@ -83,22 +113,27 @@ modal run scripts/coach_summary_modal.py --stage all --epochs 2 --style-weight 0
 The Modal model volume stores:
 
 - `adapter/`
+- `merged_model/`
 - `training_config.json`
 - `training_summary.json`
 - `evaluation.json`
 - `hf_upload.json`
+- `merge_summary.json`
+- `hf_merged_upload.json`
 - `README.md`
 
 ## Runtime Usage
 
-After publish, point Pozify runtime to the trained adapter by setting:
+For cloud inference in the current Pozify app, point runtime to the merged full model repo:
 
 ```bash
-export POZIFY_COACH_SUMMARY_ADAPTER_ID=build-small-hackathon/pozify-coach-summary
+export POZIFY_COACH_SUMMARY_MODEL=build-small-hackathon/pozify-coach-summary
 ```
 
-If you download the adapter locally instead, use:
+`POZIFY_COACH_SUMMARY_ADAPTER_ID` is no longer used as the remote inference target. Keep it only for adapter-centric workflows such as local merge/evaluation.
+
+If you download the merged model locally instead, use:
 
 ```bash
-export POZIFY_COACH_SUMMARY_LOCAL_MODEL_DIR=/path/to/adapter
+export POZIFY_COACH_SUMMARY_LOCAL_MODEL_DIR=/path/to/merged_model
 ```

docs/demo-video-transcript.md

@@ -0,0 +1,247 @@
+# Pozify Demo Video Transcript
+
+## Demo Concept
+
+`Pozify: The gym coach for people who would rather not be judged`
+
+## Characters
+
+- `Linh`: wants to work out, but avoids the gym
+- `Minh`: friend, funny but supportive
+- Optional `Narrator`: can be one of the two, or a voiceover
+
+## Tone
+
+- Light, relatable, slightly comedic
+- Short lines, each line reveals the pain point
+- Then pivot into a polished product demo
+
+## Total Length
+
+- Around 2.5 to 3 minutes
+
+## Script
+
+### Scene 1: The Problem
+
+`0:00 - 0:20`
+
+Visual:
+Linh stands in workout clothes at home, staring at a gym bag like it personally offended her.
+
+Minh walks in.
+
+Minh:
+"You're not going?"
+
+Linh:
+"It's too far."
+
+Beat.
+
+Minh:
+"That's not the real reason."
+
+Linh:
+"Fine. I don't want to be the girl doing squats wrong in front of twenty strangers and one guy filming his triceps."
+
+Minh:
+"Fair."
+
+Linh:
+"And a private trainer costs more than my groceries."
+
+Small beat.
+
+Minh:
+"So your fitness plan is... emotional support and denial?"
+
+Linh looks at the gym bag.
+
+Linh:
+"Currently, yes."
+
+Why this works:
+
+- `too far` = distance
+- `doing squats wrong in front of strangers` = shame / fear of judgment
+- `private trainer costs more than my groceries` = PT too expensive
+- funny but very clear target customer
+
+### Scene 2: The Reframe
+
+`0:20 - 0:35`
+
+Visual:
+Minh picks up Linh's phone.
+
+Minh:
+"What if you could train at home... and still get real feedback?"
+
+Linh:
+"From who? The front camera?"
+
+Minh:
+"From AI. But not the kind that just says 'great job' and disappears."
+
+Cut to product UI.
+
+Voiceover:
+"That's exactly why we built Pozify."
+
+### Scene 3: Product Intro
+
+`0:35 - 0:55`
+
+Visual:
+Screen recording of Pozify homepage and upload flow.
+
+Voiceover:
+"Pozify is an AI workout coach for people who want to train seriously, but don't want the cost, distance, or pressure of the gym. You upload a workout video, and Pozify turns it into a structured, explainable coaching report."
+
+Visual:
+Show progress steps:
+
+- video quality
+- pose tracking
+- exercise classification
+- rep counting
+- issue detection
+- coach summary
+
+Voiceover:
+"It doesn't just watch a video and guess. It checks video quality, tracks pose, identifies the exercise, counts reps, analyzes each rep, detects valid variations, flags real issues, and then generates a grounded coach summary."
+
+### Scene 4: The Magic
+
+`0:55 - 1:30`
+
+Visual:
+Show real squat run in the app.
+Open annotated video, issue clips, summary tab.
+
+Voiceover:
+"Here's the key difference: Pozify doesn't give generic advice like 'keep your chest up' and call it a day. It shows what exercise you did, how many reps you completed, which reps changed, what variation was valid, and what issue actually appeared."
+
+Visual:
+Highlight:
+
+- `squat`
+- rep count
+- `wide_squat_stance`
+- `shallow_depth`
+
+Voiceover:
+"In this example, Pozify recognizes a wide squat stance as a valid variation, not a mistake. But it still catches shallow depth on specific reps. So instead of overcorrecting everything, it separates style from actual form breakdown."
+
+### Scene 5: Why It's Trustworthy
+
+`1:30 - 1:55`
+
+Visual:
+Show JSON tab or artifacts view briefly.
+Show Coach tab with provider/model/source.
+
+Voiceover:
+"And we built guardrails into the system. The coach summary is generated from structured artifacts, not from vague intuition. Then a verifier checks whether the model mentioned issues outside the evidence, overcorrected a valid variation, or drifted into unsafe claims."
+
+Visual:
+Quick highlight:
+
+- evidence artifacts
+- verifier
+- fallback logic
+
+Voiceover:
+"If the model gets too creative, Pozify falls back to a safer summary. So the user gets feedback they can actually trust."
+
+### Scene 6: Sponsor Tech
+
+`1:55 - 2:15`
+
+Visual:
+Subtle overlays or callouts:
+
+- Hugging Face Spaces
+- ZeroGPU
+- Hugging Face Inference
+- Hugging Face Hub
+
+Voiceover:
+"We also leaned into the Hugging Face ecosystem to make this real. Pozify runs beautifully in Hugging Face Spaces, uses ZeroGPU for demo-ready compute, calls Hugging Face Inference for the coaching model, and loads our exercise router through Hugging Face Hub."
+
+### Scene 7: Return To Characters
+
+`2:15 - 2:40`
+
+Visual:
+Back to Linh and Minh at home.
+Linh finishes a set, checks the app, sees feedback.
+
+Minh:
+"So... no gym?"
+
+Linh:
+"No commute. No crowd. No fake confidence."
+
+Minh:
+"And no trainer bill?"
+
+Linh:
+"Exactly."
+
+Beat.
+
+Minh:
+"So now the only thing judging you... is a grounded, evidence-based AI."
+
+Linh:
+"Which is somehow less terrifying than people."
+
+They both laugh.
+
+### Scene 8: Closing Line
+
+`2:40 - 2:55`
+
+Visual:
+Product hero shot, annotated video, summary, issue clips.
+
+Voiceover:
+"Pozify is for the people who want to get stronger, but not embarrassed. For the people who want real coaching, but not gym anxiety. For the people who don't need hype. They need feedback."
+
+Final line on screen:
+`Pozify: Your coach, without the crowd.`
+
+## Why This Version Is Strong
+
+- The opening quickly locks onto the right customer:
+  - the gym is far away
+  - they feel uncomfortable in crowded spaces
+  - they are afraid of being judged for bad form
+  - one-on-one PT is too expensive
+- The dialogue is short, punchy, and easy to perform
+- It has a little humor without becoming silly
+- It transitions naturally into the product demo
+- It makes room to highlight sponsor tech
+- It ends on user emotion, not just a feature list
+
+## Optional Funnier Variations
+
+You can replace:
+
+Minh:
+"So your fitness plan is... emotional support and denial?"
+
+with:
+
+Minh:
+"So your current workout split is... anxiety, excuses, and one YouTube warm-up?"
+
+Or replace the ending with:
+
+Minh:
+"So now the only thing judging you is AI."
+
+Linh:
+"Perfect. AI doesn't smirk."

scripts/coach_summary_modal.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import json
+import inspect
 import os
 from pathlib import Path
 import shutil
@@ -11,9 +12,11 @@ import modal
 
 
 APP_NAME = "pozify-coach-summary"
-DEFAULT_HF_REPO_ID = "build-small-hackathon/pozify-coach-summary"
+DEFAULT_HF_REPO_NAME = "pozify-coach-summary"
 HF_REPO_ID_ENV = "POZIFY_COACH_SUMMARY_HF_REPO_ID"
+HF_MERGED_REPO_ID_ENV = "POZIFY_COACH_SUMMARY_MERGED_HF_REPO_ID"
 HF_PRIVATE_ENV = "POZIFY_COACH_SUMMARY_HF_PRIVATE"
+RUNTIME_MODEL_ENV = "POZIFY_COACH_SUMMARY_MODEL"
 DATA_ROOT = Path("/data")
 MODEL_ROOT = Path("/models")
 ROOT_DATA = Path("/root/data")
@@ -25,12 +28,17 @@ TRAINING_CONFIG_PATH = MODEL_ROOT / "training_config.json"
 TRAINING_SUMMARY_PATH = MODEL_ROOT / "training_summary.json"
 EVALUATION_PATH = MODEL_ROOT / "evaluation.json"
 HF_UPLOAD_PATH = MODEL_ROOT / "hf_upload.json"
+MERGE_SUMMARY_PATH = MODEL_ROOT / "merge_summary.json"
+HF_MERGED_UPLOAD_PATH = MODEL_ROOT / "hf_merged_upload.json"
 DEFAULT_ADAPTER_DIR = MODEL_ROOT / "adapter"
+DEFAULT_MERGED_DIR = MODEL_ROOT / "merged_model"
 HF_METADATA_FILENAMES = (
     "training_config.json",
     "training_summary.json",
     "evaluation.json",
     "hf_upload.json",
+    "merge_summary.json",
+    "hf_merged_upload.json",
 )
 HF_DATA_FILENAMES = (
     "coach_summary_train.jsonl",
@@ -89,7 +97,13 @@ def _load_local_env_vars(filename: str = ".env") -> dict[str, str]:
 def _hf_secret() -> modal.Secret:
     env_values = _load_local_env_vars()
     secret_payload: dict[str, str] = {}
-    for key in ("HF_TOKEN", HF_REPO_ID_ENV, HF_PRIVATE_ENV):
+    for key in (
+        "HF_TOKEN",
+        HF_REPO_ID_ENV,
+        HF_MERGED_REPO_ID_ENV,
+        HF_PRIVATE_ENV,
+        RUNTIME_MODEL_ENV,
+    ):
         value = os.getenv(key, env_values.get(key))
         if value is not None and str(value).strip():
             secret_payload[key] = str(value).strip()
@@ -135,6 +149,22 @@ def _env_truthy(value: str | None) -> bool:
     return value is not None and value.strip().lower() in {"1", "true", "yes", "on"}
 
 
+def _supports_kwarg(callable_obj: Any, name: str) -> bool:
+    try:
+        parameters = inspect.signature(callable_obj).parameters
+    except (TypeError, ValueError):
+        return False
+    return name in parameters
+
+
+def _filtered_kwargs(callable_obj: Any, kwargs: dict[str, Any]) -> dict[str, Any]:
+    try:
+        parameters = inspect.signature(callable_obj).parameters
+    except (TypeError, ValueError):
+        return dict(kwargs)
+    return {key: value for key, value in kwargs.items() if key in parameters}
+
+
 def _load_config() -> dict[str, Any]:
     config = _read_json(DEFAULT_CONFIG_PATH)
     if TRAINING_CONFIG_PATH.exists():
@@ -234,6 +264,29 @@ def _model_card_text(
     return "\n".join(lines)
 
 
+def _resolve_repo_id(
+    api: Any,
+    repo_id: str | None,
+    *,
+    env_names: tuple[str, ...] = (HF_REPO_ID_ENV,),
+) -> str:
+    if repo_id:
+        return repo_id
+    for env_name in env_names:
+        configured = os.getenv(env_name)
+        if configured:
+            return configured
+    try:
+        whoami = api.whoami()
+        if isinstance(whoami, dict):
+            username = whoami.get("name") or whoami.get("fullname")
+            if isinstance(username, str) and username.strip():
+                return f"{username.strip()}/{DEFAULT_HF_REPO_NAME}"
+    except Exception:
+        pass
+    return DEFAULT_HF_REPO_NAME
+
+
 def _verifier_inputs_from_evidence(payload: dict[str, Any]) -> tuple[Any, Any, Any, Any, Any]:
     sys.path.insert(0, "/root/src")
     from pozify.contracts import (
@@ -448,27 +501,43 @@ def train(
     )
 
     adapter_dir = MODEL_ROOT / output_subdir
-    trainer = SFTTrainer(
-        model=model,
-        tokenizer=tokenizer,
-        train_dataset=train_dataset,
-        eval_dataset=eval_dataset,
-        peft_config=peft_config,
-        dataset_text_field="text",
-        max_seq_length=int(config["max_seq_length"]),
-        args=SFTConfig(
-            output_dir=str(adapter_dir),
-            learning_rate=float(config["learning_rate"]),
-            num_train_epochs=float(config["num_train_epochs"]),
-            per_device_train_batch_size=int(config["per_device_train_batch_size"]),
-            gradient_accumulation_steps=int(config["gradient_accumulation_steps"]),
-            save_strategy="epoch",
-            eval_strategy="epoch",
-            logging_steps=10,
-            bf16=True,
-            report_to=[],
-        ),
-    )
+    sft_config_kwargs = {
+        "output_dir": str(adapter_dir),
+        "learning_rate": float(config["learning_rate"]),
+        "num_train_epochs": float(config["num_train_epochs"]),
+        "per_device_train_batch_size": int(config["per_device_train_batch_size"]),
+        "gradient_accumulation_steps": int(config["gradient_accumulation_steps"]),
+        "save_strategy": "epoch",
+        "logging_steps": 10,
+        "bf16": True,
+        "report_to": [],
+    }
+    if _supports_kwarg(SFTConfig.__init__, "eval_strategy"):
+        sft_config_kwargs["eval_strategy"] = "epoch"
+    elif _supports_kwarg(SFTConfig.__init__, "evaluation_strategy"):
+        sft_config_kwargs["evaluation_strategy"] = "epoch"
+    if _supports_kwarg(SFTConfig.__init__, "max_seq_length"):
+        sft_config_kwargs["max_seq_length"] = int(config["max_seq_length"])
+
+    trainer_kwargs: dict[str, Any] = {
+        "model": model,
+        "train_dataset": train_dataset,
+        "eval_dataset": eval_dataset,
+        "peft_config": peft_config,
+        "args": SFTConfig(**_filtered_kwargs(SFTConfig.__init__, sft_config_kwargs)),
+    }
+    if _supports_kwarg(SFTTrainer.__init__, "processing_class"):
+        trainer_kwargs["processing_class"] = tokenizer
+    elif _supports_kwarg(SFTTrainer.__init__, "tokenizer"):
+        trainer_kwargs["tokenizer"] = tokenizer
+    if _supports_kwarg(SFTTrainer.__init__, "dataset_text_field"):
+        trainer_kwargs["dataset_text_field"] = "text"
+    elif _supports_kwarg(SFTTrainer.__init__, "formatting_func"):
+        trainer_kwargs["formatting_func"] = lambda example: example["text"]
+    if _supports_kwarg(SFTTrainer.__init__, "max_seq_length"):
+        trainer_kwargs["max_seq_length"] = int(config["max_seq_length"])
+
+    trainer = SFTTrainer(**_filtered_kwargs(SFTTrainer.__init__, trainer_kwargs))
     train_result = trainer.train()
     trainer.save_model(str(adapter_dir))
     tokenizer.save_pretrained(str(adapter_dir))
@@ -640,6 +709,57 @@ def _upload_hf_file(
     }
 
 
+@app.function(
+    gpu="A10G",
+    volumes={str(MODEL_ROOT): model_volume},
+    secrets=[_hf_secret()],
+    timeout=90 * 60,
+)
+def merge(
+    adapter_subdir: str = "adapter",
+    merged_subdir: str = "merged_model",
+) -> dict[str, Any]:
+    import torch
+    from peft import PeftModel
+    from transformers import AutoModelForCausalLM, AutoTokenizer
+
+    config = _load_config()
+    adapter_dir = MODEL_ROOT / adapter_subdir
+    merged_dir = MODEL_ROOT / merged_subdir
+    if not adapter_dir.exists():
+        result = {"ok": False, "error": f"Adapter dir not found: {adapter_dir}"}
+        _write_json(MERGE_SUMMARY_PATH, result)
+        model_volume.commit()
+        return result
+
+    if merged_dir.exists():
+        shutil.rmtree(merged_dir)
+    merged_dir.mkdir(parents=True, exist_ok=True)
+
+    tokenizer = AutoTokenizer.from_pretrained(str(adapter_dir))
+    base_model = AutoModelForCausalLM.from_pretrained(
+        str(config["base_model"]),
+        torch_dtype=torch.bfloat16,
+        device_map="auto",
+        low_cpu_mem_usage=True,
+    )
+    model = PeftModel.from_pretrained(base_model, str(adapter_dir))
+    merged_model = model.merge_and_unload()
+    merged_model.save_pretrained(str(merged_dir), safe_serialization=True)
+    tokenizer.save_pretrained(str(merged_dir))
+
+    result = {
+        "ok": True,
+        "base_model": config["base_model"],
+        "adapter_dir": str(adapter_dir),
+        "merged_dir": str(merged_dir),
+        "dtype": "bfloat16",
+    }
+    _write_json(MERGE_SUMMARY_PATH, result)
+    model_volume.commit()
+    return result
+
+
 @app.function(
     volumes={str(MODEL_ROOT): model_volume, str(DATA_ROOT): data_volume},
     secrets=[_hf_secret()],
@@ -651,19 +771,21 @@ def publish_to_hf(
     adapter_subdir: str = "adapter",
 ) -> dict[str, Any]:
     from huggingface_hub import HfApi
+    from huggingface_hub.errors import HfHubHTTPError
 
-    repo_id = repo_id or os.getenv(HF_REPO_ID_ENV) or DEFAULT_HF_REPO_ID
     private = _env_truthy(os.getenv(HF_PRIVATE_ENV)) if private is None else private
     if not os.getenv("HF_TOKEN"):
         return {
             "ok": False,
             "error": "HF_TOKEN is required in the Modal environment or local .env",
-            "repo_id": repo_id,
+            "repo_id": repo_id or os.getenv(HF_REPO_ID_ENV) or DEFAULT_HF_REPO_NAME,
         }
 
     config = _read_json(TRAINING_CONFIG_PATH) if TRAINING_CONFIG_PATH.exists() else {}
     training_summary = _read_json(TRAINING_SUMMARY_PATH) if TRAINING_SUMMARY_PATH.exists() else None
     evaluation = _read_json(EVALUATION_PATH) if EVALUATION_PATH.exists() else None
+    api = HfApi()
+    repo_id = _resolve_repo_id(api, repo_id, env_names=(HF_REPO_ID_ENV,))
     MODEL_CARD_PATH.write_text(
         _model_card_text(
             repo_id=repo_id,
@@ -674,8 +796,23 @@ def publish_to_hf(
         encoding="utf-8",
     )
 
-    api = HfApi()
-    api.create_repo(repo_id=repo_id, repo_type="model", private=private, exist_ok=True)
+    try:
+        api.create_repo(repo_id=repo_id, repo_type="model", private=private, exist_ok=True)
+    except HfHubHTTPError as exc:
+        message = str(exc)
+        guidance = (
+            "Publish failed while creating or accessing the Hugging Face model repo. "
+            "If your token does not have org-level write access, publish to a personal repo id "
+            "such as `<your-username>/pozify-coach-summary`, or set "
+            f"`{HF_REPO_ID_ENV}` in `.env` to a repo you control."
+        )
+        return {
+            "ok": False,
+            "repo_id": repo_id,
+            "private": private,
+            "error": message,
+            "guidance": guidance,
+        }
     uploads = [
         _upload_hf_file(
             api,
@@ -729,6 +866,132 @@ def publish_to_hf(
     return result
 
 
+@app.function(
+    volumes={str(MODEL_ROOT): model_volume, str(DATA_ROOT): data_volume},
+    secrets=[_hf_secret()],
+    timeout=60 * 60,
+)
+def publish_merged_to_hf(
+    repo_id: str | None = None,
+    private: bool | None = None,
+    merged_subdir: str = "merged_model",
+) -> dict[str, Any]:
+    from huggingface_hub import HfApi
+    from huggingface_hub.errors import HfHubHTTPError
+
+    private = _env_truthy(os.getenv(HF_PRIVATE_ENV)) if private is None else private
+    resolved_repo_hint = (
+        repo_id
+        or os.getenv(RUNTIME_MODEL_ENV)
+        or os.getenv(HF_MERGED_REPO_ID_ENV)
+        or DEFAULT_HF_REPO_NAME
+    )
+    if not os.getenv("HF_TOKEN"):
+        return {
+            "ok": False,
+            "error": "HF_TOKEN is required in the Modal environment or local .env",
+            "repo_id": resolved_repo_hint,
+        }
+
+    config = _read_json(TRAINING_CONFIG_PATH) if TRAINING_CONFIG_PATH.exists() else {}
+    training_summary = _read_json(TRAINING_SUMMARY_PATH) if TRAINING_SUMMARY_PATH.exists() else None
+    evaluation = _read_json(EVALUATION_PATH) if EVALUATION_PATH.exists() else None
+    merge_summary = _read_json(MERGE_SUMMARY_PATH) if MERGE_SUMMARY_PATH.exists() else None
+    merged_dir = MODEL_ROOT / merged_subdir
+    if not merged_dir.exists():
+        result = {
+            "ok": False,
+            "error": f"Merged model dir not found: {merged_dir}",
+            "repo_id": resolved_repo_hint,
+        }
+        _write_json(HF_MERGED_UPLOAD_PATH, result)
+        model_volume.commit()
+        return result
+
+    api = HfApi()
+    repo_id = _resolve_repo_id(
+        api,
+        repo_id,
+        env_names=(RUNTIME_MODEL_ENV, HF_MERGED_REPO_ID_ENV, HF_REPO_ID_ENV),
+    )
+
+    MODEL_CARD_PATH.write_text(
+        _model_card_text(
+            repo_id=repo_id,
+            config=config,
+            training_summary=training_summary,
+            evaluation=evaluation,
+        )
+        + "\n## Packaging\n\n- Published as a merged, inference-ready Transformers checkpoint.\n",
+        encoding="utf-8",
+    )
+
+    try:
+        api.create_repo(repo_id=repo_id, repo_type="model", private=private, exist_ok=True)
+    except HfHubHTTPError as exc:
+        message = str(exc)
+        guidance = (
+            "Publish failed while creating or accessing the merged Hugging Face model repo. "
+            "Set `POZIFY_COACH_SUMMARY_MODEL` or pass `--repo-id <your-username>/pozify-coach-summary` "
+            "to publish to a repo your token can write to."
+        )
+        result = {
+            "ok": False,
+            "repo_id": repo_id,
+            "private": private,
+            "error": message,
+            "guidance": guidance,
+        }
+        _write_json(HF_MERGED_UPLOAD_PATH, result)
+        model_volume.commit()
+        return result
+
+    api.upload_folder(
+        repo_id=repo_id,
+        repo_type="model",
+        folder_path=str(merged_dir),
+    )
+
+    uploads = [
+        {
+            "path": str(merged_dir),
+            "path_in_repo": "./",
+            "uploaded": True,
+        },
+        _upload_hf_file(
+            api,
+            repo_id=repo_id,
+            local_path=MODEL_CARD_PATH,
+            path_in_repo="README.md",
+        ),
+    ]
+    uploads.extend(
+        _upload_hf_file(
+            api,
+            repo_id=repo_id,
+            local_path=MODEL_ROOT / filename,
+            path_in_repo=filename,
+        )
+        for filename in (
+            "training_config.json",
+            "training_summary.json",
+            "evaluation.json",
+            "merge_summary.json",
+        )
+    )
+
+    result = {
+        "ok": True,
+        "repo_id": repo_id,
+        "private": private,
+        "merge_summary": merge_summary,
+        "uploads": uploads,
+    }
+    _write_json(HF_MERGED_UPLOAD_PATH, result)
+    model_volume.commit()
+    return result
+
+
 @app.local_entrypoint()
 def main(
     stage: str = "evaluate",
@@ -744,14 +1007,19 @@ def main(
         print(train.remote(epochs=epochs, style_weight=style_weight))
     elif stage == "evaluate":
         print(evaluate.remote(limit=limit))
+    elif stage == "merge":
+        print(merge.remote())
     elif stage == "publish":
         print(publish_to_hf.remote(repo_id=repo_id, private=private))
+    elif stage == "publish-merged":
+        print(publish_merged_to_hf.remote(repo_id=repo_id, private=private))
     elif stage == "all":
         print(prepare_data.remote())
         print(train.remote(epochs=epochs, style_weight=style_weight))
         print(evaluate.remote(limit=limit))
-        print(publish_to_hf.remote(repo_id=repo_id, private=private))
+        print(merge.remote())
+        print(publish_merged_to_hf.remote(repo_id=repo_id, private=private))
     else:
         raise ValueError(
-            "stage must be one of: prepare-data, train, evaluate, publish, all"
+            "stage must be one of: prepare-data, train, evaluate, merge, publish, publish-merged, all"
         )

scripts/train_coach_summary_lora.py

@@ -11,7 +11,7 @@ sys.path.insert(0, str(ROOT / "src"))
 
 
 DEFAULT_CONFIG = {
-    "base_model": "Qwen/Qwen2.5-7B-Instruct",
+    "base_model": "Qwen/Qwen3-14B",
     "train_file": str(ROOT / "data/sft/coach_summary_train.jsonl"),
     "eval_file": str(ROOT / "data/sft/coach_summary_eval.jsonl"),
     "output_dir": str(ROOT / "models/coach_summary_lora"),

tests/test_coach_summary.py

@@ -56,7 +56,7 @@ class _GoodModel:
                 '"confidence_notes":["Confidence is limited."]}'
             ),
             provider="hf_inference",
-            model="Qwen/Qwen2.5-7B-Instruct",
+            model="Qwen/Qwen3-14B",
         )
 
 
@@ -159,7 +159,7 @@ class CoachSummaryTests(unittest.TestCase):
         with tempfile.TemporaryDirectory() as temp_dir:
             env_path = Path(temp_dir) / ".env"
             env_path.write_text(
-                "HF_TOKEN=test-token\nPOZIFY_COACH_SUMMARY_MODEL=Qwen/Qwen2.5-7B-Instruct\n",
+                "HF_TOKEN=test-token\nPOZIFY_COACH_SUMMARY_MODEL=Qwen/Qwen3-14B\n",
                 encoding="utf-8",
             )
             with patch.dict(os.environ, {}, clear=True):
@@ -173,7 +173,7 @@ class CoachSummaryTests(unittest.TestCase):
                 self.assertEqual(os.getenv("HF_TOKEN"), "test-token")
                 self.assertEqual(
                     os.getenv("POZIFY_COACH_SUMMARY_MODEL"),
-                    "Qwen/Qwen2.5-7B-Instruct",
+                    "Qwen/Qwen3-14B",
                 )
 
     def test_get_coach_summary_model_can_use_local_transformers_provider(self) -> None:
@@ -414,7 +414,7 @@ class CoachSummaryTests(unittest.TestCase):
         )
 
         self.assertEqual(result.provider, "hf_inference")
-        self.assertEqual(result.model, "Qwen/Qwen2.5-7B-Instruct")
+        self.assertEqual(result.model, "Qwen/Qwen3-14B")
         self.assertEqual(result.source, "model_or_local")
 
     def test_verifier_rejects_issue_not_in_json(self) -> None:

tests/test_pipeline_contracts.py

@@ -359,7 +359,7 @@ class PipelineContractTests(unittest.TestCase):
                 return_value=CoachSummaryResult(
                     summary=model_summary,
                     provider="hf_inference",
-                    model="Qwen/Qwen2.5-7B-Instruct",
+                    model="Qwen/Qwen3-14B",
                     source="model_or_local",
                 ),
             ),
@@ -389,7 +389,7 @@ class PipelineContractTests(unittest.TestCase):
         self.assertEqual(report["artifacts"]["coach_summary_provider"], "hf_inference")
         self.assertEqual(
             report["artifacts"]["coach_summary_model"],
-            "Qwen/Qwen2.5-7B-Instruct",
+            "Qwen/Qwen3-14B",
         )
         self.assertTrue(report["artifacts"]["coach_summary_verifier_bypassed"])
         self.assertFalse(report["verification"]["passed"])

tests/test_slm_providers.py

@@ -21,7 +21,7 @@ class SlmProviderTests(unittest.TestCase):
             os.environ,
             {
                 "POZIFY_COACH_SUMMARY_LOCAL_MODEL_DIR": "/tmp/local-model",
-                "POZIFY_COACH_SUMMARY_BASE_MODEL": "Qwen/Qwen2.5-7B-Instruct",
+                "POZIFY_COACH_SUMMARY_BASE_MODEL": "Qwen/Qwen3-14B",
                 "POZIFY_COACH_SUMMARY_ADAPTER_ID": "pozify/coach-summary-lora",
             },
             clear=True,
@@ -34,7 +34,7 @@ class SlmProviderTests(unittest.TestCase):
         with patch.dict(
             os.environ,
             {
-                "POZIFY_COACH_SUMMARY_MODEL": "Qwen/Qwen2.5-7B-Instruct",
+                "POZIFY_COACH_SUMMARY_MODEL": "Qwen/Qwen3-14B",
             },
             clear=True,
         ):
@@ -42,10 +42,11 @@ class SlmProviderTests(unittest.TestCase):
 
         self.assertIsInstance(model, HFInferenceCoachSummaryModel)
 
-    def test_remote_model_prefers_adapter_repo_when_present(self) -> None:
+    def test_remote_model_uses_runtime_model_not_adapter_repo(self) -> None:
         with patch.dict(
             os.environ,
             {
+                "POZIFY_COACH_SUMMARY_MODEL": "build-small-hackathon/pozify-coach-summary",
                 "POZIFY_COACH_SUMMARY_ADAPTER_ID": "pozify/coach-summary-lora",
             },
             clear=True,
@@ -53,7 +54,20 @@ class SlmProviderTests(unittest.TestCase):
             model = get_coach_summary_model()
 
         self.assertIsInstance(model, HFInferenceCoachSummaryModel)
-        self.assertEqual(model.model, "pozify/coach-summary-lora")
+        self.assertEqual(model.model, "build-small-hackathon/pozify-coach-summary")
+
+    def test_remote_model_falls_back_to_default_when_only_adapter_repo_is_set(self) -> None:
+        with patch.dict(
+            os.environ,
+            {
+                "POZIFY_COACH_SUMMARY_ADAPTER_ID": "pozify/coach-summary-lora",
+            },
+            clear=True,
+        ):
+            model = get_coach_summary_model()
+
+        self.assertIsInstance(model, HFInferenceCoachSummaryModel)
+        self.assertEqual(model.model, "Qwen/Qwen3-14B")
 
 
 if __name__ == "__main__":