"What is the central decision rule of FT10?"	"Default to PEFT for ~95% of production adaptation. Full fine-tuning must justify a ~30x cost premium AND demonstrate that PEFT provably cannot reach the target. The exception must defend itself, not the default."	c3::ft10::recall
"What is the cost asymmetry between PEFT and full FT for a 7B-class model?"	"QLoRA on a 7B runs on a single ~$1,500 RTX 4090 and trains in an evening. Full FT of a 7B typically needs a multi-GPU node (H100-class) and tens of thousands of dollars of compute. That is on the order of a 30x difference in hardware cost for the majority of adaptation tasks where both reach equivalent quality."	c3::ft10::recall
"Name the three conditions that genuinely push a project toward full fine-tuning."	"(1) Injecting genuinely NEW reasoning pathways the base cannot produce (not activating existing ones). (2) Extreme domain shift requiring new knowledge the base lacks — the rare case where RAG is structurally insufficient. (3) Large batch sizes where LoRA degrades faster than full FT (per arXiv:2410.21228). Each is rare; each must be checked, not assumed."	c3::ft10::recall
"What did Shuttleworth et al. (arXiv:2410.21228, 'An Illusion of Equivalence') find about LoRA vs full FT?"	"LoRA and full FT produce STRUCTURALLY DIFFERENT weight matrices (shown via singular value decomposition). They are NOT approximations of each other. LoRA finds a low-rank steering solution; full FT finds a higher-rank solution. They can reach similar benchmark behavior via different geometry. This makes the choice a DESIGN decision, not a cost decision."	c3::ft10::recall
"What are 'intruder dimensions' (Shuttleworth et al.)?"	"Spurious directions introduced during LoRA training — especially at low ranks and suboptimal hyperparameters — that correlate strongly with catastrophic forgetting. This is actionable guidance for configuring PEFT: avoid very small ranks, use alpha = 2 * rank, prefer DoRA. The finding sharpens PEFT config; it does not invalidate PEFT."	c3::ft10::recall
"What is GaLore, and where does it sit in the decision?"	"Gradient Low-Rank Projection (Zhao et al., arXiv:2403.03507). Instead of constraining the WEIGHTS to low rank (LoRA), it projects the OPTIMIZER's gradient state to low rank via periodic SVD. Result: full-parameter learning (higher-rank solution) at near-LoRA memory — 7B on a single 24GB GPU. It is THE BRIDGE: full-FT quality on a PEFT-class node, for when you need full-FT geometry but have limited memory."	c3::ft10::recall
"State the escalation ladder from cheapest to most expensive."	"PEFT (LoRA/QLoRA) -> DoRA / higher-rank PEFT -> GaLore (full-FT quality, PEFT memory) -> Full FT (when memory is no constraint). Escalate ONE RUNG AT A TIME WITH EVIDENCE. Do not start at full FT because 'we'll probably need it eventually.'"	c3::ft10::recall
"Why does the steering thesis (FT00) make PEFT the default, not just the budget option?"	"If fine-tuning is steering (not teaching), the useful change lives in a low-rank subspace (intrinsic dimension). For a steering task — format, style, instruction, preference, refusal — a low-rank update is not a compromise; it is the CORRECT representation of the change. When the task is steering, full FT is over-parameterized, not more powerful — it has more room to drift, forget, and fit noise."	c3::ft10::analysis
"Why is 'defaulting to full FT because it's better' an anti-pattern?"	"Full FT is NOT uniformly better. For pure steering it is over-parameterized (more degrees of freedom than the task needs), more prone to catastrophic forgetting, and ~30x the cost. The structural non-equivalence finding cuts both ways: LoRA's low-rank solution is the CORRECT representation for steering. Full FT must be justified by evidence the task is higher-rank, not assumed 'for quality.'"	c3::ft10::analysis
"How does the structural non-equivalence finding change the framing of the decision?"	"It turns the choice from a COST decision into a DESIGN decision. If LoRA and full FT were approximations of each other, the only question would be budget. Because they are structurally distinct solutions with different generalization profiles, the question is: which solution's inductive bias (low-rank vs higher-rank) matches the TASK's geometry? LoRA's low-rank solution can be MORE robust on steering; full FT's higher-rank solution can capture changes LoRA cannot."	c3::ft10::analysis
"For a format/style task (e.g., JSON output, brand voice), why is full FT the wrong call?"	"Format and style are the PUREST steering tasks — the base already does them unreliably; a small adapter makes them reliable. They are low-rank by nature. Full FT here is over-parameterized: it buys more drift and more cost for no quality gain. Rule of thumb from FT10: FORMAT AND STYLE ARE ALWAYS PEFT."	c3::ft10::application
"For a knowledge task (e.g., answer questions over a 200K-doc proprietary KB that changes monthly), what is the correct intervention, and why not full FT?"	"RAG first. The 'changes monthly' constraint is decisive: any weight-based memorization is stale within 30 days. RAG retrieves CURRENT docs at query time, is updateable without retraining, and is auditable. Fine-tune at most for the BEHAVIOR (cite the source, structure the answer) via QLoRA — never to memorize the KB. Full FT/CPT to 'teach the KB' violates the cardinal error and is operationally impossible to keep current."	c3::ft10::application
"For a medical chatbot that must structure outputs as a differential, cite sources, and flag uncertainty — what method, and why?"	"PEFT (DoRA or QLoRA). Pure steering — the model ALREADY knows medicine; you are shaping HOW it presents retrieved content. A low-rank adapter is the correct representation of a format/structure change. RAG supplies the sources the model cites; PEFT shapes the behavior of citing. The two COMPOSE — they are not alternatives. Full FT is overkill and risks forgetting the medical knowledge."	c3::ft10::application
"For adding a NEW programming language the base has never seen, what is the decision, and what must you check first?"	"Full FT or CPT — this is a genuine knowledge gap (the base lacks the language's semantics; low-rank updates cannot install it). BUT first confirm RAG (retrieve the spec + examples into context) is insufficient. Full FT/CPT is defensible only if retrieval is structurally intractable AND you have the corpus (spec, compiler, ~50K lines). Do NOT use QLoRA expecting it to 'learn the language' — it would memorize surface patterns and fail on novel programs."	c3::ft10::application
"For uncensoring an authorized-use agent (remove refusal without degrading code reasoning), why is full FT the wrong call?"	"Steering AWAY from refusal is a low-rank operation by definition (abliteration deletes a single residual-stream direction). Full FT is overkill AND, per the entanglement finding, risks MORE capability loss — more degrees of freedom to drift into the entangled math/code directions. The constraint 'avoid capability loss' rules out the over-parameterized option. Use a LoRA adapter or abliteration, then deploy inside an eval'd harness (Layer 5, FT23)."	c3::ft10::application
"For reliable tool-use formatting (model understands tools but produces schema violations ~15% of the time), what method, and why?"	"PEFT (QLoRA). Steering — the model already understands function-calling conceptually; the 15% violation rate is a reliability/format problem, exactly what SFT-via-QLoRA fixes. A low-rank update on 10K correct examples on a 24GB GPU drives violations well under 1%. The structural non-equivalence finding cuts in PEFT's favor: the low-rank solution is the correct geometry for a format change."	c3::ft10::application
"Why does the large-batch-size condition (Condition 3) matter, and where does it come from?"	"Per Shuttleworth et al. (arXiv:2410.21228), under certain regimes — notably larger batch sizes — LoRA degrades FASTER than full FT. The mechanism is tied to structural non-equivalence: LoRA's low-rank constraint, a strength for steering, becomes a liability when the optimization landscape would benefit from higher-rank updates. Practical implication: if you train at large batch sizes and LoRA underperforms, escalate to DoRA / GaLore / full FT rather than cranking LoRA's rank until it's no longer PEFT."	c3::ft10::analysis
"Why is GaLore described as collapsing the cost-quality dichotomy?"	"Before GaLore, the tension was binary: full FT gives higher-rank updates (which some tasks need) at ~30x the memory; PEFT gives low-rank updates at low memory. GaLore breaks the dichotomy by projecting the OPTIMIZER STATE (not the weights) to low rank — so you get full-parameter WEIGHTS (the higher-rank solution) at near-LoRA MEMORY. It makes 'I need full-FT geometry' and 'I have a 4090' compatible. It is the rung that removes the 'I can't afford full FT' excuse without forcing LoRA's constraint when it's wrong."	c3::ft10::analysis
"Why is the escalation ladder 'one rung at a time with evidence,' not 'start where you think you'll end up'?"	"Starting at full FT 'because we'll probably need it eventually' burns ~30x the cost upfront and, for steering tasks, produces a WORSE solution (more drift/forgetting). The correct posture: start at PEFT (the default), measure, and escalate one rung (DoRA -> GaLore -> full FT) only when you have EVIDENCE the current rung provably fails AND a hypothesis for why the task needs the next rung's geometry. GaLore exists precisely so escalation doesn't have to jump straight to a multi-GPU budget."	c3::ft10::analysis
"What distinguishes Condition 1 (new reasoning pathways) from ordinary reasoning fine-tuning like GRPO?"	"Most 'reasoning' fine-tuning is ACTIVATION, not installation — GRPO on math rewards steers the model to USE reasoning pathways it already has. That is steering; PEFT handles it. Condition 1 is the rarer case: the model cannot produce the KIND of reasoning required even with a perfect prompt and long context — it must construct NEW internal computation, where low-rank updates may be too constrained. Even here the evidence is mixed (many 'new reasoning' goals are activation in disguise), but this is the most defensible full-FT exit."	c3::ft10::analysis
"Why is 'ignoring structural non-equivalence' an anti-pattern, and what does the team that ignores it get wrong?"	"A team that treats LoRA as 'full FT minus some quality' (a point on a quality continuum) will reason about the choice as 'how much quality can I afford' — and will over-spend on full FT for steering tasks (where LoRA's geometry is actually correct) while under-spending on it for the rare higher-rank tasks that need it. Structural non-equivalence means you must reason about WHICH SOLUTION'S GEOMETRY FITS THE TASK, not how much quality you can buy. Ignoring it inverts the correct decisions."	c3::ft10::analysis
"How would you operationally apply the decision rule to a new, unfamiliar adaptation task?"	"(1) Run the three-outcome test from FT00: prompt the base with ideal input + great system prompt. (2) Classify the geometry: steering (base could do it unreliably -> PEFT), knowledge (base genuinely lacks it -> check RAG first), higher-rank (new reasoning/domain -> full-FT candidate). (3) Start at PEFT. (4) Measure against your quality bar. (5) Escalate one rung (DoRA -> GaLore -> full FT) only with evidence the current rung fails AND a hypothesis for why. Never start at full FT without evidence."	c3::ft10::application