v0.8.3 PEFT Anti-Pattern Checker — anti-bullshit pack #9

PEFT's `get_peft_model(base, config)` creates a FRESH adapter — it
does not load saved weights from a path. Users who paste tutorial code
and try to resume from a checkpoint silently throw away their training.
peft #2115 has the canonical bug report (12+ thumbs).

🔧 PEFT Lint (17th mode):
- Paste your PEFT/LoRA training script
- Static linter scans for 4 classes of bug:
1. silent_base_load — `get_peft_model` + checkpoint path string in
same script, no `PeftModel.from_pretrained`. Suggests the fix
inline with the detected path.
2. qlora_order — `prepare_model_for_kbit_training` AFTER
`get_peft_model`. Reversed order silently breaks gradient flow
through LoRA layers (loss → NaN or training nothing).
3. target_modules_mismatch — user's `target_modules=[…]` doesn't
overlap with the conventional list for the architecture
detected from a model id string. Covers Llama / Mistral / Qwen2
/ Phi / Phi-3 / Gemma / Falcon / Bloom / GPT-2 / GPT-NeoX / MPT.
4. alpha_not_2r — `lora_alpha` ratio off the α=2r / α=r
conventions (info-only).
- Findings rendered with severity badge, line number, per-rule
explainer + fix hint.

Pure logic in `js/peft_anti_pattern.js` (codes + params, no human
strings); main.js renders with i18n. Comment + string-literal stripping
prevents false positives on commented-out code or unrelated literals.

47 i18n keys × 4 langs (EN/ES/FR/ZH) = 188 keys, parity clean.
Solutions Hub `peft_loading` pain upgraded from
`tafagent_planned_mode: "🔧 PEFT Anti-Pattern Checker (v0.8.2)"` →
`tafagent_mode: "🔧 PEFT Anti-Pattern Checker"` (planned: → covered).
Help modal v0.8.3 entry + Inventory anti-bullshit-pack list updated +
task tile "⚙️ Set up an eval correctly" gains the new mode button.

Source citations:
- https://github.com/huggingface/peft/issues/2115 (the silent bug)
- https://huggingface.co/docs/peft/main/en/developer_guides/troubleshooting
- PEFT `get_layer_status() / get_model_status()` runtime check

Verified: 7/7 logic cases (silent base-load, correct from_pretrained,
QLoRA order, target_modules mismatch, alpha info, no-peft, comment
stripping) + 188/188 i18n parity + headless e2e (tab/section/three
examples render verdict+line+fix). 18 mode tabs total.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

data/solutions_hub.json

@@ -222,15 +222,14 @@
       "id": "peft_loading",
       "category": "training",
       "pain": "`get_peft_model()` before `PeftModel.from_pretrained()` silently loads base model — LoRA weights ignored.",
-      "tafagent_mode": null,
+      "tafagent_mode": "🔧 PEFT Anti-Pattern Checker",
       "external_tools": [
         {"name": "HF PEFT troubleshooting (canonical)", "url": "https://huggingface.co/docs/peft/main/en/developer_guides/troubleshooting", "type": "docs"},
         {"name": "peft #2115 — original bug report", "url": "https://github.com/huggingface/peft/issues/2115", "type": "issue"},
         {"name": "PEFT get_layer_status() / get_model_status()", "url": "https://huggingface.co/docs/peft/main/en/package_reference/peft_model", "type": "docs"}
       ],
       "best_for": "If you suspect your LoRA isn't being applied, call `model.get_layer_status()` and check `active_adapters` is non-empty.",
