"What is the deliverable of Capstone 1 (The Air-Gapped Domain Model)?"	"A reproducible end-to-end pipeline, shipped as a GitHub README asset: open-data base -> HIPAA-safe data prep -> QLoRA fine-tune -> eval -> GGUF export -> local serve (Ollama/llama.cpp). Domain is student's choice (medical/legal/security). Must run on a single consumer GPU or Apple Silicon, fully local, zero telemetry."	c3::cap1::recall
"Name the three success criteria for Capstone 1."	"(1) DOMAIN LIFT — fine-tuned measurably outperforms base on a held-out domain eval (+3 to +15 pts, non-trivial). (2) LOCAL SERVE — GGUF loads via Ollama/llama.cpp, generates fine-tuned behavior, no telemetry confirmed. (3) REPRODUCIBILITY — clone -> one command -> your numbers within tolerance (pinned deps, set seeds, numbers in README)."	c3::cap1::recall
"Name the seven phases of the Capstone 1 pipeline, bottom to top."	"(1) Choose domain + open-data base. (2) HIPAA-safe data prep. (3) QLoRA fine-tune + merge. (4) Eval (domain held-out + general benchmark). (5) GGUF export. (6) Local serve (Ollama/llama.cpp). (7) Reproducibility package (README + pinned deps + one-command run)."	c3::cap1::recall
"Why must the base model be open-data (not just open-weights) for this capstone?"	"Open-data means you get the training corpus, so you can AUDIT what the model saw. This is the foundation of the HIPAA-safety argument for sensitive domains. Open-weights-only (e.g., Llama 3.x) means you trust the publisher's word — acceptable only with explicit justification, never the default."	c3::cap1::application
"What does 'domain lift' measure, and what is the pass bar?"	"Lift = fine-tuned score MINUS base score on a held-out domain evaluation. Pass bar: a positive, non-trivial lift, typically +3 to +15 points depending on task/metric. A lift of +0.3 is noise; +0.0 is a failed fine-tune. The lift must come from steering (generalization), proven by the held-out set being truly held out."	c3::cap1::application
"What does 'forgetting' measure, and why is it required alongside lift?"	"Forgetting = base score MINUS fine-tuned score on a GENERAL benchmark (MMLU/GSM8K). Required because a +15 lift with -10 on GSM8K means the fine-tune traded away reasoning to get domain style — it steered too hard. The forgetting number is the discipline check; without it, the lift is uninterpretable. A submission with only domain lift is incomplete."	c3::cap1::analysis
"What is the pass bar for forgetting, and what does exceeding it indicate?"	"Negligible forgetting is <2 points. >5 points means the fine-tune was too aggressive (too many epochs, too high a learning rate) and traded away capability you should have kept. It's not necessarily a fail, but it must be explicitly discussed with a mitigation in the README."	c3::cap1::analysis
"Why is the air-gap a property of the WHOLE pipeline, not a deployment feature?"	"If ANY phase (data prep, training, eval, export, serve) touches the network, the air-gap claim is false. You cannot 'add air-gap later.' Every phase must be local: local data, local GPU/MPS, local eval, local GGUF conversion, local serve. The proof is verification (run with network off, or tcpdump)."	c3::cap1::analysis
"What is the HIPAA-safety rule for the data prep phase, and what are the two acceptable sources?"	"No real PHI. Two sources: (1) OPEN DATASETS — PubMedQA, MedMCQA, LegalBench, security advisory corpora (public, de-identified by construction). (2) SYNTHETIC DATA (FT05) — generate domain examples with a teacher (Distilabel/Magpie), then dedup and decontaminate (FT06). The recipe must be publishable — if you can't publish the data prep, you can't prove it was HIPAA-safe."	c3::cap1::application
"What is the evaluation rubric's passing threshold, and which dimension is a gate?"	"Passing = 12/15 or higher, with NO dimension below 2. HIPAA-safety is a GATE — a score of 1 fails the submission regardless of the total. The five dimensions: domain lift, forgetting control, local serve, reproducibility, HIPAA-safety."	c3::cap1::recall
"Why must the LoRA adapter be MERGED into the base before GGUF export?"	"GGUF export expects a single merged model, not a separate adapter. merge_and_unload() folds the adapter (Layer 2) into the base (Layer 1), producing a standalone model (Layers 1+2 fused) ready for export (Layer 4). A common mistake: skipping the merge and trying to quantize the adapter separately, which fails."	c3::cap1::application
"What does the three-outcome test (FT00) tell you about domain choice for this capstone?"	"You must pick a domain where the base already has the CAPABILITY (it saw medical/legal/security text in pretraining) but not the BEHAVIOR (doesn't reliably format clinical differentials, cite statutes, etc.). That's outcome 1 — achievable but unreliable -> fine-tune with SFT. If the base genuinely doesn't know the domain, fine-tuning won't help; you need RAG or a different base."	c3::cap1::analysis
"What are the two datasets that Phase 2 (data prep) must produce, and why?"	"TRAIN (what you fine-tune on) and HELD_OUT (what you evaluate on, NEVER seen during training). The held-out set is the test of generalization vs memorization: if your lift vanishes on held-out, you memorized the training set, you did not steer. Both must have documented provenance."	c3::cap1::application
"How do you verify the served model is your fine-tune, not the base?"	"Run a domain prompt through the SERVED model (Ollama/llama.cpp) and through the HF fine-tuned model and COMPARE. A frequent failure: the GGUF that loads is the base's GGUF, not your merged-and-quantized one. The served model must exhibit your steering (same format, same domain style), not the base's default."	c3::cap1::application
"What does 'reproducibility' concretely require in the submission?"	"Pinned dependencies (exact versions + CUDA/torch wheel + OS), one-command run (make pipeline or run_pipeline.py), deterministic-ish training (set seeds, re-run within +-2 pts of reported numbers), and the NUMBERS in the README (base, fine-tuned, lift, forgetting, latency). Wild variance (+-15 pts on re-run) means the fine-tune is unstable — report it, don't hide it."	c3::cap1::recall
"What is the default GGUF quantization for local serve, and when would you deviate?"	"Q4_K_M is the default — good quality, small footprint. Deviate to Q8_0 if you have the RAM and want minimal loss; to Q3 if severely constrained and you accept the quality hit. Document the choice and the reasoning. Always verify the GGUF loads before declaring the phase done — load failures often come from chat-template mismatches (FT07)."	c3::cap1::application
"Why is a 'notebook only' submission a failure, regardless of the results?"	"A notebook with no pipeline, no pinned deps, and no README with numbers is a RESULT, not a DELIVERABLE. The capstone deliverable is the reproducible pipeline that produced the result. A reviewer cannot clone a notebook and reproduce your numbers — the pipeline, pinned deps, and one-command run are what convert a result into a portfolio asset."	c3::cap1::analysis
"How does this capstone operationalize the course thesis (fine-tuning steers, not teaches)?"	"The held-out domain eval tests it directly: if fine-tuning were injecting knowledge, the held-out lift would be large and forgetting small. If it's steering behavior, the lift is real but bounded, and you measure the cost (forgetting). The dual eval (lift + forgetting) IS the thesis made testable — steering gains generalize (held-out lifts), knowledge-injection memorizes (held-out flat)."	c3::cap1::analysis
"What is the relationship between Capstone 1 and Pillars P00-P06?"	"CAP1 is the INTEGRATION of P00-P06. P00 gave the base + mental model; P01 gave data discipline (the steering wheel); P02 gave QLoRA (the cheap swappable steer); P03 gave the eval mindset; P06 gave quantization + serving. CAP1 chains them into one pipeline. The property no individual module could prove alone: reproducibility under air-gap."	c3::cap1::analysis
"What four things characterize a failing submission?"	"(1) Notebook only — no pipeline, no pinned deps, no README with numbers. (2) Lift without forgetting — domain lift reported but no general benchmark, so the trade-off is unknown. (3) Serve that needs the network — air-gap claim is false, fails the HIPAA gate. (4) Unjustified closed base — Llama 3.x 'because it's better' without the auditability argument."	c3::cap1::analysis
"Why is the air-gap verified rather than assumed, and how?"	"Because telemetry is often invisible — a serve stack may phone home for updates, telemetry, or model checks without obvious behavior. Verification: run the serve with the NETWORK OFF (if it still serves, you have the property), or run tcpdump / a firewall log on a clean run and confirm zero outbound calls. The air-gap is a falsifiable claim; you test it."	c3::cap1::analysis
"What is the synthesis principle this capstone sets up for Capstone 2?"	"CAP1 builds a model that is air-gapped and domain-steered (safe, local, auditable). CAP2 is the synthesis: the same pipeline skills applied to an UNCENSORED model WRAPPED IN AN EVAL'D HARNESS. The skills transfer; the domain shifts from 'air-gapped and domain-steered' to 'uncensored and harness-bounded' — the bridge to the Harness Engineering courses."	c3::cap1::analysis