"What is SFT and what is its role in the post-training stack?"	"SFT (Supervised Fine-Tuning) trains an instruct model on (input, target-output) pairs to steer format, style, instruction-following, tool-call formatting, and refusal calibration. It is stage 1 of the modern post-training stack (SFT → DPO → GRPO) — the baseline of alignment that every subsequent method builds on. It steers behavior; it does not inject knowledge."	c3::ft12::recall
"What can SFT do, and what can it NOT do?"	"SFT CAN steer format, style, instruction-following, tool-call formatting, and refusal calibration — making reliable what the base could already do unreliably. It CANNOT inject knowledge: fine-tuning on documents to 'teach' content produces surface-pattern memorization that fails out-of-distribution. For knowledge, use RAG; for genuine adaptation, rarely continued pretraining. This is the FT00 thesis restated for Layer 3."	c3::ft12::recall
"What is the FT00-thesis test for whether a behavior is an SFT problem?"	"If the base model, given a perfect prompt, could already produce the target behavior unreliably or in the wrong format — that's a steering/SFT problem (~90% of real fine-tuning). If it could not produce the behavior at all, no amount of SFT will reliably get you there — you need a different base, continued pretraining, or (usually) RAG."	c3::ft12::recall
"What are the typical mixture ratios for a production SFT dataset, and what does each source cover?"	"General instruction-following 40-50% (Magpie/teacher distillation — the substrate). Domain examples 30-40% (your use cases — where domain lift comes from). Tool-use formatting 5-10% (exact tool-call schema). Safety calibration 5-10% (refusals + compliance). The mix encodes what you want the model to be; too much of one source skews it predictably."	c3::ft12::recall
"What is the modern post-training stack, and why is SFT always stage 1?"	"SFT → DPO → (GRPO for reasoning). SFT is stage 1 because it gives the later stages substrate: DPO assumes the model already produces plausible responses in the right format (it just ranks them); GRPO assumes the model already produces candidate solutions (it just rewards correct ones). Skip SFT and the preference/reasoning stages have nothing to refine."	c3::ft12::recall
"What are the three SFT failure modes, and what causes each?"	"(1) Catastrophic forgetting — caused by too-narrow data (pure domain/tool/safety); the model loses general capability. (2) Mode collapse — caused by low-diversity data; every output converges to one style/structure. (3) Format leakage — caused by template bugs (FT07); the model learns a format that breaks in production. All three are steering failures, not knowledge failures."	c3::ft12::recall
"What is catastrophic forgetting in SFT, and how is it mitigated?"	"The model trains on a too-narrow distribution and loses general capability — domain metrics go up, general benchmarks go down. Mitigations: (1) mix general data into the SFT set (the 40-50% general source); (2) prefer LoRA, which forgets less than full FT because low-rank adapters cannot move enough parameters to forget aggressively. This is the same mechanism as CPT's mixture-of-source/replay training."	c3::ft12::application
"What is mode collapse, how do you spot it, and how do you fix it?"	"Mode collapse: low-diversity training data causes every output to converge to one style (every response starts the same, same structure, same length). Spot it: every generation looks identical regardless of input; n-gram/embedding diversity metrics collapse. Fix: diversity filtering (FT06 — semantic dedup, diversity sampling to maximize embedding spread), mix sources, and don't over-train (collapse worsens past convergence)."	c3::ft12::application
"What is format leakage, what is its signature, and how is it prevented?"	"Format leakage: the chat/tool template applied in training differs from what the inference harness applies, so the model learns a format that breaks in production (the FT07 failure at the alignment layer). Signature: fluent, confident output the harness can't parse — invalid JSON, wrong tool-call fields, cutoff responses from a wrong EOS. Prevention: use the model's tokenizer chat template (TRL does this via dataset_text_field='messages'); test the round-trip (apply, tokenize, decode, compare to inference); hand-craft tool examples in the EXACT harness schema."	c3::ft12::application
"What is the rule for when to stop at SFT versus escalate to DPO (FT13)?"	"SFT is enough when there is a single correct response (one right answer per input — the correct tool call, the right JSON, the desired summary). Escalate to DPO when you need to express 'better versus worse' between multiple plausible responses (more concise, less verbose, better cited). SFT trains on (input, target) pairs; DPO trains on (input, preferred, rejected) triples — it shows the model a direction, not a single target."	c3::ft12::application
"How do you tell whether your task needs SFT, DPO, or GRPO?"	"Ask: is there one right answer, or several acceptable answers with a quality ordering? One right answer ('return this JSON') → SFT. Several acceptable with a preference ('be concise, cite sources, be helpful') → SFT to establish format, then DPO to refine preference. Reasoning with checkable answers ('solve this math; correct gets rewarded') → SFT then GRPO (FT14). Most pipelines do SFT first and escalate only if a quality gap remains that a later stage could close."	c3::ft12::application
"What three evals matter for an SFT run, and what does each detect?"	"(1) General benchmarks (MMLU, MT-Bench, AlpacaEval) — detect catastrophic forgetting (compare to base; if they dropped, add general data). (2) Domain eval — held-out domain (input, ideal-output) pairs scored by exact match/BLEU/LLM judge; this is the domain lift, the point of the fine-tune. (3) Format compliance — does the model emit valid JSON/parseable tool calls at the needed rate? A model with great prose in the wrong format is a production failure."	c3::ft12::application
"What is the cardinal data rule for SFT, and what evidence supports it?"	"Curation beats volume: a 2,000-example set you actually read and curated will steer better than 50,000 raw outputs you did not look at. Evidence: LIMA (~1k curated examples aligned a model, arXiv:2305.11206), Magpie (filtered 300K from 1M raw beat the unfiltered pile), and the whole Pillar 1 arc. People believe scale-of-data is the lever; it is scale-of-curation."	c3::ft12::application
"What is continued pretraining (CPT), and why is it the exception to 'steering not teaching'?"	"CPT takes the base and keeps pretraining it (next-token prediction on a large corpus) to shift its KNOWLEDGE distribution toward a domain. It is the one Layer 3 technique that genuinely adapts rather than steers — it moves the model on the knowledge axis. Everything else in Layer 3 (SFT, DPO, GRPO, abliteration) moves only the behavior axis. CPT is de-emphasized because it is expensive, finicky, and for most use cases RAG or domain SFT is the better answer."	c3::ft12::analysis
"What is the plasticity-stability dilemma, and what are its mitigations in CPT?"	"The CPT tension: to learn the new domain (plasticity) the model must change weights, but changing weights risks destroying existing knowledge (stability) — catastrophic forgetting is the failure. Mitigations, in order of effectiveness: (1) mixture-of-source/replay training — mix domain with general tokens at 1:1 to 2:1, replaying general to anchor it; (2) low-perplexity token filtering (NeurIPS 2025) — train on the informative middle of the perplexity distribution; (3) small LR with warmup/cooldown — large LRs move weights too fast and forget."	c3::ft12::analysis
"What is mixture-of-source/replay training, and how does it connect to the SFT general-data mix?"	"In CPT, mix domain tokens with general tokens at roughly 1:1 to 2:1 (domain:general). The general tokens REPLAY what the model knew, anchoring it while the domain tokens shift it — the single most effective anti-forgetting technique. The connection: the SFT general-data mix (the 40-50% general source that prevents catastrophic forgetting in SFT) is the SAME mechanism at fine-tuning scale. Replay general data alongside domain data so the model does not collapse onto the narrow distribution."	c3::ft12::analysis
"When should you choose CPT over SFT, and why is CPT usually the wrong answer?"	"Choose CPT only when: you need the model to KNOW a substantial new domain it currently does poorly on (genuine knowledge gap), AND RAG cannot provide that knowledge at inference, AND you have a large domain corpus + the budget to do it right. Usually the wrong answer because: for BEHAVIOR (format, style, tools, refusal) SFT is the tool; for KNOWLEDGE RAG is usually better, cheaper, and revisable without retraining. Most practitioners need domain SFT/LoRA, not CPT."	c3::ft12::analysis
"What happens if your SFT mix has too much of each individual source?"	"Too much general → domain lift evaporates (you retrained the model to be the generic assistant it already was). Too much domain → catastrophic forgetting, the model becomes a specialist that lost general capability. Too much tool-use → format leaks into everything (tool calls on plain questions). Too much safety → refusal-happy, declining reasonable requests. The mix encodes what you want the model to be; imbalance has a visible, predictable signature."	c3::ft12::analysis
"A team fine-tunes on 100% medical Q&A. Domain accuracy rises 15%, but MMLU drops 12% and the model writes worse code than the base. What happened and what's the fix?"	"Catastrophic forgetting from too-narrow data (failure mode 1). Training on pure domain shifted the model's behavioral disposition onto the narrow distribution, away from general capability — the knowledge didn't leave the weights (FT00) but the disposition collapsed. Fix: mix general data into the SFT set (raise the general source toward 40-50%); prefer LoRA over full FT (low-rank forgets less); re-eval to confirm general benchmarks recover while domain lift holds."	c3::ft12::analysis
"You fine-tune and the loss curve is healthy, but in production the model emits tool calls with the wrong field names and your harness fails to parse them. The base model produced the right format. What happened and how do you prevent it?"	"Format leakage (failure mode 3, the FT07 failure at the alignment layer). The training examples used a tool-call schema that differs from what the inference harness parses — the model learned a format that works in training and breaks in production. The loss curve looked fine because the model learned A format, just not THE format. Prevent it: use the model's tokenizer chat template; hand-craft tool examples in the EXACT schema the harness parses; test the round-trip (tokenize, decode, compare to the inference path) before training."	c3::ft12::analysis
"Why does LoRA mitigate catastrophic forgetting more than full FT on the same narrow data?"	"LoRA injects low-rank trainable matrices (under 1% of params) while the base is frozen. Because the adapter is low-rank, it can only move the model within a low-dimensional subspace — it physically cannot shift enough parameters to forget as aggressively as full FT, which updates every weight. This is a consequence of the FT00 thesis (fine-tuning is steering, and steering is low-rank). It is one reason LoRA is the default for SFT, especially when the data is domain-narrow."	c3::ft12::analysis
"Why is SFT called 'the baseline' of alignment?"	"Because every subsequent alignment method builds on top of the SFT'd model. DPO (FT13) refines preferences — it assumes the model already produces plausible responses in the right format and just ranks them. GRPO (FT14) sharpens reasoning — it assumes the model already produces candidate solutions and just rewards correct ones. SFT is the stage that establishes the format, style, and basic behavior those refinements operate on. Skip SFT and the later stages have no substrate. 'Baseline' = the foundation, not the afterthought."	c3::ft12::analysis
"What is domain lift, and why is it the headline metric of an SFT project?"	"Domain lift is the improvement on a held-out domain-specific eval after SFT — the whole point of the fine-tune. You measure it by scoring the fine-tuned model vs the base on held-out domain (input, ideal-output) pairs (exact match, BLEU/ROUGE, or an LLM judge). If it did not go up, the SFT did not work for its purpose, no matter how good the loss curve looked. It is reported alongside general-capability change (forgetting) and format compliance in the three-axis SFT eval report."	c3::ft12::application
"In the lab, why do you hold out a separate domain eval split that is NEVER trained on, instead of using eval-during-training?"	"So the domain-lift measurement in Phase 4 is honest. If the domain eval set were seen during training (even as an eval_dataset the trainer touches), you cannot trust the lift number — the model may have leakily fit it. Holding out a pristine 100-example domain split, used ONLY for the final base-vs-FT comparison, guarantees the lift reflects genuine generalization to unseen domain examples, not memorization of the eval set. This is the FT11 eval obligation, applied with extra discipline because the domain lift is the deliverable."	c3::ft12::analysis