-      "not_for": null,
-      "tafagent_planned_mode": "🔧 PEFT Anti-Pattern Checker (v0.8.2)"
+      "not_for": null
     },
     {
       "id": "intruder_dimensions",

index.html

@@ -219,6 +219,9 @@
       <p><strong data-i18n="help.v082.cot.title">📋 JSON CoT-aware Linter</strong></p>
       <p data-i18n="help.v082.cot.body">Constrained-decoding engines (llguidance, Outlines, SGLang grammars) emit JSON properties in the order your schema declares them. If you write <code>{ answer, reasoning }</code> the model commits to <code>answer</code> first and CoT collapses into post-hoc justification. Paste any schema (or example response) — the linter classifies each field as <em>reasoning</em>, <em>answer</em>, or <em>other</em>, flags the ordering, and emits a reordered fix you can copy back. <em>Use case</em>: 'My CoT prompt works in plaintext but degrades under JSON mode' → run linter, find the inverted order, fix.</p>
 
+      <p><strong data-i18n="help.v083.peft.title">🔧 PEFT Anti-Pattern Checker</strong></p>
+      <p data-i18n="help.v083.peft.body">PEFT's <code>get_peft_model(base, config)</code> creates a FRESH adapter — it does not load saved weights from a path. Users who paste tutorial code and try to resume from a checkpoint silently throw away their training. peft #2115 has the canonical bug report. This linter scans your training script for the pattern + 3 related issues (QLoRA ordering, target_modules/arch mismatch, lora_alpha ratio) and reports findings with line numbers and suggested fixes. <em>Use case</em>: before you launch a 10-hour LoRA fine-tune, paste your script — catch the silent bugs in 200ms.</p>
+
       <p><strong data-i18n="help.v081.hub.title">🧭 Solutions Hub</strong></p>
       <p data-i18n="help.v081.hub.body">tafagent as integrator, not silo. 30+ pains across 7 categories (eval reliability · diagnostics · setup · training · retrieval · multimodal · observability), each mapped to (a) the tafagent mode that addresses it, if any, and (b) the best-of-breed external tools the community already trusts (RAGAS, MTEB, HELM, MCP Schema Validator, llm-stats, llguidance, GlitchMiner, etc.). Search box matches across pain, scenario, and tool name. <em>Use case</em>: 'I have problem X — does tafagent solve it, and if not, who does?'</p>
 
@@ -332,6 +335,7 @@
             <li data-i18n="inv.v07.niah"><strong>🔍 NIAH→Reason</strong> — does your "128k context" actually reason there, or just retrieve?</li>
             <li data-i18n="inv.v08.saturation"><strong>📈 Saturation</strong> — is your benchmark still useful, or are all frontier models tied at the top?</li>
             <li data-i18n="inv.v082.cot"><strong>📋 JSON CoT</strong> — lints structured-output schemas for the answer-before-reasoning anti-pattern that silently breaks Chain-of-Thought.</li>
+            <li data-i18n="inv.v083.peft"><strong>🔧 PEFT Lint</strong> — catches the silent <code>get_peft_model</code> base-load (peft #2115) + QLoRA order + target_modules / arch mismatch.</li>
             <li data-i18n="inv.v081.hub"><strong>🧭 Solutions Hub</strong> — every documented pain mapped to a tafagent mode or curated external tool. Don't reinvent — find.</li>
           </ul>
         </details>
@@ -404,6 +408,7 @@
             <button data-mode-link="template" data-i18n="modes.template">📜 Chat-template</button>
             <button data-mode-link="diagnose" data-i18n="modes.diagnose">🩺 Diagnose CLI</button>
             <button data-mode-link="cot" data-i18n="modes.cot">📋 JSON CoT</button>
+            <button data-mode-link="peft" data-i18n="modes.peft">🔧 PEFT Lint</button>
           </div>
         </div>
         <div class="task-tile">
@@ -461,6 +466,7 @@
         <button class="mode-btn" data-mode="niah" role="tab" aria-selected="false" data-i18n="modes.niah">🔍 NIAH→Reason</button>
         <button class="mode-btn" data-mode="saturation" role="tab" aria-selected="false" data-i18n="modes.saturation">📈 Saturation</button>
         <button class="mode-btn" data-mode="cot" role="tab" aria-selected="false" data-i18n="modes.cot">📋 JSON CoT</button>
+        <button class="mode-btn" data-mode="peft" role="tab" aria-selected="false" data-i18n="modes.peft">🔧 PEFT Lint</button>
         <button class="mode-btn" data-mode="hub" role="tab" aria-selected="false" data-i18n="modes.hub">🧭 Solutions</button>
       </div>
       <p id="mode-desc" class="recipe-desc" data-i18n="modes.desc">
@@ -1032,6 +1038,29 @@
       <div id="cot-output" style="margin-top: 1em;"></div>
     </section>
 
+    <!-- PEFT Anti-Pattern Checker (mode=peft, v0.8.3 anti-bullshit pack #9) -->
+    <section id="peft-section" style="display:none;">
+      <h2><span data-i18n="peft.title">🔧 PEFT Anti-Pattern Checker</span>
+        <span class="info"><span class="tooltip" data-i18n="peft.tip">
+          <strong>Why this matters</strong>: <code>get_peft_model(base, config)</code> creates a FRESH adapter — it does NOT load saved weights. Users who want to resume from a checkpoint must call <code>PeftModel.from_pretrained(base, path)</code>. peft #2115 documents the silent base-model bug. This linter scans your training script for that pattern (and 3 others: QLoRA ordering, target_modules/arch mismatch, lora_alpha ratio).
+        </span></span>
+      </h2>
+      <p class="recipe-desc" data-i18n="peft.desc">
+        <strong>Don't burn 10 hours of training on a base model.</strong> Paste your PEFT setup code — the linter flags silent base-model loads, QLoRA ordering bugs, target_modules/arch mismatches, and lora_alpha conventions.
+      </p>
+      <div class="form-row">
+        <textarea id="peft-input" rows="14" style="width:100%;font-family:monospace;font-size:0.9em;" data-i18n-placeholder="peft.input.placeholder" placeholder="from peft import LoraConfig, get_peft_model&#10;base = AutoModelForCausalLM.from_pretrained('meta-llama/Llama-3-8B')&#10;config = LoraConfig(r=16, lora_alpha=32, target_modules=['q_proj','v_proj'])&#10;model = get_peft_model(base, config)&#10;# resume from saved adapter:&#10;model.load_state_dict('./outputs/checkpoint-1000/adapter_model.bin')"></textarea>
+      </div>
+      <div class="form-row">
+        <button type="button" id="peft-lint-btn" data-i18n="peft.lint_btn">🔍 Lint</button>
+        <button type="button" id="peft-example-bug-btn" class="secondary" data-i18n="peft.example_bug_btn">↳ Example: silent base-load</button>
+        <button type="button" id="peft-example-qlora-btn" class="secondary" data-i18n="peft.example_qlora_btn">↳ Example: QLoRA order bug</button>
+        <button type="button" id="peft-example-clean-btn" class="secondary" data-i18n="peft.example_clean_btn">↳ Example: clean</button>
+      </div>
+      <p id="peft-status" class="recipe-desc" style="font-size:0.92em;"></p>
+      <div id="peft-output" style="margin-top: 1em;"></div>
+    </section>
+
     <section id="hub-section" style="display:none;">
       <h2><span data-i18n="hub.title">🧭 Solutions Hub</span>
         <span class="info"><span class="tooltip" data-i18n="hub.tip">

js/i18n.js

@@ -545,6 +545,55 @@ export const TRANSLATIONS = {
     "help.v082.cot.title":         "📋 JSON CoT-aware Linter",
     "help.v082.cot.body":          "Constrained-decoding engines (llguidance, Outlines, SGLang grammars) emit JSON properties in the order your schema declares them. If you write <code>{ answer, reasoning }</code> the model commits to <code>answer</code> first and CoT collapses into post-hoc justification. Paste any schema (or example response) — the linter classifies each field as <em>reasoning</em>, <em>answer</em>, or <em>other</em>, flags the ordering, and emits a reordered fix you can copy back. <em>Use case</em>: 'My CoT prompt works in plaintext but degrades under JSON mode' → run linter, find the inverted order, fix.",
 
+    // v0.8.3 — anti-bullshit pack #9: PEFT Anti-Pattern Checker
+    "modes.peft":                  "🔧 PEFT Lint",
+    "mode_desc.peft":              "Static linter for PEFT/LoRA training scripts. Catches the silent base-model load (peft #2115), QLoRA prepare/get_peft_model ordering, target_modules/arch mismatch, and lora_alpha conventions.",
+    "peft.title":                  "🔧 PEFT Anti-Pattern Checker",
+    "peft.tip":                    "<code>get_peft_model(base, config)</code> creates a FRESH adapter — it does NOT load saved weights. Users who want to resume from a checkpoint must call <code>PeftModel.from_pretrained(base, path)</code>. peft #2115 documents the silent base-model bug. This linter scans your training script for that pattern (and 3 others: QLoRA ordering, target_modules/arch mismatch, lora_alpha ratio).",
+    "peft.desc":                   "<strong>Don't burn 10 hours of training on a base model.</strong> Paste your PEFT setup code — the linter flags silent base-model loads, QLoRA ordering bugs, target_modules/arch mismatches, and lora_alpha conventions.",
+    "peft.input.placeholder":      "from peft import LoraConfig, get_peft_model …",
+    "peft.lint_btn":               "🔍 Lint",
+    "peft.example_bug_btn":        "↳ Example: silent base-load",
+    "peft.example_qlora_btn":      "↳ Example: QLoRA order bug",
+    "peft.example_clean_btn":      "↳ Example: clean",
+    "peft.status.done":            "✅ {verdict} — {n} finding(s)",
+    "peft.line":                   "line {n}",
+    "peft.summary":                "{total} finding(s)",
+    "peft.attribution":            "Refs:",
+    "peft.detected_at_line":       "appears at line",
+    "peft.suggested_fix":          "Suggested:",
+    "peft.detected_arch":          "Detected arch",
+    "peft.from_model_id":          "(from model id",
+    "peft.your_modules":           "Your target_modules",
+    "peft.expected_modules":       "Expected for this arch",
+    "peft.match_ratio":            "{hits} of {total} match.",
+    "peft.ratio":                  "ratio",
+    "peft.alpha.convention":       "convention is α=2r or α=r",
+    "peft.qlora_order.detail":     "prepare_model_for_kbit_training (line {prepare_line}) runs AFTER get_peft_model (line {get_peft_model_line}). Reverse the order — call prepare FIRST, then get_peft_model.",
+    "peft.no_peft_calls.detail":   "No get_peft_model / PeftModel.from_pretrained / LoraConfig calls detected. Paste a PEFT/LoRA setup snippet.",
+    "peft.verdict.errors_found":   "❌ Errors found",
+    "peft.verdict.warnings_only":  "⚠ Warnings",
+    "peft.verdict.info_only":      "ℹ Info",
+    "peft.verdict.clean":          "✅ Clean — no issues detected",
+    "peft.verdict.no_peft_calls":  "ℹ No PEFT calls detected",
+    "peft.verdict.empty_input":    "ℹ Empty input",
+    "peft.rule.silent_base_load.label":   "Silent base-model load (peft #2115)",
+    "peft.rule.silent_base_load.explain": "<code>get_peft_model(base, config)</code> creates a NEW adapter — it does NOT load saved weights. The checkpoint hint in your code suggests you want to RESUME training from a saved adapter, but this code path will quietly start fresh and overwrite the run.",
+    "peft.rule.silent_base_load.fix":     "Replace <code>get_peft_model(base, config)</code> with <code>PeftModel.from_pretrained(base, path)</code> when resuming. Verify with <code>model.get_layer_status()</code> after load.",
+    "peft.rule.qlora_order.label":   "QLoRA ordering bug",
+    "peft.rule.qlora_order.explain": "<code>prepare_model_for_kbit_training</code> must be called BEFORE <code>get_peft_model</code>. Reversed, the kbit prep doesn't apply to the LoRA layers and gradient computation breaks (loss → NaN, or silent training of nothing).",
+    "peft.rule.qlora_order.fix":     "Reorder: <code>base = prepare_model_for_kbit_training(base)</code> then <code>model = get_peft_model(base, config)</code>.",
+    "peft.rule.target_modules_mismatch.label":   "target_modules / arch mismatch",
+    "peft.rule.target_modules_mismatch.explain": "Your <code>target_modules</code> list doesn't match the conventional module names for the architecture detected in your code. PEFT will silently apply LoRA to nothing (or to the wrong layers).",
+    "peft.rule.target_modules_mismatch.fix":     "Verify module names with <code>print([n for n,_ in model.named_modules()])</code> on the loaded base model, or use the architecture-specific list shown above.",
+    "peft.rule.alpha_not_2r.label":   "lora_alpha ≠ 2r convention",
+    "peft.rule.alpha_not_2r.explain": "Most published LoRA recipes use either <code>α = 2r</code> (effective unit scale) or <code>α = r</code> (reduced effective LR). A custom ratio works but warrants a sanity check.",
+    "peft.rule.alpha_not_2r.fix":     "Sanity-check the ratio against your reference recipe. If intentional, ignore this finding.",
+    "peft.rule.no_peft_calls.label": "No PEFT calls detected",
+    "inv.v083.peft":               "<strong>🔧 PEFT Lint</strong> — catches the silent <code>get_peft_model</code> base-load (peft #2115) + QLoRA order + target_modules / arch mismatch.",
+    "help.v083.peft.title":        "🔧 PEFT Anti-Pattern Checker",
+    "help.v083.peft.body":         "PEFT's <code>get_peft_model(base, config)</code> creates a FRESH adapter — it does not load saved weights from a path. Users who paste tutorial code and try to resume from a checkpoint silently throw away their training. peft #2115 has the canonical bug report. This linter scans your training script for the pattern + 3 related issues (QLoRA ordering, target_modules/arch mismatch, lora_alpha ratio) and reports findings with line numbers and suggested fixes. <em>Use case</em>: before you launch a 10-hour LoRA fine-tune, paste your script — catch the silent bugs in 200ms.",
+
     "inv.v081.hub":                "<strong>🧭 Solutions Hub</strong> — every documented pain mapped to a tafagent mode or curated external tool. Don't reinvent — find.",
     "help.v081.hub.title":         "🧭 Solutions Hub",
     "help.v081.hub.body":          "tafagent as integrator, not silo. 30+ pains across 7 categories (eval reliability · diagnostics · setup · training · retrieval · multimodal · observability), each mapped to (a) the tafagent mode that addresses it, if any, and (b) the best-of-breed external tools the community already trusts (RAGAS, MTEB, HELM, MCP Schema Validator, llm-stats, llguidance, GlitchMiner, etc.). Search box matches across pain, scenario, and tool name. <em>Use case</em>: 'I have problem X — does tafagent solve it, and if not, who does?'",
@@ -1549,6 +1598,55 @@ export const TRANSLATIONS = {
     "help.v082.cot.title":         "📋 Linter JSON con consciencia CoT",
     "help.v082.cot.body":          "Los motores de constrained decoding (llguidance, Outlines, gramáticas SGLang) emiten propiedades JSON en el orden que declara tu schema. Si escribes <code>{ answer, reasoning }</code> el modelo se compromete con <code>answer</code> primero y el CoT se reduce a justificación post-hoc. Pega cualquier schema (o respuesta de ejemplo) — el linter clasifica cada campo como <em>razonamiento</em>, <em>respuesta</em> u <em>otro</em>, señala el ordenamiento, y emite una corrección reordenada para copiar de vuelta. <em>Caso de uso</em>: 'Mi prompt CoT funciona en texto pero degrada en modo JSON' → ejecuta linter, encuentra el orden invertido, corrige.",
 
+    // v0.8.3 — anti-bullshit pack #9: PEFT Anti-Pattern Checker
+    "modes.peft":                  "🔧 PEFT Lint",
+    "mode_desc.peft":              "Linter estático para scripts de entrenamiento PEFT/LoRA. Detecta carga silenciosa del modelo base (peft #2115), orden de prepare_model_for_kbit_training/get_peft_model en QLoRA, mismatch de target_modules/arch, y conveniones de lora_alpha.",
+    "peft.title":                  "🔧 Verificador de anti-patrones PEFT",
+    "peft.tip":                    "<code>get_peft_model(base, config)</code> crea un adapter NUEVO — NO carga pesos guardados. Quien quiera reanudar desde un checkpoint debe llamar <code>PeftModel.from_pretrained(base, path)</code>. peft #2115 documenta el bug de carga silenciosa del modelo base. Este linter escanea tu script en busca de ese patrón (y otros 3: orden QLoRA, mismatch target_modules/arch, ratio lora_alpha).",
+    "peft.desc":                   "<strong>No quemes 10 horas de entrenamiento sobre un modelo base.</strong> Pega tu código de setup PEFT — el linter señala cargas silenciosas del base, bugs de orden QLoRA, mismatches target_modules/arch, y conveniones lora_alpha.",
+    "peft.input.placeholder":      "from peft import LoraConfig, get_peft_model …",
+    "peft.lint_btn":               "🔍 Lintear",
+    "peft.example_bug_btn":        "↳ Ejemplo: carga silenciosa del base",
+    "peft.example_qlora_btn":      "↳ Ejemplo: bug de orden QLoRA",
+    "peft.example_clean_btn":      "↳ Ejemplo: limpio",
+    "peft.status.done":            "✅ {verdict} — {n} hallazgo(s)",
+    "peft.line":                   "línea {n}",
+    "peft.summary":                "{total} hallazgo(s)",
+    "peft.attribution":            "Referencias:",
+    "peft.detected_at_line":       "aparece en la línea",
+    "peft.suggested_fix":          "Sugerencia:",
+    "peft.detected_arch":          "Arch detectada",
+    "peft.from_model_id":          "(desde model id",
+    "peft.your_modules":           "Tus target_modules",
+    "peft.expected_modules":       "Esperados para esta arch",
+    "peft.match_ratio":            "{hits} de {total} coinciden.",
+    "peft.ratio":                  "ratio",
+    "peft.alpha.convention":       "la convención es α=2r o α=r",
+    "peft.qlora_order.detail":     "prepare_model_for_kbit_training (línea {prepare_line}) corre DESPUÉS de get_peft_model (línea {get_peft_model_line}). Invierte el orden — llama prepare PRIMERO, luego get_peft_model.",
+    "peft.no_peft_calls.detail":   "No se detectan llamadas a get_peft_model / PeftModel.from_pretrained / LoraConfig. Pega un snippet de setup PEFT/LoRA.",
+    "peft.verdict.errors_found":   "❌ Errores encontrados",
+    "peft.verdict.warnings_only":  "⚠ Avisos",
+    "peft.verdict.info_only":      "ℹ Info",
+    "peft.verdict.clean":          "✅ Limpio — sin issues detectados",
+    "peft.verdict.no_peft_calls":  "ℹ Sin llamadas PEFT detectadas",
+    "peft.verdict.empty_input":    "ℹ Entrada vacía",
+    "peft.rule.silent_base_load.label":   "Carga silenciosa del modelo base (peft #2115)",
+    "peft.rule.silent_base_load.explain": "<code>get_peft_model(base, config)</code> crea un adapter NUEVO — NO carga pesos guardados. La pista de checkpoint en tu código sugiere que quieres REANUDAR el entrenamiento desde un adapter guardado, pero esta ruta arrancará silenciosamente desde cero y sobrescribirá la corrida.",
+    "peft.rule.silent_base_load.fix":     "Reemplaza <code>get_peft_model(base, config)</code> por <code>PeftModel.from_pretrained(base, path)</code> al reanudar. Verifica con <code>model.get_layer_status()</code> tras cargar.",
+    "peft.rule.qlora_order.label":   "Bug de orden QLoRA",
+    "peft.rule.qlora_order.explain": "<code>prepare_model_for_kbit_training</code> debe llamarse ANTES de <code>get_peft_model</code>. Invertido, la prep kbit no aplica a las capas LoRA y el cálculo del gradiente se rompe (loss → NaN, o entrenamiento silencioso de nada).",
+    "peft.rule.qlora_order.fix":     "Reordena: <code>base = prepare_model_for_kbit_training(base)</code> luego <code>model = get_peft_model(base, config)</code>.",
+    "peft.rule.target_modules_mismatch.label":   "Mismatch target_modules / arch",
+    "peft.rule.target_modules_mismatch.explain": "Tu lista <code>target_modules</code> no coincide con los nombres convencionales para la arquitectura detectada en tu código. PEFT aplicará LoRA silenciosamente a nada (o a las capas equivocadas).",
+    "peft.rule.target_modules_mismatch.fix":     "Verifica los nombres con <code>print([n for n,_ in model.named_modules()])</code> sobre el modelo base cargado, o usa la lista específica de la arch mostrada arriba.",
+    "peft.rule.alpha_not_2r.label":   "lora_alpha ≠ 2r (convención)",
+    "peft.rule.alpha_not_2r.explain": "La mayoría de recetas LoRA publicadas usan o <code>α = 2r</code> (escala efectiva unitaria) o <code>α = r</code> (LR efectivo reducido). Un ratio custom funciona pero merece una verificación.",
+    "peft.rule.alpha_not_2r.fix":     "Verifica el ratio contra tu receta de referencia. Si es intencional, ignora este hallazgo.",
+    "peft.rule.no_peft_calls.label": "Sin llamadas PEFT detectadas",
+    "inv.v083.peft":               "<strong>🔧 PEFT Lint</strong> — detecta la carga silenciosa de <code>get_peft_model</code> sobre el base (peft #2115) + orden QLoRA + mismatch target_modules / arch.",
+    "help.v083.peft.title":        "🔧 Verificador de anti-patrones PEFT",
+    "help.v083.peft.body":         "El <code>get_peft_model(base, config)</code> de PEFT crea un adapter NUEVO — no carga pesos guardados desde una ruta. Quien pega código de tutorial e intenta reanudar desde un checkpoint tira silenciosamente su entrenamiento. peft #2115 tiene el bug report canónico. Este linter escanea tu script buscando el patrón + 3 issues relacionados (orden QLoRA, mismatch target_modules/arch, ratio lora_alpha) y reporta hallazgos con números de línea y sugerencias. <em>Caso de uso</em>: antes de lanzar un fine-tune LoRA de 10 horas, pega tu script — atrapa los bugs silenciosos en 200ms.",
+
     "inv.v081.hub":                "<strong>🧭 Solutions Hub</strong> — cada pain documentado mapeado a un mode tafagent o herramienta externa curada. No reinventes — encuentra.",
     "help.v081.hub.title":         "🧭 Solutions Hub",
     "help.v081.hub.body":          "tafagent como integrador, no silo. 30+ pains en 7 categorías (eval reliability · diagnósticos · setup · training · retrieval · multimodal · observability), cada uno mapeado a (a) el mode tafagent que lo resuelve, si existe, y (b) las herramientas externas best-of-breed que la comunidad ya usa (RAGAS, MTEB, HELM, MCP Schema Validator, llm-stats, llguidance, GlitchMiner, etc.). Caja de búsqueda matchea pain, scenario, y nombre de herramienta. <em>Caso de uso</em>: 'tengo problema X — ¿lo resuelve tafagent, y si no, quién?'",
@@ -2417,6 +2515,55 @@ export const TRANSLATIONS = {
     "help.v082.cot.title":         "📋 Linter JSON conscient de CoT",
     "help.v082.cot.body":          "Les moteurs de décodage contraint (llguidance, Outlines, grammaires SGLang) émettent les propriétés JSON dans l'ordre que votre schema déclare. Si vous écrivez <code>{ answer, reasoning }</code> le modèle s'engage sur <code>answer</code> en premier et le CoT se réduit à une justification a posteriori. Collez n'importe quel schema (ou réponse exemple) — le linter classe chaque champ comme <em>raisonnement</em>, <em>réponse</em> ou <em>autre</em>, signale l'ordre, et émet une correction réordonnée à copier. <em>Cas d'usage</em> : 'Mon prompt CoT marche en texte brut mais dégrade en mode JSON' → lancez le linter, trouvez l'ordre inversé, corrigez.",
 
+    // v0.8.3 — anti-bullshit pack #9: PEFT Anti-Pattern Checker
+    "modes.peft":                  "🔧 PEFT Lint",
+    "mode_desc.peft":              "Linter statique pour les scripts d'entraînement PEFT/LoRA. Attrape le chargement silencieux du modèle de base (peft #2115), l'ordre prepare/get_peft_model en QLoRA, le mismatch target_modules/arch, et les conventions de lora_alpha.",
+    "peft.title":                  "🔧 Vérificateur d'anti-patterns PEFT",
+    "peft.tip":                    "<code>get_peft_model(base, config)</code> crée un nouvel adaptateur — il ne CHARGE PAS les poids sauvegardés. Pour reprendre depuis un checkpoint il faut appeler <code>PeftModel.from_pretrained(base, path)</code>. peft #2115 documente le bug du chargement silencieux. Ce linter scanne votre script à la recherche de ce pattern (et 3 autres : ordre QLoRA, mismatch target_modules/arch, ratio lora_alpha).",
+    "peft.desc":                   "<strong>Ne brûlez pas 10 heures d'entraînement sur un modèle de base.</strong> Collez votre code de setup PEFT — le linter signale les chargements silencieux du base, les bugs d'ordre QLoRA, les mismatches target_modules/arch, et les conventions lora_alpha.",
+    "peft.input.placeholder":      "from peft import LoraConfig, get_peft_model …",
+    "peft.lint_btn":               "🔍 Linter",
+    "peft.example_bug_btn":        "↳ Exemple : chargement silencieux du base",
+    "peft.example_qlora_btn":      "↳ Exemple : bug d'ordre QLoRA",
+    "peft.example_clean_btn":      "↳ Exemple : propre",
+    "peft.status.done":            "✅ {verdict} — {n} découverte(s)",
+    "peft.line":                   "ligne {n}",
+    "peft.summary":                "{total} découverte(s)",
+    "peft.attribution":            "Réfs :",
+    "peft.detected_at_line":       "apparaît à la ligne",
+    "peft.suggested_fix":          "Suggéré :",
+    "peft.detected_arch":          "Arch détectée",
+    "peft.from_model_id":          "(depuis model id",
+    "peft.your_modules":           "Vos target_modules",
+    "peft.expected_modules":       "Attendus pour cette arch",
+    "peft.match_ratio":            "{hits} sur {total} correspondent.",
+    "peft.ratio":                  "ratio",
+    "peft.alpha.convention":       "la convention est α=2r ou α=r",
+    "peft.qlora_order.detail":     "prepare_model_for_kbit_training (ligne {prepare_line}) s'exécute APRÈS get_peft_model (ligne {get_peft_model_line}). Inversez l'ordre — appelez prepare D'ABORD, puis get_peft_model.",
+    "peft.no_peft_calls.detail":   "Aucun appel à get_peft_model / PeftModel.from_pretrained / LoraConfig détecté. Collez un snippet de setup PEFT/LoRA.",
+    "peft.verdict.errors_found":   "❌ Erreurs trouvées",
+    "peft.verdict.warnings_only":  "⚠ Avertissements",
+    "peft.verdict.info_only":      "ℹ Info",
+    "peft.verdict.clean":          "✅ Propre — aucun problème détecté",
+    "peft.verdict.no_peft_calls":  "ℹ Aucun appel PEFT détecté",
+    "peft.verdict.empty_input":    "ℹ Entrée vide",
+    "peft.rule.silent_base_load.label":   "Chargement silencieux du modèle de base (peft #2115)",
+    "peft.rule.silent_base_load.explain": "<code>get_peft_model(base, config)</code> crée un NOUVEL adaptateur — il NE charge PAS les poids sauvegardés. L'indice de checkpoint dans votre code suggère que vous voulez REPRENDRE l'entraînement depuis un adaptateur sauvegardé, mais ce chemin de code redémarrera silencieusement à zéro et écrasera la run.",
+    "peft.rule.silent_base_load.fix":     "Remplacez <code>get_peft_model(base, config)</code> par <code>PeftModel.from_pretrained(base, path)</code> à la reprise. Vérifiez avec <code>model.get_layer_status()</code> après le chargement.",
+    "peft.rule.qlora_order.label":   "Bug d'ordre QLoRA",
+    "peft.rule.qlora_order.explain": "<code>prepare_model_for_kbit_training</code> doit être appelé AVANT <code>get_peft_model</code>. Inversé, la préparation kbit ne s'applique pas aux couches LoRA et le calcul du gradient casse (loss → NaN, ou entraînement silencieux de rien).",
+    "peft.rule.qlora_order.fix":     "Réordonnez : <code>base = prepare_model_for_kbit_training(base)</code> puis <code>model = get_peft_model(base, config)</code>.",
+    "peft.rule.target_modules_mismatch.label":   "Mismatch target_modules / arch",
+    "peft.rule.target_modules_mismatch.explain": "Votre liste <code>target_modules</code> ne correspond pas aux noms de modules conventionnels pour l'architecture détectée dans votre code. PEFT appliquera LoRA silencieusement à rien (ou aux mauvaises couches).",
+    "peft.rule.target_modules_mismatch.fix":     "Vérifiez les noms avec <code>print([n for n,_ in model.named_modules()])</code> sur le modèle de base chargé, ou utilisez la liste spécifique à l'arch montrée ci-dessus.",
+    "peft.rule.alpha_not_2r.label":   "lora_alpha ≠ 2r (convention)",
+    "peft.rule.alpha_not_2r.explain": "La plupart des recettes LoRA publiées utilisent soit <code>α = 2r</code> (échelle effective unitaire) soit <code>α = r</code> (LR effectif réduit). Un ratio custom marche mais mérite une vérification.",
+    "peft.rule.alpha_not_2r.fix":     "Vérifiez le ratio contre votre recette de référence. Si intentionnel, ignorez cette découverte.",
+    "peft.rule.no_peft_calls.label": "Aucun appel PEFT détecté",
+    "inv.v083.peft":               "<strong>🔧 PEFT Lint</strong> — attrape le chargement silencieux de <code>get_peft_model</code> sur le base (peft #2115) + ordre QLoRA + mismatch target_modules / arch.",
+    "help.v083.peft.title":        "🔧 Vérificateur d'anti-patterns PEFT",
+    "help.v083.peft.body":         "Le <code>get_peft_model(base, config)</code> de PEFT crée un NOUVEL adaptateur — il ne charge pas les poids sauvegardés depuis un chemin. Quiconque colle du code de tuto et essaie de reprendre depuis un checkpoint jette silencieusement son entraînement. peft #2115 contient le bug report canonique. Ce linter scanne votre script à la recherche du pattern + 3 problèmes liés (ordre QLoRA, mismatch target_modules/arch, ratio lora_alpha) et rapporte les découvertes avec numéros de ligne et corrections suggérées. <em>Cas d'usage</em> : avant de lancer un fine-tune LoRA de 10 heures, collez votre script — attrapez les bugs silencieux en 200ms.",
+
     "inv.v081.hub":                "<strong>🧭 Solutions Hub</strong> — chaque pain documenté mappé à un mode tafagent ou outil externe curé. Ne réinventez pas — trouvez.",
     "help.v081.hub.title":         "🧭 Solutions Hub",
     "help.v081.hub.body":          "tafagent comme intégrateur, pas silo. 30+ pains à travers 7 catégories (eval reliability · diagnostics · setup · training · retrieval · multimodal · observability), chacun mappé à (a) le mode tafagent qui le résout, s'il existe, et (b) les outils externes best-of-breed que la communauté utilise déjà (RAGAS, MTEB, HELM, MCP Schema Validator, llm-stats, llguidance, GlitchMiner, etc.). La barre de recherche matche pain, scénario, et nom d'outil. <em>Cas d'usage</em> : 'j'ai le problème X — tafagent le résout-il, et sinon, qui ?'",
@@ -3285,6 +3432,55 @@ export const TRANSLATIONS = {
     "help.v082.cot.title":         "📋 JSON CoT 感知 Linter",
     "help.v082.cot.body":          "约束解码引擎（llguidance、Outlines、SGLang 语法）按 schema 声明的顺序输出 JSON 属性。如果你写 <code>{ answer, reasoning }</code>，模型先承诺 <code>answer</code>，CoT 就退化为事后辩护。粘贴任意 schema（或示例响应）——linter 把每个字段分类为<em>推理</em>、<em>答案</em>或<em>其他</em>，标记顺序，并输出可复制回去的重排修复。<em>用例</em>：『我的 CoT 提示在纯文本中正常但在 JSON 模式下退化』→ 运行 linter，找到颠倒的顺序，修复。",
 
+    // v0.8.3 — anti-bullshit pack #9: PEFT Anti-Pattern Checker
+    "modes.peft":                  "🔧 PEFT Lint",
+    "mode_desc.peft":              "PEFT/LoRA 训练脚本的静态 linter。捕获基础模型的静默加载（peft #2115）、QLoRA 中 prepare/get_peft_model 顺序、target_modules/架构不匹配、以及 lora_alpha 约定。",
+    "peft.title":                  "🔧 PEFT 反模式检查器",
+    "peft.tip":                    "<code>get_peft_model(base, config)</code> 创建一个全新的 adapter——它不加载已保存的权重。想从 checkpoint 恢复必须调用 <code>PeftModel.from_pretrained(base, path)</code>。peft #2115 记录了基础模型静默加载的 bug。这个 linter 扫描你的训练脚本查找此模式（以及另外 3 个：QLoRA 顺序、target_modules/架构不匹配、lora_alpha 比率）。",
+    "peft.desc":                   "<strong>不要在基础模型上烧掉 10 小时的训练。</strong> 粘贴你的 PEFT 设置代码——linter 会标记基础模型的静默加载、QLoRA 顺序 bug、target_modules/架构不匹配，以及 lora_alpha 约定。",
+    "peft.input.placeholder":      "from peft import LoraConfig, get_peft_model …",
+    "peft.lint_btn":               "🔍 Lint",
+    "peft.example_bug_btn":        "↳ 示例：基础模型静默加载",
+    "peft.example_qlora_btn":      "↳ 示例：QLoRA 顺序 bug",
+    "peft.example_clean_btn":      "�� 示例：干净",
+    "peft.status.done":            "✅ {verdict} — {n} 项发现",
+    "peft.line":                   "第 {n} 行",
+    "peft.summary":                "{total} 项发现",
+    "peft.attribution":            "参考：",
+    "peft.detected_at_line":       "出现在第",
+    "peft.suggested_fix":          "建议：",
+    "peft.detected_arch":          "检测到的架构",
+    "peft.from_model_id":          "（来自 model id",
+    "peft.your_modules":           "你的 target_modules",
+    "peft.expected_modules":       "此架构预期",
+    "peft.match_ratio":            "{hits} / {total} 匹配。",
+    "peft.ratio":                  "比率",
+    "peft.alpha.convention":       "约定为 α=2r 或 α=r",
+    "peft.qlora_order.detail":     "prepare_model_for_kbit_training（第 {prepare_line} 行）在 get_peft_model（第 {get_peft_model_line} 行）之后运行。请反转顺序——先调用 prepare，然后 get_peft_model。",
+    "peft.no_peft_calls.detail":   "未检测到 get_peft_model / PeftModel.from_pretrained / LoraConfig 调用。粘贴 PEFT/LoRA 设置代码片段。",
+    "peft.verdict.errors_found":   "❌ 发现错误",
+    "peft.verdict.warnings_only":  "⚠ 警告",
+    "peft.verdict.info_only":      "ℹ 信息",
+    "peft.verdict.clean":          "✅ 干净——未检测到问题",
+    "peft.verdict.no_peft_calls":  "ℹ 未检测到 PEFT 调用",
+    "peft.verdict.empty_input":    "ℹ 空输入",
+    "peft.rule.silent_base_load.label":   "基础模型静默加载（peft #2115）",
+    "peft.rule.silent_base_load.explain": "<code>get_peft_model(base, config)</code> 创建一个新的 adapter——它不加载已保存的权重。你代码中的 checkpoint 提示表明你想从已保存的 adapter 恢复训练，但这个代码路径会悄悄从头开始并覆盖该次运行。",
+    "peft.rule.silent_base_load.fix":     "恢复时请用 <code>PeftModel.from_pretrained(base, path)</code> 替换 <code>get_peft_model(base, config)</code>。加载后用 <code>model.get_layer_status()</code> 验证。",
+    "peft.rule.qlora_order.label":   "QLoRA 顺序 bug",
+    "peft.rule.qlora_order.explain": "<code>prepare_model_for_kbit_training</code> 必须在 <code>get_peft_model</code> 之前调用。反转后，kbit 准备不会应用到 LoRA 层，梯度计算会破裂（loss → NaN，或静默训练空内容）。",
+    "peft.rule.qlora_order.fix":     "重新排序：<code>base = prepare_model_for_kbit_training(base)</code> 然后 <code>model = get_peft_model(base, config)</code>。",
+    "peft.rule.target_modules_mismatch.label":   "target_modules / 架构不匹配",
+    "peft.rule.target_modules_mismatch.explain": "你的 <code>target_modules</code> 列表与代码中检测到的架构的常规模块名不匹配。PEFT 会静默地把 LoRA 应用到无（或错误的层）。",
+    "peft.rule.target_modules_mismatch.fix":     "在加载的基础模型上用 <code>print([n for n,_ in model.named_modules()])</code> 验证模块名，或使用上面显示的特定架构列表。",
+    "peft.rule.alpha_not_2r.label":   "lora_alpha ≠ 2r（约定）",
+    "peft.rule.alpha_not_2r.explain": "大多数已发表的 LoRA 配方使用 <code>α = 2r</code>（有效单位尺度）或 <code>α = r</code>（降低有效 LR）。自定义比率可行但值得检查。",
+    "peft.rule.alpha_not_2r.fix":     "对照参考配方核对比率。如果是有意的，忽略此发现。",
+    "peft.rule.no_peft_calls.label": "未检测到 PEFT 调用",
+    "inv.v083.peft":               "<strong>🔧 PEFT Lint</strong> — 捕获 <code>get_peft_model</code> 在基础模型上的静默加载（peft #2115）+ QLoRA 顺序 + target_modules / 架构不匹配。",
+    "help.v083.peft.title":        "🔧 PEFT 反模式检查器",
+    "help.v083.peft.body":         "PEFT 的 <code>get_peft_model(base, config)</code> 创建一个新的 adapter——它不从路径加载已保存的权重。粘贴教程代码并尝试从 checkpoint 恢复的人会静默地丢掉训练。peft #2115 是规范的 bug 报告。这个 linter 扫描你的脚本查找该模式 + 3 个相关问题（QLoRA 顺序、target_modules/架构不匹配、lora_alpha 比率），并报告带行号和建议修复的发现。<em>用例</em>：在启动 10 小时的 LoRA fine-tune 之前，粘贴你的脚本——在 200ms 内捕获静默 bug。",
+
     "inv.v081.hub":                "<strong>🧭 Solutions Hub</strong> — 每个文档化的问题都映射到一个 tafagent 模式或精选外部工具。别重复发明 — 去找。",
     "help.v081.hub.title":         "🧭 Solutions Hub",
     "help.v081.hub.body":          "tafagent 作为集成者而非孤岛。30+ 问题跨 7 类别（评估可靠性 · 诊断 · 设置 · 训练 · 检索 · 多模态 · 可观测性），每个映射到（a）解决它的 tafagent 模式（若存在），以及（b）社区已信任的最佳外部工具（RAGAS、MTEB、HELM、MCP Schema Validator、llm-stats、llguidance、GlitchMiner 等）。搜索框匹配 pain、场景和工具名称。<em>用例</em>：'我有问题 X — tafagent 解决它吗，如果不，谁解决？'",

js/main.js

@@ -28,6 +28,7 @@ import {
   hubStats, getCategoryMeta,
 } from "./solutions_hub.js";
 import { lintJsonCot, reorderJsonText, classifyFieldName } from "./json_cot_linter.js";
+import { lintPeftCode, ARCH_TARGET_MODULES } from "./peft_anti_pattern.js";
 
 // Attach HF Hub search-as-you-type to all 5 model id inputs (Profile, Recipe,
 // Unmask, Template, Quant). Hits public huggingface.co/api/models. Idempotent.
@@ -218,6 +219,7 @@ document.addEventListener("click", (e) => {
       quant: "quant-section", drift: "drift-section", niah: "niah-section",
       saturation: "saturation-section",
       cot: "cot-section",
+      peft: "peft-section",
       hub: "hub-section",
     }[targetMode];
     if (sectionId) {
@@ -243,7 +245,7 @@ document.querySelectorAll(".mode-btn").forEach(btn => {
      "diagnose-section", "phase-section", "unmask-section",
      "template-section", "arena-section", "contam-section",
      "quant-section", "drift-section", "niah-section",
-     "saturation-section", "cot-section", "hub-section"].forEach(id => {
+     "saturation-section", "cot-section", "peft-section", "hub-section"].forEach(id => {
       const el = $(id);
       if (el) el.style.display = "none";
     });
@@ -256,6 +258,7 @@ document.querySelectorAll(".mode-btn").forEach(btn => {
       quant: "quant-section", drift: "drift-section", niah: "niah-section",
       saturation: "saturation-section",
       cot: "cot-section",
+      peft: "peft-section",
       hub: "hub-section",
     };
     const sectionId = sectionMap[mode];
@@ -264,6 +267,7 @@ document.querySelectorAll(".mode-btn").forEach(btn => {
     if (mode === "phase") initPhaseDiagram();
     if (mode === "saturation") initSaturation();
     if (mode === "cot") initCot();
+    if (mode === "peft") initPeft();
     if (mode === "hub") initHub();
   });
 });
@@ -3555,6 +3559,159 @@ $("cot-example-bad-btn")?.addEventListener("click", () => {
   runCotLint();
 });
 
+// ════════════════════════════════════════════════════════════════════
+// 🔧 PEFT Anti-Pattern Checker (v0.8.3 anti-bullshit pack #9)
+// ════════════════════════════════════════════════════════════════════
+const PEFT_SEVERITY_BG = {
+  error:   "#f85149",
+  warning: "#d29922",
+  info:    "#58a6ff",
+};
+const PEFT_VERDICT_BG = {
+  errors_found:   "#f85149",
+  warnings_only:  "#d29922",
+  info_only:      "#58a6ff",
+  clean:          "#3fb950",
+  no_peft_calls:  "#8b949e",
+  empty_input:    "#8b949e",
+};
+
+let __peftInited = false;
+
+function initPeft() {
+  if (__peftInited) return;
+  __peftInited = true;
+  // No-op (no async data); placeholder kept for symmetry with other modes.
+}
+
+function renderPeftFinding(f) {
+  const sevBg = PEFT_SEVERITY_BG[f.severity] || "#8b949e";
+  const sevBadge = `<span class="badge" style="background:${sevBg};">${f.severity.toUpperCase()}</span>`;
+  const ruleLabel = t(`peft.rule.${f.rule}.label`) || f.rule;
+  const lineLabel = f.line != null
+    ? `<span class="subtle" style="font-size:0.85em;">${tFmt("peft.line", { n: f.line }) || `line ${f.line}`}</span>`
+    : "";
+  const explainer = t(`peft.rule.${f.rule}.explain`) || "";
+  const fixHint = t(`peft.rule.${f.rule}.fix`) || "";
+  // Per-rule rendering details
+  let detail = "";
+  if (f.rule === "silent_base_load") {
+    detail = `<p><code>${escapeHtml(f.params.checkpoint_hint)}</code> ${t("peft.detected_at_line") || "appears at line"} ${f.params.checkpoint_line}</p>
+              <p><strong>${t("peft.suggested_fix") || "Suggested:"}</strong> <code>${escapeHtml(f.params.fix)}</code></p>`;
+  } else if (f.rule === "qlora_order") {
+    detail = `<p>${tFmt("peft.qlora_order.detail", f.params) || `prepare_model_for_kbit_training (line ${f.params.prepare_line}) runs AFTER get_peft_model (line ${f.params.get_peft_model_line}). Reverse the order.`}</p>`;
+  } else if (f.rule === "target_modules_mismatch") {
+    detail = `
+      <p><strong>${t("peft.detected_arch") || "Detected arch"}:</strong> <code>${escapeHtml(f.params.detected_arch)}</code> ${t("peft.from_model_id") || "(from model id"} <code>${escapeHtml(f.params.detected_from)}</code>)</p>
+      <p><strong>${t("peft.your_modules") || "Your target_modules"}:</strong> <code>${escapeHtml(f.params.user_modules.join(", "))}</code></p>
+      <p><strong>${t("peft.expected_modules") || "Expected for this arch"}:</strong> <code>${escapeHtml(f.params.expected_modules.join(", "))}</code></p>
+      <p class="subtle" style="font-size:0.85em;">${tFmt("peft.match_ratio", f.params) || `${f.params.hits} of ${f.params.total} match.`}</p>
+    `;
+  } else if (f.rule === "alpha_not_2r") {
+    detail = `<p><code>r=${f.params.r}, lora_alpha=${f.params.lora_alpha}</code> → ${t("peft.ratio") || "ratio"} ${f.params.ratio}× (${t("peft.alpha.convention") || "convention is α=2r or α=r"})</p>`;
+  } else if (f.rule === "no_peft_calls") {
+    detail = `<p>${t("peft.no_peft_calls.detail") || "No get_peft_model / PeftModel.from_pretrained / LoraConfig calls detected. Paste a PEFT/LoRA setup snippet."}</p>`;
+  }
+  return `
+    <details open class="unmask-panel" style="margin: 0.5em 0;">
+      <summary class="unmask-panel-title">
+        ${sevBadge} <strong>${ruleLabel}</strong> ${lineLabel}
+      </summary>
+      ${explainer ? `<p>${explainer}</p>` : ""}
+      ${detail}
+      ${fixHint ? `<p class="recipe-desc" style="margin-top:0.5em;">${fixHint}</p>` : ""}
+    </details>
+  `;
+}
+
+function renderPeftResult(result) {
+  const verdict = t(`peft.verdict.${result.code}`) || result.code;
+  const verdictBg = PEFT_VERDICT_BG[result.code] || "#8b949e";
+  const verdictBadge = `<span class="badge" style="background:${verdictBg};">${verdict}</span>`;
+  const findings = result.findings || [];
+  const findingsHtml = findings.map(renderPeftFinding).join("");
+  const summary = result.summary
+    ? `<p class="subtle" style="font-size:0.9em;">${tFmt("peft.summary", result.summary) || `${result.summary.total} finding(s)`}</p>`
+    : "";
+
+  // Source attribution
+  const attribution = `
+    <p class="recipe-desc subtle" style="font-size:0.82em;margin-top:1em;">
+      ${t("peft.attribution") || "Refs:"}
+      <a href="https://github.com/huggingface/peft/issues/2115" target="_blank" rel="noopener noreferrer">peft #2115</a> ·
+      <a href="https://huggingface.co/docs/peft/main/en/developer_guides/troubleshooting" target="_blank" rel="noopener noreferrer">PEFT troubleshooting</a> ·
+      <a href="https://huggingface.co/docs/peft/main/en/package_reference/peft_model" target="_blank" rel="noopener noreferrer">get_layer_status / get_model_status</a>
+    </p>
+  `;
+
+  return `<div class="arena-result">
+    <p style="font-size:1.1em;">${verdictBadge}</p>
+    ${summary}
+    ${findingsHtml}
+    ${attribution}
+  </div>`;
+}
+
+function runPeftLint() {
+  const text = $("peft-input")?.value || "";
+  const result = lintPeftCode(text);
+  $("peft-output").innerHTML = renderPeftResult(result);
+  $("peft-status").textContent = tFmt("peft.status.done", {
+    verdict: t(`peft.verdict.${result.code}`) || result.code,
+    n: result.findings?.length || 0,
+  });
+}
+
+const PEFT_EXAMPLE_BUG = `from peft import LoraConfig, get_peft_model
+from transformers import AutoModelForCausalLM
+
+base = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3-8B")
+config = LoraConfig(
+    r=16,
+    lora_alpha=32,
+    target_modules=["q_proj", "v_proj"],
+)
+model = get_peft_model(base, config)
+# resume from saved checkpoint?
+model.load_state_dict("./outputs/checkpoint-1000/adapter_model.bin")
+`;
+
+const PEFT_EXAMPLE_QLORA = `from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
+from transformers import AutoModelForCausalLM, BitsAndBytesConfig
+
+bnb = BitsAndBytesConfig(load_in_4bit=True)
+base = AutoModelForCausalLM.from_pretrained(
+    "meta-llama/Llama-3-8B",
+    quantization_config=bnb,
+)
+config = LoraConfig(r=16, lora_alpha=32, target_modules=["q_proj", "v_proj"])
+model = get_peft_model(base, config)
+# WRONG ORDER: prepare_model_for_kbit_training must come BEFORE get_peft_model
+model = prepare_model_for_kbit_training(model)
+`;
+
+const PEFT_EXAMPLE_CLEAN = `from peft import PeftModel
+from transformers import AutoModelForCausalLM
+
+base = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3-8B")
+# Resume from saved adapter — correct PEFT pattern.
+model = PeftModel.from_pretrained(base, "./outputs/checkpoint-1000")
+`;
+
+$("peft-lint-btn")?.addEventListener("click", runPeftLint);
+$("peft-example-bug-btn")?.addEventListener("click", () => {
+  $("peft-input").value = PEFT_EXAMPLE_BUG;
+  runPeftLint();
+});
+$("peft-example-qlora-btn")?.addEventListener("click", () => {
+  $("peft-input").value = PEFT_EXAMPLE_QLORA;
+  runPeftLint();
+});
+$("peft-example-clean-btn")?.addEventListener("click", () => {
+  $("peft-input").value = PEFT_EXAMPLE_CLEAN;
+  runPeftLint();
+});
+
 // ════════════════════════════════════════════════════════════════════
 // Bootstrap
 // ════════════════════════════════════════════════════════════════════

js/peft_anti_pattern.js

@@ -0,0 +1,331 @@
+// PEFT Anti-Pattern Checker (v0.8.3 anti-bullshit pack #9)
+//
+// Static linter for PEFT / LoRA training code paths. Targets the most
+// expensive bugs the community has documented: silent base-model loads
+// (peft #2115), QLoRA ordering errors, and arch/target_modules mismatch.
+//
+// Pain (Solutions Hub `peft_loading`): `get_peft_model()` called before
+// `PeftModel.from_pretrained()` silently loads the base model and a
+// FRESH adapter, ignoring the user's saved LoRA weights. Hours of
+// training thrown away with no error.
+//
+// Source citations:
+//   - peft #2115 — original silent-load bug
+//   - https://huggingface.co/docs/peft/main/en/developer_guides/troubleshooting
+//   - PEFT `get_layer_status() / get_model_status()` runtime check
+//
+// Pure logic — no human strings. Returns codes+params; main.js does
+// the i18n lookup. Same shape as json_cot_linter.js.
+
+// =============================================================================
+// Token/pattern definitions
+// =============================================================================
+
+// Rough comment + string stripping. NOT a real Python parser; we only
+// need to remove obvious noise so regex matches don't fire inside
+// docstrings or commented-out code. Anything still in scope after this
+// is treated as "live" Python.
+function stripCommentsAndStrings(code) {
+  // Remove triple-quoted strings (greedy match across newlines)
+  let s = code.replace(/"""[\s\S]*?"""/g, "");
+  s = s.replace(/'''[\s\S]*?'''/g, "");
+  // Remove single-line strings (but keep the line so line numbers stay valid)
+  s = s.replace(/"(?:\\.|[^"\\\n])*"/g, '""');
+  s = s.replace(/'(?:\\.|[^'\\\n])*'/g, "''");
+  // Remove `# ...` comments to end of line
+  s = s.replace(/#[^\n]*/g, "");
+  return s;
+}
+
+function findFirstMatchLine(stripped, pattern) {
+  const lines = stripped.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    if (pattern.test(lines[i])) return i + 1; // 1-indexed
+  }
+  return null;
+}
+
+function findAllMatchLines(stripped, pattern) {
+  const out = [];
+  const lines = stripped.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    if (pattern.test(lines[i])) out.push(i + 1);
+  }
+  return out;
+}
+
+// Extract STRING LITERALS from the ORIGINAL code (we kept them in the
+// raw text so we can scan their contents for adapter/checkpoint hints).
+// Returns array of { value, line }.
+function extractStringLiterals(code) {
+  const out = [];
+  const re = /(["'])((?:\\.|(?!\1)[^\\\n])*)\1/g;
+  const lines = code.split("\n");
+  let lineStart = 0;
+  for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+    const line = lines[lineIdx];
+    let m;
+    re.lastIndex = 0;
+    const lineRe = new RegExp(re.source, re.flags);
+    while ((m = lineRe.exec(line)) !== null) {
+      out.push({ value: m[2], line: lineIdx + 1 });
+    }
+  }
+  return out;
+}
+
+// Extract `target_modules=[...]` literal lists. Returns array of
+// { modules: [..], line }. Best-effort; only catches literal lists.
+function extractTargetModules(code) {
+  const out = [];
+  const re = /target_modules\s*=\s*\[([^\]]*)\]/g;
+  let m;
+  while ((m = re.exec(code)) !== null) {
+    const inner = m[1];
+    const modules = (inner.match(/["']([^"']+)["']/g) || []).map(s => s.slice(1, -1));
+    // Compute line number
+    const before = code.slice(0, m.index);
+    const line = before.split("\n").length;
+    out.push({ modules, line });
+  }
+  return out;
+}
+
+// Extract `r=N` and `lora_alpha=N` from the same call site. Best-effort.
+function extractLoraConfig(code) {
+  const out = [];
+  // Find LoraConfig(...) calls and capture the args block (single-line or balanced).
+  const re = /LoraConfig\s*\(([^)]*)\)/g;
+  let m;
+  while ((m = re.exec(code)) !== null) {
+    const args = m[1];
+    const r = args.match(/\br\s*=\s*(\d+)/);
+    const alpha = args.match(/lora_alpha\s*=\s*(\d+)/);
+    const before = code.slice(0, m.index);
+    const line = before.split("\n").length;
+    out.push({
+      r: r ? parseInt(r[1], 10) : null,
+      lora_alpha: alpha ? parseInt(alpha[1], 10) : null,
+      line,
+    });
+  }
+  return out;
+}
+
+// =============================================================================
+// Architecture → conventional target_modules
+// =============================================================================
+
+// Mapping built from public PEFT docs + transformers configs. Conservative:
+// only architectures with stable, well-documented module names. When the
+// user's target_modules don't match the listed arch family, we flag it.
+const ARCH_TARGET_MODULES = {
+  llama:   ["q_proj","k_proj","v_proj","o_proj","gate_proj","up_proj","down_proj"],
+  mistral: ["q_proj","k_proj","v_proj","o_proj","gate_proj","up_proj","down_proj"],
+  qwen2:   ["q_proj","k_proj","v_proj","o_proj","gate_proj","up_proj","down_proj"],
+  phi:     ["q_proj","k_proj","v_proj","dense","fc1","fc2"],
+  phi3:    ["qkv_proj","o_proj","gate_up_proj","down_proj"],
+  gemma:   ["q_proj","k_proj","v_proj","o_proj","gate_proj","up_proj","down_proj"],
+  falcon:  ["query_key_value","dense","dense_h_to_4h","dense_4h_to_h"],
+  bloom:   ["query_key_value","dense","dense_h_to_4h","dense_4h_to_h"],
+  gpt2:    ["c_attn","c_proj","c_fc"],
+  gptneox: ["query_key_value","dense","dense_h_to_4h","dense_4h_to_h"],
+  mpt:     ["Wqkv","out_proj","up_proj","down_proj"],
+};
+
+// Token hints in HF model ids that map to the keys above. Any one of
+// these matching is enough to claim "the user is targeting arch X".
+const ARCH_ID_HINTS = {
+  llama:   /\b(?:llama|llama-?[123]|tinyllama|vicuna|alpaca|deepseek|mixtral)\b/i,
+  mistral: /\bmistral\b/i,
+  qwen2:   /\bqwen2?\b/i,
+  phi:     /\bphi-?[12]\b/i,
+  phi3:    /\bphi-?3\b/i,
+  gemma:   /\bgemma\b/i,
+  falcon:  /\bfalcon\b/i,
+  bloom:   /\bbloom\b/i,
+  gpt2:    /\bgpt-?2\b/i,
+  gptneox: /\b(?:gpt-?neox|pythia|dolly)\b/i,
+  mpt:     /\bmpt\b/i,
+};
+
+function detectArch(stringLiterals) {
+  for (const lit of stringLiterals) {
+    for (const [arch, hint] of Object.entries(ARCH_ID_HINTS)) {
+      if (hint.test(lit.value)) {
+        return { arch, source: lit.value, line: lit.line };
+      }
+    }
+  }
+  return null;
+}
+
+// =============================================================================
+// Heuristics for detecting "this string is a saved adapter checkpoint path"
+// =============================================================================
+
+const CHECKPOINT_HINT_RE =
+  /(?:adapter[_-]?(?:config|model)|adapter\.safetensors|adapter_model\.bin|peft[_-]?model|lora[_-]?weights?|checkpoint(?:[-_/]\d+)?|\boutput[_-]?dir\b|trained?[_-]?lora)/i;
+
+function findAdapterCheckpointHint(stringLiterals) {
+  for (const lit of stringLiterals) {
+    if (CHECKPOINT_HINT_RE.test(lit.value)) return lit;
+  }
+  return null;
+}
+
+// =============================================================================
+// Public entry point
+// =============================================================================
+
+const RULES = {
+  // Strong correctness issues — almost certainly a bug
+  silent_base_load: { severity: "error" },
+  qlora_order:      { severity: "error" },
+  target_modules_mismatch: { severity: "warning" },
+  // Optional / informational
+  alpha_not_2r:     { severity: "info" },
+  no_peft_calls:    { severity: "info" },
+};
+
+export function lintPeftCode(text) {
+  if (typeof text !== "string" || !text.trim()) {
+    return { code: "empty_input", findings: [] };
+  }
+
+  const stripped = stripCommentsAndStrings(text);
+
+  // Bail if no PEFT-related calls at all — unhelpful otherwise.
+  const hasGetPeftModel    = /\bget_peft_model\s*\(/.test(stripped);
+  const hasFromPretrained  = /\bPeftModel\s*\.\s*from_pretrained\s*\(/.test(stripped);
+  const hasPrepareKbit     = /\bprepare_model_for_kbit_training\s*\(/.test(stripped);
+  const hasLoraConfig      = /\bLoraConfig\s*\(/.test(stripped);
+  const hasBnbConfig       = /\bBitsAndBytesConfig\s*\(/.test(stripped);
+
+  if (
+    !hasGetPeftModel &&
+    !hasFromPretrained &&
+    !hasPrepareKbit &&
+    !hasLoraConfig
+  ) {
+    return {
+      code: "no_peft_calls",
+      findings: [{
+        rule: "no_peft_calls",
+        severity: "info",
+        line: null,
+        params: {},
+      }],
+    };
+  }
+
+  const findings = [];
+  const stringLiterals = extractStringLiterals(text);
+
+  // ─── Rule A: silent base-model load (peft #2115) ─────────────────────────
+  // Pattern: `get_peft_model(...)` is the only model-creation path AND
+  // there's a string literal that looks like a saved adapter path.
+  // Likely user wants to LOAD a saved adapter but is creating a new one.
+  if (hasGetPeftModel && !hasFromPretrained) {
+    const hint = findAdapterCheckpointHint(stringLiterals);
+    if (hint) {
+      const getPeftLine = findFirstMatchLine(stripped, /\bget_peft_model\s*\(/);
+      findings.push({
+        rule: "silent_base_load",
+        severity: "error",
+        line: getPeftLine,
+        params: {
+          checkpoint_hint: hint.value,
+          checkpoint_line: hint.line,
+          fix: `PeftModel.from_pretrained(base_model, ${JSON.stringify(hint.value)})`,
+        },
+      });
+    }
+  }
+
+  // ─── Rule B: QLoRA ordering — prepare_model_for_kbit_training AFTER get_peft_model ──
+  if (hasPrepareKbit && hasGetPeftModel) {
+    const prepLine = findFirstMatchLine(stripped, /\bprepare_model_for_kbit_training\s*\(/);
+    const peftLine = findFirstMatchLine(stripped, /\bget_peft_model\s*\(/);
+    if (prepLine !== null && peftLine !== null && prepLine > peftLine) {
+      findings.push({
+        rule: "qlora_order",
+        severity: "error",
+        line: prepLine,
+        params: {
+          prepare_line: prepLine,
+          get_peft_model_line: peftLine,
+        },
+      });
+    }
+  }
+
+  // ─── Rule C: target_modules / arch mismatch ─────────────────────────────
+  const targetModuleCalls = extractTargetModules(text);
+  const detectedArch = detectArch(stringLiterals);
+  if (targetModuleCalls.length > 0 && detectedArch !== null) {
+    const expected = ARCH_TARGET_MODULES[detectedArch.arch];
+    if (expected) {
+      const expectedSet = new Set(expected);
+      for (const tm of targetModuleCalls) {
+        if (tm.modules.length === 0) continue;
+        const hits = tm.modules.filter(m => expectedSet.has(m)).length;
+        const ratio = hits / tm.modules.length;
+        // Less than half of user's specified modules are in the expected list.
+        if (ratio < 0.5) {
+          findings.push({
+            rule: "target_modules_mismatch",
+            severity: "warning",
+            line: tm.line,
+            params: {
+              user_modules: tm.modules,
+              detected_arch: detectedArch.arch,
+              detected_from: detectedArch.source,
+              expected_modules: expected,
+              hits,
+              total: tm.modules.length,
+            },
+          });
+        }
+      }
+    }
+  }
+
+  // ─── Rule D: lora_alpha ≠ 2*r convention ────────────────────────────────
+  // Common rule of thumb: alpha = 2*r gives roughly unit-scale LoRA.
+  // alpha = r is also seen but reduces effective LR. Anything else is
+  // worth surfacing as info.
+  const loraCfgs = extractLoraConfig(text);
+  for (const cfg of loraCfgs) {
+    if (cfg.r != null && cfg.lora_alpha != null) {
+      const ratio = cfg.lora_alpha / cfg.r;
+      if (ratio !== 1 && ratio !== 2) {
+        findings.push({
+          rule: "alpha_not_2r",
+          severity: "info",
+          line: cfg.line,
+          params: {
+            r: cfg.r,
+            lora_alpha: cfg.lora_alpha,
+            ratio: Math.round(ratio * 100) / 100,
+          },
+        });
+      }
+    }
+  }
+
+  // ─── Aggregate verdict code ──────────────────────────────────────────────
+  let code;
+  if (findings.length === 0) {
+    code = "clean";
+  } else if (findings.some(f => f.severity === "error")) {
+    code = "errors_found";
+  } else if (findings.some(f => f.severity === "warning")) {
+    code = "warnings_only";
+  } else {
+    code = "info_only";
+  }
+  return { code, findings, summary: { total: findings.length } };
+}
+
+export { ARCH_TARGET_MODULES, ARCH_ID_HINTS };